postrunner 0.0.10 → 0.0.11

data/misc/openlayers/lib/OpenLayers/Control/DrawFeature.js

@@ -1,229 +0,0 @@
-/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for
- * full list of contributors). Published under the 2-clause BSD license.
- * See license.txt in the OpenLayers distribution or repository for the
- * full text of the license. */
-
-
-/**
- * @requires OpenLayers/Control.js
- * @requires OpenLayers/Feature/Vector.js
- */
-
-/**
- * Class: OpenLayers.Control.DrawFeature
- * The DrawFeature control draws point, line or polygon features on a vector
- * layer when active.
- *
- * Inherits from:
- *  - <OpenLayers.Control>
- */
-OpenLayers.Control.DrawFeature = OpenLayers.Class(OpenLayers.Control, {
-    
-    /**
-     * Property: layer
-     * {<OpenLayers.Layer.Vector>}
-     */
-    layer: null,
-
-    /**
-     * Property: callbacks
-     * {Object} The functions that are sent to the handler for callback
-     */
-    callbacks: null,
-    
-    /** 
-     * APIProperty: events
-     * {<OpenLayers.Events>} Events instance for listeners and triggering
-     *     control specific events.
-     *
-     * Register a listener for a particular event with the following syntax:
-     * (code)
-     * control.events.register(type, obj, listener);
-     * (end)
-     *
-     * Supported event types (in addition to those from <OpenLayers.Control.events>):
-     * featureadded - Triggered when a feature is added
-     */
-    
-    /**
-     * APIProperty: multi
-     * {Boolean} Cast features to multi-part geometries before passing to the
-     *     layer.  Default is false.
-     */
-    multi: false,
-
-    /**
-     * APIProperty: featureAdded
-     * {Function} Called after each feature is added
-     */
-    featureAdded: function() {},
-
-    /**
-     * APIProperty: handlerOptions
-     * {Object} Used to set non-default properties on the control's handler
-     */
-    
-    /**
-     * Constructor: OpenLayers.Control.DrawFeature
-     * 
-     * Parameters:
-     * layer - {<OpenLayers.Layer.Vector>} 
-     * handler - {<OpenLayers.Handler>} 
-     * options - {Object} 
-     */
-    initialize: function(layer, handler, options) {
-        OpenLayers.Control.prototype.initialize.apply(this, [options]);
-        this.callbacks = OpenLayers.Util.extend(
-            {
-                done: this.drawFeature,
-                modify: function(vertex, feature) {
-                    this.layer.events.triggerEvent(
-                        "sketchmodified", {vertex: vertex, feature: feature}
-                    );
-                },
-                create: function(vertex, feature) {
-                    this.layer.events.triggerEvent(
-                        "sketchstarted", {vertex: vertex, feature: feature}
-                    );
-                }
-            },
-            this.callbacks
-        );
-        this.layer = layer;
-        this.handlerOptions = this.handlerOptions || {};
-        this.handlerOptions.layerOptions = OpenLayers.Util.applyDefaults(
-            this.handlerOptions.layerOptions, {
-                renderers: layer.renderers, rendererOptions: layer.rendererOptions
-            }
-        );
-        if (!("multi" in this.handlerOptions)) {
-            this.handlerOptions.multi = this.multi;
-        }
-        var sketchStyle = this.layer.styleMap && this.layer.styleMap.styles.temporary;
-        if(sketchStyle) {
-            this.handlerOptions.layerOptions = OpenLayers.Util.applyDefaults(
-                this.handlerOptions.layerOptions,
-                {styleMap: new OpenLayers.StyleMap({"default": sketchStyle})}
-            );
-        }
-        this.handler = new handler(this, this.callbacks, this.handlerOptions);
-    },
-
-    /**
-     * Method: drawFeature
-     */
-    drawFeature: function(geometry) {
-        var feature = new OpenLayers.Feature.Vector(geometry);
-        var proceed = this.layer.events.triggerEvent(
-            "sketchcomplete", {feature: feature}
-        );
-        if(proceed !== false) {
-            feature.state = OpenLayers.State.INSERT;
-            this.layer.addFeatures([feature]);
-            this.featureAdded(feature);
-            this.events.triggerEvent("featureadded",{feature : feature});
-        }
-    },
-    
-    /**
-     * APIMethod: insertXY
-     * Insert a point in the current sketch given x & y coordinates.
-     *
-     * Parameters:
-     * x - {Number} The x-coordinate of the point.
-     * y - {Number} The y-coordinate of the point.
-     */
-    insertXY: function(x, y) {
-        if (this.handler && this.handler.line) {
-            this.handler.insertXY(x, y);
-        }
-    },
-
-    /**
-     * APIMethod: insertDeltaXY
-     * Insert a point given offsets from the previously inserted point.
-     *
-     * Parameters:
-     * dx - {Number} The x-coordinate offset of the point.
-     * dy - {Number} The y-coordinate offset of the point.
-     */
-    insertDeltaXY: function(dx, dy) {
-        if (this.handler && this.handler.line) {
-            this.handler.insertDeltaXY(dx, dy);
-        }
-    },
-
-    /**
-     * APIMethod: insertDirectionLength
-     * Insert a point in the current sketch given a direction and a length.
-     *
-     * Parameters:
-     * direction - {Number} Degrees clockwise from the positive x-axis.
-     * length - {Number} Distance from the previously drawn point.
-     */
-    insertDirectionLength: function(direction, length) {
-        if (this.handler && this.handler.line) {
-            this.handler.insertDirectionLength(direction, length);
-        }
-    },
-
-    /**
-     * APIMethod: insertDeflectionLength
-     * Insert a point in the current sketch given a deflection and a length.
-     *     The deflection should be degrees clockwise from the previously 
-     *     digitized segment.
-     *
-     * Parameters:
-     * deflection - {Number} Degrees clockwise from the previous segment.
-     * length - {Number} Distance from the previously drawn point.
-     */
-    insertDeflectionLength: function(deflection, length) {
-        if (this.handler && this.handler.line) {
-            this.handler.insertDeflectionLength(deflection, length);
-        }
-    },
-    
-    /**
-     * APIMethod: undo
-     * Remove the most recently added point in the current sketch geometry.
-     *
-     * Returns: 
-     * {Boolean} An edit was undone.
-     */
-    undo: function() {
-        return this.handler.undo && this.handler.undo();
-    },
-    
-    /**
-     * APIMethod: redo
-     * Reinsert the most recently removed point resulting from an <undo> call.
-     *     The undo stack is deleted whenever a point is added by other means.
-     *
-     * Returns: 
-     * {Boolean} An edit was redone.
-     */
-    redo: function() {
-        return this.handler.redo && this.handler.redo();
-    },
-    
-    /**
-     * APIMethod: finishSketch
-     * Finishes the sketch without including the currently drawn point.
-     *     This method can be called to terminate drawing programmatically
-     *     instead of waiting for the user to end the sketch.
-     */
-    finishSketch: function() {
-        this.handler.finishGeometry();
-    },
-
-    /**
-     * APIMethod: cancel
-     * Cancel the current sketch.  This removes the current sketch and keeps
-     *     the drawing control active.
-     */
-    cancel: function() {
-        this.handler.cancel();
-    },
-
-    CLASS_NAME: "OpenLayers.Control.DrawFeature"
-});

