postrunner 0.0.10 → 0.0.11

data/misc/openlayers/lib/OpenLayers/Handler/Pinch.js

@@ -1,239 +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/Handler.js
- */
-
-/**
- * Class: OpenLayers.Handler.Pinch
- * The pinch handler is used to deal with sequences of browser events related
- *     to pinch gestures. The handler is used by controls that want to know
- *     when a pinch sequence begins, when a pinch is happening, and when it has
- *     finished.
- *
- * Controls that use the pinch handler typically construct it with callbacks
- *     for 'start', 'move', and 'done'.  Callbacks for these keys are
- *     called when the pinch begins, with each change, and when the pinch is
- *     done.
- *
- * Create a new pinch handler with the <OpenLayers.Handler.Pinch> constructor.
- *
- * Inherits from:
- *  - <OpenLayers.Handler>
- */
-OpenLayers.Handler.Pinch = OpenLayers.Class(OpenLayers.Handler, {
-
-    /**
-     * Property: started
-     * {Boolean} When a touchstart event is received, we want to record it,
-     *     but not set 'pinching' until the touchmove get started after
-     *     starting.
-     */
-    started: false,
-
-    /**
-     * Property: stopDown
-     * {Boolean} Stop propagation of touchstart events from getting to
-     *     listeners on the same element. Default is false.
-     */
-    stopDown: false,
-
-    /**
-     * Property: pinching
-     * {Boolean}
-     */
-    pinching: false,
-
-    /**
-     * Property: last
-     * {Object} Object that store informations related to pinch last touch.
-     */
-    last: null,
-
-    /**
-     * Property: start
-     * {Object} Object that store informations related to pinch touchstart.
-     */
-    start: null,
-
-    /**
-     * Constructor: OpenLayers.Handler.Pinch
-     * Returns OpenLayers.Handler.Pinch
-     *
-     * Parameters:
-     * control - {<OpenLayers.Control>} The control that is making use of
-     *     this handler.  If a handler is being used without a control, the
-     *     handlers setMap method must be overridden to deal properly with
-     *     the map.
-     * callbacks - {Object} An object containing functions to be called when
-     *     the pinch operation start, change, or is finished. The callbacks
-     *     should expect to receive an object argument, which contains
-     *     information about scale, distance, and position of touch points.
-     * options - {Object}
-     */
-
-    /**
-     * Method: touchstart
-     * Handle touchstart events
-     *
-     * Parameters:
-     * evt - {Event}
-     *
-     * Returns:
-     * {Boolean} Let the event propagate.
-     */
-    touchstart: function(evt) {
-        var propagate = true;
-        this.pinching = false;
-        if (OpenLayers.Event.isMultiTouch(evt)) {
-            this.started = true;
-            this.last = this.start = {
-                distance: this.getDistance(evt.touches),
-                delta: 0,
-                scale: 1
-            };
-            this.callback("start", [evt, this.start]);
-            propagate = !this.stopDown;
-        } else if (this.started) {
-            // Some webkit versions send fake single-touch events during
-            // multitouch, which cause the drag handler to trigger
-            return false;
-        } else {
-            this.started = false;
-            this.start = null;
-            this.last = null;
-        }
-        // prevent document dragging
-        OpenLayers.Event.preventDefault(evt);
-        return propagate;
-    },
-
-    /**
-     * Method: touchmove
-     * Handle touchmove events
-     *
-     * Parameters:
-     * evt - {Event}
-     *
-     * Returns:
-     * {Boolean} Let the event propagate.
-     */
-    touchmove: function(evt) {
-        if (this.started && OpenLayers.Event.isMultiTouch(evt)) {
-            this.pinching = true;
-            var current = this.getPinchData(evt);
-            this.callback("move", [evt, current]);
-            this.last = current;
-            // prevent document dragging
-            OpenLayers.Event.stop(evt);
-        } else if (this.started) {
-            // Some webkit versions send fake single-touch events during
-            // multitouch, which cause the drag handler to trigger
-            return false;
-        }
-        return true;
-    },
-
-    /**
-     * Method: touchend
-     * Handle touchend events
-     *
-     * Parameters:
-     * evt - {Event}
-     *
-     * Returns:
-     * {Boolean} Let the event propagate.
-     */
-    touchend: function(evt) {
-        if (this.started && !OpenLayers.Event.isMultiTouch(evt)) {
-            this.started = false;
-            this.pinching = false;
-            this.callback("done", [evt, this.start, this.last]);
-            this.start = null;
-            this.last = null;
-            return false;
-        }
-        return true;
-    },
-
-    /**
-     * Method: activate
-     * Activate the handler.
-     *
-     * Returns:
-     * {Boolean} The handler was successfully activated.
-     */
-    activate: function() {
-        var activated = false;
-        if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) {
-            this.pinching = false;
-            activated = true;
-        }
-        return activated;
-    },
-
-    /**
-     * Method: deactivate
-     * Deactivate the handler.
-     *
-     * Returns:
-     * {Boolean} The handler was successfully deactivated.
-     */
-    deactivate: function() {
-        var deactivated = false;
-        if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) {
-            this.started = false;
-            this.pinching = false;
-            this.start = null;
-            this.last = null;
-            deactivated = true;
-        }
-        return deactivated;
-    },
-
-    /**
-     * Method: getDistance
-     * Get the distance in pixels between two touches.
-     *
-     * Parameters:
-     * touches - {Array(Object)}
-     *
-     * Returns:
-     * {Number} The distance in pixels.
-     */
-    getDistance: function(touches) {
-        var t0 = touches[0];
-        var t1 = touches[1];
-        return Math.sqrt(
-            Math.pow(t0.olClientX - t1.olClientX, 2) +
-            Math.pow(t0.olClientY - t1.olClientY, 2)
-        );
-    },
-
-
-    /**
-     * Method: getPinchData
-     * Get informations about the pinch event.
-     *
-     * Parameters:
-     * evt - {Event}
-     *
-     * Returns:
-     * {Object} Object that contains data about the current pinch.
-     */
-    getPinchData: function(evt) {
-        var distance = this.getDistance(evt.touches);
-        var scale = distance / this.start.distance;
-        return {
-            distance: distance,
-            delta: this.last.distance - distance,
-            scale: scale
-        };
-    },
-
-    CLASS_NAME: "OpenLayers.Handler.Pinch"
-});
-

