OpenLayers OpenLayers

Changeset 7372

Show
Ignore:
Timestamp:
06/17/08 16:36:54 (7 months ago)
Author:
tschaub
Message:

merge r6920:HEAD from behavior sandbox

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • sandbox/topp/geoext/build/license.txt

    r7344 r7372  
    4545 
    4646/** 
     47 * Contains portions of GoogleGears <http://gears.google.com/>: 
     48 * 
     49 * Copyright 2007, Google Inc. 
     50 * 
     51 * Redistribution and use in source and binary forms, with or without 
     52 * modification, are permitted provided that the following conditions are met: 
     53 * 
     54 *  1. Redistributions of source code must retain the above copyright notice, 
     55 *     this list of conditions and the following disclaimer. 
     56 *  2. Redistributions in binary form must reproduce the above copyright notice, 
     57 *     this list of conditions and the following disclaimer in the documentation 
     58 *     and/or other materials provided with the distribution. 
     59 *  3. Neither the name of Google Inc. nor the names of its contributors may be 
     60 *     used to endorse or promote products derived from this software without 
     61 *     specific prior written permission. 
     62 * 
     63 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
     64 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
     65 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 
     66 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
     67 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
     68 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
     69 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
     70 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
     71 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
     72 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
     73 * 
     74 */ 
     75 
     76/** 
    4777 * Contains XMLHttpRequest.js <http://code.google.com/p/xmlhttprequest/> 
    4878 * Copyright 2007 Sergey Ilinsky (http://www.ilinsky.com) 

  • sandbox/topp/geoext/lib/OpenLayers.js

    r7357 r7372  
    8484            "Rico/Corner.js", 
    8585            "Rico/Color.js", 
     86            "OpenLayers/Request.js", 
     87            "OpenLayers/Request/XMLHttpRequest.js", 
    8688            "OpenLayers/Ajax.js", 
    8789            "OpenLayers/Request.js", 
    …… 
    161163            "OpenLayers/Control/DragFeature.js", 
    162164            "OpenLayers/Control/ModifyFeature.js", 
     165            "OpenLayers/Control/DeleteFeature.js", 
    163166            "OpenLayers/Control/Panel.js", 
    164167            "OpenLayers/Control/SelectFeature.js", 
    …… 
    183186            "OpenLayers/Layer/PointTrack.js", 
    184187            "OpenLayers/Layer/GML.js", 
     188            "OpenLayers/Strategy.js", 
     189            "OpenLayers/Strategy/BBOX.js", 
     190            "OpenLayers/Strategy/Composer.js", 
     191            "OpenLayers/Strategy/Fixed.js", 
     192            "OpenLayers/Strategy/Save.js", 
     193            "OpenLayers/Strategy/GreedySave.js", 
     194            "OpenLayers/Strategy/Autosave.js", 
     195            "OpenLayers/Protocol.js", 
     196            "OpenLayers/Protocol/HTTP.js", 
     197            "OpenLayers/Protocol/SQL.js", 
     198            "OpenLayers/Protocol/SQL/GoogleGears.js", 
     199            "OpenLayers/Protocol/WFS.js", 
     200            "OpenLayers/Protocol/WFS/v1_0_0.js", 
     201            "OpenLayers/Protocol/WFSV.js", 
    185202            "OpenLayers/Style.js", 
    186203            "OpenLayers/StyleMap.js", 
    …… 
    190207            "OpenLayers/Filter/Logical.js", 
    191208            "OpenLayers/Filter/Comparison.js", 
     209            "OpenLayers/Filter/Spatial.js", 
    192210            "OpenLayers/Format.js", 
    193211            "OpenLayers/Format/XML.js", 
    194212            "OpenLayers/Format/GML.js", 
     213            "OpenLayers/Format/GML/Base.js", 
    195214            "OpenLayers/Format/KML.js", 
    196215            "OpenLayers/Format/GeoRSS.js", 
    …… 
    198217            "OpenLayers/Format/WKT.js", 
    199218            "OpenLayers/Format/OSM.js", 
     219            "OpenLayers/Format/Filter.js", 
     220            "OpenLayers/Format/Filter/v1.js", 
     221            "OpenLayers/Format/Filter/v1_0_0.js", 
    200222            "OpenLayers/Format/SLD.js", 
    201223            "OpenLayers/Format/SLD/v1.js", 

  • sandbox/topp/geoext/lib/OpenLayers/Control/DrawFeature.js

    r5904 r7372  
    6565        this.layer.addFeatures([feature]); 
    6666        this.featureAdded(feature); 
     67        this.layer.events.triggerEvent("afterfeaturemodified",  
     68                                       {feature: feature}); 
    6769    }, 
    6870 

  • sandbox/topp/geoext/lib/OpenLayers/Format/GML.js

    r6463 r7372  
    137137     */ 
    138138    parseFeature: function(node) { 
    139         // only accept on geometry per feature - look for highest "order" 
     139        // only accept one geometry per feature - look for highest "order" 
    140140        var order = ["MultiPolygon", "Polygon", 
    141141                     "MultiLineString", "LineString", 
    …… 
    566566     *  
    567567     * Parameters: 
    568      * features - {Array(<OpenLayers.Feature.Vector>)} List of features to 
     568     * features - {DOMElement} A DOM node or {Array(<OpenLayers.Feature.Vector>)} List of features to 
    569569     *     serialize into a string. 
    570570     * 
    …… 
    573573     */ 
    574574    write: function(features) { 
    575         if(!(features instanceof Array)) { 
    576             features = [features]; 
    577         } 
    578         var gml = this.createElementNS("http://www.opengis.net/wfs", 
    579                                        "wfs:" + this.collectionName); 
    580         for(var i=0; i<features.length; i++) { 
    581             gml.appendChild(this.createFeatureXML(features[i])); 
    582         } 
    583         return OpenLayers.Format.XML.prototype.write.apply(this, [gml]); 
     575        var node; 
     576        if(typeof(features.nodeType) != 'number'){ 
     577            if(!(features instanceof Array)) { 
     578                features = [features]; 
     579            } 
     580            var gml = this.createElementNS("http://www.opengis.net/wfs", 
     581                                           "wfs:" + this.collectionName); 
     582            for(var i=0; i<features.length; i++) { 
     583                gml.appendChild(this.createFeatureXML(features[i])); 
     584            } 
     585             
     586            node = gml; 
     587        } else { 
     588            node = features; 
     589        } 
     590        return OpenLayers.Format.XML.prototype.write.apply(this, [node]); 
    584591    }, 
    585592 
    …… 
    594601     * {DOMElement} A node reprensting the feature in GML. 
    595602     */ 
    596     createFeatureXML: function(feature) { 
     603    createFeatureXML: function(feature, notContained) { 
    597604        var geometry = feature.geometry; 
    598605        var geometryNode = this.buildGeometryNode(geometry); 
     606        // TODO: deal with this properly 
     607        geometryNode.setAttribute("srsName", feature.layer.projection.getCode()); 
     608         
    599609        var geomContainer = this.createElementNS(this.featureNS, 
    600610                                                 this.featurePrefix + ":" + 
    601611                                                 this.geometryName); 
    602612        geomContainer.appendChild(geometryNode); 
    603         var featureNode = this.createElementNS(this.gmlns, 
    604                                                "gml:" + this.featureName); 
    605         var featureContainer = this.createElementNS(this.featureNS, 
     613 
     614        var featureNode = this.createElementNS(this.featureNS, 
    606615                                                    this.featurePrefix + ":" + 
    607616                                                    this.layerName); 
    608617        var fid = feature.fid || feature.id; 
    609         featureContainer.setAttribute("fid", fid); 
    610         featureContainer.appendChild(geomContainer); 
     618        featureNode.setAttribute("fid", fid); 
     619        featureNode.appendChild(geomContainer); 
    611620        for(var attr in feature.attributes) { 
    612621            var attrText = this.createTextNode(feature.attributes[attr]);  
    …… 
    616625                                                     nodename); 
    617626            attrContainer.appendChild(attrText); 
    618             featureContainer.appendChild(attrContainer); 
    619         }     
    620         featureNode.appendChild(featureContainer); 
     627            featureNode.appendChild(attrContainer); 
     628        }    
     629          
     630        if(!notContained){ 
     631            var featureContainer = this.createElementNS(this.gmlns, 
     632                                               "gml:" + this.featureName); 
     633            featureContainer.appendChild(featureNode); 
     634            return featureContainer; 
     635        } 
     636 
    621637        return featureNode; 
    622638    }, 
    …… 
    798814            } 
    799815            return gml; 
     816        }, 
     817 
     818        /** 
     819         * Method: buildGeometry.rectangle 
     820         * Given an OpenLayers rectangle geometry, create a GML box. 
     821         * 
     822         * Parameters: 
     823         * geometry - {<OpenLayers.Geometry.Rectangle>} A rectangle 
     824         *     geometry. 
     825         * 
     826         * Returns: 
     827         * {DOMElement} A GML box node. 
     828         */ 
     829        rectangle: function(geometry) { 
     830            var gml = this.createElementNS(this.gmlns, "gml:Box"); 
     831            gml.appendChild(this.buildCoordinatesNode(geometry)); 
     832            return gml; 
    800833        } 
    801834    }, 
    …… 
    819852        coordinatesNode.setAttribute("cs", ","); 
    820853        coordinatesNode.setAttribute("ts", " "); 
    821          
    822         var points = (geometry.components) ? geometry.components : [geometry]; 
     854        
    823855        var parts = []; 
    824         for(var i=0; i<points.length; i++) { 
    825             parts.push(points[i].x + "," + points[i].y); 
     856        if (geometry instanceof OpenLayers.Geometry.Rectangle) { 
     857            parts.push(geometry.x + "," + geometry.y); 
     858            parts.push((geometry.x + geometry.width) + "," +  
     859                (geometry.y + geometry.height)); 
     860        } else {  
     861            var points = (geometry.components) ? geometry.components :  
     862                [geometry]; 
     863            for(var i=0; i<points.length; i++) { 
     864                parts.push(points[i].x + "," + points[i].y); 
     865            } 
    826866        } 
    827867 

  • sandbox/topp/geoext/lib/OpenLayers/Format/SLD.js

    r6894 r7372  
    1010 * @requires OpenLayers/Filter/Logical.js 
    1111 * @requires OpenLayers/Filter/Comparison.js 
     12 * @requires OpenLayers/Filter/Spatial.js 
    1213 */ 
    1314 

  • sandbox/topp/geoext/lib/OpenLayers/Format/SLD/v1.js

    r7344 r7372  
    6666     */ 
    6767    initialize: function(options) { 
     68        // extend with ogc:Filter readers and writers 
     69        this.readers["ogc"] = OpenLayers.Format.Filter.v1.prototype.readers["ogc"]; 
     70        this.writers["ogc"] = OpenLayers.Format.Filter.v1.prototype.writers["ogc"]; 
     71        // extend with custom filter methods that may get changed 
     72        this.readOgcExpression = OpenLayers.Format.Filter.v1.prototype.readOgcExpression; 
     73        this.getFilterType = OpenLayers.Format.Filter.v1.prototype.getFilterType; 
     74        this.filterMap = OpenLayers.Format.Filter.v1.prototype.filterMap; 
    6875        OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); 
    6976    }, 
    …… 
    223230                } 
    224231                if(graphic.size != undefined) { 
    225                     symbolizer.pointRadius = graphic.size / 2; 
     232                    symbolizer.pointRadius = graphic.size; 
    226233                } 
    227234                if(graphic.href != undefined) { 
    …… 
    273280                graphic.graphicFormat = this.getChildValue(node); 
    274281            } 
    275         }, 
    276         "ogc": { 
    277             "Filter": function(node, rule) { 
    278                 // Filters correspond to subclasses of OpenLayers.Filter. 
    279                 // Since they contain information we don't persist, we 
    280                 // create a temporary object and then pass on the filter 
    281                 // (ogc:Filter) to the parent rule (sld:Rule). 
    282                 var obj = { 
    283                     fids: [], 
    284                     filters: [] 
    285                 }; 
    286                 this.readChildNodes(node, obj); 
    287                 if(obj.fids.length > 0) { 
    288                     rule.filter = new OpenLayers.Filter.FeatureId({ 
    289                         fids: obj.fids 
    290                     }); 
    291                 } else if(obj.filters.length > 0) { 
    292                     rule.filter = obj.filters[0]; 
    293                 } 
    294             }, 
    295             "FeatureId": function(node, obj) { 
    296                 var fid = node.getAttribute("fid"); 
    297                 if(fid) { 
    298                     obj.fids.push(fid); 
    299                 } 
    300             }, 
    301             "And": function(node, obj) { 
    302                 var filter = new OpenLayers.Filter.Logical({ 
    303                     type: OpenLayers.Filter.Logical.AND 
    304                 }); 
    305                 this.readChildNodes(node, filter); 
    306                 obj.filters.push(filter); 
    307             }, 
    308             "Or": function(node, obj) { 
    309                 var filter = new OpenLayers.Filter.Logical({ 
    310                     type: OpenLayers.Filter.Logical.OR 
    311                 }); 
    312                 this.readChildNodes(node, filter); 
    313                 obj.filters.push(filter); 
    314             }, 
    315             "Not": function(node, obj) { 
    316                 var filter = new OpenLayers.Filter.Logical({ 
    317                     type: OpenLayers.Filter.Logical.NOT 
    318                 }); 
    319                 this.readChildNodes(node, filter); 
    320                 obj.filters.push(filter); 
    321             }, 
    322             "PropertyIsEqualTo": function(node, obj) { 
    323                 var filter = new OpenLayers.Filter.Comparison({ 
    324                     type: OpenLayers.Filter.Comparison.EQUAL_TO 
    325                 }); 
    326                 this.readChildNodes(node, filter); 
    327                 obj.filters.push(filter); 
    328             }, 
    329             "PropertyIsNotEqualTo": function(node, obj) { 
    330                 var filter = new OpenLayers.Filter.Comparison({ 
    331                     type: OpenLayers.Filter.Comparison.NOT_EQUAL_TO 
    332                 }); 
    333                 this.readChildNodes(node, filter); 
    334                 obj.filters.push(filter); 
    335             }, 
    336             "PropertyIsLessThan": function(node, obj) { 
    337                 var filter = new OpenLayers.Filter.Comparison({ 
    338                     type: OpenLayers.Filter.Comparison.LESS_THAN 
    339                 }); 
    340                 this.readChildNodes(node, filter); 
    341                 obj.filters.push(filter); 
    342             }, 
    343             "PropertyIsGreaterThan": function(node, obj) { 
    344                 var filter = new OpenLayers.Filter.Comparison({ 
    345                     type: OpenLayers.Filter.Comparison.GREATER_THAN 
    346                 }); 
    347                 this.readChildNodes(node, filter); 
    348                 obj.filters.push(filter); 
    349             }, 
    350             "PropertyIsLessThanOrEqualTo": function(node, obj) { 
    351                 var filter = new OpenLayers.Filter.Comparison({ 
    352                     type: OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO 
    353                 }); 
    354                 this.readChildNodes(node, filter); 
    355                 obj.filters.push(filter); 
    356             }, 
    357             "PropertyIsGreaterThanOrEqualTo": function(node, obj) { 
    358                 var filter = new OpenLayers.Filter.Comparison({ 
    359                     type: OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO 
    360                 }); 
    361                 this.readChildNodes(node, filter); 
    362                 obj.filters.push(filter); 
    363             }, 
    364             "PropertyIsBetween": function(node, obj) { 
    365                 var filter = new OpenLayers.Filter.Comparison({ 
    366                     type: OpenLayers.Filter.Comparison.BETWEEN 
    367                 }); 
    368                 this.readChildNodes(node, filter); 
    369                 obj.filters.push(filter); 
    370             }, 
    371             "PropertyIsLike": function(node, obj) { 
    372                 var filter = new OpenLayers.Filter.Comparison({ 
    373                     type: OpenLayers.Filter.Comparison.LIKE 
    374                 }); 
    375                 this.readChildNodes(node, filter); 
    376                 var wildCard = node.getAttribute("wildCard"); 
    377                 var singleChar = node.getAttribute("singleChar"); 
    378                 var esc = node.getAttribute("escape"); 
    379                 filter.value2regex(wildCard, singleChar, esc); 
    380                 obj.filters.push(filter); 
    381             }, 
    382             "Literal": function(node, obj) { 
    383                 obj.value = this.getChildValue(node); 
    384             }, 
    385             "PropertyName": function(node, filter) { 
    386                 filter.property = this.getChildValue(node); 
    387             }, 
    388             "LowerBoundary": function(node, filter) { 
    389                 filter.lowerBoundary = this.readOgcExpression(node); 
    390             }, 
    391             "UpperBoundary": function(node, filter) { 
    392                 filter.upperBoundary = this.readOgcExpression(node); 
    393             } 
    394         } 
    395     }, 
    396      
    397     /** 
    398      * Method: readOgcExpression 
    399      * Limited support for OGC expressions. 
    400      * 
    401      * Parameters: 
    402      * node - {DOMElement} A DOM element that contains an ogc:expression. 
    403      * 
    404      * Returns: 
    405      * {String} A value to be used in a symbolizer. 
    406      */ 
    407     readOgcExpression: function(node) { 
    408         var obj = {}; 
    409         this.readChildNodes(node, obj); 
    410         var value = obj.value; 
    411         if(!value) { 
    412             value = this.getChildValue(node); 
    413         } 
    414         return value; 
     282        } 
    415283    }, 
    416284     
    …… 
    840708                } 
    841709                if(symbolizer.pointRadius != undefined) { 
    842                     this.writeNode(node, "Size", symbolizer.pointRadius * 2); 
     710                    this.writeNode(node, "Size", symbolizer.pointRadius); 
    843711                } 
    844712                if(symbolizer.rotation != undefined) { 
    …… 
    897765                }); 
    898766            } 
    899         }, 
    900         "ogc": { 
    901             "Filter": function(filter) { 
    902                 var node = this.createElementNSPlus("ogc:Filter"); 
    903                 var sub = filter.CLASS_NAME.split(".").pop(); 
    904                 if(sub == "FeatureId") { 
    905                     for(var i=0; i<filter.fids.length; ++i) { 
    906                         this.writeNode(node, "FeatureId", filter.fids[i]); 
    907                     } 
    908                 } else { 
    909                     this.writeNode(node, this.getFilterType(filter), filter); 
    910                 } 
    911                 return node; 
    912             }, 
    913             "FeatureId": function(fid) { 
    914                 return this.createElementNSPlus("ogc:FeatureId", { 
    915                     attributes: {fid: fid} 
    916                 }); 
    917             }, 
    918             "And": function(filter) { 
    919                 var node = this.createElementNSPlus("ogc:And"); 
    920                 var childFilter; 
    921                 for(var i=0; i<filter.filters.length; ++i) { 
    922                     childFilter = filter.filters[i]; 
    923                     this.writeNode( 
    924                         node, this.getFilterType(childFilter), childFilter 
    925                     ); 
    926                 } 
    927                 return node; 
    928             }, 
    929             "Or": function(filter) { 
    930                 var node = this.createElementNSPlus("ogc:Or"); 
    931                 var childFilter; 
    932                 for(var i=0; i<filter.filters.length; ++i) { 
    933                     childFilter = filter.filters[i]; 
    934                     this.writeNode( 
    935                         node, this.getFilterType(childFilter), childFilter 
    936                     ); 
    937                 } 
    938                 return node; 
    939             }, 
    940             "Not": function(filter) { 
    941                 var node = this.createElementNSPlus("ogc:Not"); 
    942                 var childFilter = filter.filters[0]; 
    943                 this.writeNode( 
    944                     node, this.getFilterType(childFilter), childFilter 
    945                 ); 
    946                 return node; 
    947             }, 
    948             "PropertyIsEqualTo": function(filter) { 
    949                 var node = this.createElementNSPlus("ogc:PropertyIsEqualTo"); 
    950                 // no ogc:expression handling for now 
    951                 this.writeNode(node, "PropertyName", filter); 
    952                 this.writeNode(node, "Literal", filter.value); 
    953                 return node; 
    954             }, 
    955             "PropertyIsNotEqualTo": function(filter) { 
    956                 var node = this.createElementNSPlus("ogc:PropertyIsNotEqualTo"); 
    957                 // no ogc:expression handling for now 
    958                 this.writeNode(node, "PropertyName", filter); 
    959                 this.writeNode(node, "Literal", filter.value); 
    960                 return node; 
    961             }, 
    962             "PropertyIsLessThan": function(filter) { 
    963                 var node = this.createElementNSPlus("ogc:PropertyIsLessThan"); 
    964                 // no ogc:expression handling for now 
    965                 this.writeNode(node, "PropertyName", filter); 
    966                 this.writeNode(node, "Literal", filter.value);                 
    967                 return node; 
    968             }, 
    969             "PropertyIsGreaterThan": function(filter) { 
    970                 var node = this.createElementNSPlus("ogc:PropertyIsGreaterThan"); 
    971                 // no ogc:expression handling for now 
    972                 this.writeNode(node, "PropertyName", filter); 
    973                 this.writeNode(node, "Literal", filter.value); 
    974                 return node; 
    975             }, 
    976             "PropertyIsLessThanOrEqualTo": function(filter) { 
    977                 var node = this.createElementNSPlus("ogc:PropertyIsLessThanOrEqualTo"); 
    978                 // no ogc:expression handling for now 
    979                 this.writeNode(node, "PropertyName", filter); 
    980                 this.writeNode(node, "Literal", filter.value); 
    981                 return node; 
    982             }, 
    983             "PropertyIsGreaterThanOrEqualTo": function(filter) { 
    984                 var node = this.createElementNSPlus("ogc:PropertyIsGreaterThanOrEqualTo"); 
    985                 // no ogc:expression handling for now 
    986                 this.writeNode(node, "PropertyName", filter); 
    987                 this.writeNode(node, "Literal", filter.value); 
    988                 return node; 
    989             }, 
    990             "PropertyIsBetween": function(filter) { 
    991                 var node = this.createElementNSPlus("ogc:PropertyIsBetween"); 
    992                 // no ogc:expression handling for now 
    993                 this.writeNode(node, "PropertyName", filter); 
    994                 this.writeNode(node, "LowerBoundary", filter); 
    995                 this.writeNode(node, "UpperBoundary", filter); 
    996                 return node; 
    997             }, 
    998             "PropertyIsLike": function(filter) { 
    999                 var node = this.createElementNSPlus("ogc:PropertyIsLike", { 
    1000                     attributes: { 
    1001                         wildCard: "*", singleChar: ".", escape: "!" 
    1002                     } 
    1003                 }); 
    1004                 // no ogc:expression handling for now 
    1005                 this.writeNode(node, "PropertyName", filter); 
    1006                 // convert regex string to ogc string 
    1007                 this.writeNode(node, "Literal", filter.regex2value()); 
    1008                 return node; 
    1009             }, 
    1010             "PropertyName": function(filter) { 
    1011                 // no ogc:expression handling for now 
    1012                 return this.createElementNSPlus("ogc:PropertyName", { 
    1013                     value: filter.property 
    1014                 }); 
    1015             }, 
    1016             "Literal": function(value) { 
    1017                 // no ogc:expression handling for now 
    1018                 return this.createElementNSPlus("ogc:Literal", { 
    1019                     value: value 
    1020                 }); 
    1021             }, 
    1022             "LowerBoundary": function(filter) { 
    1023                 // no ogc:expression handling for now 
    1024                 var node = this.createElementNSPlus("ogc:LowerBoundary"); 
    1025                 this.writeNode(node, "Literal", filter.lowerBoundary); 
    1026                 return node; 
    1027             }, 
    1028             "UpperBoundary": function(filter) { 
    1029                 // no ogc:expression handling for now 
    1030                 var node = this.createElementNSPlus("ogc:UpperBoundary"); 
    1031                 this.writeNode(node, "Literal", filter.upperBoundary); 
    1032                 return node; 
    1033             } 
    1034         } 
    1035     }, 
    1036      
    1037     /** 
    1038      * Method: getFilterType 
    1039      */ 
    1040     getFilterType: function(filter) { 
    1041         var filterType = this.filterMap[filter.type]; 
    1042         if(!filterType) { 
    1043             throw "SLD writing not supported for rule type: " + filter.type; 
    1044         } 
    1045         return filterType; 
    1046     }, 
    1047      
    1048     /** 
    1049      * Property: filterMap 
    1050      * {Object} Contains a member for each filter type.  Values are node names 
    1051      *     for corresponding OGC Filter child elements. 
    1052      */ 
    1053     filterMap: { 
    1054         "&&": "And", 
    1055         "||": "Or", 
    1056         "!": "Not", 
    1057         "==": "PropertyIsEqualTo", 
    1058         "!=": "PropertyIsNotEqualTo", 
    1059         "<": "PropertyIsLessThan", 
    1060         ">": "PropertyIsGreaterThan", 
    1061         "<=": "PropertyIsLessThanOrEqualTo", 
    1062         ">=": "PropertyIsGreaterThanOrEqualTo", 
    1063         "..": "PropertyIsBetween", 
    1064         "~": "PropertyIsLike" 
    1065     }, 
    1066      
     767        } 
     768    }, 
    1067769 
    1068770    /** 

  • sandbox/topp/geoext/lib/OpenLayers/Format/XML.js

    r6463 r7372  
    2020OpenLayers.Format.XML = OpenLayers.Class(OpenLayers.Format, { 
    2121     
     22    /** 
     23     * Property: namespaces 
     24     * {Object} Mapping of namespace aliases to namespace URIs. 
     25     */ 
     26    namespaces: { 
     27    }, 
     28     
     29    /** 
     30     * Property: defaultNamespace 
     31     * {String} The default namespace alias for creating element nodes. 
     32     */ 
     33    defaultNamespace: null, 
     34 
    2235    /** 
    2336     * Property: xmldom 
    …… 
    385398    }, 
    386399 
     400    /** 
     401     * Method: getNamespacePrefix 
     402     * Get the namespace prefix for a given uri from the <namespaces> object. 
     403     * 
     404     * Returns: 
     405     * {String} A namespace prefix or null if none found. 
     406     */ 
     407    getNamespacePrefix: function(uri) { 
     408        var prefix = null; 
     409        if(uri == null) { 
     410            prefix = this.namespaces[this.defaultPrefix]; 
     411        } else { 
     412            var gotPrefix = false; 
     413            for(prefix in this.namespaces) { 
     414                if(this.namespaces[prefix] == uri) { 
     415                    gotPrefix = true; 
     416                    break; 
     417                } 
     418            } 
     419            if(!gotPrefix) { 
     420                prefix = null; 
     421            } 
     422        } 
     423        return prefix; 
     424    }, 
     425 
     426    /** 
     427     * Method: createElementNSPlus 
     428     * Shorthand for creating namespaced elements with optional attributes and 
     429     *     child text nodes. 
     430     * 
     431     * Parameters: 
     432     * name - {String} The qualified node name. 
     433     * options - {Object} Optional object for node configuration. 
     434     * 
     435     * Returns: 
     436     * {Element} An element node. 
     437     */ 
     438    createElementNSPlus: function(name, options) { 
     439        options = options || {}; 
     440        var loc = name.indexOf(":"); 
     441        // order of prefix preference 
     442        // 1. in the uri option 
     443        // 2. in the prefix option 
     444        // 3. in the qualified name 
     445        // 4. from the defaultPrefix 
     446        var uri = options.uri || this.namespaces[options.prefix]; 
     447        if(!uri) { 
     448            loc = name.indexOf(":"); 
     449            uri = this.namespaces[name.substring(0, loc)]; 
     450        } 
     451        if(!uri) { 
     452            uri = this.namespaces[this.defaultPrefix]; 
     453        } 
     454        var node = this.createElementNS(uri, name); 
     455        if(options.attributes) { 
     456            this.setAttributes(node, options.attributes); 
     457        } 
     458        if(options.value) { 
     459            node.appendChild(this.createTextNode(options.value)); 
     460        } 
     461        return node; 
     462    }, 
     463     
     464    /** 
     465     * Method: setAttributes 
     466     * Set multiple attributes given key value pairs from an object. 
     467     * 
     468     * Parameters: 
     469     * node - {Element} An element node. 
     470     * obj - {Object || Array} An object whose properties represent attribute 
     471     *     names and values represent attribute values.  If an attribute name 
     472     *     is a qualified name ("prefix:local"), the prefix will be looked up 
     473     *     in the parsers {namespaces} object.  If the prefix is found, 
     474     *     setAttributeNS will be used instead of setAttribute. 
     475     */ 
     476    setAttributes: function(node, obj) { 
     477        var value, loc, alias, uri; 
     478        for(var name in obj) { 
     479            if(obj[name].toString) { 
     480                value = obj[name].toString(); 
     481                // check for qualified attribute name ("prefix:local") 
     482                uri = this.namespaces[name.substring(0, name.indexOf(":"))] || null; 
     483                this.setAttributeNS(node, uri, name, value); 
     484            } 
     485        } 
     486    }, 
     487 
    387488    CLASS_NAME: "OpenLayers.Format.XML"  
    388489 

  • sandbox/topp/geoext/lib/OpenLayers/Handler/Path.js

    r5904 r7372  
    139139     */ 
    140140    geometryClone: function() { 
    141         return this.line.geometry.clone(); 
     141        var geometry = this.line.geometry.clone(); 
     142        if(this.multi) { 
     143            geometry = new OpenLayers.Geometry.MultiLineString([geometry]); 
     144        } 
     145        return geometry; 
    142146    }, 
    143147 

  • sandbox/topp/geoext/lib/OpenLayers/Handler/Point.js

    r6463 r7372  
    3232     */ 
    3333    layer: null, 
     34     
     35    /** 
     36     * Property: multi 
     37     * {Boolean} Cast features to multi-part geometries before passing to the 
     38     *     layer.  Default is false. 
     39     */ 
     40    multi: false, 
    3441     
    3542    /** 
    …… 
    150157     * Method: finalize 
    151158     * Finish the geometry and call the "done" callback. 
    152      */ 
    153     finalize: function() { 
     159     * 
     160     * Parameters: 
     161     * cancel - {Boolean} Call cancel instead of done callback.  Default is 
     162     *     false. 
     163     */ 
     164    finalize: function(cancel) { 
     165        var key = cancel ? "cancel" : "done"; 
    154166        this.layer.renderer.clear(); 
    155167        this.drawing = false; 
    …… 
    157169        this.lastDown = null; 
    158170        this.lastUp = null; 
    159         this.callback("done", [this.geometryClone()]); 
     171        this.callback(key, [this.geometryClone()]); 
    160172        this.destroyFeature(); 
    161173    }, 
    …… 
    166178     */ 
    167179    cancel: function() { 
    168         this.layer.renderer.clear(); 
    169         this.drawing = false; 
    170         this.mouseDown = false; 
    171         this.lastDown = null; 
    172         this.lastUp = null; 
    173         this.callback("cancel", [this.geometryClone()]); 
    174         this.destroyFeature(); 
     180        this.finalize(true); 
    175181    }, 
    176182 
    …… 
    223229     */ 
    224230    geometryClone: function() { 
    225         return this.point.geometry.clone(); 
     231        var geometry = this.point.geometry.clone(); 
     232        if(this.multi) { 
     233            geometry = new OpenLayers.Geometry.MultiPoint([geometry]); 
     234        } 
     235        return geometry; 
    226236    }, 
    227237