OpenLayers OpenLayers

Changeset 3321

Show
Ignore:
Timestamp:
06/12/07 10:27:35 (1 year ago)
Author:
crschmidt
Message:

Pullup to trunk HEAD.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • sandbox/crschmidt/slowvector/doc/authors.txt

    r2948 r3321  
    22Howard Butler 
    33Bertil Chaupis                                                                
     4John Cole 
    45Jeff Dege 
    56Schuyler Erle 

  • sandbox/crschmidt/slowvector/examples/georss-serialize.html

    r2978 r3321  
    33    <style type="text/css"> 
    44        #map { 
    5             width: 512px; 
     5            width: 45%; 
    66            height: 350px; 
    77            border: 1px solid gray; 
    …… 
    4343  <body onload="init()"> 
    4444    <h1>OpenLayers Draw Point Example</h1> 
    45     <div style="float:right"> 
    46     <textarea id="gml" cols="80" rows="30"></textarea> 
     45    <div style="float:right;width:50%"> 
     46    <textarea id="gml" style="width:100%" rows="30"></textarea> 
    4747    </div> 
    4848    <div id="map"></div> 

  • sandbox/crschmidt/slowvector/examples/lite.html

    r2978 r3321  
    1919            map = new OpenLayers.Map( 'map' ); 
    2020            layer = new OpenLayers.Layer.WMS( "OpenLayers WMS",  
    21                     "http://labs.metacarta.com/wms/vmap0", {layers: 'basic'} ); 
     21                    "http://labs.metacarta.com/wms/vmap0", 
     22                    {layers: 'basic'} ); 
    2223            map.addLayer(layer); 
    2324            map.setCenter(new OpenLayers.LonLat(lon, lat), zoom); 

  • sandbox/crschmidt/slowvector/examples/panel.html

    r2978 r3321  
    7070             
    7171            zb = new OpenLayers.Control.ZoomBox(); 
    72             panel = new OpenLayers.Control.Panel({defaultControl: zb}); 
     72            var panel = new OpenLayers.Control.Panel({defaultControl: zb}); 
    7373            panel.addControls([ 
    7474                new OpenLayers.Control.MouseDefaults(), 

  • sandbox/crschmidt/slowvector/examples/popups.html

    r1704 r3321  
    4848                                         new OpenLayers.LonLat(5,40), 
    4949                                         new OpenLayers.Size(200,200), 
    50                                          "example popup"); 
     50                                         "example popup", true); 
    5151         
    5252            map.addPopup(popup); 
    …… 
    7070         
    7171        function mousedown(evt) { 
     72             // check to see if the popup was hidden by the close box 
     73             // if so, then destroy it before continuing 
     74            if (popup != null) { 
     75                if (!popup.visible()) { 
     76                    markers.map.removePopup(popup); 
     77                    popup.destroy(); 
     78                    popup = null; 
     79                } 
     80            } 
    7281            if (popup == null) { 
    73                 popup = feature.createPopup(); 
     82                popup = feature.createPopup(true); 
    7483                popup.setContentHTML("<a href='http://www.somethingconstructive.net' target='_blank'>click me</a>"); 
    7584                popup.setBackgroundColor("yellow"); 

  • sandbox/crschmidt/slowvector/examples/vector-features.html

    r3038 r3321  
    1818                    "http://labs.metacarta.com/wms/vmap0", {layers: 'basic'} ); 
    1919            map.addLayer(layer); 
     20             
     21            var style_blue = OpenLayers.Util.extend({}, OpenLayers.Feature.Vector.style['default']); 
     22            style_blue.strokeColor = "blue";  
     23            style_blue.fillColor = "blue";  
     24            var style_green = { 
     25                strokeColor: "#00FF00", 
     26                strokeOpacity: 1, 
     27                strokeWidth: 3, 
     28                pointRadius: 6, 
     29                pointerEvents: "visiblePainted" 
     30            }; 
     31             
    2032            var vectorLayer = new OpenLayers.Layer.Vector("Simple Geometry"); 
    2133             
    2234            // create a point feature 
    2335            var point = new OpenLayers.Geometry.Point(-111.04, 45.68); 
    24             var pointFeature = new OpenLayers.Feature.Vector(point); 
     36            var pointFeature = new OpenLayers.Feature.Vector(point,null,style_blue); 
    2537             
    2638            // create a line feature from a list of points 
    …… 
    3345            } 
    3446            var lineFeature = new OpenLayers.Feature.Vector( 
    35                 new OpenLayers.Geometry.LineString(pointList)); 
     47                new OpenLayers.Geometry.LineString(pointList),null,style_green); 
    3648             
    3749            // create a polygon feature from a linear ring of points 
    …… 
    6072  <body onload="init()"> 
    6173    <div id="map"></div> 
     74    <p>This example shows drawing simple vector features -- point, line, polygon 
     75       in different styles, created 'manually', by constructing the entire style 
     76       object, via 'copy', extending the default style object, and by  
     77       inheriting the default style from the layer.</p> 
    6278  </body> 
    6379</html> 

  • sandbox/crschmidt/slowvector/examples/wkt.html

    r3043 r3321  
    7979         
    8080        function displayWKT(feature) { 
    81             var str = wkt.write(feature.geometry); 
     81            var str = wkt.write(feature); 
    8282            // not a good idea in general, just for this demo 
    8383            str = str.replace(/,/g, ', '); 
    …… 
    8787        function parseWKT() { 
    8888            var element = document.getElementById('wkt'); 
    89             var collection = wkt.read(element.value); 
     89            var features = wkt.read(element.value); 
    9090            var bounds; 
    91             if(collection) { 
    92                 if(collection.constructor != Array) { 
    93                     collection = [collection]; 
     91            if(features) { 
     92                if(features.constructor != Array) { 
     93                    features = [features]; 
    9494                } 
    95                 var features = []; 
    96                 for(var i=0; i<collection.length; ++i) { 
    97                     features.push(new OpenLayers.Feature.Vector(collection[i])); 
     95                for(var i=0; i<features.length; ++i) { 
    9896                    if (!bounds) { 
    99                         bounds = collection[i].getBounds(); 
     97                        bounds = features[i].geometry.getBounds(); 
     98                    } else { 
     99                        bounds.extend(features[i].geometry.getBounds()); 
    100100                    } 
    101                     bounds.extend(collection[i].getBounds()); 
    102101                     
    103102                } 

  • sandbox/crschmidt/slowvector/lib/OpenLayers.js

    r3080 r3321  
    5555        "OpenLayers/BaseTypes.js", 
    5656        "OpenLayers/Util.js", 
     57        "OpenLayers/Console.js", 
    5758        "Rico/Corner.js", 
    5859        "Rico/Color.js", 

  • sandbox/crschmidt/slowvector/lib/OpenLayers/Ajax.js

    r2803 r3321  
    212212      this.transport.send(this.options.method == 'post' ? body : null); 
    213213 
     214      /* Force Firefox to handle ready state 4 for synchronous requests */ 
     215      if (!this.options.asynchronous && this.transport.overrideMimeType) { 
     216          this.onStateChange(); 
     217      } 
     218 
    214219    } catch (e) { 
    215220      this.dispatchException(e); 
    …… 
    297302 
    298303  dispatchException: function(exception) { 
    299     (this.options.onException || OpenLayers.Ajax.emptyFunction)(this, exception); 
     304    if (this.options.onException) { 
     305        this.options.onException(this, exception); 
     306    } else { 
     307        // if we get here, Responders.dispatch('onException') will never 
     308        // be called. too bad. we should probably take out the Responders 
     309        // stuff anyway. 
     310        throw exception; 
     311    } 
    300312    OpenLayers.Ajax.Responders.dispatch('onException', this, exception); 
    301313  } 

  • sandbox/crschmidt/slowvector/lib/OpenLayers/BaseTypes.js

    r2943 r3321  
    3232            //  
    3333            // to be revisited in 3.0 
    34             //  
    35             if (arguments[i].hasOwnProperty('toString')) { 
     34            // 
     35            if((arguments[i].hasOwnProperty && arguments[i].hasOwnProperty('toString')) || 
     36               (!arguments[i].hasOwnProperty && arguments[i].toString)) { 
    3637                proto.toString = arguments[i].toString; 
    3738            } 

  • sandbox/crschmidt/slowvector/lib/OpenLayers/Control.js

    r2944 r3321  
    2727     * Controls can have a 'type'. The type determines the type of interactions 
    2828     * which are possible with them when they are placed into a toolbar. 
     29     *  
    2930     * @type OpenLayers.Control.TYPES 
    3031     */ 
    …… 
    3233 
    3334    /**  This property is used for CSS related to the drawing of the Control. 
     35     *  
    3436     * @type string  
    3537     */ 
    3638    displayClass: "", 
    3739 
    38     /** 
    39      * @type boolean 
    40      */ 
     40    /** @type boolean */ 
    4141    active: null, 
    4242 
    43     /** 
    44      * @type OpenLayers.Handler 
    45      */ 
     43    /** @type OpenLayers.Handler */ 
    4644    handler: null, 
    4745 
    …… 
    5452        // We do this before the extend so that instances can override 
    5553        // className in options. 
    56         this.displayClass = this.CLASS_NAME.replace("OpenLayers.", "ol").replace(".",""); 
     54        this.displayClass =  
     55            this.CLASS_NAME.replace("OpenLayers.", "ol").replace(".",""); 
    5756         
    5857        OpenLayers.Util.extend(this, options); 

  • sandbox/crschmidt/slowvector/lib/OpenLayers/Control/ArgParser.js

    r1721 r3321  
    2525     * @constructor 
    2626     *  
    27      * @param {DOMElement} element 
    28      * @param {String} base 
     27     * @param {Object} options 
    2928     */ 
    30     initialize: function(element, base) { 
     29    initialize: function(options) { 
    3130        OpenLayers.Control.prototype.initialize.apply(this, arguments); 
    3231    }, 

  • sandbox/crschmidt/slowvector/lib/OpenLayers/Control/LayerSwitcher.js

    r3068 r3321  
    100100 
    101101        // set mode to minimize 
    102         this.minimizeControl(); 
    103          
     102        if(!this.outsideViewport) { 
     103            this.minimizeControl(); 
     104        } 
     105 
    104106        // populate div with current info 
    105107        this.redraw();     

  • sandbox/crschmidt/slowvector/lib/OpenLayers/Control/OverviewMap.js

    r3070 r3321  
    181181            OpenLayers.Event.stop(e); 
    182182        }); 
    183         this.rectEvents = new OpenLayers.Events(this, this.extentRectangle); 
     183        this.rectEvents = new OpenLayers.Events(this, this.extentRectangle, 
     184                                                null, true); 
    184185        this.rectEvents.register('mouseout', this, this.rectMouseOut); 
    185186        this.rectEvents.register('mousedown', this, this.rectMouseDown); 
    …… 
    521522        this.extentRectangle.style.top = parseInt(top) + 'px'; 
    522523        this.extentRectangle.style.left = parseInt(left) + 'px'; 
    523         this.extentRectangle.style.height = parseInt(bottom - top)+ 'px'; 
    524         this.extentRectangle.style.width = parseInt(right - left) + 'px'; 
     524        this.extentRectangle.style.height = parseInt(Math.max(bottom - top, 0))+ 'px'; 
     525        this.extentRectangle.style.width = parseInt(Math.max(right - left, 0)) + 'px'; 
    525526    }, 
    526527 

  • sandbox/crschmidt/slowvector/lib/OpenLayers/Control/Panel.js

    r2978 r3321  
    104104            control.trigger(); 
    105105            return; 
    106         }      
     106        } 
     107        if (control.type == OpenLayers.Control.TYPE_TOGGLE) { 
     108            if (control.active) { 
     109                control.deactivate(); 
     110            } else { 
     111                control.activate(); 
     112            } 
     113            return; 
     114        } 
    107115        for (var i = 0; i < this.controls.length; i++) { 
    108116            if (this.controls[i] == control) { 
    …… 
    130138        // Access to this div is via the panel_div attribute of the  
    131139        // control added to the panel. 
     140        // Also, stop mousedowns and clicks, but don't stop mouseup, 
     141        // since they need to pass through. 
    132142        for (var i = 0; i < controls.length; i++) { 
    133143            var element = document.createElement("div"); 
    …… 
    138148            OpenLayers.Event.observe(controls[i].panel_div, "mousedown",  
    139149                              OpenLayers.Event.stop.bindAsEventListener()); 
    140             OpenLayers.Event.observe(controls[i].panel_div, "mouseup",  
    141                                   OpenLayers.Event.stop.bindAsEventListener()); 
    142150        }     
    143151 

  • sandbox/crschmidt/slowvector/lib/OpenLayers/Feature.js

    r2894 r3321  
    122122 
    123123    /** 
     124     * @param {Boolean} closeBox create popup with closebox or not 
    124125     * @returns A Popup Object created from the 'lonlat', 'popupSize', 
    125126     *          and 'popupContentHTML' properties set in this.data. It uses 
    …… 
    133134     * @type OpenLayers.Popup.AnchoredBubble 
    134135     */ 
    135     createPopup: function() { 
     136    createPopup: function(closeBox) { 
    136137 
    137138        if (this.lonlat != null) { 
    …… 
    144145                                                    this.data.popupSize, 
    145146                                                    this.data.popupContentHTML, 
    146                                                     anchor);  
     147                                                    anchor, closeBox);  
    147148        }         
    148149        return this.popup; 

  • sandbox/crschmidt/slowvector/lib/OpenLayers/Feature/Vector.js

    r3066 r3321  
    207207        strokeOpacity: 1, 
    208208        strokeWidth: 1, 
     209        strokeLinecap: "round", 
    209210        hoverStrokeColor: "red", 
    210211        hoverStrokeOpacity: 1, 
    …… 
    223224        strokeOpacity: 1, 
    224225        strokeWidth: 2, 
     226        strokeLinecap: "round", 
    225227        hoverStrokeColor: "red", 
    226228        hoverStrokeOpacity: 1, 
    …… 
    239241        strokeColor: "yellow", 
    240242        strokeOpacity: 1, 
     243        strokeLinecap: "round", 
    241244        strokeWidth: 4, 
    242245        hoverStrokeColor: "red", 

  • sandbox/crschmidt/slowvector/lib/OpenLayers/Format/GML.js

    r3043 r3321  
    8585        var feature = new OpenLayers.Feature.Vector(); 
    8686 
    87         if (xmlNode.firstChild.attributes && xmlNode.firstChild.attributes['fid']) { 
    88             feature.fid = xmlNode.firstChild.attributes['fid'].nodeValue; 
    89         } 
    90          
    9187        // match MultiPolygon 
    9288        if (OpenLayers.Ajax.getElementsByTagNameNS(xmlNode, this.gmlns, "gml", "MultiPolygon").length != 0) { 
    9389            var multipolygon = OpenLayers.Ajax.getElementsByTagNameNS(xmlNode, this.gmlns, "gml", "MultiPolygon")[0]; 
     90            feature.fid = multipolygon.parentNode.parentNode.getAttribute('fid'); 
     91 
    9492            geom = new OpenLayers.Geometry.MultiPolygon(); 
    9593            var polygons = OpenLayers.Ajax.getElementsByTagNameNS(multipolygon, 
    …… 
    105103            var multilinestring = OpenLayers.Ajax.getElementsByTagNameNS(xmlNode, 
    106104            this.gmlns, "gml", "MultiLineString")[0]; 
     105            feature.fid = multilinestring.parentNode.parentNode.getAttribute('fid'); 
    107106             
    108107            geom = new OpenLayers.Geometry.MultiLineString(); 
    …… 
    123122            var multiPoint = OpenLayers.Ajax.getElementsByTagNameNS(xmlNode, 
    124123                this.gmlns, "gml", "MultiPoint")[0]; 
     124            feature.fid = multiPoint.parentNode.parentNode.getAttribute('fid'); 
    125125                 
    126126            geom = new OpenLayers.Geometry.MultiPoint(); 
    …… 
    139139            var polygon = OpenLayers.Ajax.getElementsByTagNameNS(xmlNode, 
    140140                this.gmlns, "gml", "Polygon")[0]; 
     141            feature.fid = polygon.parentNode.parentNode.getAttribute('fid'); 
    141142             
    142143            geom = this.parsePolygonNode(polygon); 
    …… 
    147148            var lineString = OpenLayers.Ajax.getElementsByTagNameNS(xmlNode, 
    148149                this.gmlns, "gml", "LineString")[0]; 
     150            feature.fid = lineString.parentNode.parentNode.getAttribute('fid'); 
     151 
    149152            p = this.parseCoords(lineString); 
    150153            if (p.points) { 
    …… 
    158161            var point = OpenLayers.Ajax.getElementsByTagNameNS(xmlNode, 
    159162                this.gmlns, "gml", "Point")[0]; 
     163            feature.fid = point.parentNode.parentNode.getAttribute('fid'); 
    160164             
    161165            p = this.parseCoords(point); 

  • sandbox/crschmidt/slowvector/lib/OpenLayers/Format/GeoRSS.js

    r2978 r3321  
    9898        if (points) { 
    9999            for (var i = 0; i < points.length; i++) { 
    100                 path += points[i].lat + " " + points[i].lon + " "; 
     100                path += points[i].y + " " + points[i].x + " "; 
    101101            } 
    102102        } else { 
    103            path += geometry.lat + " " + geometry.lon + " "; 
     103           path += geometry.y + " " + geometry.x + " "; 
    104104        } 
    105105        return document.createTextNode(path); 

  • sandbox/crschmidt/slowvector/lib/OpenLayers/Format/WFS.js

    r2978 r3321  
    4848         
    4949        var transaction = document.createElementNS('http://www.opengis.net/wfs', 'wfs:Transaction'); 
     50        transaction.setAttribute("version","1.0.0"); 
     51        transaction.setAttribute("service","WFS"); 
    5052        for (var i=0; i < features.length; i++) { 
    5153            switch (features[i].state) { 

  • sandbox/crschmidt/slowvector/lib/OpenLayers/Format/WKT.js

    </
    r2978 r3321  
    2626 
    2727    /** 
    28      * Deserialize a WKT string and return an OpenLayers.Geometry or an array 
    29      * of OpenLayers.Geometry.  Supports WKT for POINT, MULTIPOINT, LINESTRING, 
    30      * MULTILINESTRING, POLYGON, MULTIPOLYGON, and GEOMETRYCOLLECTION. 
     28     * Deserialize a WKT string and return an OpenLayers.Feature.Vector or an 
     29     * array of OpenLayers.Feature.Vector.  Supports WKT for POINT, MULTIPOINT, 
     30     * LINESTRING, MULTILINESTRING, POLYGON, MULTIPOLYGON, and 
     31     * GEOMETRYCOLLECTION. 
    3132     * @param {String} wkt A WKT string 
    32      * @returns {OpenLayers.Geometry|Array} A geometry or array of geometries 
    33      *                                      for GEOMETRYCOLLECTION WKT. 
     33     * @returns {OpenLayers.Feature.Vector|Array} A feature or array of 
     34     *                                            features for 
     35     *                                            GEOMETRYCOLLECTION WKT. 
    3436     */ 
    3537    read: function(wkt) { 
    36         var geometry, type, str; 
     38        var features, type, str; 
    3739        var matches = this.regExes.typeStr.exec(wkt); 
    3840        if(matches) { 
    …… 
    4042            str = matches[2]; 
    4143            if(this.parse[type]) { 
    42                 geometry = this.parse[type].apply(this, [str]); 
    43             } 
    44         } 
    45         return geometry; 
    46     }, 
    47  
    48     /** 
    49      * Serialize a geometry or array of geometries into a WKT string. 
    50      * @param {OpenLayers.Geometry|Array} geom A geometry or array of geometries 
     44                features = this.parse[type].apply(this, [str]); 
     45            } 
     46        } 
     47        return features; 
     48    }, 
     49 
     50    /** 
     51     * Serialize a feature or array of features into a WKT string. 
     52     * @param {OpenLayers.Feature.Vector|Array} features A feature or array of 
     53     *                                                   features 
    5154     * @returns {String} The WKT string representation of the input geometries 
    5255     */ 
    53     write: function(geom) { 
     56    write: function(features) { 
    5457        var collection, geometry, type, data, isCollection; 
    55         if(geom.constructor == Array) { 
    56             collection = geom; 
     58        if(features.constructor == Array) { 
     59            collection = features; 
    5760            isCollection = true; 
    5861        } else { 
    59             collection = [geom]; 
     62            collection = [features]; 
    6063            isCollection = false; 
    6164        } 
    …… 
    6871                pieces.push(','); 
    6972            } 
    70             geometry = collection[i]; 
     73            geometry = collection[i].geometry; 
    7174            type = geometry.CLASS_NAME.split('.')[2].toLowerCase(); 
    7275            if(!this.extract[type]) { 
    …… 
    179182    parse: { 
    180183        /** 
    181          * Return point geometry given a point WKT fragment. 
     184         * Return point feature given a point WKT fragment. 
    182185         * @param {String} str A WKT fragment representing the point 
    183          * @returns {OpenLayers.Geometry.Point} A point geometry 
     186         * @returns {OpenLayers.Feature.Vector} A point feature 
     187         * @private 
    184188         */ 
    185189        'point': function(str) { 
    186190            var coords = str.trim().split(this.regExes.spaces); 
    187             return new OpenLayers.Geometry.Point(coords[0], coords[1]); 
    188         }, 
    189  
    190         /** 
    191          * Return a multipoint geometry given a multipoint WKT fragment. 
     191            return new OpenLayers.Feature.Vector( 
     192                new OpenLayers.Geometry.Point(coords[0], coords[1]) 
     193            ); 
     194        }, 
     195 
     196        /** 
     197         * Return a multipoint feature given a multipoint WKT fragment. 
    192198         * @param {String} A WKT fragment representing the multipoint 
    193          * @returns {OpenLayers.Geometry.MultiPoint} A multipoint geometry 
     199         * @returns {OpenLayers.Feature.Vector} A multipoint feature 
     200         * @private 
    194201         */ 
    195202        'multipoint': function(str) { 
    …… 
    197204            var components = []; 
    198205            for(var i=0; i<points.length; ++i) { 
    199                 components.push(this.parse.point.apply(this, [points[i]])); 
    200             } 
    201             return new OpenLayers.Geometry.MultiPoint(components); 
     206                components.push(this.parse.point.apply(this, [points[i]]).geometry); 
     207            } 
     208            return new OpenLayers.Feature.Vector( 
     209                new OpenLayers.Geometry.MultiPoint(components) 
     210            ); 
    202211        }, 
    203212         
    204213        /** 
    205          * Return a linestring geometry given a linestring WKT fragment. 
     214         * Return a linestring feature given a linestring WKT fragment. 
    206215         * @param {String} A WKT fragment representing the linestring 
    207          * @returns {OpenLayers.Geometry.LineString} A linestring geometry 
     216         * @returns {OpenLayers.Feature.Vector} A linestring feature 
     217         * @private 
    208218         */ 
    209219        'linestring': function(str) { 
    …… 
    211221            var components = []; 
    212222            for(var i=0; i<points.length; ++i) { 
    213                 components.push(this.parse.point.apply(this, [points[i]])); 
    214             } 
    215             return new OpenLayers.Geometry.LineString(components); 
    216         }, 
    217  
    218         /** 
    219          * Return a multilinestring geometry given a multilinestring WKT fragment. 
     223                components.push(this.parse.point.apply(this, [points[i]]).geometry); 
     224            } 
     225            return new OpenLayers.Feature.Vector( 
     226                new OpenLayers.Geometry.LineString(components) 
     227            ); 
     228        }, 
     229 
     230        /** 
     231         * Return a multilinestring feature given a multilinestring WKT fragment. 
    220232         * @param {String} A WKT fragment representing the multilinestring 
    221          * @returns {OpenLayers.Geometry.LineString} A multilinestring geometry 
     233         * @returns {OpenLayers.Feature.Vector} A multilinestring feature 
     234         * @private 
    222235         */ 
    223236        'multilinestring': function(str) { 
    …… 
    227240            for(var i=0; i<lines.length; ++i) { 
    228241                line = lines[i].replace(this.regExes.trimParens, '$1'); 
    229                 components.push(this.parse.linestring.apply(this, [line])); 
    230             } 
    231             return new OpenLayers.Geometry.MultiLineString(components); 
     242                components.push(this.parse.linestring.apply(this, [line]).geometry); 
     243            } 
     244            return new OpenLayers.Feature.Vector( 
     245                new OpenLayers.Geometry.MultiLineString(components) 
     246            ); 
    232247        }, 
    233248         
    234249        /** 
    235          * Return a polygon geometry given a polygon WKT fragment. 
     250         * Return a polygon feature given a polygon WKT fragment. 
    236251         * @param {String} A WKT fragment representing the polygon 
    237          * @returns {OpenLayers.Geometry.Polygon} A polygon geometry 
     252         * @returns {OpenLayers.Feature.Vector} A polygon feature 
     253         * @private 
    238254         */ 
    239255        'polygon': function(str) { 
    …… 
    243259            for(var i=0; i<rings.length; ++i) { 
    244260                ring = rings[i].replace(this.regExes.trimParens, '$1'); 
    245                 linestring = this.parse.linestring.apply(this, [ring]); 
    246                 linearring = new OpenLayers.Geometry.LinearRing(linestring.components); 
     261                linestring = this.parse.linestring.apply(this, [ring]).geometry; 
     262                linearring = new OpenLayers.Geometry.LinearRing(linestring.components) 
    247263                components.push(linearring); 
    248264            } 
    249             return new OpenLayers.Geometry.Polygon(components); 
    250         }, 
    251  
    252         /** 
    253          * Return a multipolygon geometry given a multipolygon WKT fragment. 
     265            return new OpenLayers.Feature.Vector( 
     266                new OpenLayers.Geometry.Polygon(components) 
     267            ); 
     268        }, 
     269 
     270        /** 
     271         * Return a multipolygon feature given a multipolygon WKT fragment. 
    254272         * @param {String} A WKT fragment representing the multipolygon 
    255          * @returns {OpenLayers.Geometry.MultiPolygon} A multipolygon geometry 
     273         * @returns {OpenLayers.Feature.Vector} A multipolygon feature 
     274         * @private 
    256275         */ 
    257276        'multipolygon': function(str) { 
    …… 
    261280            for(var i=0; i<polygons.length; ++i) { 
    262281                polygon = polygons[i].replace(this.regExes.trimParens, '$1'); 
    263                 components.push(this.parse.polygon.apply(this, [polygon])); 
    264             } 
    265             return new OpenLayers.Geometry.MultiPolygon(components); 
    266         }, 
    267  
    268         /** 
    269          * Return an array of geometries given a geometrycollection WKT fragment. 
     282                components.push(this.parse.polygon.apply(this, [polygon]).geometry); 
     283            } 
     284            return new OpenLayers.Feature.Vector(