set correct VERSION_NUMBER

Merge pull request #1019 from ahocevar/chrome-optimized
Deal with recent Chrome optimizations to avoid failing TileManager and tests
2013-07-09 11:26:12 +02:00 · 2013-07-09 11:23:27 +02:00 · 2013-07-09 11:22:52 +02:00 · 2013-06-17 14:03:59 +02:00 · 2013-06-07 10:53:30 +02:00 · 2013-06-07 10:51:48 +02:00
41 changed files with 743 additions and 207 deletions
--- a/examples/feature-events.html
+++ b/examples/feature-events.html
@@ -0,0 +1,46 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
+    <meta name="apple-mobile-web-app-capable" content="yes">
+    <title>OpenLayers Feature Events Example</title>
+    <link rel="stylesheet" href="../theme/default/style.css" type="text/css">
+    <link rel="stylesheet" href="style.css" type="text/css">
+    <style type="text/css">
+    #result {
+        height: 60px;
+        width: 514px;
+        font-size: smaller;
+        overflow: auto;
+        margin-top: 5px;
+    }
+    </style>
+  </head>
+  <body>
+    <h1 id="title">Feature Events Example</h1>
+
+    <div id="tags">
+        feature, select, hover
+    </div>
+
+    <div id="shortdesc">Feature hover and click events</div>
+
+    <div id="map" class="smallmap"></div>
+    <div id="docs">
+        <p id="result">Hover over or click features on the map.</p>
+
+        <p>This example shows how to use the 'featureclick', 'nofeatureclick',
+            'featureover' and 'featureout' events to make features interactive.
+            Look at the <a href="feature-events.js">feature-events.js</a> source
+            code to see how this is done.</p>
+        
+        <p>Note that these events can be registered both on the map and on
+            individual layers. If many layers need to be observed, it is
+            recommended to register listeners once on the map for performance
+            reasons.</p>
+    </div>
+    <script src="../lib/OpenLayers.js"></script>
+    <script src="feature-events.js"></script>
+  </body>
+</html>
--- a/examples/feature-events.js
+++ b/examples/feature-events.js
@@ -0,0 +1,67 @@
+var layerListeners = {
+    featureclick: function(e) {
+        log(e.object.name + " says: " + e.feature.id + " clicked.");
+        return false;
+    },
+    nofeatureclick: function(e) {
+        log(e.object.name + " says: No feature clicked.");
+    }
+};
+
+var style = new OpenLayers.StyleMap({
+    'default': OpenLayers.Util.applyDefaults(
+        {label: "${l}", pointRadius: 10},
+        OpenLayers.Feature.Vector.style["default"]
+    ),
+    'select': OpenLayers.Util.applyDefaults(
+        {pointRadius: 10},
+        OpenLayers.Feature.Vector.style.select
+    )
+});
+var layer1 = new OpenLayers.Layer.Vector("Layer 1", {
+    styleMap: style,
+    eventListeners: layerListeners
+});
+layer1.addFeatures([
+    new OpenLayers.Feature.Vector(OpenLayers.Geometry.fromWKT("POINT(-1 -1)"), {l:1}),
+    new OpenLayers.Feature.Vector(OpenLayers.Geometry.fromWKT("POINT(1 1)"), {l:1})
+]);
+var layer2 = new OpenLayers.Layer.Vector("Layer 2", {
+    styleMap: style,
+    eventListeners: layerListeners
+});
+layer2.addFeatures([
+    new OpenLayers.Feature.Vector(OpenLayers.Geometry.fromWKT("POINT(-1 1)"), {l:2}),
+    new OpenLayers.Feature.Vector(OpenLayers.Geometry.fromWKT("POINT(1 -1)"), {l:2})
+]);
+
+var map = new OpenLayers.Map({
+    div: "map",
+    allOverlays: true,
+    layers: [layer1, layer2],
+    zoom: 6,
+    center: [0, 0],
+    eventListeners: {
+        featureover: function(e) {
+            e.feature.renderIntent = "select";
+            e.feature.layer.drawFeature(e.feature);
+            log("Map says: Pointer entered " + e.feature.id + " on " + e.feature.layer.name);
+        },
+        featureout: function(e) {
+            e.feature.renderIntent = "default";
+            e.feature.layer.drawFeature(e.feature);
+            log("Map says: Pointer left " + e.feature.id + " on " + e.feature.layer.name);
+        },
+        featureclick: function(e) {
+            log("Map says: " + e.feature.id + " clicked on " + e.feature.layer.name);
+        }
+    }
+});
+
+function log(msg) {
+    if (!log.timer) {
+        result.innerHTML = "";
+        log.timer = window.setTimeout(function() {delete log.timer;}, 100);
+    }
+    result.innerHTML += msg + "<br>";
+}
--- a/examples/fullScreen.js
+++ b/examples/fullScreen.js
@@ -1,6 +1,5 @@
 var map = new OpenLayers.Map({
    div: "map",
-    tileManager: new OpenLayers.TileManager(),
    layers: [
        new OpenLayers.Layer.OSM("OSM (without buffer)"),
        new OpenLayers.Layer.OSM("OSM (with buffer)", null, {buffer: 2})
--- a/examples/mobile-base.js
+++ b/examples/mobile-base.js
@@ -42,7 +42,6 @@ var init = function (onSelectFeatureFunction) {
        theme: null,
        projection: sm,
        numZoomLevels: 18,
-        tileManager: new OpenLayers.TileManager(),
        controls: [
            new OpenLayers.Control.Attribution(),
            new OpenLayers.Control.TouchNavigation({
--- a/examples/mobile-wmts-vienna.js
+++ b/examples/mobile-wmts-vienna.js
@@ -102,7 +102,6 @@ var map;
        units: "m",
        maxResolution: 38.21851413574219,
        numZoomLevels: 8,
-        tileManager: new OpenLayers.TileManager(),
        controls: [
            new OpenLayers.Control.Navigation(),
            new OpenLayers.Control.Attribution(),
--- a/lib/OpenLayers.js
+++ b/lib/OpenLayers.js
@@ -146,6 +146,7 @@
                "OpenLayers/Kinetic.js",
                "OpenLayers/Events.js",
                "OpenLayers/Events/buttonclick.js",
+                "OpenLayers/Events/featureclick.js",
                "OpenLayers/Request.js",
                "OpenLayers/Request/XMLHttpRequest.js",
                "OpenLayers/Projection.js",
@@ -425,4 +426,4 @@
 * When asking questions or reporting issues, make sure to include the output of
 *     OpenLayers.VERSION_NUMBER in the question or issue-description.
 */
-OpenLayers.VERSION_NUMBER="Release 2.13-rc2";
+OpenLayers.VERSION_NUMBER="Release 2.13.1";
--- a/lib/OpenLayers/Control/DragPan.js
+++ b/lib/OpenLayers/Control/DragPan.js
@@ -32,11 +32,12 @@ OpenLayers.Control.DragPan = OpenLayers.Class(OpenLayers.Control, {
    /**
     * Property: interval
     * {Integer} The number of milliseconds that should ellapse before
-     *     panning the map again. Defaults to 1 millisecond. In most cases
-     *     you won't want to change this value. For slow machines/devices
-     *     larger values can be tried out.
+     *     panning the map again. Defaults to 0 milliseconds, which means that
+     *     no separate cycle is used for panning. In most cases you won't want
+     *     to change this value. For slow machines/devices larger values can be
+     *     tried out.
     */
-    interval: 1,
+    interval: 0,
    
    /**
     * APIProperty: documentDrag
--- a/lib/OpenLayers/Control/ModifyFeature.js
+++ b/lib/OpenLayers/Control/ModifyFeature.js
@@ -235,8 +235,8 @@ OpenLayers.Control.ModifyFeature = OpenLayers.Class(OpenLayers.Control, {
                        this.handlers.drag.evt);
                if (feature) {
                    this.dragStart(feature);
-                } else if (this.feature && this.clickout) {
-                    this.unselectFeature(this.feature);
+                } else if (this.clickout) {
+                    this._unselect = this.feature;
                }
            },
            move: function(pixel) {
@@ -363,8 +363,9 @@ OpenLayers.Control.ModifyFeature = OpenLayers.Class(OpenLayers.Control, {
     * feature - {<OpenLayers.Feature.Vector>} the selected feature.
     */
    selectFeature: function(feature) {
-        if (this.geometryTypes && OpenLayers.Util.indexOf(this.geometryTypes,
-                feature.geometry.CLASS_NAME) == -1) {
+        if (this.feature === feature ||
+           (this.geometryTypes && OpenLayers.Util.indexOf(this.geometryTypes,
+           feature.geometry.CLASS_NAME) == -1)) {
            return;
        }
        if (this.beforeSelectFeature(feature) !== false) {
--- a/lib/OpenLayers/Control/ZoomBox.js
+++ b/lib/OpenLayers/Control/ZoomBox.js
@@ -101,14 +101,18 @@ OpenLayers.Control.ZoomBox = OpenLayers.Class(OpenLayers.Control, {
                centerPx = {x: size.w / 2, y: size.h / 2},
                zoom = this.map.getZoomForExtent(bounds),
                oldRes = this.map.getResolution(),
-                newRes = this.map.getResolutionForZoom(zoom),
-                zoomOriginPx = {
+                newRes = this.map.getResolutionForZoom(zoom);
+            if (oldRes == newRes) {
+                this.map.setCenter(this.map.getLonLatFromPixel(targetCenterPx));
+            } else {
+              var zoomOriginPx = {
                    x: (oldRes * targetCenterPx.x - newRes * centerPx.x) /
                        (oldRes - newRes),
                    y: (oldRes * targetCenterPx.y - newRes * centerPx.y) /
                        (oldRes - newRes)
                };
-            this.map.zoomTo(zoom, zoomOriginPx);
+                this.map.zoomTo(zoom, zoomOriginPx);
+            }
            if (lastZoom == this.map.getZoom() && this.alwaysZoom == true){ 
                this.map.zoomTo(lastZoom + (this.out ? -1 : 1)); 
            }
--- a/lib/OpenLayers/Events/featureclick.js
+++ b/lib/OpenLayers/Events/featureclick.js
@@ -0,0 +1,321 @@
+/* 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/Events.js
+ */
+
+/**
+ * Class: OpenLayers.Events.featureclick
+ *
+ * Extension event type for handling feature click events, including overlapping
+ * features. 
+ * 
+ * Event types provided by this extension:
+ * - featureclick 
+ */
+OpenLayers.Events.featureclick = OpenLayers.Class({
+    
+    /**
+     * Property: cache
+     * {Object} A cache of features under the mouse.
+     */
+    cache: null,
+    
+    /**
+     * Property: map
+     * {<OpenLayers.Map>} The map to register browser events on.
+     */
+    map: null,
+    
+    /**
+     * Property: provides
+     * {Array(String)} The event types provided by this extension.
+     */
+    provides: ["featureclick", "nofeatureclick", "featureover", "featureout"],
+    
+    /**
+     * Constructor: OpenLayers.Events.featureclick
+     * Create a new featureclick event type.
+     *
+     * Parameters:
+     * target - {<OpenLayers.Events>} The events instance to create the events
+     *     for.
+     */
+    initialize: function(target) {
+        this.target = target;
+        if (target.object instanceof OpenLayers.Map) {
+            this.setMap(target.object);
+        } else if (target.object instanceof OpenLayers.Layer.Vector) {
+            if (target.object.map) {
+                this.setMap(target.object.map);
+            } else {
+                target.object.events.register("added", this, function(evt) {
+                    this.setMap(target.object.map);
+                });
+            }
+        } else {
+            throw("Listeners for '" + this.provides.join("', '") +
+                "' events can only be registered for OpenLayers.Layer.Vector " + 
+                "or OpenLayers.Map instances");
+        }
+        for (var i=this.provides.length-1; i>=0; --i) {
+            target.extensions[this.provides[i]] = true;
+        }
+    },
+    
+    /**
+     * Method: setMap
+     *
+     * Parameters:
+     * map - {<OpenLayers.Map>} The map to register browser events on.
+     */
+    setMap: function(map) {
+        this.map = map;
+        this.cache = {};
+        map.events.register("mousedown", this, this.start, {extension: true});
+        map.events.register("mouseup", this, this.onClick, {extension: true});
+        map.events.register("touchstart", this, this.start, {extension: true});
+        map.events.register("touchmove", this, this.cancel, {extension: true});
+        map.events.register("touchend", this, this.onClick, {extension: true});
+        map.events.register("mousemove", this, this.onMousemove, {extension: true});
+    },
+    
+    /**
+     * Method: start
+     * Sets startEvt = evt.
+     *
+     * Parameters:
+     * evt - {<OpenLayers.Event>}
+     */
+    start: function(evt) {
+        this.startEvt = evt;
+    },
+    
+    /**
+     * Method: cancel
+     * Deletes the start event.
+     *
+     * Parameters:
+     * evt - {<OpenLayers.Event>}
+     */    
+    cancel: function(evt) {
+        delete this.startEvt;
+    },
+    
+    /**
+     * Method: onClick
+     * Listener for the click event.
+     *
+     * Parameters:
+     * evt - {<OpenLayers.Event>}
+     */
+    onClick: function(evt) {
+        if (!this.startEvt || evt.type !== "touchend" &&
+                !OpenLayers.Event.isLeftClick(evt)) {
+            return;
+        }
+        var features = this.getFeatures(this.startEvt);
+        delete this.startEvt;
+        // fire featureclick events
+        var feature, layer, more, clicked = {};
+        for (var i=0, len=features.length; i<len; ++i) {
+            feature = features[i];
+            layer = feature.layer;
+            clicked[layer.id] = true;
+            more = this.triggerEvent("featureclick", {feature: feature});
+            if (more === false) {
+                break;
+            }
+        }
+        // fire nofeatureclick events on all vector layers with no targets
+        for (i=0, len=this.map.layers.length; i<len; ++i) {
+            layer = this.map.layers[i];
+            if (layer instanceof OpenLayers.Layer.Vector && !clicked[layer.id]) {
+                this.triggerEvent("nofeatureclick", {layer: layer});
+            }
+        }
+    },
+    
+    /**
+     * Method: onMousemove
+     * Listener for the mousemove event.
+     *
+     * Parameters:
+     * evt - {<OpenLayers.Event>}
+     */
+    onMousemove: function(evt) {
+        delete this.startEvt;
+        var features = this.getFeatures(evt);
+        var over = {}, newly = [], feature;
+        for (var i=0, len=features.length; i<len; ++i) {
+            feature = features[i];
+            over[feature.id] = feature;
+            if (!this.cache[feature.id]) {
+                newly.push(feature);
+            }
+        }
+        // check if already over features
+        var out = [];
+        for (var id in this.cache) {
+            feature = this.cache[id];
+            if (feature.layer && feature.layer.map) {
+                if (!over[feature.id]) {
+                    out.push(feature);
+                }
+            } else {
+                // removed
+                delete this.cache[id];
+            }
+        }
+        // fire featureover events
+        var more;
+        for (i=0, len=newly.length; i<len; ++i) {
+            feature = newly[i];
+            this.cache[feature.id] = feature;
+            more = this.triggerEvent("featureover", {feature: feature});
+            if (more === false) {
+                break;
+            }
+        }
+        // fire featureout events
+        for (i=0, len=out.length; i<len; ++i) {
+            feature = out[i];
+            delete this.cache[feature.id];
+            more = this.triggerEvent("featureout", {feature: feature});
+            if (more === false) {
+                break;
+            }
+        }
+    },
+    
+    /**
+     * Method: triggerEvent
+     * Determines where to trigger the event and triggers it.
+     *
+     * Parameters:
+     * type - {String} The event type to trigger
+     * evt - {Object} The listener argument
+     *
+     * Returns:
+     * {Boolean} The last listener return.
+     */
+    triggerEvent: function(type, evt) {
+        var layer = evt.feature ? evt.feature.layer : evt.layer,
+            object = this.target.object;
+        if (object instanceof OpenLayers.Map || object === layer) {
+            return this.target.triggerEvent(type, evt);
+        }
+    },
+
+    /**
+     * Method: getFeatures
+     * Get all features at the given screen location.
+     *
+     * Parameters:
+     * evt - {Object} Event object.
+     *
+     * Returns:
+     * {Array(<OpenLayers.Feature.Vector>)} List of features at the given point.
+     */
+    getFeatures: function(evt) {
+        var x = evt.clientX, y = evt.clientY,
+            features = [], targets = [], layers = [],
+            layer, target, feature, i, len;
+        // go through all layers looking for targets
+        for (i=this.map.layers.length-1; i>=0; --i) {
+            layer = this.map.layers[i];
+            if (layer.div.style.display !== "none") {
+                if (layer.renderer instanceof OpenLayers.Renderer.Elements) {
+                    if (layer instanceof OpenLayers.Layer.Vector) {
+                        target = document.elementFromPoint(x, y);
+                        while (target && target._featureId) {
+                            feature = layer.getFeatureById(target._featureId);
+                            if (feature) {
+                                features.push(feature);
+                                target.style.display = "none";
+                                targets.push(target);
+                                target = document.elementFromPoint(x, y);
+                            } else {
+                                // sketch, all bets off
+                                target = false;
+                            }
+                        }
+                    }
+                    layers.push(layer);
+                    layer.div.style.display = "none";
+                } else if (layer.renderer instanceof OpenLayers.Renderer.Canvas) {
+                    feature = layer.renderer.getFeatureIdFromEvent(evt);
+                    if (feature) {
+                        features.push(feature);
+                        layers.push(layer);
+                    }
+                }
+            }
+        }
+        // restore feature visibility
+        for (i=0, len=targets.length; i<len; ++i) {
+            targets[i].style.display = "";
+        }
+        // restore layer visibility
+        for (i=layers.length-1; i>=0; --i) {
+            layers[i].div.style.display = "block";
+        }
+        return features;
+    },
+    
+    /**
+     * APIMethod: destroy
+     * Clean up.
+     */
+    destroy: function() {
+        for (var i=this.provides.length-1; i>=0; --i) {
+            delete this.target.extensions[this.provides[i]];
+        }        
+        this.map.events.un({
+            mousemove: this.onMousemove,
+            mousedown: this.start,
+            mouseup: this.onClick,
+            touchstart: this.start,
+            touchmove: this.cancel,
+            touchend: this.onClick,
+            scope: this
+        });
+        delete this.cache;
+        delete this.map;
+        delete this.target;
+    }
+    
+});
+ 
+/**
+ * Class: OpenLayers.Events.nofeatureclick
+ *
+ * Extension event type for handling click events that do not hit a feature. 
+ * 
+ * Event types provided by this extension:
+ * - nofeatureclick 
+ */
+OpenLayers.Events.nofeatureclick = OpenLayers.Events.featureclick;
+
+/**
+ * Class: OpenLayers.Events.featureover
+ *
+ * Extension event type for handling hovering over a feature. 
+ * 
+ * Event types provided by this extension:
+ * - featureover 
+ */
+OpenLayers.Events.featureover = OpenLayers.Events.featureclick;
+
+/**
+ * Class: OpenLayers.Events.featureout
+ *
+ * Extension event type for handling leaving a feature. 
+ * 
+ * Event types provided by this extension:
+ * - featureout 
+ */
+OpenLayers.Events.featureout = OpenLayers.Events.featureclick;
--- a/lib/OpenLayers/Format/EncodedPolyline.js
+++ b/lib/OpenLayers/Format/EncodedPolyline.js
@@ -102,8 +102,9 @@ OpenLayers.Format.EncodedPolyline = OpenLayers.Class(OpenLayers.Format, {
     * {Array(Array(int))} An array containing n-dimensional arrays of
     *     coordinates.
     */
-    decode: function(encoded, dims) {
-        var flatPoints = this.decodeDeltas(encoded, dims, 1);
+    decode: function(encoded, dims, opt_factor) {
+        var factor = opt_factor || 1e5;
+        var flatPoints = this.decodeDeltas(encoded, dims, factor);
        var flatPointsLength = flatPoints.length;

        var points = [];
@@ -177,7 +178,8 @@ OpenLayers.Format.EncodedPolyline = OpenLayers.Class(OpenLayers.Format, {
     * Returns:
     * {String} An encoded string
     */
-    encode: function (points, dims) {
+    encode: function (points, dims, opt_factor) {
+        var factor = opt_factor || 1e5;
        var flatPoints = [];

        var pointsLength = points.length;
@@ -189,7 +191,7 @@ OpenLayers.Format.EncodedPolyline = OpenLayers.Class(OpenLayers.Format, {
            }
        }

-        return this.encodeDeltas(flatPoints, dims, 1);
+        return this.encodeDeltas(flatPoints, dims, factor);
    },

    /**
--- a/lib/OpenLayers/Layer.js
+++ b/lib/OpenLayers/Layer.js
@@ -743,6 +743,12 @@ OpenLayers.Layer = OpenLayers.Class({
            this.visibility = visibility;
            this.display(visibility);
            this.redraw();
+            if (this.map != null) {
+                this.map.events.triggerEvent("changelayer", {
+                    layer: this,
+                    property: "visibility"
+                });
+            }
            this.events.triggerEvent("visibilitychanged");
        }
    },
@@ -759,11 +765,6 @@ OpenLayers.Layer = OpenLayers.Class({
    display: function(display) {
        if (display != (this.div.style.display != "none")) {
            this.div.style.display = (display && this.calculateInRange()) ? "block" : "none";
-            if(this.map){
-                this.map.events.triggerEvent("changelayer", {
-                    layer: this, property: "visibility"
-                });
-            }
        }
    },

--- a/lib/OpenLayers/Layer/Google.js
+++ b/lib/OpenLayers/Layer/Google.js
@@ -274,6 +274,10 @@ OpenLayers.Layer.Google = OpenLayers.Class(
            if (poweredBy && poweredBy.parentNode) {
                poweredBy.parentNode.removeChild(poweredBy);
            }
+            if (this.mapObject && window.google && google.maps &&
+                    google.maps.event && google.maps.event.clearListeners) {
+                google.maps.event.clearListeners(this.mapObject, 'tilesloaded');
+            }
        }
    },

--- a/lib/OpenLayers/Layer/Google/v3.js
+++ b/lib/OpenLayers/Layer/Google/v3.js
@@ -53,10 +53,9 @@ OpenLayers.Layer.Google.v3 = {

    /** 
     * Method: loadMapObject
-     * Load the GMap and register appropriate event listeners. If we can't 
-     *     load GMap2, then display a warning message.
+     * Load the GMap and register appropriate event listeners.
     */
-    loadMapObject:function() {
+    loadMapObject: function() {
        if (!this.type) {
            this.type = google.maps.MapTypeId.ROADMAP;
        }
@@ -92,7 +91,6 @@ OpenLayers.Layer.Google.v3 = {
            googleControl.style.width = '100%';
            googleControl.style.height = '100%';
            mapObject.controls[google.maps.ControlPosition.TOP_LEFT].push(googleControl);
-            this.map.div.appendChild(container);
            
            // cache elements for use by any other google layers added to
            // this same map
@@ -141,13 +139,24 @@ OpenLayers.Layer.Google.v3 = {
            }
            var container = this.mapObject.getDiv();
            if (visible === true) {
-                container.style.display = '';
-                cache.googleControl.appendChild(map.viewPortDiv);
-                google.maps.event.trigger(this.mapObject, 'resize');
+                if (container.parentNode !== map.div) {
+                    if (!cache.rendered) {
+                        var me = this;
+                        google.maps.event.addListenerOnce(this.mapObject, 'tilesloaded', function() {
+                            cache.rendered = true;
+                            me.setGMapVisibility(me.getVisibility());
+                            me.moveTo(me.map.getCenter());
+                        });
+                    } else {
+                        map.div.appendChild(container);
+                        cache.googleControl.appendChild(map.viewPortDiv);
+                        google.maps.event.trigger(this.mapObject, 'resize');
+                    }
+                }
                this.mapObject.setMapTypeId(type);                
-            } else {
+            } else if (cache.googleControl.hasChildNodes()) {
                map.div.appendChild(map.viewPortDiv);
-                container.style.display = 'none';
+                map.div.removeChild(container);
            }
        }
    },
--- a/lib/OpenLayers/Layer/Grid.js
+++ b/lib/OpenLayers/Layer/Grid.js
@@ -1100,7 +1100,7 @@ OpenLayers.Layer.Grid = OpenLayers.Class(OpenLayers.Layer.HTTPRequest, {
            this.events.triggerEvent("tileloadstart", {tile: tile});
            this.numLoadingTiles++;
            if (!this.singleTile && this.backBuffer && this.gridResolution === this.backBufferResolution) {
-                OpenLayers.Element.addClass(tile.imgDiv, replacingCls);
+                OpenLayers.Element.addClass(tile.getTile(), replacingCls);
            }
        };
      
@@ -1112,13 +1112,14 @@ OpenLayers.Layer.Grid = OpenLayers.Class(OpenLayers.Layer.HTTPRequest, {
                aborted: aborted
            });
            if (!this.singleTile && !aborted && this.backBuffer && this.gridResolution === this.backBufferResolution) {
-                if (OpenLayers.Element.getStyle(tile.imgDiv, 'display') === 'none') {
+                var tileDiv = tile.getTile();
+                if (OpenLayers.Element.getStyle(tileDiv, 'display') === 'none') {
                    var bufferTile = document.getElementById(tile.id + '_bb');
                    if (bufferTile) {
                        bufferTile.parentNode.removeChild(bufferTile);
                    }
                }
-                OpenLayers.Element.removeClass(tile.imgDiv, replacingCls);
+                OpenLayers.Element.removeClass(tileDiv, replacingCls);
            }
            //if that was the last tile, then trigger a 'loadend' on the layer
            if (this.numLoadingTiles === 0) {
--- a/lib/OpenLayers/Map.js
+++ b/lib/OpenLayers/Map.js
@@ -372,15 +372,16 @@ OpenLayers.Map = OpenLayers.Class({
     *     property at the time the control is added to the map. 
     */
    displayProjection: null,
-    
+
    /**
     * APIProperty: tileManager
-     * {<OpenLayers.TileManager>} If configured at construction time, the map
-     * will use the TileManager to queue image requests and to cache tile image
-     * elements. Note: make sure that OpenLayers/TileManager.js is included in
-     * your build profile.
+     * {<OpenLayers.TileManager>|Object} By default, and if the build contains
+     * TileManager.js, the map will use the TileManager to queue image requests
+     * and to cache tile image elements. To create a map without a TileManager
+     * configure the map with tileManager: null. To create a TileManager with
+     * non-default options, supply the options instead or alternatively supply
+     * an instance of {<OpenLayers.TileManager>}.
     */
-    tileManager: null,

    /**
     * APIProperty: fallThrough
@@ -613,7 +614,10 @@ OpenLayers.Map = OpenLayers.Class({
            {includeXY: true}
        );
        
-        if (this.tileManager) {
+        if (OpenLayers.TileManager && this.tileManager !== null) {
+            if (!(this.tileManager instanceof OpenLayers.TileManager)) {
+                this.tileManager = new OpenLayers.TileManager(this.tileManager);
+            }
            this.tileManager.addMap(this);
        }

@@ -2034,7 +2038,9 @@ OpenLayers.Map = OpenLayers.Class({
                        if (!inRange) {
                            layer.display(false);
                        }
-
+                        this.events.triggerEvent("changelayer", {
+                            layer: layer, property: "visibility"
+                        });
                    }
                    if (inRange && layer.visibility) {
                        layer.moveTo(bounds, zoomChanged, options.dragging);
--- a/lib/OpenLayers/SingleFile.js
+++ b/lib/OpenLayers/SingleFile.js
@@ -7,7 +7,7 @@ var OpenLayers = {
    /**
     * Constant: VERSION_NUMBER
     */
-    VERSION_NUMBER: "Release 2.13-rc2",
+    VERSION_NUMBER: "Release 2.13.1",

    /**
     * Constant: singleFile
--- a/lib/OpenLayers/Tile/Image.js
+++ b/lib/OpenLayers/Tile/Image.js
@@ -314,11 +314,17 @@ OpenLayers.Tile.Image = OpenLayers.Class(OpenLayers.Tile, {
     * Creates the content for the frame on the tile.
     */
    initImage: function() {
+        if (!this.url && !this.imgDiv) {
+            // fast path out - if there is no tile url and no previous image
+            this.isLoading = false;
+            return;
+        }
        this.events.triggerEvent('beforeload');
        this.layer.div.appendChild(this.getTile());
        this.events.triggerEvent(this._loadEvent);
        var img = this.getImage();
-        if (this.url && OpenLayers.Util.isEquivalentUrl(img.src, this.url)) {
+        var src = img.getAttribute('src') || '';
+        if (this.url && OpenLayers.Util.isEquivalentUrl(src, this.url)) {
            this._loadTimeout = window.setTimeout(
                OpenLayers.Function.bind(this.onImageLoad, this), 0
            );
--- a/lib/OpenLayers/TileManager.js
+++ b/lib/OpenLayers/TileManager.js
@@ -5,10 +5,11 @@


 /**
- * @requires OpenLayers/Layer/Grid.js
 * @requires OpenLayers/Util.js
 * @requires OpenLayers/BaseTypes.js
 * @requires OpenLayers/BaseTypes/Element.js
+ * @requires OpenLayers/Layer/Grid.js
+ * @requires OpenLayers/Tile/Image.js
 */

 /**
@@ -117,7 +118,7 @@ OpenLayers.TileManager = OpenLayers.Class({
     * map - {<OpenLayers.Map>}
     */
    addMap: function(map) {
-        if (this._destroyed) {
+        if (this._destroyed || !OpenLayers.Layer.Grid) {
            return;
        }
        this.maps.push(map);
@@ -143,7 +144,7 @@ OpenLayers.TileManager = OpenLayers.Class({
     * map - {<OpenLayers.Map>}
     */
    removeMap: function(map) {
-        if (this._destroyed) {
+        if (this._destroyed || !OpenLayers.Layer.Grid) {
            return;
        }
        window.clearTimeout(this.tileQueueId[map.id]);
@@ -175,7 +176,7 @@ OpenLayers.TileManager = OpenLayers.Class({
     * evt - {Object} Listener argument
     */
    move: function(evt) {
-        this.updateTimeout(evt.object, this.moveDelay);
+        this.updateTimeout(evt.object, this.moveDelay, true);
    },
    
    /**
@@ -222,7 +223,7 @@ OpenLayers.TileManager = OpenLayers.Class({
                for (j=layer.grid[i].length-1; j>=0; --j) {
                    tile = layer.grid[i][j];
                    this.addTile({tile: tile});
-                    if (tile.url) {
+                    if (tile.url && !tile.imgDiv) {
                        this.manageTileCache({object: tile});
                    }
                }
@@ -254,9 +255,6 @@ OpenLayers.TileManager = OpenLayers.Class({
                    for (j=layer.grid[i].length-1; j>=0; --j) {
                        tile = layer.grid[i][j];
                        this.unloadTile({object: tile});
-                        if (tile.url) {
-                            this.manageTileCache({object: tile});
-                        }
                    }
                }
            }
@@ -272,11 +270,16 @@ OpenLayers.TileManager = OpenLayers.Class({
     * Parameters:
     * map - {<OpenLayers.Map>} The map to update the timeout for
     * delay - {Number} The delay to apply
+     * nice - {Boolean} If true, the timeout function will only be created if
+     *     the tilequeue is not empty. This is used by the move handler to
+     *     avoid impacts on dragging performance. For other events, the tile
+     *     queue may not be populated yet, so we need to set the timer
+     *     regardless of the queue size.
     */
-    updateTimeout: function(map, delay) {
+    updateTimeout: function(map, delay, nice) {
        window.clearTimeout(this.tileQueueId[map.id]);
        var tileQueue = this.tileQueue[map.id];
-        if (tileQueue.length) {
+        if (!nice || tileQueue.length) {
            this.tileQueueId[map.id] = window.setTimeout(
                OpenLayers.Function.bind(function() {
                    this.drawTilesFromQueue(map);
@@ -296,13 +299,18 @@ OpenLayers.TileManager = OpenLayers.Class({
     * evt - {Object} The listener argument
     */
    addTile: function(evt) {
-        evt.tile.events.on({
-            beforedraw: this.queueTileDraw,
-            beforeload: this.manageTileCache,
-            loadend: this.addToCache,
-            unload: this.unloadTile,
-            scope: this
-        });        
+        if (evt.tile instanceof OpenLayers.Tile.Image) {
+            evt.tile.events.on({
+                beforedraw: this.queueTileDraw,
+                beforeload: this.manageTileCache,
+                loadend: this.addToCache,
+                unload: this.unloadTile,
+                scope: this
+            });        
+        } else {
+            // Layer has the wrong tile type, so don't handle it any longer
+            this.removeLayer({layer: evt.tile.layer});
+        }
    },
    
    /**
@@ -379,20 +387,23 @@ OpenLayers.TileManager = OpenLayers.Class({
    manageTileCache: function(evt) {
        var tile = evt.object;
        var img = this.tileCache[tile.url];
-        // only use image from cache if it is not on a layer already
-        if (img && (!img.parentNode ||
-                 OpenLayers.Element.hasClass(img.parentNode, 'olBackBuffer'))) {
-            if (tile.layer.backBuffer) {
-                img.style.opacity = 0;
-                img.style.visibility = 'hidden';
-            }
-            // Only backbuffer tiles have an id, so we don't want one here
-            img.id = null;
-            tile.setImage(img);
-            // LRU - move tile to the end of the array to mark it as the most
-            // recently used
-            OpenLayers.Util.removeItem(this.tileCacheIndex, tile.url);
-            this.tileCacheIndex.push(tile.url);
+        if (img) {
+          // if image is on its layer's backbuffer, remove it from backbuffer
+          if (img.parentNode &&
+                  OpenLayers.Element.hasClass(img.parentNode, 'olBackBuffer')) {
+              img.parentNode.removeChild(img);
+              img.id = null;
+          }
+          // only use image from cache if it is not on a layer already
+          if (!img.parentNode) {
+              img.style.visibility = 'hidden';
+              img.style.opacity = 0;
+              tile.setImage(img);
+              // LRU - move tile to the end of the array to mark it as the most
+              // recently used
+              OpenLayers.Util.removeItem(this.tileCacheIndex, tile.url);
+              this.tileCacheIndex.push(tile.url);
+          }
        }
    },
    
--- a/notes/2.13.md
+++ b/notes/2.13.md
@@ -35,6 +35,11 @@ Corresponding issues/pull requests:

 * http://github.com/openlayers/openlayers/pull/700

+## New Map and Vector Layer Events for Feature Interaction
+
+The featureclick events extension (`lib/Events/featureclick.js`) provides four new events ("featureclick", "nofeatureclick", "featureover", "featureout") that can be used as an alternative to the Feature handler or the
+SelectFeature control. It works with multiple layers out of the box and can detect hits on multiple features (except when using the Canvas renderer). See `examples/feature-events.html` for an implementation example.
+
 # Behavior Changes from Past Releases

 ## Control.DragPan: Kinetic by default
@@ -44,7 +49,7 @@ The `enableKinetic` property for the DragPan control has been changed to true by
 ## Control.ModifyFeature: no more built-in SelectFeature control

 The ModifyFeature control is now much leaner, making it more reliable when combined with other controls. The most noticable change is that it has no
-`selectControl` member any more. Users who previously relied on this built-in SelectFeature control will now have to create both a SelectFeature and a ModifyFeature control and configure the ModifyFeature control with `standalone: true`. To get features selected, call the `selectFeature` method e.g. from a `featureselected` listener on the vector layer.
+`selectControl` member any more. Users who previously relied on this built-in SelectFeature control will now have to create both a SelectFeature and a ModifyFeature control and configure the ModifyFeature control with `standalone: true`. To get features selected, call the `selectFeature` method e.g. from a `featureselected` listener on the vector layer. Note that other than in the old implementation, calling `selectFeature` on an already selected feature will not do anything.

 ## Format.GPX: No more prefixes

@@ -60,18 +65,16 @@ This was necessary for WCS support because there are no properties in common bet

 ## Layer.Grid: Tile queue and tileLoadingDelay changes

-With the introduction of OpenLayers.TileManager, tile queueing has become optional. The default behavior is back to how it was in OpenLayers 2.11. To use a tile queue in 2.13, the map needs to be configured with a tileManager, e.g.:
+With the introduction of OpenLayers.TileManager, tile queueing has become optional but is enabled by default. To not use a tile queue in 2.13, the map needs to be configured with tileManager: null, e.g.:

    var map = new OpenLayers.Map('map', {
-        tileManager: new OpenLayers.TileManager()
+        tileManager: null
    });

-The tile queue also works differently than before: it no longer loads one tile at a time. Instead, it waits after a zoom or pan, and loads all tiles after a delay. This has the same effect as previously (less burden on the server), but makes use of the browser's request management. The delay can be configured separately for zooming and moving the map, using the `zoomDelay` (default: 200 ms) and `moveDelay` (default: 100 ms) config options of the TileManager.
+The tile queue works differently than before: it no longer loads one tile at a time. Instead, it waits after a zoom or pan, and loads all tiles after a delay. This has the same effect as previously (less burden on the server), but makes use of the browser's request management. The delay can be configured separately for zooming and moving the map, using the `zoomDelay` (default: 200 ms) and `moveDelay` (default: 100 ms) config options of the TileManager. If you want to have the map be associated with a TileManager with non-default options, supply the options instead or create your own TileManager instance and supply it to the Map constructor.

 The `moveDelay` is the replacement for the `tileLoadingDelay` layer config option, which has been removed. There is no magic any more to only use the delay when requestAnimationFrame is not natively available.

-In general, when targeting mobile devices or when using slow servers or connections for tiled layers, it is recommended to configure the map with a TileManager.
-
 ## Layer.Grid: Resize transitions by default

 The `transitionEffect` property for grid layers has been changed to "resize" by default.  This allows smooth transitions with animated zooming (also enabled by default).  If resize transitions are not wanted for individual layers, set `transitionEffect` to `null`.
--- a/tests/Control/ModifyFeature.html
+++ b/tests/Control/ModifyFeature.html
@@ -225,6 +225,7 @@
        
        // Points don't call collectVertices
        control.selectFeature(fakeFeature);
+        control.unselectFeature(fakeFeature);
        
        control.collectVertices = function() { 
          t.ok(true, "collectVertices called"); 
@@ -237,7 +238,8 @@
        layer.addFeatures = function(features) { 
            t.ok(features == 'a' || features == 'd', "features passed correctly"); 
        }
-        
+        layer.destroyFeatures = function() {};
+
        fakeFeature.geometry = new OpenLayers.Geometry.Polygon([
            new OpenLayers.Geometry.LinearRing([
                new OpenLayers.Geometry.Point(0, 0),
@@ -246,7 +248,9 @@
        ]);
        
        // OnSelect calls collectVertices and passes features to layer 
-        control.selectFeature(fakeFeature);
+        control.selectFeature(fakeFeature);        
+        control.unselectFeature(fakeFeature);
+        layer.destroyFeatures = OpenLayers.Layer.Vector.prototype.destroyFeatures;
        
        control.vertices = ['a'];
        control.virtualVertices = [{destroy: function() {}}];
--- a/tests/Control/UTFGrid.html
+++ b/tests/Control/UTFGrid.html
@@ -30,6 +30,7 @@
        });
        map = new OpenLayers.Map({
            div: "map",
+            tileManager: null,
            projection: "EPSG:900913",
            layers: [layer],
            center: [0, 0],
--- a/tests/Events/featureclick.html
+++ b/tests/Events/featureclick.html
@@ -0,0 +1,91 @@
+<html>
+<head>
+<script src="../OLLoader.js"></script>
+<script type="text/javascript">
+
+var layer1, style, logevt, lognoevt, map, lonlat, pixel, element;
+
+function init() {
+
+	element = document.getElementById("map");
+
+	style = new OpenLayers.StyleMap({
+		 'default': OpenLayers.Util.applyDefaults(
+		     {label: "${l}", pointRadius: 30},
+		     OpenLayers.Feature.Vector.style["default"]
+		 ),
+		 'select': OpenLayers.Util.applyDefaults(
+		     {pointRadius: 30},
+		     OpenLayers.Feature.Vector.style.select
+		 )
+	});
+	
+	layer1 = new OpenLayers.Layer.Vector("Layer 1", {
+		styleMap: style
+	});
+
+	layer1.addFeatures([
+		 new OpenLayers.Feature.Vector(OpenLayers.Geometry.fromWKT("POINT(0 0)"), {l:1}),
+		 new OpenLayers.Feature.Vector(OpenLayers.Geometry.fromWKT("POINT(0 0)"), {l:1}),
+		 new OpenLayers.Feature.Vector(OpenLayers.Geometry.fromWKT("POINT(0 0)"), {l:1}),
+		 new OpenLayers.Feature.Vector(OpenLayers.Geometry.fromWKT("POINT(0 0)"), {l:1})
+	]);
+
+	map = new OpenLayers.Map({
+		div: "map",
+		allOverlays: true,
+		layers: [layer1],
+		zoom: 6,
+		center: [0, 0],
+		eventListeners: {
+            featureclick: logEvent,
+            nofeatureclick: logNoEvent
+		}
+	});	
+}
+
+function logNoEvent(e) {
+	lognoevt.push(e);
+}
+
+function logEvent(e) {
+	logevt.push(e);	
+}
+
+function trigger(type, pxl) {
+	var map_position = OpenLayers.Util.pagePosition(element);
+	map.events.triggerEvent(type, {
+		xy: pxl, 
+		clientX: pxl.x + map_position[0], 
+		clientY: pxl.y + map_position[1], 
+		which: 1  // which == 1 means left-click
+	}); 	
+}
+
+// TESTS
+
+function test_onClick(t) {
+	t.plan(2);
+	logevt = [];
+	lognoevt = [];
+	lonlat = new OpenLayers.LonLat(0,0);
+	pixel = map.getPixelFromLonLat(lonlat);
+
+	trigger('mousedown', pixel);
+	trigger('mouseup', pixel);
+	
+	t.eq(logevt.length, 4, "4 features hit");
+    
+    trigger('mousedown', {x: 40, y: 40});
+    trigger('mouseup', {x: 40, y: 40});
+	t.eq(lognoevt.length, 1, "nofeatureclick fired for click outside features.");
+}
+
+// END TESTS
+
+</script>
+</head>
+<body onload="init()">
+<div id="map" style="width: 300px; height: 150px; border: 1px solid black"></div>
+</body>
+</html>
--- a/tests/Format/EncodedPolyline.html
+++ b/tests/Format/EncodedPolyline.html
@@ -3,12 +3,12 @@
    <script src="../OLLoader.js"></script>
    <script type="text/javascript">

-      var flatPoints;
-      var floats, smallFloats, encodedFloats;
-      var signedIntegers, encodedSignedIntegers;
-      var unsignedIntegers, encodedUnsignedIntegers;
+    var flatPoints;
+    var floats, smallFloats, encodedFloats;
+    var signedIntegers, encodedSignedIntegers;
+    var unsignedIntegers, encodedUnsignedIntegers;

-      function resetTestingData() {
+    function resetTestingData() {
        flatPoints = [38.50000, -120.20000,
                      40.70000, -120.95000,
                      43.25200, -126.45300];
@@ -22,7 +22,7 @@

        unsignedIntegers = [0, 30, 1, 31, 32, 2, 174];
        encodedUnsignedIntegers = '?]@^_@AmD';
-      }
+    }

    var basePoints = new Array(
        new Array(3850000, -12020000),
@@ -106,8 +106,8 @@
        for (i in decodedPoints) {
            var point = basePoints[i];
            var decodedPoint = decodedPoints[i];
-            t.eq(point[0], decodedPoint[0]);
-            t.eq(point[1], decodedPoint[1]);
+            t.eq(parseInt(decodedPoint[0] * 1e5), point[0]);
+            t.eq(parseInt(decodedPoint[1] * 1e5), point[1]);
        }
    }

@@ -141,7 +141,7 @@

        var format = new OpenLayers.Format.EncodedPolyline();

-        t.eq(format.encode(basePoints, 2), encoded);
+        t.eq(format.encode(basePoints, 2, 1), encoded);
    }

    function test_encodeDeltas_returns_expected_value(t) {
--- a/tests/Layer.html
+++ b/tests/Layer.html
@@ -858,44 +858,6 @@
             "setOpacity() does not trigger changelayer if the opacity value is the same");
    }

-    function test_display(t) {
-        t.plan(9);
-
-        var map, layer, log;
-
-        map = new OpenLayers.Map("map");
-        layer = new OpenLayers.Layer("", {
-            alwaysInRange: true,
-            visibility: true
-        });
-        map.addLayer(layer);
-
-        log = [];
-        map.events.register('changelayer', t, function(event) {
-            log.push({
-                layer: event.layer,
-                property: event.property
-            });
-        });
-        layer.display(false);
-        t.eq(layer.div.style.display, "none", "display() set layer's display style to correct value");
-        t.eq(layer.getVisibility(), true, "display() does not affect layer's visibility state");
-        t.eq(log.length, 1, "display() triggers changelayer once");
-        t.ok(log[0].layer == layer, "changelayer listener called with expected layer");
-        t.eq(log[0].property, "visibility", "changelayer listener called with expected property");
-        layer.visibility = false;
-        layer.display(true);
-        t.eq(layer.div.style.display, "block", "display() set layer's display style to correct value");
-        t.eq(layer.getVisibility(), false, "display() does not affect layer's visibility state");
-        layer.setVisibility(true);
-
-        // This call must not trig the event because the opacity value is the same.
-        log = [];
-        layer.display(true);
-        t.eq(log.length, 0, "display() does not trigger changelayer if the display value is the same");
-        layer.setVisibility(false);
-        t.eq(log.length, 1, "changelayer event called only once. setVisibility doesn't fire any extra changelayer events");
-    }

 /******
 * 
--- a/tests/Layer/ArcGIS93Rest.html
+++ b/tests/Layer/ArcGIS93Rest.html
@@ -60,7 +60,7 @@
        t.plan( 6 );
    
        layer = new OpenLayers.Layer.ArcGIS93Rest(name, url, params);
-        var map = new OpenLayers.Map('map');
+        var map = new OpenLayers.Map('map', {tileManager: null});
        map.addLayer(layer);
        var pixel = new OpenLayers.Pixel(5,6);
        var tile = layer.addTile(new OpenLayers.Bounds(1,2,3,4), pixel);
@@ -258,7 +258,7 @@
        t.plan( 9 );
    
        layer = new OpenLayers.Layer.ArcGIS93Rest(name, url, params);
-        var map = new OpenLayers.Map('map');
+        var map = new OpenLayers.Map('map', {tileManager: null});
        map.addLayer(layer);
        var pixel = new OpenLayers.Pixel(5,6);
        var tile = layer.addTile(new OpenLayers.Bounds(1,2,3,4), pixel);
--- a/tests/Layer/Grid.html
+++ b/tests/Layer/Grid.html
@@ -48,7 +48,7 @@

    function test_setMap(t) {
        t.plan(1);
-        var map = new OpenLayers.Map('map');
+        var map = new OpenLayers.Map('map', {tileManager: null});
        layer = new OpenLayers.Layer.Grid(name, url, params, null);
        map.addLayer(layer);
        t.ok(OpenLayers.Element.hasClass(layer.div, "olLayerGrid"),
@@ -682,7 +682,7 @@

        t.plan( 9 );

-        var map = new OpenLayers.Map('map');
+        var map = new OpenLayers.Map('map', {tileManager: null});
        layer = new OpenLayers.Layer.Grid(name, url, params);
        map.addLayer(layer);
        layer.destroy();
@@ -1130,32 +1130,31 @@
    
    function test_backbuffer_replace(t) {
        t.plan(6);
-        var map = new OpenLayers.Map('map');
+        var map = new OpenLayers.Map('map', {tileManager: null});
        var layer = new OpenLayers.Layer.WMS('', '../../img/blank.gif');
        map.addLayer(layer);
        map.zoomToMaxExtent();
        
-        t.delay_call(1, function() {
-            layer.mergeNewParams({foo: 'bar'});
-            var tile = layer.grid[1][1];
-            t.ok(OpenLayers.Element.hasClass(tile.imgDiv, 'olTileReplacing'), 'tile is marked for being replaced');
-            t.ok(document.getElementById(tile.id + '_bb'), 'backbuffer created for tile');
-            // simulate a css declaration where '.olTileReplacing' sets display
-            // to none.
-            tile.imgDiv.style.display = 'none';
-            tile.onImageLoad();
-            t.ok(!OpenLayers.Element.hasClass(tile.imgDiv, 'olTileReplacing'), 'tile replaced, no longer marked');
-            t.ok(!document.getElementById(tile.id + '_bb'), 'backbuffer removed for tile');
-            
-            layer.mergeNewParams({foo: 'baz'});
-            tile = layer.grid[1][1];
-            // simulate a css declaration where '.olTileReplacing' does not set
-            // display to none.
-            tile.imgDiv.style.display = 'block';
-            tile.onImageLoad();
-            t.ok(!OpenLayers.Element.hasClass(tile.imgDiv, 'olTileReplacing'), 'tile replaced, no longer marked');
-            t.ok(document.getElementById(tile.id + '_bb'), 'backbuffer not removed for visible tile');
-        });
+        layer.grid[1][1].onImageLoad();
+        layer.mergeNewParams({foo: 'bar'});
+        var tile = layer.grid[1][1];
+        t.ok(OpenLayers.Element.hasClass(tile.imgDiv, 'olTileReplacing'), 'tile is marked for being replaced');
+        t.ok(document.getElementById(tile.id + '_bb'), 'backbuffer created for tile');
+        // simulate a css declaration where '.olTileReplacing' sets display
+        // to none.
+        tile.imgDiv.style.display = 'none';
+        tile.onImageLoad();
+        t.ok(!OpenLayers.Element.hasClass(tile.imgDiv, 'olTileReplacing'), 'tile replaced, no longer marked');
+        t.ok(!document.getElementById(tile.id + '_bb'), 'backbuffer removed for tile');
+        
+        layer.mergeNewParams({foo: 'baz'});
+        tile = layer.grid[1][1];
+        // simulate a css declaration where '.olTileReplacing' does not set
+        // display to none.
+        tile.imgDiv.style.display = 'block';
+        tile.onImageLoad();
+        t.ok(!OpenLayers.Element.hasClass(tile.imgDiv, 'olTileReplacing'), 'tile replaced, no longer marked');
+        t.ok(document.getElementById(tile.id + '_bb'), 'backbuffer not removed for visible tile');
    }

    function test_backbuffer_replace_singleTile(t) {
@@ -1220,7 +1219,8 @@

        var map = new OpenLayers.Map('map', {
            resolutions: [32, 16, 8, 4, 2, 1],
-            zoomMethod: null
+            zoomMethod: null,
+            tileManager: null
        });
        var layer = new OpenLayers.Layer.WMS(
            "WMS",
--- a/tests/Layer/MapServer.html
+++ b/tests/Layer/MapServer.html
@@ -36,7 +36,7 @@
    
        var url = "http://labs.metacarta.com/cgi-bin/mapserv";
        layer = new OpenLayers.Layer.MapServer(name, url, params);
-        var map = new OpenLayers.Map('map');
+        var map = new OpenLayers.Map('map', {tileManager: null});
        map.addLayer(layer);
        var pixel = new OpenLayers.Pixel(5,6);
        var tile = layer.addTile(new OpenLayers.Bounds(1,2,3,4), pixel);
--- a/tests/Layer/UTFGrid.html
+++ b/tests/Layer/UTFGrid.html
@@ -32,7 +32,8 @@
            projection: "EPSG:900913",
            layers: [layer],
            center: [0, 0],
-            zoom: 1
+            zoom: 1,
+            tileManager: null
        });
    }
    
--- a/tests/Layer/WMS.html
+++ b/tests/Layer/WMS.html
@@ -73,7 +73,7 @@

        var url = "http://octo.metacarta.com/cgi-bin/mapserv";
        layer = new OpenLayers.Layer.WMS(name, url, params);
-        var map = new OpenLayers.Map('map');
+        var map = new OpenLayers.Map('map', {tileManager: null});
        map.addLayer(layer);
        var pixel = new OpenLayers.Pixel(5,6);
        var tile = layer.addTile(new OpenLayers.Bounds(1,2,3,4), pixel);
@@ -104,7 +104,7 @@

        var url = "http://octo.metacarta.com/cgi-bin/mapserv";
        layer = new OpenLayers.Layer.WMS(name, url, params, {encodeBBOX:true});
-        var map = new OpenLayers.Map('map');
+        var map = new OpenLayers.Map('map', {tileManager: null});
        map.addLayer(layer);
        var pixel = new OpenLayers.Pixel(5,6);
        var tile = layer.addTile(new OpenLayers.Bounds(1,2,3,4), pixel);
--- a/tests/Layer/WrapDateLine.html
+++ b/tests/Layer/WrapDateLine.html
@@ -134,7 +134,7 @@

        var url = "http://octo.metacarta.com/cgi-bin/mapserv";
        layer = new OpenLayers.Layer.WMS(name, url, params, {'wrapDateLine':true,encodeBBOX:true, buffer: 2});
-        var m = new OpenLayers.Map('map', {adjustZoom: function(z) {return z;}});
+        var m = new OpenLayers.Map('map', {tileManager: null, adjustZoom: function(z) {return z;}});
        m.addLayer(layer);
        m.zoomToMaxExtent();
        t.eq(layer.grid[3][0].url, "http://octo.metacarta.com/cgi-bin/mapserv?MAP=%2Fmapdata%2Fvmap_wms.map&LAYERS=basic&FORMAT=image%2Fpng&SERVICE=WMS&VERSION=1.1.1&REQUEST=GetMap&STYLES=&SRS=EPSG%3A4326&BBOX=0%2C-90%2C180%2C90&WIDTH=256&HEIGHT=256", "cell [3][0] is wrapped around the world.");
@@ -151,7 +151,7 @@
             "http://www.openlayers.org/world/index.php",
             {g: "satellite", map: "world"},
             {wrapDateLine: true, buffer: 2} ); 
-        var m = new OpenLayers.Map('map', {adjustZoom: function(z) {return z;}});
+        var m = new OpenLayers.Map('map', {tileManager: null, adjustZoom: function(z) {return z;}});
        m.addLayer(layer);
        m.zoomToMaxExtent();
        t.eq(layer.grid[4][7].url, "http://www.openlayers.org/world/index.php?g=satellite&map=world&i=jpeg&t=0&l=-256&s=221471921.25", "grid[5][7] kamap is okay");
@@ -170,7 +170,7 @@
                     "prov_bound,fedlimit,rail,road,popplace",
             transparent: "true", format: "image/png"},
            {wrapDateLine: true, encodeBBOX:true, buffer:2});
-        var m = new OpenLayers.Map('map', {adjustZoom: function(z) {return z;}});
+        var m = new OpenLayers.Map('map', {tileManager: null, adjustZoom: function(z) {return z;}});
        m.addLayers([baselayer,layer]);
        m.zoomToMaxExtent();
        t.eq(layer.grid[3][0].url, "http://www2.dmsolutions.ca/cgi-bin/mswms_gmap?LAYERS=bathymetry%2Cland_fn%2Cpark%2Cdrain_fn%2Cdrainage%2Cprov_bound%2Cfedlimit%2Crail%2Croad%2Cpopplace&TRANSPARENT=true&FORMAT=image%2Fpng&SERVICE=WMS&VERSION=1.1.1&REQUEST=GetMap&STYLES=&SRS=EPSG%3A4326&BBOX=0%2C-90%2C180%2C90&WIDTH=256&HEIGHT=256", "grid[0][0] wms overlay is okay");
--- a/tests/Map.html
+++ b/tests/Map.html
@@ -193,6 +193,7 @@
        // test that events.on is called at map construction
        var options = {
            eventListeners: {foo: "bar"},
+            tileManager: null,
            controls: []
        };
        OpenLayers.Events.prototype.on = function(obj) {
@@ -207,7 +208,7 @@
        OpenLayers.Events.prototype.on = function(obj) {
            t.fail("events.on called without eventListeners");
        }
-        var map2 = new OpenLayers.Map("map", {controls: []});
+        var map2 = new OpenLayers.Map("map", {tileManager: null, controls: []});
        OpenLayers.Events.prototype.on = method;
        map2.destroy();
    }
@@ -983,22 +984,14 @@
    }

    function test_Map_moveTo(t) {
-        t.plan(12);
+        t.plan(2);

        map = new OpenLayers.Map('map');
        var baseLayer = new OpenLayers.Layer.WMS("Test Layer", 
            "http://octo.metacarta.com/cgi-bin/mapserv?",
            {map: "/mapdata/vmap_wms.map", layers: "basic"},
            {maxResolution: 'auto', maxExtent: new OpenLayers.Bounds(-10,-10,10,10)});
-        var testLayer = new OpenLayers.Layer("",{maxResolution: 0.1, minResolution: 0.03, isBaseLayer: false, visibility: true});
-        var log = [];
-        map.events.register('changelayer', t, function(event) {
-            log.push({
-                layer: event.layer,
-                property: event.property
-            });
-        });
-        map.events.on({
+        baseLayer.events.on({
            move: function() {
                t.ok(true, "move listener called");
            },
@@ -1012,20 +1005,10 @@
            }
        });
        map.addLayer(baseLayer);
-        map.addLayer(testLayer);
-        log = [];
        var ll = new OpenLayers.LonLat(-100,-150);
        map.moveTo(ll, 2);
-        
        t.ok(map.getCenter().equals(new OpenLayers.LonLat(0,0)), "safely sets out-of-bounds lonlat");
-        t.eq(testLayer.div.style.display, "none", "moveTo out of resolution range set layer's display style to correct value");
-        t.eq(log.length, 1, "Map.moveTo out of resolution range triggers changelayer once");
-        t.ok(log[0].layer == testLayer, "changelayer listener called with expected layer");
-        t.eq(log[0].property, "visibility", "changelayer listener called with expected property");

-        map.moveTo(new OpenLayers.LonLat(0,0), 0);
-        t.eq(testLayer.div.style.display, "block", "moveTo in to resolution range set layer's display style to correct value");
-        
        map.destroy();
    }

@@ -2249,6 +2232,20 @@
        map.destroy();
    }

+    function test_tileManager(t) {
+        t.plan(3);
+        var map = new OpenLayers.Map('map');
+        t.ok(map.tileManager instanceof OpenLayers.TileManager, "Default tileManager created");
+        map.destroy();
+        map = new OpenLayers.Map('map', {tileManager: null});
+        t.ok(map.tileManager === null, "No tileManager created");
+        map.destroy();
+        var options = {cacheSize: 512};
+        map = new OpenLayers.Map('map', {tileManager: options});
+        t.eq(map.tileManager.cacheSize, 512, "cacheSize taken from options");
+        map.destroy();
+    }
+
  </script>
 </head>
 <body>
--- a/tests/Tile/Image.html
+++ b/tests/Tile/Image.html
@@ -282,7 +282,7 @@
                       format: 'image/png'};


-        var map = new OpenLayers.Map('map');
+        var map = new OpenLayers.Map('map', {tileManager: null});
        var layer = new OpenLayers.Layer.WMS(name, url, params, {gutter: gutter});
        map.addLayer(layer);
        map.setCenter(new OpenLayers.LonLat(0,0), 5);
@@ -296,7 +296,7 @@
        map.destroy();
        
        var gutter = 15;
-        var map = new OpenLayers.Map('map');
+        var map = new OpenLayers.Map('map', {tileManager: null});
        var layer = new OpenLayers.Layer.WMS(name, url, params, {gutter: gutter});
        map.addLayer(layer);
        map.setCenter(new OpenLayers.LonLat(0,0), 5);
@@ -320,7 +320,7 @@
    function test_createBackBuffer(t) {
        t.plan(3);

-        var map = new OpenLayers.Map('map');
+        var map = new OpenLayers.Map('map', {tileManager: null});
        var layer = new OpenLayers.Layer.WMS( "OpenLayers WMS", 
            "../../img/blank.gif", {layers: 'basic'});
        map.addLayer(layer);
@@ -345,7 +345,7 @@
    function test_onImageLoad(t) {
        t.plan(3);

-        var map = new OpenLayers.Map('map');
+        var map = new OpenLayers.Map('map', {tileManager: null});
        var layer = new OpenLayers.Layer.WMS( "OpenLayers WMS",
            "../../img/blank.gif", {layers: 'basic'}, {opacity: 0.5});
        map.addLayer(layer);
@@ -382,12 +382,9 @@

            t.delay_call(5, function() {
                var tile = layer.grid[0][0];
-                if (tile.isLoading) {
-                    t.ok(false, "test_getCanvasContext timeout");
-                } else {
-                    t.ok(tile.getCanvasContext() instanceof CanvasRenderingContext2D,
-                         "getCanvasContext() returns CanvasRenderingContext2D instance");
-                }
+                tile.onImageLoad();
+                t.ok(tile.getCanvasContext() instanceof CanvasRenderingContext2D,
+                     "getCanvasContext() returns CanvasRenderingContext2D instance");
                map.destroy();
            });
        }
--- a/tests/Tile/Image/IFrame.html
+++ b/tests/Tile/Image/IFrame.html
@@ -19,7 +19,7 @@
    
    function test_Tile_Image_IFrame_create (t) {
        t.plan( 3 );
-        map   = new OpenLayers.Map('map');
+        map   = new OpenLayers.Map('map', {tileManager: null});
        var bar = new Array(205).join("1234567890");
        layer = new OpenLayers.Layer.WMS(name, wmsUrl,
                                         {layers: 'basic', foo: bar},
@@ -87,7 +87,7 @@
    function test_Tile_Image_IFrame_createImage (t) {
        t.plan( 9 );

-        map   = new OpenLayers.Map('map');
+        map   = new OpenLayers.Map('map', {tileManager: null});
        layer = new OpenLayers.Layer.WMS(name, wmsUrl, {layers: 'basic'}, {tileOptions: {maxGetUrlLength: 0}}); 
        map.addLayer(layer);  
        var tile = layer.addTile(bounds, position);
--- a/tests/Tile/UTFGrid.html
+++ b/tests/Tile/UTFGrid.html
@@ -32,7 +32,8 @@
            projection: "EPSG:900913",
            layers: [layer],
            center: [0, 0],
-            zoom: 1
+            zoom: 1,
+            tileManager: null
        });
    }
    
--- a/tests/TileManager.html
+++ b/tests/TileManager.html
@@ -134,4 +134,4 @@
 <body>
 <div id="map" style="width:499px;height:549px;display:none"></div>
 </body>
-</html>
+</html>
--- a/tests/deprecated/Layer/MapServer.html
+++ b/tests/deprecated/Layer/MapServer.html
@@ -23,7 +23,7 @@
            t.debug_print("Can't test google reprojection in Opera or Safari.");
        } else if(validkey) {
            t.plan(5);
-            var map = new OpenLayers.Map('map');
+            var map = new OpenLayers.Map('map', {tileManager: null});
            var layer = new OpenLayers.Layer.Google("Google");
            map.addLayer(layer);
            layer = new OpenLayers.Layer.MapServer(name, url, params, {reproject: true, isBaseLayer: false, buffer: 2});
@@ -42,7 +42,7 @@
                          window.location.host);
        }

-        var map = new OpenLayers.Map('map');
+        var map = new OpenLayers.Map('map', {tileManager: null});
        layer = new OpenLayers.Layer.MapServer(name, url, params, {buffer:2});
        map.addLayer(layer);
        map.setCenter(new OpenLayers.LonLat(0,0), 5);
--- a/tests/deprecated/Layer/MapServer/Untiled.html
+++ b/tests/deprecated/Layer/MapServer/Untiled.html
@@ -69,7 +69,7 @@
    function test_Layer_MapServer_Untiled_mergeNewParams (t) {
        t.plan( 5 );

-        var map = new OpenLayers.Map("map");
+        var map = new OpenLayers.Map("map", {tileManager: null});
        var url = "http://labs.metacarta.com/cgi-bin/mapserv";
        layer = new OpenLayers.Layer.MapServer.Untiled(name, url, params);
        
--- a/tests/deprecated/Layer/WMS.html
+++ b/tests/deprecated/Layer/WMS.html
@@ -23,7 +23,7 @@
        } else if(validkey) {
            t.plan(5);

-            var map = new OpenLayers.Map('map');
+            var map = new OpenLayers.Map('map', {tileManager: null});
            var layer = new OpenLayers.Layer.Google("Google");
            map.addLayer(layer);
            var wmslayer = new OpenLayers.Layer.WMS(name, url, params,
@@ -43,7 +43,7 @@
                          window.location.host);
        }

-        var map = new OpenLayers.Map('map');
+        var map = new OpenLayers.Map('map', {tileManager: null});
        layer = new OpenLayers.Layer.WMS(name, url, params, {buffer: 2});
        map.addLayer(layer);
        map.setCenter(new OpenLayers.LonLat(0,0), 5);
--- a/tests/list-tests.html
+++ b/tests/list-tests.html
@@ -52,6 +52,7 @@
    <li>Control/ZoomBox.html</li>
    <li>Events.html</li>
    <li>Events/buttonclick.html</li>
+    <li>Events/featureclick.html?visible</li>
    <li>Extras.html</li>
    <li>Feature.html</li>
    <li>Feature/Vector.html</li>
--- a/theme/default/style.css
+++ b/theme/default/style.css
@@ -506,7 +506,7 @@ a.olControlZoomOut {
 }

 /* when replacing tiles, do not show tile and backbuffer at the same time */
-.olTileImage.olTileReplacing {
+.olTileReplacing {
    display: none;
 }
Author	SHA1	Message	Date
Bart van den Eijnden	f4a4090814	set correct VERSION_NUMBER	2013-07-09 11:26:12 +02:00
ahocevar	49dd5a4fd8	Merge pull request #1019 from ahocevar/chrome-optimized Deal with recent Chrome optimizations to avoid failing TileManager and tests	2013-07-09 11:23:27 +02:00
ahocevar	d020e8f666	Merge pull request #1018 from ahocevar/tilemanager-image-only UTFGrid examples broken because of TileManager. r=@bartvde	2013-07-09 11:22:52 +02:00
Bart van den Eijnden	c8d4105d23	set VERSION_NUMBER to 2.13 final	2013-06-17 14:03:59 +02:00
Bart van den Eijnden	d60d1e5789	update version number to rc7	2013-06-07 10:53:30 +02:00
Bart van den Eijnden	afaee6880d	Merge pull request #1003 from openlayers/notilemgrtest Whenever we run tests with the tileManager, we cannot inspect any grid...(r=@ahocevar)	2013-06-07 10:51:48 +02:00
ahocevar	cc69b73dcf	Revert "Merge pull request #708 from mpriour/displayEvent" This reverts commit `0b3f582e10`, reversing changes made to `74103ec3e0`. The reason for reverting this is a regression. See #997.	2013-06-07 10:51:13 +02:00
ahocevar	fe0ffbf56e	Fixing dependencies This avoids undefined this.tileManager.addMap, and re-adds the TileManager to the mobile build profile.	2013-06-07 09:08:54 +02:00
ahocevar	f4f72d5eeb	TileManager dependency management If the build does not contain TileManager.js, do not create a TileManager instance for the map. If the build does not contain Layer/Grid.js, do not try to add Grid layer instances to the list of layers managed by the TileManager.	2013-06-07 09:08:30 +02:00
Bart van den Eijnden	1c21d9cc15	Merge pull request #998 from bartvde/tilemgrdefault enable TileManager by default as suggested by @marcjansen and @bartvde ... (r=@ahocevar)	2013-06-06 14:18:18 +02:00
ahocevar	4d52d4aeb5	Drag interval of 0 (i.e. no separate cycle) seems appropriate now The reason for setting this to 1 was ancient IPhones with ancient iOS versions. On all other devices, 0 seems to work better, and it removes the overhead of spawning a separate cycle for each drag.	2013-06-06 13:38:13 +02:00
Bart van den Eijnden	1e94821042	set VERSION_NUMBER to 2.13-rc6	2013-06-06 09:19:42 +02:00
ahocevar	8cccbfb189	Protect ZoomBox from division by zero When the map is at the highest zoom level, the old and the current resolution will be the same. This would cause a division by zero, which the JavaScript engine does not recognize as such. So we have to protect zoomOriginPx from becoming {x: Infinity, y: Infinity}.	2013-06-06 09:18:35 +02:00
Bart van den Eijnden	1cf69634cf	update VERSION_NUMBER to 2.13-rc5	2013-05-30 15:41:00 +02:00
ahocevar	c2b7e8b327	Merge pull request #987 from ahocevar/google-orphaned Vector layer duplicates when changeing to google base layer. r=@bartvde	2013-05-30 15:37:35 +02:00
ahocevar	fe0620dc7f	Merge pull request #174 from ahocevar/feature-events Turning @tschaub's FeatureAgent into an event extension. r=@bartvde	2013-05-30 15:33:24 +02:00
Bart van den Eijnden	8778b746b3	update VERSION_NUMBER to 2.13-rc4	2013-05-24 12:09:53 +02:00
ahocevar	a5ea8d7fcf	Fixing tests Selecting the same feature again should not do anything, which was ensured in the old implementation by a check in the SelectFeature control. This means that the previous commit causes a change in behavior in standalone mode, which I would consider a bugfix. I documented this change in the release notes.	2013-05-24 12:07:49 +02:00
ahocevar	b103d3b428	We don't want to re-select an already selected feature	2013-05-24 12:07:35 +02:00
ahocevar	8562582dd2	Avoiding duplicate events	2013-05-24 12:07:22 +02:00
ahocevar	cd5ae45273	Do not manage cache when cached tile is on target layer's backbuffer	2013-05-24 12:06:58 +02:00
Tobias Bieniek	d1b00824fc	Format/EncodedPolyline: Change default factor to 1e5 This matches the factors in the other methods and the default of the original algorithm. Having this set at 1 before can be considered as a bug.	2013-05-24 12:06:39 +02:00
Tobias Bieniek	4399ebcb04	Format/EncodedPolyline: Added opt_factor parameter to encode/decode()	2013-05-24 12:06:25 +02:00
Tobias Bieniek	0bb804c9e7	tests/EncodedPolyline: Fixed indent	2013-05-24 12:06:12 +02:00
Bart van den Eijnden	572d78fb4d	set version number to 2.13-rc3	2013-05-17 13:16:49 +02:00
ahocevar	1d948fc914	Make sure that drawTilesFromQueue gets executed For events other than move, the tile queue may not be populated yet when updateTimeout is called. So instead of checking for the queue's length, we register the timer unconditionally in these cases.	2013-05-17 13:15:01 +02:00
ahocevar	449b85966e	.olTileReplacing is on the parent of .olTileImage when using frame	2013-05-17 13:14:36 +02:00
ahocevar	1223ea339d	Use getTile() instead of imgDiv to get the correct element The correct way to get the markup of a tile is to use getTile() - the imgDiv will only be available if the tile does not use a frame.	2013-05-17 13:14:16 +02:00