AtomPublishingProtocol: app.patch

tests/list-tests.html

@@ -60 +60 @@
-    <li>Tile/test_Image.html</li>
-    <li>test_Control.html</li>
-    <li>Control/test_DragFeature.html</li>
+    <li>Control/test_ModifyFeature.html</li>
-    <li>Control/test_DragPan.html</li>
-    <li>Control/test_OverviewMap.html</li>
-    <li>Control/test_NavToolbar.html</li>

lib/OpenLayers/Format/APP.js

@@ +1 @@
+/* Copyright (c) 2006-2007 MetaCarta, Inc., published under a modified BSD license.
+ * See http://svn.openlayers.org/trunk/openlayers/repository-license.txt 
+ * for the full text of the license. */
+
+/**
+ * @requires OpenLayers/Format.js
+ *
+ * Class: OpenLayers.Format.APP
+ * Write-only APP. Create a new instance with the 
+ *     <OpenLayers.Format.APP> constructor.
+ *
+ * Inherits from:
+ *  - <OpenLayers.Format>
+ */
+OpenLayers.Format.APP = OpenLayers.Class(OpenLayers.Format.XML, {
+    
+    /**
+     * APIProperty: rssns
+     * RSS namespace to use.
+     */
+    rssns: "http://backend.userland.com/rss2",
+    
+    /**
+     * APIProperty: featurens
+     * Feature Attributes namespace
+     */
+    featureNS: "http://mapserver.gis.umn.edu/mapserver",
+    
+    /**
+     * APIProperty: georssns
+     * APP namespace to use.
+     */
+    georssns: "http://www.georss.org/georss",
+    
+    
+    /**
+     * Constructor: OpenLayers.Format.APP
+     * Create a new parser for APP
+     *
+     * Parameters:
+     * options - {Object} An optional object whose properties will be set on
+     *                    this instance.
+     */
+    initialize: function(options) {
+        OpenLayers.Format.prototype.initialize.apply(this, [options]);
+    },
+    
+    /**
+     * APIMethod: read
+     * Return a list of features from a APP doc
+     
+     * Parameters:
+     * data - {Element} 
+     *
+     * Returns:
+     * An Array of <OpenLayers.Feature.Vector>s
+     */
+    read: function(doc) {
+        if (typeof doc == "string") { 
+            doc = OpenLayers.Format.XML.prototype.read.apply(this, [doc]);
+        }
+
+        /* Try RSS items first, then Atom entries */
+        var itemlist = null;
+        itemlist = this.getElementsByTagNameNS(doc, '*', 'item');
+        if (itemlist.length == 0) {
+            itemlist = this.getElementsByTagNameNS(doc, '*', 'entry');
+        }
+        
+        var features = [];
+        for(var i=0; i<itemlist.length; i++) {
+            // this is horrendous - please change this
+            var point = OpenLayers.Util.getNodes(itemlist[i], 'georss:point');
+            var lat = OpenLayers.Util.getNodes(itemlist[i], 'geo:lat');
+            var lon = OpenLayers.Util.getNodes(itemlist[i], 'geo:long');
+            if (point.length > 0) {
+                var location = point[0].firstChild.nodeValue.trim().split(/\s+/);
+                
+                if (location.length !=2) {
+                    var location = point[0].firstChild.nodeValue.trim().split(/\s*,\s*/);
+                }
+            } else if (lat.length > 0 && lon.length > 0) {
+                var location = [parseFloat(lat[0].firstChild.nodeValue), parseFloat(lon[0].firstChild.nodeValue)];
+            } else {
+                continue;
+            }
+            var geometry = new OpenLayers.Geometry.Point(parseFloat(location[1]),
+                                                         parseFloat(location[0]));
+
+            /* Provide defaults for title and description */
+            var title = "Untitled";
+            try {
+                title = OpenLayers.Util.getNodes(itemlist[i], 
+                        "title")[0].firstChild.nodeValue;
+            }
+            catch (e) { title="Untitled"; }
+           
+            /* First try RSS descriptions, then Atom summaries */
+            var descr_nodes = this.getElementsByTagNameNS(itemlist[i],
+                                                          "*",
+                                                          "description");
+            if (descr_nodes.length == 0) {
+                descr_nodes = this.getElementsByTagNameNS(itemlist[i],
+                                                          "*",
+                                                          "summary");
+            }
+            var description = "No description.";
+            try {
+              description = descr_nodes[0].firstChild.nodeValue;
+            }
+            catch (e) { description="No description."; }
+
+            /* If no link URL is found in the first child node, try the
+               href attribute */
+            var link = null;
+            var edit_link = null;
+            try {
+                var link = OpenLayers.Util.getNodes(itemlist[i], "link")[0].firstChild.nodeValue;
+            }
+            catch (e) {
+                var link_list = OpenLayers.Util.getNodes(itemlist[i], "link");
+                for (var i = 0; i < link_list.length; i++) {
+                    var this_link = link_list[i];
+                    if (this_link.getAttribute("href") && this_link.getAttribute("rel") == "edit") {
+                        edit_link = this_link.getAttribute("href");
+                    }  else {
+                        link = this_link.getAttribute("href");
+                    }    
+                }    
+            }
+            
+            var data = {
+                "title": title,
+                "description": description,
+                "link": link,
+                "edit_link": edit_link
+            };
+            features.push(new OpenLayers.Feature.Vector(geometry, data));
+        }
+        return features;
+    },
+    
+
+    /**
+     * APIMethod: write
+     * Accept Feature Collection, and return a string. 
+     * 
+     * Parameters: 
+     * features - Array({<OpenLayers.Feature.Vector>}) List of features to serialize into a string.
+     */
+    write: function(features) {
+        var georss;
+        if(features instanceof Array) {
+            georss = this.createElementNS(this.rssns, "rss");
+            for(var i=0; i < features.length; i++) {
+                georss.appendChild(this.createFeatureXML(features[i]));
+            }
+        } else {
+            georss = this.createFeatureXML(features);
+        }
+        return OpenLayers.Format.XML.prototype.write.apply(this, [georss]);
+     },
+
+    /**
+     * Method: createFeatureXML
+     * Accept an <OpenLayers.Feature.Vector>, and build a geometry for it.
+     * 
+     * Parameters:
+     * feature - {<OpenLayers.Feature.Vector>} 
+     *
+     * Returns:
+     * {DOMElement}
+     */
+    createFeatureXML: function(feature) {
+        var geometryNode = this.buildGeometryNode(feature.geometry);
+        var featureNode = this.createElementNS(this.rssns, "item");
+        var titleNode = this.createElementNS(this.rssns, "title");
+        titleNode.appendChild(this.createTextNode(feature.attributes.title ? feature.attributes.title : ""));
+        var descNode = this.createElementNS(this.rssns, "description");
+        descNode.appendChild(this.createTextNode(feature.attributes.description ? feature.attributes.description : ""));
+        featureNode.appendChild(titleNode);
+        featureNode.appendChild(descNode);
+        for(var attr in feature.attributes) {
+            if (attr == "edit_link" || attr == "title" || attr == "description" ) { continue; }
+            var attrText = this.createTextNode(feature.attributes[attr]); 
+            var nodename = attr;
+            if (attr.search(":") != -1) {
+                nodename = attr.split(":")[1];
+            }    
+            var attrContainer = this.createElementNS(this.featureNS, "feature:"+nodename);
+            attrContainer.appendChild(attrText);
+            featureNode.appendChild(attrContainer);
+        }    
+        featureNode.appendChild(geometryNode);
+        return featureNode;
+    },    
+    
+    /** 
+     * Method: buildGeometryNode
+     * builds a APP node with a given geometry
+     * 
+     * Parameters:
+     * geometry - {<OpenLayers.Geometry>} 
+     */
+    buildGeometryNode: function(geometry) {
+        var gml = "";
+        // match MultiPolygon or Polygon
+        if (geometry.CLASS_NAME == "OpenLayers.Geometry.Polygon") {
+            gml = this.createElementNS(this.georssns, 'georss:polygon');
+            
+            gml.appendChild(this.buildCoordinatesNode(geometry.components[0]));
+        }
+        // match MultiLineString or LineString
+        else if (geometry.CLASS_NAME == "OpenLayers.Geometry.LineString") {
+            gml = this.createElementNS(this.georssns, 'georss:line');
+            
+            gml.appendChild(this.buildCoordinatesNode(geometry));
+        }
+        // match MultiPoint or Point
+        else if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") {
+            gml = this.createElementNS(this.georssns, 'georss:point');
+            gml.appendChild(this.buildCoordinatesNode(geometry));
+        } else {    
+            alert("Couldn't parse " + geometry.CLASS_NAME);
+        }  
+        return gml;         
+    },
+    
+    /** 
+     * Method: buildCoordinatesNode
+     * 
+     * Parameters:
+     * geometry - {<OpenLayers.Geometry>}
+     */
+    buildCoordinatesNode: function(geometry) {
+        var points = null;
+        
+        if (geometry.components) {
+            points = geometry.components;
+        }
+
+        var path = "";
+        if (points) {
+            for (var i = 0; i < points.length; i++) {
+                path += points[i].y + " " + points[i].x + " ";
+            }
+        } else {
+           path += geometry.y + " " + geometry.x + " ";
+        }
+        return this.createTextNode(path);
+    },
+
+    CLASS_NAME: "OpenLayers.Format.APP" 
+});     

