AtomPublishingProtocol: app.2.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/Control/ModifyFeature.js

@@ +1 @@
+/* Copyright (c) 2006 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/Control/DragFeature.js
+ * @requires OpenLayers/Control/SelectFeature.js
+ * @requires OpenLayers/Handler/Keyboard.js
+ * 
+ * Class: OpenLayers.Control.ModifyFeature
+ * Control to modify features.  When activated, a click renders the vertices
+ *     of a feature - these vertices can then be dragged.  By default, the
+ *     delete key will delete the vertex under the mouse.  New features are
+ *     added by dragging "virtual vertices" between vertices.  Create a new
+ *     control with the <OpenLayers.Control.ModifyFeature> constructor.
+ *
+ * Inherits From:
+ *  - <OpenLayers.Control>
+ */
+OpenLayers.Control.ModifyFeature = OpenLayers.Class(OpenLayers.Control, {
+
+    /**
+     * APIProperty: geometryTypes
+     * {Array(String)} To restrict modification to a limited set of geometry
+     *     types, send a list of strings corresponding to the geometry class
+     *     names.
+     */
+    geometryTypes: null,
+
+    /**
+     * Property: layer
+     * {OpenLayers.Layer.Vector}
+     */
+    layer: null,
+    
+    /**
+     * Property: feature
+     * {<OpenLayers.Feature.Vector>} Feature currently available for modification.
+     */
+    feature: null,
+    
+    /**
+     * Property: vertices
+     * {Array(<OpenLayers.Feature.Vector>)} Verticies currently available
+     *     for dragging.
+     */
+    vertices: null,
+    
+    /**
+     * Property: virtualVertices
+     * {Array(<OpenLayers.Feature.Vector>)} Virtual vertices in the middle
+     *     of each edge.
+     */
+    virtualVertices: null,
+
+    /**
+     * Property: selectControl
+     * {<OpenLayers.Control.Select>}
+     */
+    selectControl: null,
+    
+    /**
+     * Property: dragControl
+     * {<OpenLayers.Control.DragFeature>}
+     */
+    dragControl: null,
+    
+    /**
+     * Property: keyboardHandler
+     * {<OpenLayers.Handler.Keyboard>}
+     */
+    keyboardHandler: null,
+    
+    /**
+     * APIProperty: deleteCodes
+     * {Array(Integer)} Keycodes for deleting verticies.  Set to null to disable
+     *     vertex deltion by keypress.  If non-null, keypresses with codes
+     *     in this array will delete vertices under the mouse. Default
+     *     is 46 and 100, the 'delete' and lowercase 'd' keys.
+     */
+    deleteCodes: null,
+
+    /**
+     * APIProperty: virtualStyle
+     * {<OpenLayers.Feature.Vector.Style>}
+     */
+    virtualStyle: null,
+    
+    /**
+     * APIProperty: onModificationStart 
+     * {Function} Optional function to be called when a feature is selected
+     *     to be modified. The function should expect to be called with a
+     *     feature.  This could be used for example to allow to lock the
+     *     feature on server-side.
+     */
+    onModificationStart: function() {},
+
+    /**
+     * APIProperty: onModification
+     * {Function} Optional function to be called when a feature has been
+     *     modified.  The function should expect to be called with a feature.
+     */
+    onModification: function() {},
+
+    /**
+     * APIProperty: onModificationEnd
+     * {Function} Optional function to be called when a feature is finished 
+     *     being modified.  The function should expect to be called with a
+     *     feature.
+     */
+    onModificationEnd: function() {},
+    
+    /**
+     * Constructor: OpenLayers.Control.ModifyFeature
+     * Create a new modify feature control.
+     *
+     * Parameters:
+     * layer - {OpenLayers.Layer.Vector} Layer that contains features that
+     *     will be modified.
+     * options - {Object} Optional object whose properties will be set on the
+     *     control.
+     */
+    initialize: function(layer, options) {
+        this.layer = layer;
+        this.vertices = [];
+        this.virtualVertices = [];
+        this.styleVirtual = OpenLayers.Util.extend({}, this.layer.style);
+        this.styleVirtual.fillOpacity = 0.3;
+        this.styleVirtual.strokeOpacity = 0.3;
+        this.deleteCodes = [46, 100];
+        OpenLayers.Control.prototype.initialize.apply(this, [options]);
+        if(!(this.deleteCodes instanceof Array)) {
+            this.deleteCodes = [this.deleteCodes];
+        }
+        var control = this;
+
+        // configure the select control
+        var selectOptions = {
+            geometryTypes: this.geometryTypes,
+            onSelect: function(feature) {
+                control.selectFeature.apply(control, [feature]);
+            },
+            onUnselect: function(feature) {
+                control.unselectFeature.apply(control, [feature]);
+            }
+        };
+        this.selectControl = new OpenLayers.Control.SelectFeature(
+            layer, selectOptions
+        );
+
+        // configure the drag control
+        var dragOptions = {
+            geometryTypes: ["OpenLayers.Geometry.Point"],
+            snappingOptions: this.snappingOptions,
+            onStart: function(feature, pixel) {
+                control.dragStart.apply(control, [feature, pixel]);
+            },
+            onDrag: function(feature) {
+                control.dragVertex.apply(control, [feature]);
+            },
+            onComplete: function(feature) {
+                control.dragComplete.apply(control, [feature]);
+            }
+        };
+        this.dragControl = new OpenLayers.Control.DragFeature(
+            layer, dragOptions
+        );
+
+        // configure the keyboard handler
+        var keyboardOptions = {
+            keypress: this.handleKeypress
+        };
+        this.keyboardHandler = new OpenLayers.Handler.Keyboard(
+            this, keyboardOptions
+        );
+    },
+
+    /**
+     * APIMethod: destroy
+     * Take care of things that are not handled in superclass.
+     */
+    destroy: function() {
+        this.layer = null;
+        this.selectControl.destroy();
+        this.dragControl.destroy();
+        this.keyboardHandler.destroy();
+        OpenLayers.Control.prototype.destroy.apply(this, []);
+    },
+
+    /**
+     * APIMethod: activate
+     * Activate the control and the feature handler.
+     * 
+     * Returns:
+     * {Boolean} Successfully activated the control and feature handler.
+     */
+    activate: function() {
+        return (this.selectControl.activate() &&
+                this.keyboardHandler.activate() &&
+                OpenLayers.Control.prototype.activate.apply(this, arguments));
+    },
+
+    /**
+     * APIMethod: deactivate
+     * Deactivate the controls.
+     *
+     * Returns: 
+     * {Boolean} Successfully deactivated the control.
+     */
+    deactivate: function() {
+        var deactivated = false;
+        // the return from the controls is unimportant in this case
+        if(OpenLayers.Control.prototype.deactivate.apply(this, arguments)) {
+            this.layer.removeFeatures(this.vertices);
+            this.layer.removeFeatures(this.virtualVertices);
+            this.vertices = [];
+            this.dragControl.deactivate();
+            if(this.feature) {
+                this.selectControl.unselect.apply(this.selectControl,
+                                                  [this.feature]);
+            }
+            this.selectControl.deactivate();
+            this.keyboardHandler.deactivate();
+            deactivated = true;
+        }
+        return deactivated;
+    },
+
+    /**
+     * Method: selectFeature
+     * Called when the select feature control selects a feature.
+     *
+     * Parameters:
+     * feature - {<OpenLayers.Feature.Vector>} The selected feature.
+     */
+    selectFeature: function(feature) {
+        this.feature = feature;
+        this.resetVertices();
+        this.dragControl.activate();
+        this.onModificationStart(this.feature);
+    },
+
+    /**
+     * Method: unselectFeature
+     * Called when the select feature control unselects a feature.
+     *
+     * Parameters:
+     * feature - {<OpenLayers.Feature.Vector>} The unselected feature.
+     */
+    unselectFeature: function(feature) {
+        this.layer.removeFeatures(this.vertices);
+        this.layer.removeFeatures(this.virtualVertices);
+        this.vertices = [];
+        this.virtualVertices = [];
+        this.feature = null;
+        this.dragControl.deactivate();
+        this.onModificationEnd(feature);
+    },
+
+    /**
+     * Method: dragStart
+     * Called by the drag feature control with before a feature is dragged.
+     *     This method is used to differentiate between points and vertices
+     *     of higher order geometries.  This respects the <geometryTypes>
+     *     property and forces a select of points when the drag control is
+     *     already active (and stops events from propagating to the select
+     *     control).
+     *
+     * Parameters:
+     * feature - {<OpenLayers.Feature.Vector>} The point or vertex about to be
+     *     dragged.
+     * pixel - {<OpenLayers.Pixel>} Pixel location of the mouse event.
+     */
+    dragStart: function(feature, pixel) {
+        // only change behavior if the feature is not in the vertices array
+        if(feature != this.feature &&
+           OpenLayers.Util.indexOf(this.vertices, feature) == -1 &&
+           OpenLayers.Util.indexOf(this.virtualVertices, feature) == -1) {
+            if(this.feature) {
+                // unselect the currently selected feature
+                this.selectControl.clickFeature.apply(this.selectControl,
+                                                      [this.feature]);
+            }
+            // check any constraints on the geometry type
+            if(this.geometryTypes == null ||
+               OpenLayers.Util.indexOf(this.geometryTypes,
+                                       feature.geometry.CLASS_NAME) != -1) {
+                // select the point
+                this.selectControl.clickFeature.apply(this.selectControl,
+                                                      [feature]);
+                /**
+                 * TBD: These lines improve workflow by letting the user
+                 *     immediately start dragging after the mouse down.
+                 *     However, it is very ugly to be messing with controls
+                 *     and their handlers in this way.  I'd like a better
+                 *     solution if the workflow change is necessary.
+                 */
+                // prepare the point for dragging
+                this.dragControl.overFeature.apply(this.dragControl,
+                                                   [feature]);
+                this.dragControl.lastPixel = pixel;
+                this.dragControl.dragHandler.started = true;
+                this.dragControl.dragHandler.start = pixel;
+                this.dragControl.dragHandler.last = pixel;
+            }
+        }
+    },
+    
+    /**
+     * Method: dragVertex
+     * Called by the drag feature control with each drag move of a vertex.
+     *
+     * Parameters:
+     * vertex - {<OpenLayers.Feature.Vector>} The vertex being dragged.
+     */
+    dragVertex: function(vertex) {
+        if(this.feature.geometry.CLASS_NAME == "OpenLayers.Geometry.Point") {
+            if(this.feature != vertex) {
+                this.feature = vertex;
+            }
+        } else {
+            if(OpenLayers.Util.indexOf(this.virtualVertices, vertex) != -1) {
+                vertex.geometry.parent.addComponent(vertex.geometry,
+                                                    vertex._index);
+                delete vertex._index;
+                OpenLayers.Util.removeItem(this.virtualVertices, vertex);
+                this.layer.removeFeatures(vertex);
+            }
+        }
+        this.layer.drawFeature(this.feature, this.selectControl.selectStyle);
+        this.layer.removeFeatures(this.virtualVertices);
+        // keep the vertex on top so it gets the mouseout after dragging
+        // this should be removed in favor of an option to draw under or
+        // maintain node z-index
+        this.layer.drawFeature(vertex);
+    },
+    
+    /**
+     * Method: dragComplete
+     * Called by the drag feature control when the feature dragging is complete.
+     *
+     * Parameters:
+     * vertex - {<OpenLayers.Feature.Vector>} The vertex being dragged.
+     */
+    dragComplete: function(vertex) {
+        this.resetVertices();
+        this.onModification(this.feature);
+    },
+    
+    /**
+     * Method: resetVertices
+     */
+    resetVertices: function() {
+        if(this.vertices.length > 0) {
+            this.layer.removeFeatures(this.vertices);
+            this.vertices = [];
+        }
+        if(this.virtualVertices.length > 0) {
+            this.layer.removeFeatures(this.virtualVertices);
+            this.virtualVertices = [];
+        }
+        if(this.feature.geometry.CLASS_NAME != "OpenLayers.Geometry.Point") {
+            this.collectVertices(this.feature.geometry);
+            this.layer.addFeatures(this.vertices);
+            this.layer.addFeatures(this.virtualVertices);
+        }
+    },
+    
+    /**
+     * Method: handleKeypress
+     * Called by the feature handler on keypress.  This is used to delete
+     *     vertices and point features.  If the <deleteCode> property is set,
+     *     vertices and points will be deleted when a feature is selected
+     *     for modification and the mouse is over a vertex.
+     *
+     * Parameters:
+     * {Integer} Key code corresponding to the keypress event.
+     */
+    handleKeypress: function(code) {
+        // check for delete key
+        if(OpenLayers.Util.indexOf(this.deleteCodes, code) != -1) { 
+            var vertex = this.dragControl.feature;
+            if(vertex) {
+                if(this.feature.geometry.CLASS_NAME ==
+                   "OpenLayers.Geometry.Point") {
+                    // delete the point
+                    this.layer.removeFeatures([vertex]);
+                } else {
+                    if(OpenLayers.Util.indexOf(this.vertices, vertex) != -1) {
+                        // remove the vertex
+                        vertex.geometry.parent.removeComponent(vertex.geometry);
+                        this.layer.drawFeature(this.feature,
+                                               this.selectControl.selectStyle);
+                        this.resetVertices();
+                    }
+                }
+            }
+        }
+    },
+
+    /**
+     * Method: collectVertices
+     * Collect the vertices from the modifiable feature's geometry and push
+     *     them on to the control's vertices array.
+     */
+    collectVertices: function() {
+        this.vertices = [];
+        this.virtualVirtices = [];        
+        var control = this;
+        function collectComponentVertices(geometry) {
+            var i, vertex, component;
+            if(geometry.CLASS_NAME == "OpenLayers.Geometry.Point") {
+                vertex = new OpenLayers.Feature.Vector(geometry);
+                control.vertices.push(vertex);
+            } else {
+                for(i=0; i<geometry.components.length; ++i) {
+                    component = geometry.components[i];
+                    if(component.CLASS_NAME == "OpenLayers.Geometry.Point") {
+                        vertex = new OpenLayers.Feature.Vector(component);
+                        control.vertices.push(vertex);
+                    } else {
+                        collectComponentVertices(component);
+                    }
+                }
+                
+                // add virtual vertices in the middle of each edge
+                if(geometry.CLASS_NAME != "OpenLayers.Geometry.MultiPoint") {
+                    for(i=0; i<geometry.components.length-1; ++i) {
+                        var prevVertex = geometry.components[i];
+                        var nextVertex = geometry.components[i + 1];
+                        if(prevVertex.CLASS_NAME == "OpenLayers.Geometry.Point" &&
+                           nextVertex.CLASS_NAME == "OpenLayers.Geometry.Point") {
+                            var x = (prevVertex.x + nextVertex.x) / 2;
+                            var y = (prevVertex.y + nextVertex.y) / 2;
+                            var point = new OpenLayers.Feature.Vector(
+                                new OpenLayers.Geometry.Point(x, y),
+                                null, control.styleVirtual
+                            );
+                            // set the virtual parent and intended index
+                            point.geometry.parent = geometry;
+                            point._index = i + 1;
+                            control.virtualVertices.push(point);
+                        }
+                    }
+                }
+            }
+        }       
+        collectComponentVertices(this.feature.geometry);
+    },
+
+    /**
+     * Method: setMap
+     * Set the map property for the control and all handlers.
+     *
+     * Parameters:
+     * map - {OpenLayers.Map} The control's map.
+     */
+    setMap: function(map) {
+        this.selectControl.setMap(map);
+        this.dragControl.setMap(map);
+        OpenLayers.Control.prototype.setMap.apply(this, arguments);
+    },
+
+    CLASS_NAME: "OpenLayers.Control.ModifyFeature"
+});

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>