Ticket #927: KML.js.patch

/home/dcorpataux/workspace/openlayers/lib/OpenLayers/Format/KML.js

@@ -1 @@
-modified 
-pository
+
+lease
- * for the full text of the license. */
-
-/**
@@ -6 +6 @@
- * @requires OpenLayers/Format.js
- * @requires OpenLayers/Feature/Vector.js
- * @requires OpenLayers/Ajax.js
+ *
+ * Class: OpenLayers.Format.KML
+ * Read/Wite KML. Create a new instance with the <OpenLayers.Format.KML>
+ *     constructor. 
- * 
- * Class: OpenLayers.Format.KML
- * Read only KML. Largely Proof of Concept: does not support advanced Features,
- *     including Polygons.  Create a new instance with the 
- *     <OpenLayers.Format.KML> constructor.
- *
- * Inherits from:
- *  - <OpenLayers.Format>
- */
-
+
+
+
-    
-    /**
-     * APIProperty: kmlns
@@ -23 +24 @@
-     */
-    kmlns: "http://earth.google.com/kml/2.0",
-    
+    /** 
+     * APIProperty: placemarksDesc
+     * Name of the placemarks.
+     */
+    placemarksDesc: "No description available",
+    
+    /** 
+     * APIProperty: foldersName
+     * Name of the folders.
+     */
+    foldersName: "OpenLayers export",
+    
+    /** 
+     * APIProperty: foldersDesc
+     * Description of the folders.
+     */
+    foldersDesc: "Exported on " + new Date(),
+    
-    /**
-     * Constructor: OpenLayers.Format.KML
-     * Create a new parser for KML
@@ -40 +59 @@
-     * Read data from a string, and return a list of features. 
-     * 
-     * Parameters: 
-
+<
-     */
-     read: function(data) {
- 
-    
-
-OpenLayers.Ajax.getElementsByTagNameNS(data, this.kmlns, ""
-
+
+   
+        
+this.getElementsByTagNameNS(data, this.kmlns
+
-        var features = [];
-        
-        // Process all the featureMembers
@@ -77 +96 @@
-        var feature = new OpenLayers.Feature.Vector();
-
-        // match Point
-
-
-
-
-
+
+
-            p = this.parseCoords(point);
-            if (p.points) {
-                geom = p.points[0];
@@ -90 +106 @@
-            }
-        
-        // match LineString 
-
-
-
-
+
+
-            p = this.parseCoords(linestring);
-            if (p.points) {
-                geom = new OpenLayers.Geometry.LineString(p.points);
@@ -100 +114 @@
-                // TBD Bounds only set for one of multiple geometries
-                geom.extendBounds(p.bounds);
-            }
+
+        // match Polygon 
+        } else if (this.getElementsByTagNameNS(xmlNode, this.kmlns, "Polygon").length != 0) {
+            var polygon = this.getElementsByTagNameNS(xmlNode, this.kmlns, "Polygon")[0];
+            p = this.parseCoords(polygon);
+            if (p.points) {
+                var linearRing = new OpenLayers.Geometry.LinearRing(p.points);
+                geom = new OpenLayers.Geometry.Polygon(linearRing);
+                // TBD Bounds only set for one of multiple geometries
+                geom.extendBounds(p.bounds);
+            }
-        }
-        
-        feature.geometry = geom;
@@ -156 +181 @@
-        p.points = [];
-        // TBD: Need to handle an array of coordNodes not just coordNodes[0]
-        
-OpenLayers.Ajax.getElementsByTagNameNS(xmlNode, this.kmlns, ""
+this.getElementsByTagNameNS(xmlNode, this.kmlns
-        var coordString = OpenLayers.Util.getXmlNodeValue(coordNodes);
-        
-        var firstCoord = coordString.split(" ");
@@ -191 +216 @@
-        return p;
-    },
-
+    /**
+     * APIMethod: write
+     * Accept Feature Collection, and return a string. 
+     * 
+     * Parameters:
+     * features - An array of <OpenLayers.Feature.Vector> features.
+     */    
+     write: function(features) {
+        var kml = this.createElementNS(this.kmlns, "kml");
+        var folder = this.createFolderXML();
+        for (var i=0; i < features.length; i++) {
+            folder.appendChild(this.createPlacemarkXML(features[i]));
+        }
+        kml.appendChild(folder);
+        return (new OpenLayers.Format.XML).write(kml);
+     },
+
+    /**
+     * Method: createFolderXML
+     * Creates and returns a KML folder node
+     * 
+     * Returns:
+     * {<XMLNode>}
+     */
+    createFolderXML: function() {
+        // Folder name
+        var folderName = this.createElementNS(this.kmlns, "name");
+        var folderNameText = this.createTextNode(this.foldersName); 
+        folderName.appendChild(folderNameText);
+
+        // Folder description
+        var folderDesc = this.createElementNS(this.kmlns, "description");        
+        var folderDescText = this.createTextNode(this.foldersDesc); 
+        folderDesc.appendChild(folderDescText);
+
+        // Folder
+        var folder = this.createElementNS(this.kmlns, "Folder");
+        folder.appendChild(folderName);
+        folder.appendChild(folderDesc);
+        
+        return folder;
+    },
+
+    /**
+     * Method: createPlacemarkXML
+     * Creates and returns a KML placemark node representing the
+     * given feature. 
+     * 
+     * Parameters:
+     * feature - {<OpenLayers.Feature.Vector>}
+     * 
+     * Returns:
+     * {<XMLNode>}
+     */
+    createPlacemarkXML: function(feature) {
+        // Placemark name
+        var placemarkName = this.createElementNS(this.kmlns, "name");
+        var placemarkNameText = this.createTextNode(feature.id); 
+        placemarkName.appendChild(placemarkNameText);
+
+        // Placemark description
+        var placemarkDesc = this.createElementNS(this.kmlns, "description");
+        var placemarkDescText = this.createTextNode(this.placemarksDesc); 
+        placemarkDesc.appendChild(placemarkDescText);
+        
+        // Placemark
+        var placemarkNode = this.createElementNS(this.kmlns, "Placemark");
+        placemarkNode.appendChild(placemarkName);
+        placemarkNode.appendChild(placemarkDesc);
+
+        // Geometry node (Point, LineString, etc. nodes)
+        var geometryNode = this.buildGeometryNode(feature.geometry);
+        placemarkNode.appendChild(geometryNode);        
+        
+        return placemarkNode;
+    },    
+
+    /**
+     * Method: buildGeometryNode
+     * Builds and returns a KML geometry node with the given geometry
+     * 
+     * Parameters:
+     * geometry - {<OpenLayers.Geometry>}
+     * 
+     * Return:
+     * {<XMLNode>}
+     */
+    buildGeometryNode: function(geometry) {
+    // TBD test if geoserver can be given a Multi-geometry for a simple-geometry data store
+    // ie if multipolygon can be sent for a polygon feature type
+        var kml = "";
+        // match MultiPolygon or Polygon
+        if (geometry.CLASS_NAME == "OpenLayers.Geometry.MultiPolygon"
+            || geometry.CLASS_NAME == "OpenLayers.Geometry.Polygon") {
+                kml = this.createElementNS(this.kmlns, 'Polygon');
+                
+                var outerRing = this.createElementNS(this.kmlns, 'outerBoundaryIs');
+                var linearRing = this.createElementNS(this.kmlns, 'LinearRing');
+                
+                // TBD manage polygons with holes
+                linearRing.appendChild(this.buildCoordinatesNode(geometry.components[0]));
+                outerRing.appendChild(linearRing);
+                
+                kml.appendChild(outerRing);
+            }
+        // match MultiLineString or LineString
+        else if (geometry.CLASS_NAME == "OpenLayers.Geometry.MultiLineString"
+                 || geometry.CLASS_NAME == "OpenLayers.Geometry.LineString") {
+                     kml = this.createElementNS(this.kmlns, 'LineString');
+                                          
+                     kml.appendChild(this.buildCoordinatesNode(geometry));
+                 }
+        // match MultiPoint or Point
+        else if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point" || 
+                  geometry.CLASS_NAME == "OpenLayers.Geometry.MultiPoint") {                     
+                kml = this.createElementNS(this.kmlns, 'Point');
+
+                // FIXME: There should be only one Point node per Placemark node
+                var parts = "";
+                if (geometry.CLASS_NAME == "OpenLayers.Geometry.MultiPoint") {
+                    parts = geometry.components;
+                } else {
+                    parts = [geometry];
+                }    
+                
+                for (var i = 0; i < parts.length; i++) {
+                    kml.appendChild(this.buildCoordinatesNode(parts[i]));
+               }     
+        }
+        return kml;         
+    },
+
+    /**
+     * Method: buildGeometryNode
+     * Builds and returns the KML coordinates node with the given geometry
+     * <coordinates>...</coordinates>
+     * 
+     * Parameters:
+     * geometry - {<OpenLayers.Geometry>}
+     * 
+     * Return:
+     * {<XMLNode>}
+     */     
+    buildCoordinatesNode: function(geometry) {
+        var coordinatesNode = this.createElementNS(this.kmlns, "coordinates");
+        
+        var points = null;
+        if (geometry.components) {
+            points = geometry.components;
+        }
+
+        var path = "";
+        if (points) {
+            for (var i = 0; i < points.length; i++) {
+                path += points[i].x + "," + points[i].y + " ";
+            }
+        } else {
+           path += geometry.x + "," + geometry.y + " ";
+        }    
+        
+        var txtNode = this.createTextNode(path);
+        coordinatesNode.appendChild(txtNode);
+        
+        return coordinatesNode;
+    },    
+
+    /** @final @type String */
-    CLASS_NAME: "OpenLayers.Format.KML" 
-     
+