data/misc/openlayers/lib/OpenLayers/Control/EditingToolbar.js

@@ -1,81 +0,0 @@
-/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for
- * full list of contributors). Published under the 2-clause BSD license.
- * See license.txt in the OpenLayers distribution or repository for the
- * full text of the license. */
-
-/**
- * @requires OpenLayers/Control/Panel.js
- * @requires OpenLayers/Control/Navigation.js
- * @requires OpenLayers/Control/DrawFeature.js
- * @requires OpenLayers/Handler/Point.js
- * @requires OpenLayers/Handler/Path.js
- * @requires OpenLayers/Handler/Polygon.js
- */
-
-/**
- * Class: OpenLayers.Control.EditingToolbar 
- * The EditingToolbar is a panel of 4 controls to draw polygons, lines, 
- * points, or to navigate the map by panning. By default it appears in the 
- * upper right corner of the map.
- * 
- * Inherits from:
- *  - <OpenLayers.Control.Panel>
- */
-OpenLayers.Control.EditingToolbar = OpenLayers.Class(
-  OpenLayers.Control.Panel, {
-
-    /**
-     * APIProperty: citeCompliant
-     * {Boolean} If set to true, coordinates of features drawn in a map extent
-     * crossing the date line won't exceed the world bounds. Default is false.
-     */
-    citeCompliant: false,
-
-    /**
-     * Constructor: OpenLayers.Control.EditingToolbar
-     * Create an editing toolbar for a given layer. 
-     *
-     * Parameters:
-     * layer - {<OpenLayers.Layer.Vector>} 
-     * options - {Object} 
-     */
-    initialize: function(layer, options) {
-        OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]);
-        
-        this.addControls(
-          [ new OpenLayers.Control.Navigation() ]
-        );  
-        var controls = [
-            new OpenLayers.Control.DrawFeature(layer, OpenLayers.Handler.Point, {
-                displayClass: 'olControlDrawFeaturePoint',
-                handlerOptions: {citeCompliant: this.citeCompliant}
-            }),
-            new OpenLayers.Control.DrawFeature(layer, OpenLayers.Handler.Path, {
-                displayClass: 'olControlDrawFeaturePath',
-                handlerOptions: {citeCompliant: this.citeCompliant}
-            }),
-            new OpenLayers.Control.DrawFeature(layer, OpenLayers.Handler.Polygon, {
-                displayClass: 'olControlDrawFeaturePolygon',
-                handlerOptions: {citeCompliant: this.citeCompliant}
-            })
-        ];
-        this.addControls(controls);
-    },
-
-    /**
-     * Method: draw
-     * calls the default draw, and then activates mouse defaults.
-     *
-     * Returns:
-     * {DOMElement}
-     */
-    draw: function() {
-        var div = OpenLayers.Control.Panel.prototype.draw.apply(this, arguments);
-        if (this.defaultControl === null) {
-            this.defaultControl = this.controls[0];
-        }
-        return div;
-    },
-
-    CLASS_NAME: "OpenLayers.Control.EditingToolbar"
-});    

