Adding support for write in the GPX format, r=marcjansen, (Closes #3495)

git-svn-id: http://svn.openlayers.org/trunk/openlayers@12370 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf

lib/OpenLayers/Format/GPX.js

@@ -20,6 +20,16 @@
  *  - <OpenLayers.Format.XML>
  */
 OpenLayers.Format.GPX = OpenLayers.Class(OpenLayers.Format.XML, {
+    
+
+    /** 
+     * APIProperty: defaultDesc
+     * {String} Default description for the waypoints/tracks in the case
+     *     where the feature has no "description" attribute.
+     *     Default is "No description available".
+     */
+    defaultDesc: "No description available",
+
    /**
     * APIProperty: extractWaypoints
     * {Boolean} Extract waypoints from GPX. (default: true)
@@ -45,6 +55,13 @@ OpenLayers.Format.GPX = OpenLayers.Class(OpenLayers.Format.XML, {
      *     be extracted.
      */
     extractAttributes: true,
+
+    /**
+     * APIProperty: gpxns
+     * {String} GPX namespace to use. Defaults to
+     *   "http://www.topografix.com/GPX/1/1"
+     */
+    gpxns: "http://www.topografix.com/GPX/1/1",
     
     /**
      * Constructor: OpenLayers.Format.GPX
@@ -179,6 +196,170 @@ OpenLayers.Format.GPX = OpenLayers.Class(OpenLayers.Format.XML, {
         }
         return attributes;
     },
+
+    /**
+     * APIMethod: write
+     * Accepts Feature Collection, and returns a string. 
+     * 
+     * Parameters: 
+     * features - {Array(<OpenLayers.Feature.Vector>)} List of features to serialize into a string.
+     * metadata - {Object} A key/value pairs object to build a metadata node to
+     *      add to the gpx. Supported keys are 'name', 'desc', 'author'.
+     */
+    write: function(features, metadata) {
+        var gpx;
+        features = OpenLayers.Util.isArray(features) ?
+            features : [features];
+        gpx = this.createElementNS(this.gpxns, "gpx");
+
+        for(var i=0, len=features.length; i<len; i++) {
+            gpx.appendChild(this.buildFeatureNode(features[i]));
+        }
+        if (metadata && typeof metadata == 'object') {
+            gpx.appendChild(this.buildMetadataNode(metadata));
+        }
+        return OpenLayers.Format.XML.prototype.write.apply(this, [gpx]);
+    },
+
+    /**
+     * Method: buildMetadataNode
+     * Creates a "metadata" node.
+     *
+     * Returns:
+     * {DOMElement}
+     */
+    buildMetadataNode: function(metadata) {
+        var types = ['name', 'desc', 'author'],
+            node = this.createElementNS(this.gpxns, 'metadata');
+        for (var i=0; i < types.length; i++) {
+            var type = types[i];
+            if (metadata[type]) {
+                var n = this.createElementNS(this.gpxns, type);
+                n.appendChild(this.createTextNode(metadata[type]));
+                node.appendChild(n);
+            }
+        }
+        return node;
+    },
+
+    /**
+     * Method: buildFeatureNode
+     * Accepts an <OpenLayers.Feature.Vector>, and builds a node for it.
+     * 
+     * Parameters:
+     * feature - {<OpenLayers.Feature.Vector>}
+     *
+     * Returns:
+     * {DOMElement} - The created node, either a 'wpt' or a 'trk'.
+     */
+    buildFeatureNode: function(feature) {
+        var geometry = feature.geometry;
+            geometry = geometry.clone();
+        if (this.internalProjection && this.externalProjection) {
+            geometry.transform(this.internalProjection, 
+                               this.externalProjection);
+        }
+        if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") {
+            var wpt = this.buildWptNode(feature);
+            return wpt;
+        } else {
+            var trkNode = this.createElementNS(this.gpxns, "trk");
+            this.appendAttributesNode(trkNode, feature);
+            var trkSegNodes = this.buildTrkSegNode(geometry);
+            trkSegNodes = OpenLayers.Util.isArray(trkSegNodes) ?
+                trkSegNodes : [trkSegNodes];
+            for (var i = 0, len = trkSegNodes.length; i < len; i++) {
+                trkNode.appendChild(trkSegNodes[i]);
+            }
+            return trkNode;
+        }
+    },
+
+    /**
+     * Method: buildTrkSegNode
+     * Builds trkseg node(s) given a geometry
+     *
+     * Parameters:
+     * trknode
+     * geometry - {OpenLayers.Geometry}
+     */
+    buildTrkSegNode: function(geometry) {
+        var node,
+            i,
+            len,
+            point,
+            nodes;
+        if (geometry.CLASS_NAME == "OpenLayers.Geometry.LineString" ||
+            geometry.CLASS_NAME == "OpenLayers.Geometry.LinearRing") {
+            node = this.createElementNS(this.gpxns, "trkseg");
+            for (i = 0, len=geometry.components.length; i < len; i++) {
+                point = geometry.components[i];
+                node.appendChild(this.buildTrkPtNode(point));
+            }
+            return node;
+        } else {
+            nodes = [];
+            for (i = 0, len = geometry.components.length; i < len; i++) {
+                nodes.push(this.buildTrkSegNode(geometry.components[i]));
+            }
+            return nodes;
+        }
+    },
     
+    /**
+     * Method: buildTrkPtNode
+     * Builds a trkpt node given a point 
+     *
+     * Parameters:
+     * line - {OpenLayers.Geometry.Point}
+     *
+     * Returns:
+     * {DOMElement} A trkpt node
+     */
+    buildTrkPtNode: function(point) {
+        var node = this.createElementNS(this.gpxns, "trkpt");
+        node.setAttribute("lon", point.x);
+        node.setAttribute("lat", point.y);
+        return node;
+    },
+
+    /**
+     * Method: buildWptNode
+     * Builds a wpt node given a point
+     *
+     * Parameters:
+     * feature - {OpenLayers.Feature.Vector}
+     *
+     * Returns:
+     * {DOMElement} A wpt node
+     */
+    buildWptNode: function(feature) {
+        var node = this.createElementNS(this.gpxns, "wpt");
+        node.setAttribute("lon", feature.geometry.x);
+        node.setAttribute("lat", feature.geometry.y);
+        this.appendAttributesNode(node, feature);
+        return node;
+    },
+
+    /**
+     * Method: appendAttributesNode
+     * Adds some attributes node.
+     *
+     * Parameters:
+     * node - {DOMElement} the node to append the attribute nodes to.
+     * feature - {OpenLayers.Feature.Vector}
+     */
+    appendAttributesNode: function(node, feature) {
+        var name = this.createElementNS(this.gpxns, 'name');
+        name.appendChild(this.createTextNode(
+            feature.attributes.name || feature.id));
+        node.appendChild(name);
+        var desc = this.createElementNS(this.gpxns, 'desc');
+        desc.appendChild(this.createTextNode(
+            feature.attributes.description || this.defaultDesc));
+        node.appendChild(desc);
+        // TBD - deal with remaining (non name/description) attributes.
+    },
+
     CLASS_NAME: "OpenLayers.Format.GPX"
 });