postrunner 0.0.10 → 0.0.11

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

@@ -1,182 +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/DragPan.js
- * @requires OpenLayers/Control/PinchZoom.js
- * @requires OpenLayers/Handler/Click.js
- */
-
-/**
- * Class: OpenLayers.Control.TouchNavigation
- * The navigation control handles map browsing with touch events (dragging,
- *     double-tapping, tap with two fingers, and pinch zoom).  Create a new 
- *     control with the <OpenLayers.Control.TouchNavigation> constructor.
- *
- * If you’re only targeting touch enabled devices with your mapping application,
- *     you can create a map with only a TouchNavigation control. The 
- *     <OpenLayers.Control.Navigation> control is mobile ready by default, but 
- *     you can generate a smaller build of the library by only including this
- *     touch navigation control if you aren't concerned about mouse interaction.
- *
- * Inherits:
- *  - <OpenLayers.Control>
- */
-OpenLayers.Control.TouchNavigation = OpenLayers.Class(OpenLayers.Control, {
-
-    /**
-     * Property: dragPan
-     * {<OpenLayers.Control.DragPan>}
-     */
-    dragPan: null,
-
-    /**
-     * APIProperty: dragPanOptions
-     * {Object} Options passed to the DragPan control.
-     */
-    dragPanOptions: null,
-
-    /**
-     * Property: pinchZoom
-     * {<OpenLayers.Control.PinchZoom>}
-     */
-    pinchZoom: null,
-
-    /**
-     * APIProperty: pinchZoomOptions
-     * {Object} Options passed to the PinchZoom control.
-     */
-    pinchZoomOptions: null,
-
-    /**
-     * APIProperty: clickHandlerOptions
-     * {Object} Options passed to the Click handler.
-     */
-    clickHandlerOptions: null,
-
-    /**
-     * APIProperty: documentDrag
-     * {Boolean} Allow panning of the map by dragging outside map viewport.
-     *     Default is false.
-     */
-    documentDrag: false,
-
-    /**
-     * APIProperty: autoActivate
-     * {Boolean} Activate the control when it is added to a map.  Default is
-     *     true.
-     */
-    autoActivate: true,
-
-    /**
-     * Constructor: OpenLayers.Control.TouchNavigation
-     * Create a new navigation control
-     *
-     * Parameters:
-     * options - {Object} An optional object whose properties will be set on
-     *                    the control
-     */
-    initialize: function(options) {
-        this.handlers = {};
-        OpenLayers.Control.prototype.initialize.apply(this, arguments);
-    },
-
-    /**
-     * Method: destroy
-     * The destroy method is used to perform any clean up before the control
-     * is dereferenced.  Typically this is where event listeners are removed
-     * to prevent memory leaks.
-     */
-    destroy: function() {
-        this.deactivate();
-        if(this.dragPan) {
-            this.dragPan.destroy();
-        }
-        this.dragPan = null;
-        if (this.pinchZoom) {
-            this.pinchZoom.destroy();
-            delete this.pinchZoom;
-        }
-        OpenLayers.Control.prototype.destroy.apply(this,arguments);
-    },
-
-    /**
-     * Method: activate
-     */
-    activate: function() {
-        if(OpenLayers.Control.prototype.activate.apply(this,arguments)) {
-            this.dragPan.activate();
-            this.handlers.click.activate();
-            this.pinchZoom.activate();
-            return true;
-        }
-        return false;
-    },
-
-    /**
-     * Method: deactivate
-     */
-    deactivate: function() {
-        if(OpenLayers.Control.prototype.deactivate.apply(this,arguments)) {
-            this.dragPan.deactivate();
-            this.handlers.click.deactivate();
-            this.pinchZoom.deactivate();
-            return true;
-        }
-        return false;
-    },
-    
-    /**
-     * Method: draw
-     */
-    draw: function() {
-        var clickCallbacks = {
-            click: this.defaultClick,
-            dblclick: this.defaultDblClick
-        };
-        var clickOptions = OpenLayers.Util.extend({
-            "double": true,
-            stopDouble: true,
-            pixelTolerance: 2
-        }, this.clickHandlerOptions);
-        this.handlers.click = new OpenLayers.Handler.Click(
-            this, clickCallbacks, clickOptions
-        );
-        this.dragPan = new OpenLayers.Control.DragPan(
-            OpenLayers.Util.extend({
-                map: this.map,
-                documentDrag: this.documentDrag
-            }, this.dragPanOptions)
-        );
-        this.dragPan.draw();
-        this.pinchZoom = new OpenLayers.Control.PinchZoom(
-            OpenLayers.Util.extend({map: this.map}, this.pinchZoomOptions)
-        );
-    },
-
-    /**
-     * Method: defaultClick
-     *
-     * Parameters:
-     * evt - {Event}
-     */
-    defaultClick: function (evt) {
-        if(evt.lastTouches && evt.lastTouches.length == 2) {
-            this.map.zoomOut();
-        }
-    },
-
-    /**
-     * Method: defaultDblClick
-     *
-     * Parameters:
-     * evt - {Event}
-     */
-    defaultDblClick: function (evt) {
-        this.map.zoomTo(this.map.zoom + 1, evt.xy);
-    },
-
-    CLASS_NAME: "OpenLayers.Control.TouchNavigation"
-});

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