lib/OpenLayers.js

@@ -139 +139 @@
-            "OpenLayers/Control/LayerSwitcher.js",
-            "OpenLayers/Control/DrawFeature.js",
-            "OpenLayers/Control/DragFeature.js",
+            "OpenLayers/Control/ModifyFeature.js",
-            "OpenLayers/Control/Panel.js",
-            "OpenLayers/Control/SelectFeature.js",
-            "OpenLayers/Geometry.js",
@@ -164 +165 @@
-            "OpenLayers/Format/GML.js",
-            "OpenLayers/Format/KML.js",
-            "OpenLayers/Format/GeoRSS.js",
+            "OpenLayers/Format/APP.js",
-            "OpenLayers/Format/JSON.js",
-            "OpenLayers/Format/GeoJSON.js",
-            "OpenLayers/Format/WFS.js",

examples/gml-layer.html

@@ -16 +16 @@
-        var map, layer;
-
-        function init(){
+            OpenLayers.ProxyHost = "/cgi-bin/proxy.cgi?url=";
-            map = new OpenLayers.Map('map');
-            layer = new OpenLayers.Layer.WMS( "OpenLayers WMS", 
-                    "http://labs.metacarta.com/wms/vmap0", {layers: 'basic'} );
-            map.addLayer(layer);
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        }
-        // -->
-    </script>