data/misc/openlayers/lib/OpenLayers/Control/Geolocate.js

@@ -1,192 +0,0 @@
-/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for
- * full list of contributors). Published under the 2-clause BSD license.
- * See license.txt in the OpenLayers distribution or repository for the
- * full text of the license. */
-
-/**
- * @requires OpenLayers/Control.js
- * @requires OpenLayers/Geometry/Point.js
- * @requires OpenLayers/Projection.js
- */
-
-/**
- * Class: OpenLayers.Control.Geolocate
- * The Geolocate control wraps w3c geolocation API into control that can be
- * bound to a map, and generate events on location update
- *
- * To use this control requires to load the proj4js library if the projection
- * of the map is not EPSG:4326 or EPSG:900913.
- *
- * Inherits from:
- *  - <OpenLayers.Control>
- */
-OpenLayers.Control.Geolocate = OpenLayers.Class(OpenLayers.Control, {
-
-    /** 
-     * APIProperty: events
-     * {<OpenLayers.Events>} Events instance for listeners and triggering
-     *     control specific events.
-     *
-     * Register a listener for a particular event with the following syntax:
-     * (code)
-     * control.events.register(type, obj, listener);
-     * (end)
-     *
-     * Supported event types (in addition to those from <OpenLayers.Control.events>):
-     * locationupdated - Triggered when browser return a new position. Listeners will 
-     *     receive an object with a 'position' property which is the browser.geolocation.position
-     *     native object, as well as a 'point' property which is the location transformed in the 
-     *     current map projection.
-     * locationfailed - Triggered when geolocation has failed
-     * locationuncapable - Triggered when control is activated on a browser
-     *     which doesn't support geolocation
-     */
-
-    /**
-     * Property: geolocation
-     * {Object} The geolocation engine, as a property to be possibly mocked.
-     * This is set lazily to avoid a memory leak in IE9.
-     */
-    geolocation: null,
-
-    /**
-     * Property: available
-     * {Boolean} The navigator.geolocation object is available.
-     */
-    available: ('geolocation' in navigator),
-
-    /**
-     * APIProperty: bind
-     * {Boolean} If true, map center will be set on location update.
-     */
-    bind: true,
-
-    /**
-     * APIProperty: watch
-     * {Boolean} If true, position will be update regularly.
-     */
-    watch: false,
-
-    /**
-     * APIProperty: geolocationOptions
-     * {Object} Options to pass to the navigator's geolocation API. See
-     *     <http://dev.w3.org/geo/api/spec-source.html>. No specific
-     *     option is passed to the geolocation API by default.
-     */
-    geolocationOptions: null,
-
-    /**
-     * Constructor: OpenLayers.Control.Geolocate
-     * Create a new control to deal with browser geolocation API
-     *
-     */
-
-    /**
-     * Method: destroy
-     */
-    destroy: function() {
-        this.deactivate();
-        OpenLayers.Control.prototype.destroy.apply(this, arguments);
-    },
-
-    /**
-     * Method: activate
-     * Activates the control.
-     *
-     * Returns:
-     * {Boolean} The control was effectively activated.
-     */
-    activate: function () {
-        if (this.available && !this.geolocation) {
-            // set lazily to avoid IE9 memory leak
-            this.geolocation = navigator.geolocation;
-        }
-        if (!this.geolocation) {
-            this.events.triggerEvent("locationuncapable");
-            return false;
-        }
-        if (OpenLayers.Control.prototype.activate.apply(this, arguments)) {
-            if (this.watch) {
-                this.watchId = this.geolocation.watchPosition(
-                    OpenLayers.Function.bind(this.geolocate, this),
-                    OpenLayers.Function.bind(this.failure, this),
-                    this.geolocationOptions
-                );
-            } else {
-                this.getCurrentLocation();
-            }
-            return true;
-        }
-        return false;
-    },
-
-    /**
-     * Method: deactivate
-     * Deactivates the control.
-     *
-     * Returns:
-     * {Boolean} The control was effectively deactivated.
-     */
-    deactivate: function () {
-        if (this.active && this.watchId !== null) {
-            this.geolocation.clearWatch(this.watchId);
-        }
-        return OpenLayers.Control.prototype.deactivate.apply(
-            this, arguments
-        );
-    },
-
-    /**
-     * Method: geolocate
-     * Activates the control.
-     *
-     */
-    geolocate: function (position) {
-        var center = new OpenLayers.LonLat(
-            position.coords.longitude,
-            position.coords.latitude
-        ).transform(
-            new OpenLayers.Projection("EPSG:4326"),
-            this.map.getProjectionObject()
-        );
-        if (this.bind) {
-            this.map.setCenter(center);
-        }
-        this.events.triggerEvent("locationupdated", {
-            position: position,
-            point: new OpenLayers.Geometry.Point(
-                center.lon, center.lat
-            )
-        });
-    },
-
-    /**
-     * APIMethod: getCurrentLocation
-     *
-     * Returns:
-     * {Boolean} Returns true if a event will be fired (successfull
-     * registration)
-     */
-    getCurrentLocation: function() {
-        if (!this.active || this.watch) {
-            return false;
-        }
-        this.geolocation.getCurrentPosition(
-            OpenLayers.Function.bind(this.geolocate, this),
-            OpenLayers.Function.bind(this.failure, this),
-            this.geolocationOptions
-        );
-        return true;
-    },
-
-    /**
-     * Method: failure
-     * method called on browser's geolocation failure
-     *
-     */
-    failure: function (error) {
-        this.events.triggerEvent("locationfailed", {error: error});
-    },
-
-    CLASS_NAME: "OpenLayers.Control.Geolocate"
-});