data/misc/openlayers/lib/OpenLayers/Handler/Point.js

@@ -1,556 +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/Handler.js
- * @requires OpenLayers/Geometry/Point.js
- */
-
-/**
- * Class: OpenLayers.Handler.Point
- * Handler to draw a point on the map. Point is displayed on activation,
- *     moves on mouse move, and is finished on mouse up. The handler triggers
- *     callbacks for 'done', 'cancel', and 'modify'. The modify callback is
- *     called with each change in the sketch and will receive the latest point
- *     drawn.  Create a new instance with the <OpenLayers.Handler.Point>
- *     constructor.
- * 
- * Inherits from:
- *  - <OpenLayers.Handler>
- */
-OpenLayers.Handler.Point = OpenLayers.Class(OpenLayers.Handler, {
-    
-    /**
-     * Property: point
-     * {<OpenLayers.Feature.Vector>} The currently drawn point
-     */
-    point: null,
-
-    /**
-     * Property: layer
-     * {<OpenLayers.Layer.Vector>} The temporary drawing layer
-     */
-    layer: null,
-    
-    /**
-     * APIProperty: multi
-     * {Boolean} Cast features to multi-part geometries before passing to the
-     *     layer.  Default is false.
-     */
-    multi: false,
-    
-    /**
-     * 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,
-    
-    /**
-     * Property: mouseDown
-     * {Boolean} The mouse is down
-     */
-    mouseDown: false,
-
-    /**
-     * Property: stoppedDown
-     * {Boolean} Indicate whether the last mousedown stopped the event
-     * propagation.
-     */
-    stoppedDown: null,
-
-    /**
-     * Property: lastDown
-     * {<OpenLayers.Pixel>} Location of the last mouse down
-     */
-    lastDown: null,
-
-    /**
-     * Property: lastUp
-     * {<OpenLayers.Pixel>}
-     */
-    lastUp: null,
-
-    /**
-     * APIProperty: persist
-     * {Boolean} Leave the feature rendered until destroyFeature is called.
-     *     Default is false.  If set to true, the feature remains rendered until
-     *     destroyFeature is called, typically by deactivating the handler or
-     *     starting another drawing.
-     */
-    persist: false,
-
-    /**
-     * APIProperty: stopDown
-     * {Boolean} Stop event propagation on mousedown. Must be false to
-     *     allow "pan while drawing". Defaults to false.
-     */
-    stopDown: false,
-
-    /**
-     * APIPropery: stopUp
-     * {Boolean} Stop event propagation on mouse. Must be false to
-     *     allow "pan while dragging". Defaults to fase.
-     */
-    stopUp: false,
-
-    /**
-     * Property: layerOptions
-     * {Object} Any optional properties to be set on the sketch layer.
-     */
-    layerOptions: null,
-    
-    /**
-     * APIProperty: pixelTolerance
-     * {Number} Maximum number of pixels between down and up (mousedown
-     *     and mouseup, or touchstart and touchend) for the handler to
-     *     add a new point. If set to an integer value, if the
-     *     displacement between down and up is great to this value
-     *     no point will be added. Default value is 5.
-     */
-    pixelTolerance: 5,
-
-    /**
-     * Property: lastTouchPx
-     * {<OpenLayers.Pixel>} The last pixel used to know the distance between
-     * two touches (for double touch).
-     */
-    lastTouchPx: null,
-
-    /**
-     * Constructor: OpenLayers.Handler.Point
-     * Create a new point handler.
-     *
-     * Parameters:
-     * control - {<OpenLayers.Control>} The control that owns this handler
-     * callbacks - {Object} An object with a properties whose values are
-     *     functions.  Various callbacks described below.
-     * options - {Object} An optional object with properties to be set on the
-     *           handler
-     *
-     * Named callbacks:
-     * create - Called when a sketch is first created.  Callback called with
-     *     the creation point geometry and sketch feature.
-     * modify - Called with each move of a vertex with the vertex (point)
-     *     geometry and the sketch feature.
-     * done - Called when the point drawing is finished.  The callback will
-     *     recieve a single argument, the point geometry.
-     * cancel - Called when the handler is deactivated while drawing.  The
-     *     cancel callback will receive a geometry.
-     */
-    initialize: function(control, callbacks, options) {
-        if(!(options && options.layerOptions && options.layerOptions.styleMap)) {
-            this.style = OpenLayers.Util.extend(OpenLayers.Feature.Vector.style['default'], {});
-        }
-
-        OpenLayers.Handler.prototype.initialize.apply(this, arguments);
-    },
-    
-    /**
-     * APIMethod: activate
-     * turn on the handler
-     */
-    activate: function() {
-        if(!OpenLayers.Handler.prototype.activate.apply(this, arguments)) {
-            return false;
-        }
-        // create temporary vector layer for rendering geometry sketch
-        // TBD: this could be moved to initialize/destroy - setting visibility here
-        var options = OpenLayers.Util.extend({
-            displayInLayerSwitcher: false,
-            // indicate that the temp vector layer will never be out of range
-            // without this, resolution properties must be specified at the
-            // map-level for this temporary layer to init its resolutions
-            // correctly
-            calculateInRange: OpenLayers.Function.True,
-            wrapDateLine: this.citeCompliant
-        }, this.layerOptions);
-        this.layer = new OpenLayers.Layer.Vector(this.CLASS_NAME, options);
-        this.map.addLayer(this.layer);
-        return true;
-    },
-    
-    /**
-     * Method: createFeature
-     * Add temporary features
-     *
-     * Parameters:
-     * pixel - {<OpenLayers.Pixel>} A pixel location on the map.
-     */
-    createFeature: function(pixel) {
-        var lonlat = this.layer.getLonLatFromViewPortPx(pixel); 
-        var geometry = new OpenLayers.Geometry.Point(
-            lonlat.lon, lonlat.lat
-        );
-        this.point = new OpenLayers.Feature.Vector(geometry);
-        this.callback("create", [this.point.geometry, this.point]);
-        this.point.geometry.clearBounds();
-        this.layer.addFeatures([this.point], {silent: true});
-    },
-
-    /**
-     * APIMethod: deactivate
-     * turn off the handler
-     */
-    deactivate: function() {
-        if(!OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) {
-            return false;
-        }
-        this.cancel();
-        // If a layer's map property is set to null, it means that that layer
-        // isn't added to the map. Since we ourself added the layer to the map
-        // in activate(), we can assume that if this.layer.map is null it means
-        // that the layer has been destroyed (as a result of map.destroy() for
-        // example.
-        if (this.layer.map != null) {
-            this.destroyFeature(true);
-            this.layer.destroy(false);
-        }
-        this.layer = null;
-        return true;
-    },
-    
-    /**
-     * Method: destroyFeature
-     * Destroy the temporary geometries
-     *
-     * Parameters:
-     * force - {Boolean} Destroy even if persist is true.
-     */
-    destroyFeature: function(force) {
-        if(this.layer && (force || !this.persist)) {
-            this.layer.destroyFeatures();
-        }
-        this.point = null;
-    },
-
-    /**
-     * Method: destroyPersistedFeature
-     * Destroy the persisted feature.
-     */
-    destroyPersistedFeature: function() {
-        var layer = this.layer;
-        if(layer && layer.features.length > 1) {
-            this.layer.features[0].destroy();
-        }
-    },
-
-    /**
-     * Method: finalize
-     * Finish the geometry and call the "done" callback.
-     *
-     * Parameters:
-     * cancel - {Boolean} Call cancel instead of done callback.  Default
-     *          is false.
-     */
-    finalize: function(cancel) {
-        var key = cancel ? "cancel" : "done";
-        this.mouseDown = false;
-        this.lastDown = null;
-        this.lastUp = null;
-        this.lastTouchPx = null;
-        this.callback(key, [this.geometryClone()]);
-        this.destroyFeature(cancel);
-    },
-
-    /**
-     * APIMethod: cancel
-     * Finish the geometry and call the "cancel" callback.
-     */
-    cancel: function() {
-        this.finalize(true);
-    },
-
-    /**
-     * Method: click
-     * Handle clicks.  Clicks are stopped from propagating to other listeners
-     *     on map.events or other dom elements.
-     * 
-     * Parameters:
-     * evt - {Event} The browser event
-     *
-     * Returns: 
-     * {Boolean} Allow event propagation
-     */
-    click: function(evt) {
-        OpenLayers.Event.stop(evt);
-        return false;
-    },
-
-    /**
-     * Method: dblclick
-     * Handle double-clicks.  Double-clicks are stopped from propagating to other
-     *     listeners on map.events or other dom elements.
-     * 
-     * Parameters:
-     * evt - {Event} The browser event
-     *
-     * Returns: 
-     * {Boolean} Allow event propagation
-     */
-    dblclick: function(evt) {
-        OpenLayers.Event.stop(evt);
-        return false;
-    },
-    
-    /**
-     * Method: modifyFeature
-     * Modify the existing geometry given a pixel location.
-     *
-     * Parameters:
-     * pixel - {<OpenLayers.Pixel>} A pixel location on the map.
-     */
-    modifyFeature: function(pixel) {
-        if(!this.point) {
-            this.createFeature(pixel);
-        }
-        var lonlat = this.layer.getLonLatFromViewPortPx(pixel); 
-        this.point.geometry.x = lonlat.lon;
-        this.point.geometry.y = lonlat.lat;
-        this.callback("modify", [this.point.geometry, this.point, false]);
-        this.point.geometry.clearBounds();
-        this.drawFeature();
-    },
-
-    /**
-     * Method: drawFeature
-     * Render features on the temporary layer.
-     */
-    drawFeature: function() {
-        this.layer.drawFeature(this.point, this.style);
-    },
-    
-    /**
-     * Method: getGeometry
-     * Return the sketch geometry.  If <multi> is true, this will return
-     *     a multi-part geometry.
-     *
-     * Returns:
-     * {<OpenLayers.Geometry.Point>}
-     */
-    getGeometry: function() {
-        var geometry = this.point && this.point.geometry;
-        if(geometry && this.multi) {
-            geometry = new OpenLayers.Geometry.MultiPoint([geometry]);
-        }
-        return geometry;
-    },
-
-    /**
-     * Method: geometryClone
-     * Return a clone of the relevant geometry.
-     *
-     * Returns:
-     * {<OpenLayers.Geometry>}
-     */
-    geometryClone: function() {
-        var geom = this.getGeometry();
-        return geom && geom.clone();
-    },
-
-    /**
-     * Method: mousedown
-     * Handle mousedown.
-     * 
-     * Parameters:
-     * evt - {Event} The browser event
-     *
-     * Returns: 
-     * {Boolean} Allow event propagation
-     */
-    mousedown: function(evt) {
-        return this.down(evt);
-    },
-
-    /**
-     * Method: touchstart
-     * Handle touchstart.
-     * 
-     * Parameters:
-     * evt - {Event} The browser event
-     *
-     * Returns: 
-     * {Boolean} Allow event propagation
-     */
-    touchstart: function(evt) {
-        this.startTouch();
-        this.lastTouchPx = evt.xy;
-        return this.down(evt);
-    },
-
-    /**
-     * Method: mousemove
-     * Handle mousemove.
-     * 
-     * Parameters:
-     * evt - {Event} The browser event
-     *
-     * Returns: 
-     * {Boolean} Allow event propagation
-     */
-    mousemove: function(evt) {
-        return this.move(evt);
-    },
-
-    /**
-     * Method: touchmove
-     * Handle touchmove.
-     * 
-     * Parameters:
-     * evt - {Event} The browser event
-     *
-     * Returns: 
-     * {Boolean} Allow event propagation
-     */
-    touchmove: function(evt) {
-        this.lastTouchPx = evt.xy;
-        return this.move(evt);
-    },
-
-    /**
-     * Method: mouseup
-     * Handle mouseup.
-     * 
-     * Parameters:
-     * evt - {Event} The browser event
-     *
-     * Returns: 
-     * {Boolean} Allow event propagation
-     */
-    mouseup: function(evt) {
-        return this.up(evt);
-    },
-
-    /**
-     * Method: touchend
-     * Handle touchend.
-     * 
-     * Parameters:
-     * evt - {Event} The browser event
-     *
-     * Returns: 
-     * {Boolean} Allow event propagation
-     */
-    touchend: function(evt) {
-        evt.xy = this.lastTouchPx;
-        return this.up(evt);
-    },
-  
-    /**
-     * Method: down
-     * Handle mousedown and touchstart.  Adjust the geometry and redraw.
-     * Return determines whether to propagate the event on the map.
-     * 
-     * Parameters:
-     * evt - {Event} The browser event
-     *
-     * Returns: 
-     * {Boolean} Allow event propagation
-     */
-    down: function(evt) {
-        this.mouseDown = true;
-        this.lastDown = evt.xy;
-        if(!this.touch) { // no point displayed until up on touch devices
-            this.modifyFeature(evt.xy);
-        }
-        this.stoppedDown = this.stopDown;
-        return !this.stopDown;
-    },
-
-    /**
-     * Method: move
-     * Handle mousemove and touchmove.  Adjust the geometry and redraw.
-     * Return determines whether to propagate the event on the map.
-     * 
-     * Parameters:
-     * evt - {Event} The browser event
-     *
-     * Returns: 
-     * {Boolean} Allow event propagation
-     */
-    move: function (evt) {
-        if(!this.touch // no point displayed until up on touch devices
-           && (!this.mouseDown || this.stoppedDown)) {
-            this.modifyFeature(evt.xy);
-        }
-        return true;
-    },
-
-    /**
-     * Method: up
-     * Handle mouseup and touchend.  Send the latest point in the geometry to the control.
-     * Return determines whether to propagate the event on the map.
-     *
-     * Parameters:
-     * evt - {Event} The browser event
-     *
-     * Returns: 
-     * {Boolean} Allow event propagation
-     */
-    up: function (evt) {
-        this.mouseDown = false;
-        this.stoppedDown = this.stopDown;
-
-        // check keyboard modifiers
-        if(!this.checkModifiers(evt)) {
-            return true;
-        }
-        // ignore double-clicks
-        if (this.lastUp && this.lastUp.equals(evt.xy)) {
-            return true;
-        }
-        if (this.lastDown && this.passesTolerance(this.lastDown, evt.xy,
-                                                  this.pixelTolerance)) {
-            if (this.touch) {
-                this.modifyFeature(evt.xy);
-            }
-            if(this.persist) {
-                this.destroyPersistedFeature();
-            }
-            this.lastUp = evt.xy;
-            this.finalize();
-            return !this.stopUp;
-        } else {
-            return true;
-        }
-    },
-
-    /**
-     * Method: mouseout
-     * Handle mouse out.  For better user experience reset mouseDown
-     * and stoppedDown when the mouse leaves the map viewport.
-     *
-     * Parameters:
-     * evt - {Event} The browser event
-     */
-    mouseout: function(evt) {
-        if(OpenLayers.Util.mouseLeft(evt, this.map.viewPortDiv)) {
-            this.stoppedDown = this.stopDown;
-            this.mouseDown = false;
-        }
-    },
-
-    /**
-     * Method: passesTolerance
-     * Determine whether the event is within the optional pixel tolerance.
-     *
-     * Returns:
-     * {Boolean} The event is within the pixel tolerance (if specified).
-     */
-    passesTolerance: function(pixel1, pixel2, tolerance) {
-        var passes = true;
-
-        if (tolerance != null && pixel1 && pixel2) {
-            var dist = pixel1.distanceTo(pixel2);
-            if (dist > tolerance) {
-                passes = false;
-            }
-        }
-        return passes;
-    },
-    
-    CLASS_NAME: "OpenLayers.Handler.Point"
-});