@@ -1,624 +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/Control/DragFeature.js
- * @requires OpenLayers/Feature/Vector.js
- * @requires OpenLayers/Geometry/LineString.js
- * @requires OpenLayers/Geometry/Point.js
- */
-
-/**
- * Class: OpenLayers.Control.TransformFeature
- * Control to transform features with a standard transformation box.
- *
- * Inherits From:
- *  - <OpenLayers.Control>
- */
-OpenLayers.Control.TransformFeature = 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>):
-     * beforesetfeature - Triggered before a feature is set for
-     *     tranformation. The feature will not be set if a listener returns
-     *     false. Listeners receive a *feature* property, with the feature
-     *     that will be set for transformation. Listeners are allowed to
-     *     set the control's *scale*, *ratio* and *rotation* properties,
-     *     which will set the initial scale, ratio and rotation of the
-     *     feature, like the <setFeature> method's initialParams argument.
-     * setfeature - Triggered when a feature is set for tranformation.
-     *     Listeners receive a *feature* property, with the feature that
-     *     is now set for transformation.
-     * beforetransform - Triggered while dragging, before a feature is
-     *     transformed. The feature will not be transformed if a listener
-     *     returns false (but the box still will). Listeners receive one or
-     *     more of *center*, *scale*, *ratio* and *rotation*. The *center*
-     *     property is an <OpenLayers.Geometry.Point> object with the new
-     *     center of the transformed feature, the others are Floats with the
-     *     scale, ratio or rotation change since the last transformation.
-     * transform - Triggered while dragging, when a feature is transformed.
-     *     Listeners receive an event object with one or more of *center*,
-     *     scale*, *ratio* and *rotation*. The *center* property is an
-     *     <OpenLayers.Geometry.Point> object with the new center of the
-     *     transformed feature, the others are Floats with the scale, ratio
-     *     or rotation change of the feature since the last transformation.
-     * transformcomplete - Triggered after dragging. Listeners receive
-     *     an event object with the transformed *feature*.
-     */
-
-    /**
-     * APIProperty: geometryTypes
-     * {Array(String)} To restrict transformation 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,
-    
-    /**
-     * APIProperty: preserveAspectRatio
-     * {Boolean} set to true to not change the feature's aspect ratio.
-     */
-    preserveAspectRatio: false,
-    
-    /**
-     * APIProperty: rotate
-     * {Boolean} set to false if rotation should be disabled. Default is true.
-     *     To be passed with the constructor or set when the control is not
-     *     active.
-     */
-    rotate: true,
-    
-    /**
-     * APIProperty: feature
-     * {<OpenLayers.Feature.Vector>} Feature currently available for
-     *     transformation. Read-only, use <setFeature> to set it manually.
-     */
-    feature: null,
-    
-    /**
-     * APIProperty: renderIntent
-     * {String|Object} Render intent for the transformation box and
-     *     handles. A symbolizer object can also be provided here.
-     */
-    renderIntent: "temporary",
-    
-    /**
-     * APIProperty: rotationHandleSymbolizer
-     * {Object|String} Optional. A custom symbolizer for the rotation handles.
-     *     A render intent can also be provided here. Defaults to
-     *     (code)
-     *     {
-     *         stroke: false,
-     *         pointRadius: 10,
-     *         fillOpacity: 0,
-     *         cursor: "pointer"
-     *     }
-     *     (end)
-     */
-    rotationHandleSymbolizer: null,
-    
-    /**
-     * APIProperty: box
-     * {<OpenLayers.Feature.Vector>} The transformation box rectangle.
-     *     Read-only.
-     */
-    box: null,
-    
-    /**
-     * APIProperty: center
-     * {<OpenLayers.Geometry.Point>} The center of the feature bounds.
-     * Read-only.
-     */
-    center: null,
-    
-    /**
-     * APIProperty: scale
-     * {Float} The scale of the feature, relative to the scale the time the
-     *     feature was set. Read-only, except for *beforesetfeature*
-     *     listeners.
-     */
-    scale: 1,
-    
-    /**
-     * APIProperty: ratio
-     * {Float} The ratio of the feature relative to the ratio the time the
-     *     feature was set. Read-only, except for *beforesetfeature*
-     *     listeners.
-     */
-    ratio: 1,
-    
-    /**
-     * Property: rotation
-     * {Integer} the current rotation angle of the box. Read-only, except for
-     *     *beforesetfeature* listeners.
-     */
-    rotation: 0,
-    
-    /**
-     * APIProperty: handles
-     * {Array(<OpenLayers.Feature.Vector>)} The 8 handles currently available
-     *     for scaling/resizing. Numbered counterclockwise, starting from the
-     *     southwest corner. Read-only.
-     */
-    handles: null,
-    
-    /**
-     * APIProperty: rotationHandles
-     * {Array(<OpenLayers.Feature.Vector>)} The 4 rotation handles currently
-     *     available for rotating. Numbered counterclockwise, starting from
-     *     the southwest corner. Read-only.
-     */
-    rotationHandles: null,
-    
-    /**
-     * Property: dragControl
-     * {<OpenLayers.Control.DragFeature>}
-     */
-    dragControl: null,
-    
-    /**
-     * APIProperty: irregular
-     * {Boolean} Make scaling/resizing work irregularly. If true then
-     *     dragging a handle causes the feature to resize in the direction
-     *     of movement. If false then the feature resizes symetrically
-     *     about it's center.
-     */
-    irregular: false,
-    
-    /**
-     * Constructor: OpenLayers.Control.TransformFeature
-     * Create a new transform feature control.
-     *
-     * Parameters:
-     * layer - {<OpenLayers.Layer.Vector>} Layer that contains features that
-     *     will be transformed.
-     * options - {Object} Optional object whose properties will be set on the
-     *     control.
-     */
-    initialize: function(layer, options) {
-        OpenLayers.Control.prototype.initialize.apply(this, [options]);
-
-        this.layer = layer;
-
-        if(!this.rotationHandleSymbolizer) {
-            this.rotationHandleSymbolizer = {
-                stroke: false,
-                pointRadius: 10,
-                fillOpacity: 0,
-                cursor: "pointer"
-            };
-        }
-
-        this.createBox();
-        this.createControl();        
-    },
-    
-    /**
-     * APIMethod: activate
-     * Activates the control.
-     */
-    activate: function() {
-        var activated = false;
-        if(OpenLayers.Control.prototype.activate.apply(this, arguments)) {
-            this.dragControl.activate();
-            this.layer.addFeatures([this.box]);
-            this.rotate && this.layer.addFeatures(this.rotationHandles);
-            this.layer.addFeatures(this.handles);        
-            activated = true;
-        }
-        return activated;
-    },
-    
-    /**
-     * APIMethod: deactivate
-     * Deactivates the control.
-     */
-    deactivate: function() {
-        var deactivated = false;
-        if(OpenLayers.Control.prototype.deactivate.apply(this, arguments)) {
-            this.layer.removeFeatures(this.handles);
-            this.rotate && this.layer.removeFeatures(this.rotationHandles);
-            this.layer.removeFeatures([this.box]);
-            this.dragControl.deactivate();
-            deactivated = true;
-        }
-        return deactivated;
-    },
-    
-    /**
-     * Method: setMap
-     * 
-     * Parameters:
-     * map - {<OpenLayers.Map>}
-     */
-    setMap: function(map) {
-        this.dragControl.setMap(map);
-        OpenLayers.Control.prototype.setMap.apply(this, arguments);
-    },
-
-    /**
-     * APIMethod: setFeature
-     * Place the transformation box on a feature and start transforming it.
-     * If the control is not active, it will be activated.
-     * 
-     * Parameters:
-     * feature - {<OpenLayers.Feature.Vector>}
-     * initialParams - {Object} Initial values for rotation, scale or ratio.
-     *     Setting a rotation value here will cause the transformation box to
-     *     start rotated. Setting a scale or ratio will not affect the
-     *     transormation box, but applications may use this to keep track of
-     *     scale and ratio of a feature across multiple transforms.
-     */
-    setFeature: function(feature, initialParams) {
-        initialParams = OpenLayers.Util.applyDefaults(initialParams, {
-            rotation: 0,
-            scale: 1,
-            ratio: 1
-        });
-
-        var oldRotation = this.rotation;
-        var oldCenter = this.center;
-        OpenLayers.Util.extend(this, initialParams);
-
-        var cont = this.events.triggerEvent("beforesetfeature",
-            {feature: feature}
-        );
-        if (cont === false) {
-            return;
-        }
-
-        this.feature = feature;
-        this.activate();
-
-        this._setfeature = true;
-
-        var featureBounds = this.feature.geometry.getBounds();
-        this.box.move(featureBounds.getCenterLonLat());
-        this.box.geometry.rotate(-oldRotation, oldCenter);
-        this._angle = 0;
-
-        var ll;
-        if(this.rotation) {
-            var geom = feature.geometry.clone();
-            geom.rotate(-this.rotation, this.center);
-            var box = new OpenLayers.Feature.Vector(
-                geom.getBounds().toGeometry());
-            box.geometry.rotate(this.rotation, this.center);
-            this.box.geometry.rotate(this.rotation, this.center);
-            this.box.move(box.geometry.getBounds().getCenterLonLat());
-            var llGeom = box.geometry.components[0].components[0];
-            ll = llGeom.getBounds().getCenterLonLat();
-        } else {
-            ll = new OpenLayers.LonLat(featureBounds.left, featureBounds.bottom);
-        }
-        this.handles[0].move(ll);
-        
-        delete this._setfeature;
-
-        this.events.triggerEvent("setfeature", {feature: feature});
-    },
-    
-    /**
-     * APIMethod: unsetFeature
-     * Remove the transformation box off any feature.
-     * If the control is active, it will be deactivated first.
-     */
-    unsetFeature: function() {
-        if (this.active) {
-            this.deactivate();
-        } else {
-            this.feature = null;
-            this.rotation = 0;
-            this.scale = 1;
-            this.ratio = 1;
-        }
-    },
-    
-    /**
-     * Method: createBox
-     * Creates the box with all handles and transformation handles.
-     */
-    createBox: function() {
-        var control = this;
-        
-        this.center = new OpenLayers.Geometry.Point(0, 0);
-        this.box = new OpenLayers.Feature.Vector(
-            new OpenLayers.Geometry.LineString([
-                new OpenLayers.Geometry.Point(-1, -1),
-                new OpenLayers.Geometry.Point(0, -1),
-                new OpenLayers.Geometry.Point(1, -1),
-                new OpenLayers.Geometry.Point(1, 0),
-                new OpenLayers.Geometry.Point(1, 1),
-                new OpenLayers.Geometry.Point(0, 1),
-                new OpenLayers.Geometry.Point(-1, 1),
-                new OpenLayers.Geometry.Point(-1, 0),
-                new OpenLayers.Geometry.Point(-1, -1)
-            ]), null,
-            typeof this.renderIntent == "string" ? null : this.renderIntent
-        );
-        
-        // Override for box move - make sure that the center gets updated
-        this.box.geometry.move = function(x, y) {
-            control._moving = true;
-            OpenLayers.Geometry.LineString.prototype.move.apply(this, arguments);
-            control.center.move(x, y);
-            delete control._moving;
-        };
-
-        // Overrides for vertex move, resize and rotate - make sure that
-        // handle and rotationHandle geometries are also moved, resized and
-        // rotated.
-        var vertexMoveFn = function(x, y) {
-            OpenLayers.Geometry.Point.prototype.move.apply(this, arguments);
-            this._rotationHandle && this._rotationHandle.geometry.move(x, y);
-            this._handle.geometry.move(x, y);
-        };
-        var vertexResizeFn = function(scale, center, ratio) {
-            OpenLayers.Geometry.Point.prototype.resize.apply(this, arguments);
-            this._rotationHandle && this._rotationHandle.geometry.resize(
-                scale, center, ratio);
-            this._handle.geometry.resize(scale, center, ratio);
-        };
-        var vertexRotateFn = function(angle, center) {
-            OpenLayers.Geometry.Point.prototype.rotate.apply(this, arguments);
-            this._rotationHandle && this._rotationHandle.geometry.rotate(
-                angle, center);
-            this._handle.geometry.rotate(angle, center);
-        };
-        
-        // Override for handle move - make sure that the box and other handles
-        // are updated, and finally transform the feature.
-        var handleMoveFn = function(x, y) {
-            var oldX = this.x, oldY = this.y;
-            OpenLayers.Geometry.Point.prototype.move.call(this, x, y);
-            if(control._moving) {
-                return;
-            }
-            var evt = control.dragControl.handlers.drag.evt;
-            var preserveAspectRatio = !control._setfeature &&
-                control.preserveAspectRatio;
-            var reshape = !preserveAspectRatio && !(evt && evt.shiftKey);
-            var oldGeom = new OpenLayers.Geometry.Point(oldX, oldY);
-            var centerGeometry = control.center;
-            this.rotate(-control.rotation, centerGeometry);
-            oldGeom.rotate(-control.rotation, centerGeometry);
-            var dx1 = this.x - centerGeometry.x;
-            var dy1 = this.y - centerGeometry.y;
-            var dx0 = dx1 - (this.x - oldGeom.x);
-            var dy0 = dy1 - (this.y - oldGeom.y);
-            if (control.irregular && !control._setfeature) {
-               dx1 -= (this.x - oldGeom.x) / 2;
-               dy1 -= (this.y - oldGeom.y) / 2;
-            }
-            this.x = oldX;
-            this.y = oldY;
-            var scale, ratio = 1;
-            if (reshape) {
-                scale = Math.abs(dy0) < 0.00001 ? 1 : dy1 / dy0;
-                ratio = (Math.abs(dx0) < 0.00001 ? 1 : (dx1 / dx0)) / scale;
-            } else {
-                var l0 = Math.sqrt((dx0 * dx0) + (dy0 * dy0));
-                var l1 = Math.sqrt((dx1 * dx1) + (dy1 * dy1));
-                scale = l1 / l0;
-            }
-
-            // rotate the box to 0 before resizing - saves us some
-            // calculations and is inexpensive because we don't drawFeature.
-            control._moving = true;
-            control.box.geometry.rotate(-control.rotation, centerGeometry);
-            delete control._moving;
-
-            control.box.geometry.resize(scale, centerGeometry, ratio);
-            control.box.geometry.rotate(control.rotation, centerGeometry);
-            control.transformFeature({scale: scale, ratio: ratio});
-            if (control.irregular && !control._setfeature) {
-               var newCenter = centerGeometry.clone();
-               newCenter.x += Math.abs(oldX - centerGeometry.x) < 0.00001 ? 0 : (this.x - oldX);
-               newCenter.y += Math.abs(oldY - centerGeometry.y) < 0.00001 ? 0 : (this.y - oldY);
-               control.box.geometry.move(this.x - oldX, this.y - oldY);
-               control.transformFeature({center: newCenter});
-            }
-        };
-        
-        // Override for rotation handle move - make sure that the box and
-        // other handles are updated, and finally transform the feature.
-        var rotationHandleMoveFn = function(x, y){
-            var oldX = this.x, oldY = this.y;
-            OpenLayers.Geometry.Point.prototype.move.call(this, x, y);
-            if(control._moving) {
-                return;
-            }
-            var evt = control.dragControl.handlers.drag.evt;
-            var constrain = (evt && evt.shiftKey) ? 45 : 1;
-            var centerGeometry = control.center;
-            var dx1 = this.x - centerGeometry.x;
-            var dy1 = this.y - centerGeometry.y;
-            var dx0 = dx1 - x;
-            var dy0 = dy1 - y;
-            this.x = oldX;
-            this.y = oldY;
-            var a0 = Math.atan2(dy0, dx0);
-            var a1 = Math.atan2(dy1, dx1);
-            var angle = a1 - a0;
-            angle *= 180 / Math.PI;
-            control._angle = (control._angle + angle) % 360;
-            var diff = control.rotation % constrain;
-            if(Math.abs(control._angle) >= constrain || diff !== 0) {
-                angle = Math.round(control._angle / constrain) * constrain -
-                    diff;
-                control._angle = 0;
-                control.box.geometry.rotate(angle, centerGeometry);
-                control.transformFeature({rotation: angle});
-            } 
-        };
-
-        var handles = new Array(8);
-        var rotationHandles = new Array(4);
-        var geom, handle, rotationHandle;
-        var positions = ["sw", "s", "se", "e", "ne", "n", "nw", "w"];
-        for(var i=0; i<8; ++i) {
-            geom = this.box.geometry.components[i];
-            handle = new OpenLayers.Feature.Vector(geom.clone(), {
-                role: positions[i] + "-resize"
-            }, typeof this.renderIntent == "string" ? null :
-                this.renderIntent);
-            if(i % 2 == 0) {
-                rotationHandle = new OpenLayers.Feature.Vector(geom.clone(), {
-                    role: positions[i] + "-rotate"
-                }, typeof this.rotationHandleSymbolizer == "string" ?
-                    null : this.rotationHandleSymbolizer);
-                rotationHandle.geometry.move = rotationHandleMoveFn;
-                geom._rotationHandle = rotationHandle;
-                rotationHandles[i/2] = rotationHandle;
-            }
-            geom.move = vertexMoveFn;
-            geom.resize = vertexResizeFn;
-            geom.rotate = vertexRotateFn;
-            handle.geometry.move = handleMoveFn;
-            geom._handle = handle;
-            handles[i] = handle;
-        }
-        
-        this.rotationHandles = rotationHandles;
-        this.handles = handles;
-    },
-    
-    /**
-     * Method: createControl
-     * Creates a DragFeature control for this control.
-     */
-    createControl: function() {
-        var control = this;
-        this.dragControl = new OpenLayers.Control.DragFeature(this.layer, {
-            documentDrag: true,
-            // avoid moving the feature itself - move the box instead
-            moveFeature: function(pixel) {
-                if(this.feature === control.feature) {
-                    this.feature = control.box;
-                }
-                OpenLayers.Control.DragFeature.prototype.moveFeature.apply(this,
-                    arguments);
-            },
-            // transform while dragging
-            onDrag: function(feature, pixel) {
-                if(feature === control.box) {
-                    control.transformFeature({center: control.center});
-                }
-            },
-            // set a new feature
-            onStart: function(feature, pixel) {
-                var eligible = !control.geometryTypes ||
-                    OpenLayers.Util.indexOf(control.geometryTypes,
-                        feature.geometry.CLASS_NAME) !== -1;
-                var i = OpenLayers.Util.indexOf(control.handles, feature);
-                i += OpenLayers.Util.indexOf(control.rotationHandles,
-                    feature);
-                if(feature !== control.feature && feature !== control.box &&
-                                                        i == -2 && eligible) {
-                    control.setFeature(feature);
-                }
-            },
-            onComplete: function(feature, pixel) {
-                control.events.triggerEvent("transformcomplete",
-                    {feature: control.feature});
-            }
-        });
-    },
-    
-    /**
-     * Method: drawHandles
-     * Draws the handles to match the box.
-     */
-    drawHandles: function() {
-        var layer = this.layer;
-        for(var i=0; i<8; ++i) {
-            if(this.rotate && i % 2 === 0) {
-                layer.drawFeature(this.rotationHandles[i/2],
-                    this.rotationHandleSymbolizer);
-            }
-            layer.drawFeature(this.handles[i], this.renderIntent);
-        }
-    },
-    
-    /**
-     * Method: transformFeature
-     * Transforms the feature.
-     * 
-     * Parameters:
-     * mods - {Object} An object with optional scale, ratio, rotation and
-     *     center properties.
-     */
-    transformFeature: function(mods) {
-        if(!this._setfeature) {
-            this.scale *= (mods.scale || 1);
-            this.ratio *= (mods.ratio || 1);
-            var oldRotation = this.rotation;
-            this.rotation = (this.rotation + (mods.rotation || 0)) % 360;
-            
-            if(this.events.triggerEvent("beforetransform", mods) !== false) {
-                var feature = this.feature;
-                var geom = feature.geometry;
-                var center = this.center;
-                geom.rotate(-oldRotation, center);
-                if(mods.scale || mods.ratio) {
-                    geom.resize(mods.scale, center, mods.ratio);
-                } else if(mods.center) {
-                    feature.move(mods.center.getBounds().getCenterLonLat());
-                }
-                geom.rotate(this.rotation, center);
-                this.layer.drawFeature(feature);
-                feature.toState(OpenLayers.State.UPDATE);
-                this.events.triggerEvent("transform", mods);
-            }
-        }
-        this.layer.drawFeature(this.box, this.renderIntent);
-        this.drawHandles();
-    },
-        
-    /**
-     * APIMethod: destroy
-     * Take care of things that are not handled in superclass.
-     */
-    destroy: function() {
-        var geom;
-        for(var i=0; i<8; ++i) {
-            geom = this.box.geometry.components[i];
-            geom._handle.destroy();
-            geom._handle = null;
-            geom._rotationHandle && geom._rotationHandle.destroy();
-            geom._rotationHandle = null;
-        }
-        this.center = null;
-        this.feature = null;
-        this.handles = null;
-        this.rotationHandleSymbolizer = null;
-        this.rotationHandles = null;
-        this.box.destroy();
-        this.box = null;
-        this.layer = null;
-        this.dragControl.destroy();
-        this.dragControl = null;
-        OpenLayers.Control.prototype.destroy.apply(this, arguments);
-    },
-
-    CLASS_NAME: "OpenLayers.Control.TransformFeature"
-});