From c53374c797b3eabce6b288c39743ccdde3e1e686 Mon Sep 17 00:00:00 2001
From: ahocevar <andreas.hocevar@gmail.com>
Date: Thu, 29 Sep 2011 10:03:02 -0600
Subject: [PATCH 01/34] always start the map extent on the right of the
 dateline

---
 lib/OpenLayers/Map.js | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/lib/OpenLayers/Map.js b/lib/OpenLayers/Map.js
index cad15bf620..78eb0c3f74 100644
--- a/lib/OpenLayers/Map.js
+++ b/lib/OpenLayers/Map.js
@@ -1940,7 +1940,18 @@ OpenLayers.Map = OpenLayers.Class({
         var valid = false;
         if (lonlat != null) {
             var maxExtent = this.getMaxExtent();
-            valid = maxExtent.containsLonLat(lonlat);        
+            valid = maxExtent.containsLonLat(lonlat);
+            if (!valid && this.baseLayer.wrapDateLine) {
+                lonlat = lonlat.clone();
+                var worldWidth = maxExtent.getWidth();
+                while(lonlat.lon > maxExtent.right) {
+                    lonlat.lon -= worldWidth;
+                    valid = maxExtent.containsLonLat(lonlat);
+                    if (valid) {
+                        break;
+                    }
+                }
+            }
         }
         return valid;
     },
@@ -2254,12 +2265,9 @@ OpenLayers.Map = OpenLayers.Class({
             }
             //if the bounds was straddling (see above), then the center point 
             // we got from it was wrong. So we take our new bounds and ask it
-            // for the center. Because our new bounds is at least partially 
-            // outside the bounds of maxExtent, the new calculated center 
-            // might also be. We don't want to pass a bad center value to 
-            // setCenter, so we have it wrap itself across the date line.
+            // for the center.
             //
-            center = bounds.getCenterLonLat().wrapDateLine(maxExtent);
+            center = bounds.getCenterLonLat();
         }
         this.setCenter(center, this.getZoomForExtent(bounds, closest));
     },

From 516914c935981e5bdfdb098e00b7aad2a7e91a61 Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Thu, 29 Sep 2011 12:21:05 -0600
Subject: [PATCH 02/34] Push dateline wrapping to intersectsBounds method.

It should simplify things by pushing the dateline wrapping stuff into the intersectsBounds method.
---
 lib/OpenLayers/BaseTypes/Bounds.js     | 78 +++++++++++++++++++-------
 lib/OpenLayers/Tile.js                 | 27 ++-------
 tests/manual/dateline-smallextent.html | 18 ++++--
 3 files changed, 76 insertions(+), 47 deletions(-)

diff --git a/lib/OpenLayers/BaseTypes/Bounds.js b/lib/OpenLayers/BaseTypes/Bounds.js
index e33c49667f..06dc5e1d2f 100644
--- a/lib/OpenLayers/BaseTypes/Bounds.js
+++ b/lib/OpenLayers/BaseTypes/Bounds.js
@@ -428,48 +428,79 @@ OpenLayers.Bounds = OpenLayers.Class({
      * 
      * Parameters:
      * bounds - {<OpenLayers.Bounds>} The target bounds.
+     * options - {Object} Optional parameters.
+     * 
+     * Acceptable options:
      * inclusive - {Boolean} Treat coincident borders as intersecting.  Default
      *     is true.  If false, bounds that do not overlap but only touch at the
      *     border will not be considered as intersecting.
+     * worldBounds - {<OpenLayers.Bounds>} If a worldBounds is provided, two
+     *     bounds will be considered as intersecting if they intersect when 
+     *     shifted to within the world bounds.  This applies only to bounds that
+     *     cross or are completely outside the world bounds.
      *
      * Returns:
      * {Boolean} The passed-in bounds object intersects this bounds.
      */
-    intersectsBounds:function(bounds, inclusive) {
-        if (inclusive == null) {
-            inclusive = true;
+    intersectsBounds:function(bounds, options) {
+        options = options || {};
+        if (typeof options === "boolean")  {
+            options = {inclusive: true};
+        }
+        if (options.worldBounds) {
+            var self = this.wrapDateLine(options.worldBounds)
+            bounds = bounds.wrapDateLine(options.worldBounds);
+        } else {
+            self = this;
+        }
+        if (options.inclusive == null) {
+            options.inclusive = true;
         }
         var intersects = false;
         var mightTouch = (
-            this.left == bounds.right ||
-            this.right == bounds.left ||
-            this.top == bounds.bottom ||
-            this.bottom == bounds.top
+            self.left == bounds.right ||
+            self.right == bounds.left ||
+            self.top == bounds.bottom ||
+            self.bottom == bounds.top
         );
         
         // if the two bounds only touch at an edge, and inclusive is false,
         // then the bounds don't *really* intersect.
-        if (inclusive || !mightTouch) {
+        if (options.inclusive || !mightTouch) {
             // otherwise, if one of the boundaries even partially contains another,
             // inclusive of the edges, then they do intersect.
             var inBottom = (
-                ((bounds.bottom >= this.bottom) && (bounds.bottom <= this.top)) ||
-                ((this.bottom >= bounds.bottom) && (this.bottom <= bounds.top))
+                ((bounds.bottom >= self.bottom) && (bounds.bottom <= self.top)) ||
+                ((self.bottom >= bounds.bottom) && (self.bottom <= bounds.top))
             );
             var inTop = (
-                ((bounds.top >= this.bottom) && (bounds.top <= this.top)) ||
-                ((this.top > bounds.bottom) && (this.top < bounds.top))
+                ((bounds.top >= self.bottom) && (bounds.top <= self.top)) ||
+                ((self.top > bounds.bottom) && (self.top < bounds.top))
             );
             var inLeft = (
-                ((bounds.left >= this.left) && (bounds.left <= this.right)) ||
-                ((this.left >= bounds.left) && (this.left <= bounds.right))
+                ((bounds.left >= self.left) && (bounds.left <= self.right)) ||
+                ((self.left >= bounds.left) && (self.left <= bounds.right))
             );
             var inRight = (
-                ((bounds.right >= this.left) && (bounds.right <= this.right)) ||
-                ((this.right >= bounds.left) && (this.right <= bounds.right))
+                ((bounds.right >= self.left) && (bounds.right <= self.right)) ||
+                ((self.right >= bounds.left) && (self.right <= bounds.right))
             );
             intersects = ((inBottom || inTop) && (inLeft || inRight));
         }
+        // document me
+        if (options.worldBounds && !intersects) {
+            var world = options.worldBounds;
+            var width = world.getWidth();
+            var selfCrosses = !world.containsBounds(self);
+            var boundsCrosses = !world.containsBounds(bounds);
+            if (selfCrosses && !boundsCrosses) {
+                bounds = bounds.add(-width, 0);
+                intersects = self.intersectsBounds(bounds, {inclusive: options.inclusive});
+            } else if (boundsCrosses && !selfCrosses) {
+                self = self.add(-width, 0);
+                intersects = bounds.intersectsBounds(self, {inclusive: options.inclusive});                
+            }
+        }
         return intersects;
     },
     
@@ -577,8 +608,9 @@ OpenLayers.Bounds = OpenLayers.Class({
      *                       a different bounds value if this bounds is 
      *                       *entirely* outside of the maxExtent. If this 
      *                       bounds straddles the dateline (is part in/part 
-     *                       out of maxExtent), the returned bounds will be 
-     *                       merely a copy of this one.
+     *                       out of maxExtent), the returned bounds will always 
+     *                       cross the left edge of the given maxExtent.
+     *.
      */
     wrapDateLine: function(maxExtent, options) {    
         options = options || {};
@@ -589,18 +621,24 @@ OpenLayers.Bounds = OpenLayers.Class({
         var newBounds = this.clone();
     
         if (maxExtent) {
+            var width = maxExtent.getWidth();
 
            //shift right?
            while ( newBounds.left < maxExtent.left && 
                    (newBounds.right - rightTolerance) <= maxExtent.left ) { 
-                newBounds = newBounds.add(maxExtent.getWidth(), 0);
+                newBounds = newBounds.add(width, 0);
            }
 
            //shift left?
            while ( (newBounds.left + leftTolerance) >= maxExtent.right && 
                    newBounds.right > maxExtent.right ) { 
-                newBounds = newBounds.add(-maxExtent.getWidth(), 0);
+                newBounds = newBounds.add(-width, 0);
            }
+           
+           // crosses right? force left
+           if (newBounds.left < maxExtent.right && newBounds.right > maxExtent.right) {
+                newBounds = newBounds.add(-width, 0);
+            }
         }
                 
         return newBounds;
diff --git a/lib/OpenLayers/Tile.js b/lib/OpenLayers/Tile.js
index bc7c1baf6f..aa3b89b1ee 100644
--- a/lib/OpenLayers/Tile.js
+++ b/lib/OpenLayers/Tile.js
@@ -175,29 +175,10 @@ OpenLayers.Tile = OpenLayers.Class({
         var withinMaxExtent = false,
             maxExtent = this.layer.maxExtent;
         if (maxExtent) {
-            // prepare up to 3 versions of the layer's maxExtent, to make sure
-            // that the intersectsBounds check below catches all cases of
-            // extents that cross the dateline:
-            // (1) left bound positive, right bound negative (wrapped)
-            // (2) left bound positive, right bound positive (exceeding world)
-            // (3) left bound negative (exceeding world), right bound positive
-            var maxExtents = [maxExtent];
-            if (this.layer.map.baseLayer.wrapDateLine) {
-                if (maxExtent.left > maxExtent.right) {
-                    var worldWidth = this.layer.map.getMaxExtent().getWidth();
-                    maxExtent = this.layer.maxExtent.clone();
-                    maxExtent.left -= worldWidth;
-                    maxExtents.push(maxExtent);
-                    maxExtent = this.layer.maxExtent.clone();
-                    maxExtent.right += worldWidth;
-                    maxExtents.push(maxExtent);
-                }
-            }
-            for (var i=maxExtents.length-1; i>=0; --i) {
-                if (this.bounds.intersectsBounds(maxExtents[i], false)) {
-                    withinMaxExtent = true;
-                    break;
-                }
+            var map = this.layer.map;
+            var worldBounds = map.baseLayer.wrapDateLine && map.getMaxExtent();
+            if (this.bounds.intersectsBounds(maxExtent, {inclusive: false, worldBounds: worldBounds})) {
+                withinMaxExtent = true;
             }
         }
         
diff --git a/tests/manual/dateline-smallextent.html b/tests/manual/dateline-smallextent.html
index ed80a8a9e7..3dc9025f18 100644
--- a/tests/manual/dateline-smallextent.html
+++ b/tests/manual/dateline-smallextent.html
@@ -22,19 +22,29 @@ var map;
 function init(){
     map = new OpenLayers.Map('map');
 
-    var osm = new OpenLayers.Layer.OSM(
-        "OSM", null,
+    var base = new OpenLayers.Layer.WMS("marble", 
+        "http://demo.opengeo.org/geoserver/wms",
+        {layers: "topp:naturalearth"},
         {wrapDateLine: true}
     );
-    var extent = new OpenLayers.Bounds(15849982.183008, -11368938.517442, -14206280.326992, -1350184.3474419);
+    var extent = new OpenLayers.Bounds(142.3828125,-70.902270266175,233.6171875,-12.039326531729);
     var wms = new OpenLayers.Layer.WMS( "world",
         "http://demo.opengeo.org/geoserver/wms",
         {layers: 'world', transparent: true},
         {maxExtent: extent}
     );
+    
+    var poly = extent.toGeometry();
+    var vector = new OpenLayers.Layer.Vector();
+    poly.components[0].components.forEach(function(point) {
+        vector.addFeatures([
+            new OpenLayers.Feature.Vector(point)
+        ]);
+    })
 
-    map.addLayers([osm, wms]);
+    map.addLayers([base, wms, vector]);
 
+    map.addControl(new OpenLayers.Control.LayerSwitcher());
     map.zoomToExtent(extent);
 }
 

From c2582c1970b8ebbdf5cc64e2b27b30e877fa1a5f Mon Sep 17 00:00:00 2001
From: ahocevar <andreas.hocevar@gmail.com>
Date: Thu, 29 Sep 2011 13:35:00 -0600
Subject: [PATCH 03/34] use tolerance for crosses right / force left

---
 lib/OpenLayers/BaseTypes/Bounds.js | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/lib/OpenLayers/BaseTypes/Bounds.js b/lib/OpenLayers/BaseTypes/Bounds.js
index 06dc5e1d2f..e43e813227 100644
--- a/lib/OpenLayers/BaseTypes/Bounds.js
+++ b/lib/OpenLayers/BaseTypes/Bounds.js
@@ -623,20 +623,21 @@ OpenLayers.Bounds = OpenLayers.Class({
         if (maxExtent) {
             var width = maxExtent.getWidth();
 
-           //shift right?
-           while ( newBounds.left < maxExtent.left && 
-                   (newBounds.right - rightTolerance) <= maxExtent.left ) { 
+            //shift right?
+            while (newBounds.left < maxExtent.left && 
+                   newBounds.right - rightTolerance <= maxExtent.left ) { 
                 newBounds = newBounds.add(width, 0);
-           }
+            }
 
-           //shift left?
-           while ( (newBounds.left + leftTolerance) >= maxExtent.right && 
+            //shift left?
+            while (newBounds.left + leftTolerance >= maxExtent.right && 
                    newBounds.right > maxExtent.right ) { 
                 newBounds = newBounds.add(-width, 0);
-           }
+            }
            
-           // crosses right? force left
-           if (newBounds.left < maxExtent.right && newBounds.right > maxExtent.right) {
+            // crosses right? force left
+            if (newBounds.left + leftTolerance < maxExtent.right &&
+                   newBounds.right - rightTolerance > maxExtent.right) {
                 newBounds = newBounds.add(-width, 0);
             }
         }

From dc6989b9f04c335c7f79224846c5d913dc96c247 Mon Sep 17 00:00:00 2001
From: ahocevar <andreas.hocevar@gmail.com>
Date: Thu, 29 Sep 2011 13:35:22 -0600
Subject: [PATCH 04/34] adding missing comma

---
 lib/OpenLayers/BaseTypes/Bounds.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/OpenLayers/BaseTypes/Bounds.js b/lib/OpenLayers/BaseTypes/Bounds.js
index e43e813227..6c85c8ab0b 100644
--- a/lib/OpenLayers/BaseTypes/Bounds.js
+++ b/lib/OpenLayers/BaseTypes/Bounds.js
@@ -448,7 +448,7 @@ OpenLayers.Bounds = OpenLayers.Class({
             options = {inclusive: true};
         }
         if (options.worldBounds) {
-            var self = this.wrapDateLine(options.worldBounds)
+            var self = this.wrapDateLine(options.worldBounds);
             bounds = bounds.wrapDateLine(options.worldBounds);
         } else {
             self = this;

From 0277eb1ed3fd5ad6f952a7e74c52a3951eee97b8 Mon Sep 17 00:00:00 2001
From: ahocevar <andreas.hocevar@gmail.com>
Date: Thu, 29 Sep 2011 13:38:40 -0600
Subject: [PATCH 05/34] worldBounds option for containsLonLat.

This is basically the same enhancement we made for intersectsBounds, and we no longer have to do dateline shifting in other components to get proper containsLonLat results.
---
 lib/OpenLayers/BaseTypes/Bounds.js | 33 ++++++++++++++++++++++++++++--
 lib/OpenLayers/Map.js              | 14 ++-----------
 2 files changed, 33 insertions(+), 14 deletions(-)

diff --git a/lib/OpenLayers/BaseTypes/Bounds.js b/lib/OpenLayers/BaseTypes/Bounds.js
index 6c85c8ab0b..83e0c79ded 100644
--- a/lib/OpenLayers/BaseTypes/Bounds.js
+++ b/lib/OpenLayers/BaseTypes/Bounds.js
@@ -358,14 +358,43 @@ OpenLayers.Bounds = OpenLayers.Class({
      * 
      * Parameters:
      * ll - {<OpenLayers.LonLat>}
+     * options - {Object} Optional parameters
+     *
+     * Acceptable options:
      * inclusive - {Boolean} Whether or not to include the border.
      *     Default is true.
+     * worldBounds - {<OpenLayers.Bounds>} If a worldBounds is provided, the
+     *     ll will be considered as contained if it exceeds the world bounds,
+     *     but can be wrapped around the dateline so it is contained by this
+     *     bounds.
      *
      * Returns:
      * {Boolean} The passed-in lonlat is within this bounds.
      */
-    containsLonLat:function(ll, inclusive) {
-        return this.contains(ll.lon, ll.lat, inclusive);
+    containsLonLat: function(ll, options) {
+        options = options || {};
+        if (typeof options === "boolean") {
+            options.inclusive = options;
+        }
+        var contains = this.contains(ll.lon, ll.lat, options.inclusive),
+            worldBounds = options.worldBounds;
+        if (worldBounds && !contains) {
+            var worldWidth = worldBounds.getWidth();
+            ll = ll.clone();
+            while(!contains && ll.lon > worldBounds.right) {
+                ll.lon -= worldWidth;
+                contains = worldBounds.containsLonLat(
+                    ll, {inclusive: options.inclusive}
+                );
+            }
+            while(!contains && ll.lon < worldBounds.left) {
+                ll.lon += worldWidth;
+                contains = worldBounds.containsLonLat(
+                    ll, {inclusive: options.inclusive}
+                );
+            }
+        }
+        return contains;
     },
 
     /**
diff --git a/lib/OpenLayers/Map.js b/lib/OpenLayers/Map.js
index 78eb0c3f74..44771f09ce 100644
--- a/lib/OpenLayers/Map.js
+++ b/lib/OpenLayers/Map.js
@@ -1940,18 +1940,8 @@ OpenLayers.Map = OpenLayers.Class({
         var valid = false;
         if (lonlat != null) {
             var maxExtent = this.getMaxExtent();
-            valid = maxExtent.containsLonLat(lonlat);
-            if (!valid && this.baseLayer.wrapDateLine) {
-                lonlat = lonlat.clone();
-                var worldWidth = maxExtent.getWidth();
-                while(lonlat.lon > maxExtent.right) {
-                    lonlat.lon -= worldWidth;
-                    valid = maxExtent.containsLonLat(lonlat);
-                    if (valid) {
-                        break;
-                    }
-                }
-            }
+            var worldBounds = this.baseLayer.wrapDateLine && maxExtent;
+            valid = maxExtent.containsLonLat(lonlat, {worldBounds: worldBounds});
         }
         return valid;
     },

From 23a17fc355b451031e5df7eb3d32ba26502c588a Mon Sep 17 00:00:00 2001
From: ahocevar <andreas.hocevar@gmail.com>
Date: Thu, 29 Sep 2011 13:39:16 -0600
Subject: [PATCH 06/34] use tolerance for correct tile bounds shifting

---
 lib/OpenLayers/Tile.js | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/lib/OpenLayers/Tile.js b/lib/OpenLayers/Tile.js
index aa3b89b1ee..fb8b08d931 100644
--- a/lib/OpenLayers/Tile.js
+++ b/lib/OpenLayers/Tile.js
@@ -195,8 +195,12 @@ OpenLayers.Tile = OpenLayers.Class({
     setBounds: function(bounds) {
         bounds = bounds.clone();
         if (this.layer.map.baseLayer.wrapDateLine) {
-            var worldExtent = this.layer.map.getMaxExtent();
-            bounds = bounds.wrapDateLine(worldExtent);
+            var worldExtent = this.layer.map.getMaxExtent(),
+                tolerance = this.layer.map.getResolution();
+            bounds = bounds.wrapDateLine(worldExtent, {
+                leftTolerance: tolerance,
+                rightTolerance: tolerance
+            });
         }
         this.bounds = bounds;
     },

From 2e6c9bfdc290724c1a6f09025c4b3ab15214bc05 Mon Sep 17 00:00:00 2001
From: ahocevar <andreas.hocevar@gmail.com>
Date: Thu, 29 Sep 2011 13:53:32 -0600
Subject: [PATCH 07/34] Remove action that is now covered by wrapDateLine.

With the changes in wrapDateLine, we don't have to shift the bounds here any more.
---
 lib/OpenLayers/Layer/Grid.js | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/lib/OpenLayers/Layer/Grid.js b/lib/OpenLayers/Layer/Grid.js
index 696d6e92cf..56d5cfb8e4 100644
--- a/lib/OpenLayers/Layer/Grid.js
+++ b/lib/OpenLayers/Layer/Grid.js
@@ -404,15 +404,9 @@ OpenLayers.Layer.Grid = OpenLayers.Class(OpenLayers.Layer.HTTPRequest, {
      */
     calculateGridLayout: function(bounds, origin, resolution) {
         bounds = bounds.clone();
-        if (this.map.baseLayer.wrapDateLine) {
-            var maxExtent = this.map.getMaxExtent(),
-                width = maxExtent.getWidth();
-            // move the bounds one world width to the right until the origin is
-            // within the world extent
-            while (bounds.left < maxExtent.left) {
-                bounds.left += width;
-                bounds.right += width;
-            } 
+        var map = this.map;
+        if (map.wrapDateLine) {
+            bounds = bounds.wrapDateLine(map.getMaxExtent());
         }
         
         var tilelon = resolution * this.tileSize.w;

From 085c1156c21f8ae0d93adc4d42aa37075c60bf1b Mon Sep 17 00:00:00 2001
From: ahocevar <andreas.hocevar@gmail.com>
Date: Thu, 29 Sep 2011 13:54:05 -0600
Subject: [PATCH 08/34] simplified the example a bit; improved description

---
 tests/manual/dateline-smallextent.html | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/tests/manual/dateline-smallextent.html b/tests/manual/dateline-smallextent.html
index 3dc9025f18..1d05e849cf 100644
--- a/tests/manual/dateline-smallextent.html
+++ b/tests/manual/dateline-smallextent.html
@@ -4,7 +4,7 @@
     <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: Sketch handlers crossing the dateline</title>
+    <title>OpenLayers: Overlay layer extents crossing the dateline</title>
     <link rel="stylesheet" href="../../theme/default/style.css" type="text/css">
     <link rel="stylesheet" href="../../examples/style.css" type="text/css">
     <style type="text/css">
@@ -34,13 +34,10 @@ function init(){
         {maxExtent: extent}
     );
     
-    var poly = extent.toGeometry();
     var vector = new OpenLayers.Layer.Vector();
-    poly.components[0].components.forEach(function(point) {
-        vector.addFeatures([
-            new OpenLayers.Feature.Vector(point)
-        ]);
-    })
+    vector.addFeatures([
+        new OpenLayers.Feature.Vector(extent.toGeometry())
+    ]);
 
     map.addLayers([base, wms, vector]);
 
@@ -54,9 +51,10 @@ function init(){
     <h1 id="title">OpenLayers overlays crossing the dateline test</h1>
 
     <p id="shortdesc">
-        The overlay has an extent smaller than the world extent. The base layer
-        is configured with wrapDateLine set to true. New Zealand and a part of
-        Australia should always be visible on the map.
+        The overlay has an extent smaller than the world extent, but exceeds
+        the world extent. The base layer is configured with wrapDateLine set to
+        true. The area inside the orange rectangle should always contain tiles
+        from the world layer, regardless of the zoom level.
     </p>
     <div id="map" class="smallmap"></div>
   </body>

From 275b310bda3a5844cef61871dee8264750a52e92 Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Thu, 29 Sep 2011 16:08:38 -0600
Subject: [PATCH 09/34] Coordinates that are easier to visualize.

---
 tests/manual/dateline-sketch.html | 48 +++++++++++++------------------
 1 file changed, 20 insertions(+), 28 deletions(-)

diff --git a/tests/manual/dateline-sketch.html b/tests/manual/dateline-sketch.html
index 2a49d836d3..ade4945033 100644
--- a/tests/manual/dateline-sketch.html
+++ b/tests/manual/dateline-sketch.html
@@ -16,35 +16,8 @@
     <script src="http://maps.google.com/maps/api/js?v=3.5&amp;sensor=false"></script>
 
     <script src="../../lib/OpenLayers.js"></script>
-    <script type="text/javascript">
-
-// make map available for easy debugging
-var map;
-
-function init(){
-    var options = {
-        projection: new OpenLayers.Projection("EPSG:900913"),
-        units: "m",
-        maxResolution: 156543.0339,
-        maxExtent: new OpenLayers.Bounds(-20037508, -20037508, 20037508, 20037508)
-    };
-    map = new OpenLayers.Map('map', options);
-
-    var osm = new OpenLayers.Layer.OSM(
-        "OSM", null, {wrapDateLine: true}
-    );
-    var vector = new OpenLayers.Layer.Vector("Editable Vectors");
-
-    map.addLayers([osm, vector]);
-    map.addControl(new OpenLayers.Control.EditingToolbar(vector));
-
-    var extent = new OpenLayers.Bounds(15849982.183008, -11368938.517442, -14206280.326992, -1350184.3474418);
-    map.zoomToExtent(extent);
-}
-
-    </script>
   </head>
-  <body onload="init()">
+  <body>
     <h1 id="title">OpenLayers sketch handlers crossing the dateline example</h1>
 
     <div id="tags">
@@ -60,5 +33,24 @@ function init(){
 
     <div id="docs">
     </div>
+        <script type="text/javascript">
+
+        var map = new OpenLayers.Map('map');
+
+        var base = new OpenLayers.Layer.WMS("marble", 
+            "http://demo.opengeo.org/geoserver/wms",
+            {layers: "topp:naturalearth"},
+            {wrapDateLine: true}
+        );
+
+        var vector = new OpenLayers.Layer.Vector("Editable Vectors");
+
+        map.addLayers([base, vector]);
+        map.addControl(new OpenLayers.Control.EditingToolbar(vector));
+
+        map.setCenter(new OpenLayers.LonLat(-179, 0), 2);
+
+        </script>
+
   </body>
 </html>

From 5925cb12d724383588cc68288d71ee94dbcc2faf Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Thu, 29 Sep 2011 19:46:00 -0600
Subject: [PATCH 10/34] Only shift extents that cross once.

---
 lib/OpenLayers/BaseTypes/Bounds.js | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/lib/OpenLayers/BaseTypes/Bounds.js b/lib/OpenLayers/BaseTypes/Bounds.js
index 83e0c79ded..25e4a9cbde 100644
--- a/lib/OpenLayers/BaseTypes/Bounds.js
+++ b/lib/OpenLayers/BaseTypes/Bounds.js
@@ -652,21 +652,24 @@ OpenLayers.Bounds = OpenLayers.Class({
         if (maxExtent) {
             var width = maxExtent.getWidth();
 
+            var newRight = newBounds.right - rightTolerance;
+            var newLeft = newBounds.left + leftTolerance;
+
             //shift right?
             while (newBounds.left < maxExtent.left && 
-                   newBounds.right - rightTolerance <= maxExtent.left ) { 
+                   newRight <= maxExtent.left ) { 
                 newBounds = newBounds.add(width, 0);
             }
 
             //shift left?
-            while (newBounds.left + leftTolerance >= maxExtent.right && 
+            while (newLeft >= maxExtent.right && 
                    newBounds.right > maxExtent.right ) { 
                 newBounds = newBounds.add(-width, 0);
             }
            
-            // crosses right? force left
-            if (newBounds.left + leftTolerance < maxExtent.right &&
-                   newBounds.right - rightTolerance > maxExtent.right) {
+            // crosses right only? force left
+            if (newLeft < maxExtent.right && newLeft > maxExtent.left && 
+                   newRight > maxExtent.right) {
                 newBounds = newBounds.add(-width, 0);
             }
         }

From cc8165790733508e760e6116bee72aa9904d47c7 Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Thu, 29 Sep 2011 19:46:53 -0600
Subject: [PATCH 11/34] Always left justify the renderer extent.

---
 lib/OpenLayers/Renderer.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/lib/OpenLayers/Renderer.js b/lib/OpenLayers/Renderer.js
index 6a35b3f34c..b4fba7f717 100644
--- a/lib/OpenLayers/Renderer.js
+++ b/lib/OpenLayers/Renderer.js
@@ -125,6 +125,9 @@ OpenLayers.Renderer = OpenLayers.Class({
      */
     setExtent: function(extent, resolutionChanged) {
         this.extent = extent.clone();
+        if (this.map.baseLayer && this.map.baseLayer.wrapDateLine) {
+            this.extent = extent.wrapDateLine(this.map.getMaxExtent());
+        }
         if (resolutionChanged) {
             this.resolution = null;
         }

From 2549935a8ae74887aa906425cc51b8e4d3aa1c9f Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Thu, 29 Sep 2011 19:48:20 -0600
Subject: [PATCH 12/34] Only hide features if they don't intersect in a wrapped
 sense.

---
 lib/OpenLayers/Renderer.js | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/lib/OpenLayers/Renderer.js b/lib/OpenLayers/Renderer.js
index b4fba7f717..83c203e2bf 100644
--- a/lib/OpenLayers/Renderer.js
+++ b/lib/OpenLayers/Renderer.js
@@ -182,7 +182,11 @@ OpenLayers.Renderer = OpenLayers.Class({
         if (feature.geometry) {
             var bounds = feature.geometry.getBounds();
             if(bounds) {
-                if (!bounds.intersectsBounds(this.extent)) {
+                var worldBounds;
+                if (this.map.baseLayer && this.map.baseLayer.wrapDateLine) {
+                    worldBounds = this.map.getMaxExtent();
+                }
+                if (!bounds.intersectsBounds(this.extent, {worldBounds: worldBounds})) {
                     style = {display: "none"};
                 }
                 var rendered = this.drawGeometry(feature.geometry, style, feature.id);

From f5f93ac947126141ea322a8584756882680a1231 Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Thu, 29 Sep 2011 19:50:11 -0600
Subject: [PATCH 13/34] Don't render if feature doesn't intersect renderer
 extent in a warped sense.

---
 lib/OpenLayers/Renderer/Canvas.js | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/lib/OpenLayers/Renderer/Canvas.js b/lib/OpenLayers/Renderer/Canvas.js
index d9e7828469..582fe62e14 100644
--- a/lib/OpenLayers/Renderer/Canvas.js
+++ b/lib/OpenLayers/Renderer/Canvas.js
@@ -141,8 +141,15 @@ OpenLayers.Renderer.Canvas = OpenLayers.Class(OpenLayers.Renderer, {
             style = this.applyDefaultSymbolizer(style || feature.style);
             // don't render if display none or feature outside extent
             var bounds = feature.geometry.getBounds();
-            rendered = (style.display !== "none") && !!bounds && 
-                bounds.intersectsBounds(this.extent);
+
+            var worldBounds;
+            if (this.map.baseLayer && this.map.baseLayer.wrapDateLine) {
+                worldBounds = this.map.getMaxExtent();
+            }
+
+            var intersects = bounds.intersectsBounds(this.extent, {worldBounds: worldBounds});
+
+            rendered = (style.display !== "none") && !!bounds && intersects;
             if (rendered) {
                 // keep track of what we have rendered for redraw
                 this.features[feature.id] = [feature, style];

From 9ab440e615f921a8b9ae81f4f8dd6b896587b73a Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Thu, 29 Sep 2011 19:51:20 -0600
Subject: [PATCH 14/34] Calculate x-offset for features outside the world
 bounds.

---
 lib/OpenLayers/Renderer/Canvas.js | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/lib/OpenLayers/Renderer/Canvas.js b/lib/OpenLayers/Renderer/Canvas.js
index 582fe62e14..2d2f79e581 100644
--- a/lib/OpenLayers/Renderer/Canvas.js
+++ b/lib/OpenLayers/Renderer/Canvas.js
@@ -580,7 +580,7 @@ OpenLayers.Renderer.Canvas = OpenLayers.Class(OpenLayers.Renderer, {
     getLocalXY: function(point) {
         var resolution = this.getResolution();
         var extent = this.extent;
-        var x = (point.x / resolution + (-extent.left / resolution));
+        var x = ((point.x - this.featureDx) / resolution + (-extent.left / resolution));
         var y = ((extent.top / resolution) - point.y / resolution);
         return [x, y];
     },
@@ -666,10 +666,21 @@ OpenLayers.Renderer.Canvas = OpenLayers.Class(OpenLayers.Renderer, {
                 this.hitContext.clearRect(0, 0, width, height);
             }
             var labelMap = [];
-            var feature, style;
+            var feature, style, bounds;
+            var worldBounds = (this.map.baseLayer && this.map.baseLayer.wrapDateLine) && this.map.getMaxExtent();
             for (var id in this.features) {
                 if (!this.features.hasOwnProperty(id)) { continue; }
                 feature = this.features[id][0];
+
+                this.featureDx = 0;
+                if (worldBounds) {
+                    bounds = feature.geometry.getBounds();
+                    if (!(bounds.intersectsBounds(this.extent))) {
+                        var wrappedBounds = bounds.wrapDateLine(worldBounds);
+                        this.featureDx = bounds.left - wrappedBounds.left;
+                    }
+                }
+
                 style = this.features[id][1];
                 this.drawGeometry(feature.geometry, style, feature.id);
                 if(style.label) {

From d8c269c891b2df64ec2188c0201ce257569f2767 Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Thu, 29 Sep 2011 19:51:54 -0600
Subject: [PATCH 15/34] Update example to use canvas renderer and start with
 some features.

---
 tests/manual/dateline-sketch.html | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/tests/manual/dateline-sketch.html b/tests/manual/dateline-sketch.html
index 86e14287a7..85a0058f89 100644
--- a/tests/manual/dateline-sketch.html
+++ b/tests/manual/dateline-sketch.html
@@ -40,10 +40,19 @@
             {layers: "topp:naturalearth"},
             {wrapDateLine: true}
         );
+        
 
-        var vector = new OpenLayers.Layer.Vector("Editable Vectors");
+        var vector = new OpenLayers.Layer.Vector("Editable Vectors", {renderers: ["Canvas"]});
 
         map.addLayers([base, vector]);
+        
+        var wkt = new OpenLayers.Format.WKT();
+        var f = wkt.read("POLYGON((210.8828125 39.7265625,151.8203125 36.2109375,152.171875 -9.4921875,219.3203125 -10.546875,210.8828125 39.7265625))");
+        
+        var f2 = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.Point(-190, 0));
+        
+        vector.addFeatures([f, f2]);
+        
         map.addControl(new OpenLayers.Control.EditingToolbar(vector));
 
         map.setCenter(new OpenLayers.LonLat(-179, 0), 2);

From 449042d5673dc384c435507786d59820c87f90b4 Mon Sep 17 00:00:00 2001
From: ahocevar <andreas.hocevar@gmail.com>
Date: Fri, 30 Sep 2011 11:29:35 -0600
Subject: [PATCH 16/34] making renderer configurable

---
 tests/manual/dateline-sketch.html | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/manual/dateline-sketch.html b/tests/manual/dateline-sketch.html
index 85a0058f89..1be1f36a06 100644
--- a/tests/manual/dateline-sketch.html
+++ b/tests/manual/dateline-sketch.html
@@ -41,8 +41,11 @@
             {wrapDateLine: true}
         );
         
+        // allow testing of specific renderers via "?renderer=Canvas", etc
+        var renderer = OpenLayers.Util.getParameters(window.location.href).renderer;
+        renderer = (renderer) ? [renderer] : OpenLayers.Layer.Vector.prototype.renderers;
 
-        var vector = new OpenLayers.Layer.Vector("Editable Vectors", {renderers: ["Canvas"]});
+        var vector = new OpenLayers.Layer.Vector("Editable Vectors", {renderers: renderer});
 
         map.addLayers([base, vector]);
         

From fe08a843eec3b83737d03e635b457aabe5881bfa Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Fri, 30 Sep 2011 13:20:15 -0600
Subject: [PATCH 17/34] Don't cache newRight or newLeft while changing bounds.

---
 lib/OpenLayers/BaseTypes/Bounds.js | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/lib/OpenLayers/BaseTypes/Bounds.js b/lib/OpenLayers/BaseTypes/Bounds.js
index 25e4a9cbde..1afc93a577 100644
--- a/lib/OpenLayers/BaseTypes/Bounds.js
+++ b/lib/OpenLayers/BaseTypes/Bounds.js
@@ -652,24 +652,22 @@ OpenLayers.Bounds = OpenLayers.Class({
         if (maxExtent) {
             var width = maxExtent.getWidth();
 
-            var newRight = newBounds.right - rightTolerance;
-            var newLeft = newBounds.left + leftTolerance;
-
             //shift right?
             while (newBounds.left < maxExtent.left && 
-                   newRight <= maxExtent.left ) { 
+                   newBounds.right - rightTolerance <= maxExtent.left ) { 
                 newBounds = newBounds.add(width, 0);
             }
 
             //shift left?
-            while (newLeft >= maxExtent.right && 
+            while (newBounds.left + leftTolerance >= maxExtent.right && 
                    newBounds.right > maxExtent.right ) { 
                 newBounds = newBounds.add(-width, 0);
             }
            
             // crosses right only? force left
+            var newLeft = newBounds.left + leftTolerance;
             if (newLeft < maxExtent.right && newLeft > maxExtent.left && 
-                   newRight > maxExtent.right) {
+                   newBounds.right - rightTolerance > maxExtent.right) {
                 newBounds = newBounds.add(-width, 0);
             }
         }

From b82a24ef36d69101bd5eb7ed6ed6e63970ec6d2c Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Fri, 30 Sep 2011 13:22:29 -0600
Subject: [PATCH 18/34] Determine how many worlds away we are instead of simply
 wrapping.

---
 lib/OpenLayers/Renderer/Canvas.js | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/lib/OpenLayers/Renderer/Canvas.js b/lib/OpenLayers/Renderer/Canvas.js
index 2d2f79e581..97b9741b9b 100644
--- a/lib/OpenLayers/Renderer/Canvas.js
+++ b/lib/OpenLayers/Renderer/Canvas.js
@@ -675,10 +675,11 @@ OpenLayers.Renderer.Canvas = OpenLayers.Class(OpenLayers.Renderer, {
                 this.featureDx = 0;
                 if (worldBounds) {
                     bounds = feature.geometry.getBounds();
-                    if (!(bounds.intersectsBounds(this.extent))) {
-                        var wrappedBounds = bounds.wrapDateLine(worldBounds);
-                        this.featureDx = bounds.left - wrappedBounds.left;
-                    }
+                    var worldWidth = worldBounds.getWidth();
+                    var rendererCenterX = (this.extent.left + this.extent.right) / 2;
+                    var featureCenterX = (bounds.left + bounds.right) / 2;
+                    var worldsAway = Math.round((featureCenterX - rendererCenterX) / worldWidth);
+                    this.featureDx = worldsAway * worldWidth;
                 }
 
                 style = this.features[id][1];

From 38e59965f16c5b85e0e6d0190b03607c3132f828 Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Fri, 30 Sep 2011 16:53:33 -0600
Subject: [PATCH 19/34] Quicker route to contains when wrapping.

Instead of moving one world at a time and testing for containment, we can jump immediately by the number of worlds we are away from the bounds.
---
 lib/OpenLayers/BaseTypes/Bounds.js | 28 ++++++++-------------
 tests/BaseTypes/Bounds.html        | 40 +++++++++++++++++++++++++++++-
 2 files changed, 50 insertions(+), 18 deletions(-)

diff --git a/lib/OpenLayers/BaseTypes/Bounds.js b/lib/OpenLayers/BaseTypes/Bounds.js
index 1afc93a577..fba59ec7b8 100644
--- a/lib/OpenLayers/BaseTypes/Bounds.js
+++ b/lib/OpenLayers/BaseTypes/Bounds.js
@@ -372,27 +372,21 @@ OpenLayers.Bounds = OpenLayers.Class({
      * {Boolean} The passed-in lonlat is within this bounds.
      */
     containsLonLat: function(ll, options) {
-        options = options || {};
         if (typeof options === "boolean") {
-            options.inclusive = options;
+            options =  {inclusive: options};
         }
+        options = options || {};
         var contains = this.contains(ll.lon, ll.lat, options.inclusive),
             worldBounds = options.worldBounds;
         if (worldBounds && !contains) {
             var worldWidth = worldBounds.getWidth();
             ll = ll.clone();
-            while(!contains && ll.lon > worldBounds.right) {
-                ll.lon -= worldWidth;
-                contains = worldBounds.containsLonLat(
-                    ll, {inclusive: options.inclusive}
-                );
-            }
-            while(!contains && ll.lon < worldBounds.left) {
-                ll.lon += worldWidth;
-                contains = worldBounds.containsLonLat(
-                    ll, {inclusive: options.inclusive}
-                );
-            }
+            var worldCenterX = (worldBounds.left + worldBounds.right) / 2;
+            var worldsAway = Math.round((ll.lon - worldCenterX) / worldWidth);
+            ll.lon -= (worldsAway * worldWidth);
+            contains = this.containsLonLat(
+                ll, {inclusive: options.inclusive}
+            );
         }
         return contains;
     },
@@ -472,10 +466,10 @@ OpenLayers.Bounds = OpenLayers.Class({
      * {Boolean} The passed-in bounds object intersects this bounds.
      */
     intersectsBounds:function(bounds, options) {
-        options = options || {};
-        if (typeof options === "boolean")  {
-            options = {inclusive: true};
+        if (typeof options === "boolean") {
+            options =  {inclusive: options};
         }
+        options = options || {};
         if (options.worldBounds) {
             var self = this.wrapDateLine(options.worldBounds);
             bounds = bounds.wrapDateLine(options.worldBounds);
diff --git a/tests/BaseTypes/Bounds.html b/tests/BaseTypes/Bounds.html
index f5620af87b..54d41c13fd 100644
--- a/tests/BaseTypes/Bounds.html
+++ b/tests/BaseTypes/Bounds.html
@@ -124,6 +124,43 @@
         t.eq( bounds.containsLonLat(ll), bounds.contains(ll.lon, ll.lat), "containsLonLat works");
 
     }
+    
+    function test_containsLonLat_wraped(t) {
+        
+        var worldBounds = new OpenLayers.Bounds(-180, -90, 180, 90);
+
+        var cases = [{
+            ll: [0, 0], bbox: [-10, -10, 10, 10], contained: true
+        }, {
+            ll: [20, 0], bbox: [-10, -10, 10, 10], contained: false
+        }, {
+            ll: [360, 0], bbox: [-10, -10, 10, 10], contained: true
+        }, {
+            ll: [380, 0], bbox: [-10, -10, 10, 10], contained: false
+        }, {
+            ll: [725, 5], bbox: [-10, -10, 10, 10], contained: true
+        }, {
+            ll: [-355, -5], bbox: [-10, -10, 10, 10], contained: true
+        }, {
+            ll: [-715, 5], bbox: [-10, -10, 10, 10], contained: true
+        }, {
+            ll: [-735, 5], bbox: [-10, -10, 10, 10], contained: false
+        }, {
+            ll: [-180 * 50, 5], bbox: [-10, -10, 10, 10], contained: true
+        }];
+        
+        var len = cases.length;
+        t.plan(len);
+        
+        var c, bounds, loc;
+        for (var i=0; i<len; ++i) {
+            c = cases[i];
+            loc = new OpenLayers.LonLat(c.ll[0], c.ll[1]);
+            bounds = new OpenLayers.Bounds.fromArray(c.bbox);
+            t.eq(bounds.containsLonLat(loc, {worldBounds: worldBounds}), c.contained, "case " + i);
+        }
+        
+    }
 
     function test_Bounds_fromString(t) {
        t.plan( 12 );
@@ -555,7 +592,8 @@
     //straddling right
         testBounds = simpleBounds.add(10,0);
         wrappedBounds = testBounds.wrapDateLine(maxExtent);
-        t.ok(wrappedBounds.equals(testBounds), "wrapping a bounds that straddles the right of maxextent does nothing");
+        desiredBounds = testBounds.add(-maxExtent.getWidth(), 0)
+        t.ok(wrappedBounds.equals(desiredBounds), "wrapping a bounds that straddles the right of maxextent moves extent to left side of the world");
     
     //right leftTolerance
         testBounds = simpleBounds.add(14,0);

From 868757501fb320d408dea4cbf3929ff93cdc82a0 Mon Sep 17 00:00:00 2001
From: ahocevar <andreas.hocevar@gmail.com>
Date: Sun, 2 Oct 2011 15:40:13 -0600
Subject: [PATCH 20/34] deal with the dateline in the SVG renderer. Not yet
 fully functional.

---
 lib/OpenLayers/Renderer/SVG.js | 31 ++++++++++++++++++++++---------
 1 file changed, 22 insertions(+), 9 deletions(-)

diff --git a/lib/OpenLayers/Renderer/SVG.js b/lib/OpenLayers/Renderer/SVG.js
index f7f53bf08e..e21d37c8e3 100644
--- a/lib/OpenLayers/Renderer/SVG.js
+++ b/lib/OpenLayers/Renderer/SVG.js
@@ -117,14 +117,16 @@ OpenLayers.Renderer.SVG = OpenLayers.Class(OpenLayers.Renderer.Elements, {
         OpenLayers.Renderer.Elements.prototype.setExtent.apply(this, 
                                                                arguments);
         
-        var resolution = this.getResolution();
-        var left = -extent.left / resolution;
-        var top = extent.top / resolution;
+        var resolution = this.getResolution(),
+            left = -extent.left / resolution,
+            rightLL = -extent.right,
+            top = extent.top / resolution;
 
         // If the resolution has changed, start over changing the corner, because
         // the features will redraw.
         if (resolutionChanged) {
             this.left = left;
+            this.rightLL = rightLL;
             this.top = top;
             // Set the viewbox
             var extentString = "0 0 " + this.size.w + " " + this.size.h;
@@ -133,6 +135,17 @@ OpenLayers.Renderer.SVG = OpenLayers.Class(OpenLayers.Renderer.Elements, {
             this.translate(0, 0);
             return true;
         } else {
+            if (this.map.baseLayer && this.map.baseLayer.wrapDateLine) {
+                var oldLeft = this.left * resolution,
+                    newLeft = left * resolution,
+                    worldBounds = this.map.getMaxExtent(),
+                    worldWidth = worldBounds.getWidth(),
+                    oldCenterX = (oldLeft + this.rightLL) / 2,
+                    newCenterX = (newLeft + rightLL) / 2,
+                    worldsAway = Math.round((oldCenterX - newCenterX) / worldWidth);
+                left += worldsAway * worldWidth / resolution;
+                console.log(extent.toString());
+            }
             var inRange = this.translate(left - this.left, top - this.top);
             if (!inRange) {
                 // recenter the coordinate system
@@ -505,7 +518,7 @@ OpenLayers.Renderer.SVG = OpenLayers.Class(OpenLayers.Renderer.Elements, {
      */
     drawCircle: function(node, geometry, radius) {
         var resolution = this.getResolution();
-        var x = (geometry.x / resolution + this.left);
+        var x = ((geometry.x - this.featureDx) / resolution + this.left);
         var y = (this.top - geometry.y / resolution);
 
         if (this.inValidRange(x, y)) { 
@@ -615,7 +628,7 @@ OpenLayers.Renderer.SVG = OpenLayers.Class(OpenLayers.Renderer.Elements, {
      */ 
     drawRectangle: function(node, geometry) {
         var resolution = this.getResolution();
-        var x = (geometry.x / resolution + this.left);
+        var x = ((geometry.x - this.featureDx) / resolution + this.left);
         var y = (this.top - geometry.y / resolution);
 
         if (this.inValidRange(x, y)) { 
@@ -681,7 +694,7 @@ OpenLayers.Renderer.SVG = OpenLayers.Class(OpenLayers.Renderer.Elements, {
     drawText: function(featureId, style, location) {
         var resolution = this.getResolution();
 
-        var x = (location.x / resolution + this.left);
+        var x = ((location.x - this.featureDx) / resolution + this.left);
         var y = (location.y / resolution - this.top);
 
         var label = this.nodeFactory(featureId + this.LABEL_ID_SUFFIX, "text");
@@ -833,9 +846,9 @@ OpenLayers.Renderer.SVG = OpenLayers.Class(OpenLayers.Renderer.Elements, {
         var resolution = this.getResolution();
         var maxX = this.MAX_PIXEL - this.translationParameters.x;
         var maxY = this.MAX_PIXEL - this.translationParameters.y;
-        var x1 = goodComponent.x / resolution + this.left;
+        var x1 = (goodComponent.x - this.featureDx) / resolution + this.left;
         var y1 = this.top - goodComponent.y / resolution;
-        var x2 = badComponent.x / resolution + this.left;
+        var x2 = (badComponent.x - this.featureDx) / resolution + this.left;
         var y2 = this.top - badComponent.y / resolution;
         var k;
         if (x2 < -maxX || x2 > maxX) {
@@ -862,7 +875,7 @@ OpenLayers.Renderer.SVG = OpenLayers.Class(OpenLayers.Renderer.Elements, {
      */
     getShortString: function(point) {
         var resolution = this.getResolution();
-        var x = (point.x / resolution + this.left);
+        var x = ((point.x - this.featureDx) / resolution + this.left);
         var y = (this.top - point.y / resolution);
 
         if (this.inValidRange(x, y)) { 

From de8425db17792e746367bbe031addc157bacb954 Mon Sep 17 00:00:00 2001
From: ahocevar <andreas.hocevar@gmail.com>
Date: Sun, 2 Oct 2011 15:40:44 -0600
Subject: [PATCH 21/34] world shifting for renderers

---
 lib/OpenLayers/Renderer.js | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/lib/OpenLayers/Renderer.js b/lib/OpenLayers/Renderer.js
index 83c203e2bf..a0772559a4 100644
--- a/lib/OpenLayers/Renderer.js
+++ b/lib/OpenLayers/Renderer.js
@@ -188,9 +188,20 @@ OpenLayers.Renderer = OpenLayers.Class({
                 }
                 if (!bounds.intersectsBounds(this.extent, {worldBounds: worldBounds})) {
                     style = {display: "none"};
+                } else {
+                    this.featureDx = 0;
+                    if (worldBounds) {
+                        bounds = feature.geometry.getBounds();
+                        var worldWidth = worldBounds.getWidth(),
+                            rendererCenterX = (this.extent.left + this.extent.right) / 2,
+                            featureCenterX = (bounds.left + bounds.right) / 2,
+                            worldsAway = Math.round((featureCenterX - rendererCenterX) / worldWidth);
+                        this.featureDx = worldsAway * worldWidth;
+                    }
                 }
                 var rendered = this.drawGeometry(feature.geometry, style, feature.id);
                 if(style.display != "none" && style.label && rendered !== false) {
+
                     var location = feature.geometry.getCentroid(); 
                     if(style.labelXOffset || style.labelYOffset) {
                         var xOffset = isNaN(style.labelXOffset) ? 0 : style.labelXOffset;

From 2cfe6f83c26c65ec66e92254a9c8bee716c26a84 Mon Sep 17 00:00:00 2001
From: ahocevar <andreas.hocevar@gmail.com>
Date: Sat, 8 Oct 2011 11:33:35 -0400
Subject: [PATCH 22/34] Cross-dateline rendering fixed for SVG and added for
 VML renderer.

---
 lib/OpenLayers/Renderer.js          |  6 +++++
 lib/OpenLayers/Renderer/Elements.js | 35 +++++++++++++++++++++++++++++
 lib/OpenLayers/Renderer/SVG.js      | 24 +++++---------------
 lib/OpenLayers/Renderer/VML.js      | 25 ++++++++++-----------
 4 files changed, 58 insertions(+), 32 deletions(-)

diff --git a/lib/OpenLayers/Renderer.js b/lib/OpenLayers/Renderer.js
index a0772559a4..15078748ef 100644
--- a/lib/OpenLayers/Renderer.js
+++ b/lib/OpenLayers/Renderer.js
@@ -122,6 +122,11 @@ OpenLayers.Renderer = OpenLayers.Class({
      * Parameters:
      * extent - {<OpenLayers.Bounds>}
      * resolutionChanged - {Boolean}
+     *
+     * Returns:
+     * {Boolean} true to notify the layer that the new extent does not exceed
+     *     the coordinate range, and the features will not need to be redrawn.
+     *     False otherwise.
      */
     setExtent: function(extent, resolutionChanged) {
         this.extent = extent.clone();
@@ -131,6 +136,7 @@ OpenLayers.Renderer = OpenLayers.Class({
         if (resolutionChanged) {
             this.resolution = null;
         }
+        return true;
     },
     
     /**
diff --git a/lib/OpenLayers/Renderer/Elements.js b/lib/OpenLayers/Renderer/Elements.js
index 12b036bf13..d3822a9483 100644
--- a/lib/OpenLayers/Renderer/Elements.js
+++ b/lib/OpenLayers/Renderer/Elements.js
@@ -458,6 +458,41 @@ OpenLayers.Renderer.Elements = OpenLayers.Class(OpenLayers.Renderer, {
             this.indexer.clear();
         }
     },
+    
+    /**
+     * Method: setExtent
+     * Set the visible part of the layer.
+     *
+     * Parameters:
+     * extent - {<OpenLayers.Bounds>}
+     * resolutionChanged - {Boolean}
+     *
+     * Returns:
+     * {Boolean} true to notify the layer that the new extent does not exceed
+     *     the coordinate range, and the features will not need to be redrawn.
+     *     False otherwise.
+     */
+    setExtent: function(extent, resolutionChanged) {
+        var coordSysUnchanged = OpenLayers.Renderer.prototype.setExtent.apply(this, arguments);
+        var resolution = this.getResolution();
+        if (this.map.baseLayer && this.map.baseLayer.wrapDateLine) {
+            coordSysUnchanged = this.featureDx === 0;
+            var rightOfDateLine,
+                world = this.map.getMaxExtent();
+            if (world.right > extent.left && world.right < extent.right) {
+                rightOfDateLine = true;
+            } else if (world.left > extent.left && world.left < extent.right) {
+                rightOfDateLine = false;
+            }
+            if (rightOfDateLine !== this.rightOfDateLine || resolutionChanged) {
+                coordSysUnchanged = false;
+                this.xOffset = rightOfDateLine === true ?
+                    world.getWidth() / resolution : 0;
+            }
+            this.rightOfDateLine = rightOfDateLine;
+        }
+        return coordSysUnchanged;
+    },
 
     /** 
      * Method: getNodeType
diff --git a/lib/OpenLayers/Renderer/SVG.js b/lib/OpenLayers/Renderer/SVG.js
index e21d37c8e3..b2d475a4f0 100644
--- a/lib/OpenLayers/Renderer/SVG.js
+++ b/lib/OpenLayers/Renderer/SVG.js
@@ -114,44 +114,30 @@ OpenLayers.Renderer.SVG = OpenLayers.Class(OpenLayers.Renderer.Elements, {
      *     False otherwise.
      */
     setExtent: function(extent, resolutionChanged) {
-        OpenLayers.Renderer.Elements.prototype.setExtent.apply(this, 
-                                                               arguments);
+        var coordSysUnchanged = OpenLayers.Renderer.Elements.prototype.setExtent.apply(this, arguments);
         
         var resolution = this.getResolution(),
             left = -extent.left / resolution,
-            rightLL = -extent.right,
             top = extent.top / resolution;
 
         // If the resolution has changed, start over changing the corner, because
         // the features will redraw.
         if (resolutionChanged) {
             this.left = left;
-            this.rightLL = rightLL;
             this.top = top;
             // Set the viewbox
             var extentString = "0 0 " + this.size.w + " " + this.size.h;
 
             this.rendererRoot.setAttributeNS(null, "viewBox", extentString);
-            this.translate(0, 0);
+            this.translate(this.xOffset, 0);
             return true;
         } else {
-            if (this.map.baseLayer && this.map.baseLayer.wrapDateLine) {
-                var oldLeft = this.left * resolution,
-                    newLeft = left * resolution,
-                    worldBounds = this.map.getMaxExtent(),
-                    worldWidth = worldBounds.getWidth(),
-                    oldCenterX = (oldLeft + this.rightLL) / 2,
-                    newCenterX = (newLeft + rightLL) / 2,
-                    worldsAway = Math.round((oldCenterX - newCenterX) / worldWidth);
-                left += worldsAway * worldWidth / resolution;
-                console.log(extent.toString());
-            }
-            var inRange = this.translate(left - this.left, top - this.top);
+            inRange = this.translate(left - this.left + this.xOffset, top - this.top);
             if (!inRange) {
                 // recenter the coordinate system
                 this.setExtent(extent, true);
             }
-            return inRange;
+            return coordSysUnchanged && inRange;
         }
     },
     
@@ -921,7 +907,7 @@ OpenLayers.Renderer.SVG = OpenLayers.Class(OpenLayers.Renderer.Elements, {
         var id = this.container.id + "-" + graphicName;
         
         // check if symbol already exists in the defs
-        var existing = document.getElementById(id)
+        var existing = document.getElementById(id);
         if (existing != null) {
             return existing;
         }
diff --git a/lib/OpenLayers/Renderer/VML.js b/lib/OpenLayers/Renderer/VML.js
index 88c6f292fb..7f9783d4aa 100644
--- a/lib/OpenLayers/Renderer/VML.js
+++ b/lib/OpenLayers/Renderer/VML.js
@@ -90,8 +90,7 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
      *     the coordinate range, and the features will not need to be redrawn.
      */
     setExtent: function(extent, resolutionChanged) {
-        OpenLayers.Renderer.Elements.prototype.setExtent.apply(this, 
-                                                               arguments);
+        var coordSysUnchanged = OpenLayers.Renderer.Elements.prototype.setExtent.apply(this, arguments);
         var resolution = this.getResolution();
     
         var left = (extent.left/resolution) | 0;
@@ -106,7 +105,7 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
         }
 
         
-        var org = left + " " + top;
+        var org = (left - this.xOffset) + " " + top;
         this.root.coordorigin = org;
         var roots = [this.root, this.vectorRoot, this.textRoot];
         var root;
@@ -121,7 +120,7 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
         // matches the display Y axis of the map
         this.root.style.flip = "y";
         
-        return true;
+        return coordSysUnchanged;
     },
 
 
@@ -226,7 +225,7 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
                 var yOffset = (style.graphicYOffset != undefined) ?
                     style.graphicYOffset : -(0.5 * height);
                 
-                node.style.left = (((geometry.x/resolution - this.offset.x)+xOffset) | 0) + "px";
+                node.style.left = ((((geometry.x - this.featureDx)/resolution - this.offset.x)+xOffset) | 0) + "px";
                 node.style.top = (((geometry.y/resolution - this.offset.y)-(yOffset+height)) | 0) + "px";
                 node.style.width = width + "px";
                 node.style.height = height + "px";
@@ -483,9 +482,9 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
             var resolution = this.getResolution();
         
             var scaledBox = 
-                new OpenLayers.Bounds((bbox.left/resolution - this.offset.x) | 0,
+                new OpenLayers.Bounds(((bbox.left - this.featureDx)/resolution - this.offset.x) | 0,
                                       (bbox.bottom/resolution - this.offset.y) | 0,
-                                      (bbox.right/resolution - this.offset.x) | 0,
+                                      ((bbox.right - this.featureDx)/resolution - this.offset.x) | 0,
                                       (bbox.top/resolution - this.offset.y) | 0);
             
             // Set the internal coordinate system to draw the path
@@ -652,7 +651,7 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
         if(!isNaN(geometry.x)&& !isNaN(geometry.y)) {
             var resolution = this.getResolution();
 
-            node.style.left = (((geometry.x /resolution - this.offset.x) | 0) - radius) + "px";
+            node.style.left = ((((geometry.x - this.featureDx) /resolution - this.offset.x) | 0) - radius) + "px";
             node.style.top = (((geometry.y /resolution - this.offset.y) | 0) - radius) + "px";
     
             var diameter = radius * 2;
@@ -718,7 +717,7 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
         var comp, x, y;
         for (var i = 0; i < numComponents; i++) {
             comp = geometry.components[i];
-            x = (comp.x/resolution - this.offset.x) | 0;
+            x = ((comp.x - this.featureDx)/resolution - this.offset.x) | 0;
             y = (comp.y/resolution - this.offset.y) | 0;
             parts[i] = " " + x + "," + y + " l ";
         }
@@ -754,7 +753,7 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
             second = null;
             for (i=0, ii=points.length; i<ii; i++) {
                 comp = points[i];
-                x = (comp.x / resolution - this.offset.x) | 0;
+                x = ((comp.x - this.featureDx) / resolution - this.offset.x) | 0;
                 y = (comp.y / resolution - this.offset.y) | 0;
                 pathComp = " " + x + "," + y;
                 path.push(pathComp);
@@ -801,7 +800,7 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
     drawRectangle: function(node, geometry) {
         var resolution = this.getResolution();
     
-        node.style.left = ((geometry.x/resolution - this.offset.x) | 0) + "px";
+        node.style.left = (((geometry.x - this.featureDx)/resolution - this.offset.x) | 0) + "px";
         node.style.top = ((geometry.y/resolution - this.offset.y) | 0) + "px";
         node.style.width = ((geometry.width/resolution) | 0) + "px";
         node.style.height = ((geometry.height/resolution) | 0) + "px";
@@ -823,7 +822,7 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
         var textbox = this.nodeFactory(featureId + this.LABEL_ID_SUFFIX + "_textbox", "olv:textbox");
         
         var resolution = this.getResolution();
-        label.style.left = ((location.x/resolution - this.offset.x) | 0) + "px";
+        label.style.left = (((location.x - this.featureDx)/resolution - this.offset.x) | 0) + "px";
         label.style.top = ((location.y/resolution - this.offset.y) | 0) + "px";
         label.style.flip = "y";
 
@@ -900,7 +899,7 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
         var comp, x, y;
         for (var i=0, len=geometry.components.length; i<len; i++) {
             comp = geometry.components[i];
-            x = (comp.x / resolution - this.offset.x) | 0;
+            x = ((comp.x - this.featureDx) / resolution - this.offset.x) | 0;
             y = (comp.y / resolution - this.offset.y) | 0;
             if ((i%3)==0 && (i/3)==0) {
                 path.push("m");

From bb80c893fd8630b63433d0bf0f9704d9e525a97e Mon Sep 17 00:00:00 2001
From: ahocevar <andreas.hocevar@gmail.com>
Date: Sat, 8 Oct 2011 12:03:16 -0400
Subject: [PATCH 23/34] Documenting the featureDx, xOffset and rightOfDateLine
 member variables.

---
 lib/OpenLayers/Renderer.js          | 11 +++++++++++
 lib/OpenLayers/Renderer/Elements.js | 22 ++++++++++++++++++++++
 2 files changed, 33 insertions(+)

diff --git a/lib/OpenLayers/Renderer.js b/lib/OpenLayers/Renderer.js
index 15078748ef..651d53f48f 100644
--- a/lib/OpenLayers/Renderer.js
+++ b/lib/OpenLayers/Renderer.js
@@ -73,6 +73,17 @@ OpenLayers.Renderer = OpenLayers.Class({
      */
     map: null,
     
+    /**
+     * Property: featureDx
+     * {Number} Feature offset in x direction. Will be calculated for and
+     * applied to the current feature while rendering. Looking at the center of
+     * the feature bounds and the renderer extent, we calculate how many world
+     * widths the two are away from each other. This value is used to shift the
+     * feature as close as possible to the center of the current renderer
+     * extent. This ensures that the feature is visible in the current
+     * viewport.
+     */
+    
     /**
      * Constructor: OpenLayers.Renderer 
      *
diff --git a/lib/OpenLayers/Renderer/Elements.js b/lib/OpenLayers/Renderer/Elements.js
index d3822a9483..fe24292326 100644
--- a/lib/OpenLayers/Renderer/Elements.js
+++ b/lib/OpenLayers/Renderer/Elements.js
@@ -373,6 +373,28 @@ OpenLayers.Renderer.Elements = OpenLayers.Class(OpenLayers.Renderer, {
      */    
     xmlns: null,
     
+    /**
+     * Property: xOffset
+     * {Number} Offset to apply to the renderer viewport translation in x
+     * direction. If the renderer extent's center is on the right of the
+     * dateline (i.e. exceeds the world bounds), we shift the viewport to the
+     * left by one world width. This avoids that features disappear from the
+     * map viewport. Because our dateline handling logic in other places
+     * ensures that extents crossing the dateline always have a center
+     * exceeding the world bounds on the left, we need this offset to make sure
+     * that the same is true for the renderer extent in pixel space as well.
+     */
+    
+    /**
+     * Property: rightOfDateLine
+     * {Boolean} Keeps track of the location of the map extent's center
+     * relative to the date line. The <setExtent> method compares this value
+     * (which is the one from the previous <setExtent> call) with the current
+     * position of the map extent relative to the date line and updates the
+     * xOffset when the extent's center has moved from one side of the date
+     * line to the other.
+     */
+    
     /**
      * Property: Indexer
      * {<OpenLayers.ElementIndexer>} An instance of OpenLayers.ElementsIndexer 

From f2fcb5a95ca2d62eacb07f71adbf8de65061d686 Mon Sep 17 00:00:00 2001
From: ahocevar <andreas.hocevar@gmail.com>
Date: Sat, 8 Oct 2011 12:21:51 -0400
Subject: [PATCH 24/34] Canvas renderer needs to return false from setExtent

---
 lib/OpenLayers/Renderer/Canvas.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/lib/OpenLayers/Renderer/Canvas.js b/lib/OpenLayers/Renderer/Canvas.js
index 97b9741b9b..707a4ab81c 100644
--- a/lib/OpenLayers/Renderer/Canvas.js
+++ b/lib/OpenLayers/Renderer/Canvas.js
@@ -70,6 +70,25 @@ OpenLayers.Renderer.Canvas = OpenLayers.Class(OpenLayers.Renderer, {
         }
     },
     
+    /**
+     * Method: setExtent
+     * Set the visible part of the layer.
+     *
+     * Parameters:
+     * extent - {<OpenLayers.Bounds>}
+     * resolutionChanged - {Boolean}
+     *
+     * Returns:
+     * {Boolean} true to notify the layer that the new extent does not exceed
+     *     the coordinate range, and the features will not need to be redrawn.
+     *     False otherwise.
+     */
+    setExtent: function() {
+        OpenLayers.Renderer.prototype.setExtent.apply(this, arguments);
+        // always redraw features
+        return false;
+    },
+    
     /** 
      * Method: eraseGeometry
      * Erase a geometry from the renderer. Because the Canvas renderer has

From 281ae3dfe7db1d4196cb910408f454e450973ee3 Mon Sep 17 00:00:00 2001
From: ahocevar <andreas.hocevar@gmail.com>
Date: Sat, 8 Oct 2011 12:26:19 -0400
Subject: [PATCH 25/34] new calculateFeatureDx method which is used by both
 Canvas and Elements renderers.

---
 lib/OpenLayers/Renderer.js        | 41 ++++++++++++++++++++-----------
 lib/OpenLayers/Renderer/Canvas.js | 17 +++----------
 2 files changed, 30 insertions(+), 28 deletions(-)

diff --git a/lib/OpenLayers/Renderer.js b/lib/OpenLayers/Renderer.js
index 651d53f48f..685fce3ac8 100644
--- a/lib/OpenLayers/Renderer.js
+++ b/lib/OpenLayers/Renderer.js
@@ -76,12 +76,8 @@ OpenLayers.Renderer = OpenLayers.Class({
     /**
      * Property: featureDx
      * {Number} Feature offset in x direction. Will be calculated for and
-     * applied to the current feature while rendering. Looking at the center of
-     * the feature bounds and the renderer extent, we calculate how many world
-     * widths the two are away from each other. This value is used to shift the
-     * feature as close as possible to the center of the current renderer
-     * extent. This ensures that the feature is visible in the current
-     * viewport.
+     * applied to the current feature while rendering (see
+     * <calculateFeatureDx>).
      */
     
     /**
@@ -206,15 +202,7 @@ OpenLayers.Renderer = OpenLayers.Class({
                 if (!bounds.intersectsBounds(this.extent, {worldBounds: worldBounds})) {
                     style = {display: "none"};
                 } else {
-                    this.featureDx = 0;
-                    if (worldBounds) {
-                        bounds = feature.geometry.getBounds();
-                        var worldWidth = worldBounds.getWidth(),
-                            rendererCenterX = (this.extent.left + this.extent.right) / 2,
-                            featureCenterX = (bounds.left + bounds.right) / 2,
-                            worldsAway = Math.round((featureCenterX - rendererCenterX) / worldWidth);
-                        this.featureDx = worldsAway * worldWidth;
-                    }
+                    this.calculateFeatureDx(bounds, worldBounds);
                 }
                 var rendered = this.drawGeometry(feature.geometry, style, feature.id);
                 if(style.display != "none" && style.label && rendered !== false) {
@@ -235,6 +223,29 @@ OpenLayers.Renderer = OpenLayers.Class({
         }
     },
 
+    /**
+     * Method: calculateFeatureDx
+     * {Number} Calculates the feature offset in x direction. Looking at the
+     * center of the feature bounds and the renderer extent, we calculate how
+     * many world widths the two are away from each other. This distance is
+     * used to shift the feature as close as possible to the center of the
+     * current enderer extent, which ensures that the feature is visible in the
+     * current viewport.
+     *
+     * Parameters:
+     * bounds - {<OpenLayers.Bounds>} Bounds of the feature
+     * worldBounds - {<OpenLayers.Bounds>} Bounds of the world
+     */
+    calculateFeatureDx: function(bounds, worldBounds) {
+        this.featureDx = 0;
+        if (worldBounds) {
+            var worldWidth = worldBounds.getWidth(),
+                rendererCenterX = (this.extent.left + this.extent.right) / 2,
+                featureCenterX = (bounds.left + bounds.right) / 2,
+                worldsAway = Math.round((featureCenterX - rendererCenterX) / worldWidth);
+            this.featureDx = worldsAway * worldWidth;
+        }
+    },
 
     /** 
      * Method: drawGeometry
diff --git a/lib/OpenLayers/Renderer/Canvas.js b/lib/OpenLayers/Renderer/Canvas.js
index 707a4ab81c..12d6083c44 100644
--- a/lib/OpenLayers/Renderer/Canvas.js
+++ b/lib/OpenLayers/Renderer/Canvas.js
@@ -685,24 +685,15 @@ OpenLayers.Renderer.Canvas = OpenLayers.Class(OpenLayers.Renderer, {
                 this.hitContext.clearRect(0, 0, width, height);
             }
             var labelMap = [];
-            var feature, style, bounds;
+            var feature, geometry, style;
             var worldBounds = (this.map.baseLayer && this.map.baseLayer.wrapDateLine) && this.map.getMaxExtent();
             for (var id in this.features) {
                 if (!this.features.hasOwnProperty(id)) { continue; }
                 feature = this.features[id][0];
-
-                this.featureDx = 0;
-                if (worldBounds) {
-                    bounds = feature.geometry.getBounds();
-                    var worldWidth = worldBounds.getWidth();
-                    var rendererCenterX = (this.extent.left + this.extent.right) / 2;
-                    var featureCenterX = (bounds.left + bounds.right) / 2;
-                    var worldsAway = Math.round((featureCenterX - rendererCenterX) / worldWidth);
-                    this.featureDx = worldsAway * worldWidth;
-                }
-
+                geometry = feature.geometry;
+                this.calculateFeatureDx(geometry.getBounds(), worldBounds);
                 style = this.features[id][1];
-                this.drawGeometry(feature.geometry, style, feature.id);
+                this.drawGeometry(geometry, style, feature.id);
                 if(style.label) {
                     labelMap.push([feature, style]);
                 }

From b56af5a5cf4de2d7b2dcc6823801832d32c50226 Mon Sep 17 00:00:00 2001
From: ahocevar <andreas.hocevar@gmail.com>
Date: Sat, 8 Oct 2011 14:34:59 -0400
Subject: [PATCH 26/34] Tests for setExtent; improved comments.

---
 lib/OpenLayers/Renderer/Elements.js | 11 +++++----
 tests/Renderer.html                 |  1 +
 tests/Renderer/Elements.html        | 35 ++++++++++++++++++++++++++++-
 3 files changed, 40 insertions(+), 7 deletions(-)

diff --git a/lib/OpenLayers/Renderer/Elements.js b/lib/OpenLayers/Renderer/Elements.js
index fe24292326..4fe85f8a54 100644
--- a/lib/OpenLayers/Renderer/Elements.js
+++ b/lib/OpenLayers/Renderer/Elements.js
@@ -387,12 +387,11 @@ OpenLayers.Renderer.Elements = OpenLayers.Class(OpenLayers.Renderer, {
     
     /**
      * Property: rightOfDateLine
-     * {Boolean} Keeps track of the location of the map extent's center
-     * relative to the date line. The <setExtent> method compares this value
-     * (which is the one from the previous <setExtent> call) with the current
-     * position of the map extent relative to the date line and updates the
-     * xOffset when the extent's center has moved from one side of the date
-     * line to the other.
+     * {Boolean} Keeps track of the location of the map extent relative to the
+     * date line. The <setExtent> method compares this value (which is the one
+     * from the previous <setExtent> call) with the current position of the map
+     * extent relative to the date line and updates the xOffset when the extent
+     * has moved from one side of the date line to the other.
      */
     
     /**
diff --git a/tests/Renderer.html b/tests/Renderer.html
index a149d63746..be085f2d60 100644
--- a/tests/Renderer.html
+++ b/tests/Renderer.html
@@ -24,6 +24,7 @@
         t.plan(2);
         
         var r = new OpenLayers.Renderer();
+        r.map = {};
         var extent = new OpenLayers.Bounds(1,2,3,4);
         r.resolution = 1;
         r.setExtent(extent, true);
diff --git a/tests/Renderer/Elements.html b/tests/Renderer/Elements.html
index 48db70adf0..c38c0376a0 100644
--- a/tests/Renderer/Elements.html
+++ b/tests/Renderer/Elements.html
@@ -616,7 +616,40 @@
         tearDown();
     }
 
-
+    function test_setExtent(t) {
+        t.plan(10);
+        setUp();
+        var resolution = 1;
+        var r = create_renderer();
+        r.map = {
+            getMaxExtent: function() {
+                return new OpenLayers.Bounds(-180,-90,180,90);
+            },
+            getResolution: function() {
+                return resolution;
+            },
+            baseLayer: {wrapDateLine: true}
+        }
+        
+        r.setExtent(new OpenLayers.Bounds(179, -1, 182, 1), true);
+        t.eq(r.rightOfDateLine, true, "on the right side of the dateline");
+        t.eq(r.xOffset, r.map.getMaxExtent().getWidth(), "correct xOffset");
+        r.setExtent(new OpenLayers.Bounds(179.5, -1, 182.5, 1), false);
+        t.eq(r.rightOfDateLine, true, "still on the right side of the dateline");
+        t.eq(r.xOffset, r.map.getMaxExtent().getWidth(), "still correct xOffset");
+        resolution = 2;
+        r.setExtent(new OpenLayers.Bounds(178, -2, 184, 2), true);
+        t.eq(r.rightOfDateLine, true, "still on the right side of the dateline");
+        t.eq(r.xOffset, r.map.getMaxExtent().getWidth() / resolution, "xOffset adjusted for new resolution");
+        r.setExtent(new OpenLayers.Bounds(-184, -2, 178, 2), false);
+        t.eq(r.rightOfDateLine, false, "on the left side of the dateline");
+        t.eq(r.xOffset, 0, "no xOffset");
+        r.setExtent(new OpenLayers.Bounds(178, -2, 184, 2), true);
+        t.eq(r.rightOfDateLine, true, "back on the right side of the dateline");
+        t.eq(r.xOffset, r.map.getMaxExtent().getWidth() / resolution, "correct xOffset");
+        
+        tearDown();
+    }
 
   </script>
 </head>

From 9670b140cb13a38d0208f20be799344e3798a249 Mon Sep 17 00:00:00 2001
From: ahocevar <andreas.hocevar@gmail.com>
Date: Sun, 9 Oct 2011 10:10:21 +0200
Subject: [PATCH 27/34] Tests for calculateFeatureDx

---
 tests/Renderer.html | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/tests/Renderer.html b/tests/Renderer.html
index be085f2d60..4ec44f6ab8 100644
--- a/tests/Renderer.html
+++ b/tests/Renderer.html
@@ -53,6 +53,21 @@
         t.eq(resolution, map.getResolution(), "resolution matches the map resolution");
         t.eq(r.resolution, resolution, "resolution is correctly set");
     }
+    
+    function test_calculateFeatureDx(t) {
+        t.plan(4);
+        var r = new OpenLayers.Renderer();
+        r.extent = new OpenLayers.Bounds(177, -2, 183, 2);
+        var worldBounds = new OpenLayers.Bounds(-180,-90,180,90);
+        r.calculateFeatureDx(new OpenLayers.Bounds(179,-1,181,1), worldBounds);
+        t.eq(r.featureDx, 0, "no offset for feature inside extent");
+        r.calculateFeatureDx(new OpenLayers.Bounds(-181,-1,-179,1), worldBounds);
+        t.eq(r.featureDx, -360, "negative offset for feature on other end of world");
+        r.calculateFeatureDx(new OpenLayers.Bounds(359,-1,361,1), worldBounds);
+        t.eq(r.featureDx, 360, "positive offset for feature that is one world away");
+        r.calculateFeatureDx(new OpenLayers.Bounds(719,-1,721,1), worldBounds);
+        t.eq(r.featureDx, 720, "correct offset for feature that is two worlds away");
+    }
 
     function test_Renderer_destroy(t) {
         t.plan(5);

From cb74ede41b17c89dc3ad28f37ac1044d6673ad8c Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Tue, 11 Oct 2011 14:48:10 -0600
Subject: [PATCH 28/34] Handle features without bounds.

Updates to tests to work with new wrap dateline code.  Canvas renderer needs to handle geometries without bounds as well.
---
 lib/OpenLayers/Renderer/Canvas.js |  2 +-
 tests/Renderer/Canvas.html        | 41 +++++++++++++++++++------------
 2 files changed, 26 insertions(+), 17 deletions(-)

diff --git a/lib/OpenLayers/Renderer/Canvas.js b/lib/OpenLayers/Renderer/Canvas.js
index 12d6083c44..a9a87bb788 100644
--- a/lib/OpenLayers/Renderer/Canvas.js
+++ b/lib/OpenLayers/Renderer/Canvas.js
@@ -166,7 +166,7 @@ OpenLayers.Renderer.Canvas = OpenLayers.Class(OpenLayers.Renderer, {
                 worldBounds = this.map.getMaxExtent();
             }
 
-            var intersects = bounds.intersectsBounds(this.extent, {worldBounds: worldBounds});
+            var intersects = bounds && bounds.intersectsBounds(this.extent, {worldBounds: worldBounds});
 
             rendered = (style.display !== "none") && !!bounds && intersects;
             if (rendered) {
diff --git a/tests/Renderer/Canvas.html b/tests/Renderer/Canvas.html
index c4bef1259a..bdec99948c 100644
--- a/tests/Renderer/Canvas.html
+++ b/tests/Renderer/Canvas.html
@@ -3,6 +3,24 @@
 <script src="../OLLoader.js"></script>
   <script type="text/javascript">
     var supported = OpenLayers.Renderer.Canvas.prototype.supported();
+    
+    var map, layer;
+    function setUp() {
+        map = new OpenLayers.Map("map");
+        layer = new OpenLayers.Layer.Vector(null, {
+            isBaseLayer: true,
+            renderers: ["Canvas"]
+        });
+        map.addLayer(layer);
+        map.setCenter(new OpenLayers.LonLat(0, 0));
+    }
+    
+    function tearDown() {
+        map.destroy();
+        map = null;
+        layer = null;
+    }
+    
     function test_Renderer_Canvas_constructor(t) {
         if (!supported) { t.plan(0); return; }
         t.plan(2);
@@ -18,16 +36,17 @@
     function test_Renderer_Canvas_setextent(t) {
         if (!supported) { t.plan(0); return; }
         t.plan(2);
-        var el = document.body;
-        el.id = "foo";
-        var r = new OpenLayers.Renderer.Canvas(el.id);
         
+        setUp();
+        
+        var r = layer.renderer;        
         var extent = new OpenLayers.Bounds(1,2,3,4);
         r.resolution = 1;
         r.setExtent(extent, true);
         t.ok(r.extent.equals(extent), "extent is correctly set");
         t.eq(r.resolution, null, "resolution nullified");
-        r.destroy();
+        
+        tearDown();
     }
     
     function test_Renderer_Canvas_setsize(t) {
@@ -124,18 +143,8 @@
         }
         
         t.plan(10);
-        var layer = new OpenLayers.Layer.Vector(null, {
-            isBaseLayer: true,
-            renderers: ["Canvas"]
-        });
         
-        var map = new OpenLayers.Map({
-            div: "map",
-            controls: [],
-            layers: [layer],
-            center: new OpenLayers.LonLat(0, 0),
-            zoom: 0
-        });
+        setUp();
         
         var renderer = layer.renderer;
         var count = 0;
@@ -192,7 +201,7 @@
         t.eq(count, 1, "d) redraw is called when drawing a feature without bounds");
         renderer.clear();
 
-        map.destroy();
+        tearDown();
     }
 
 

From d65fde60e2191290871c6f820e254a8698282363 Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Tue, 11 Oct 2011 15:11:03 -0600
Subject: [PATCH 29/34] Avoid test failures due to partial mocking.

Add setup and teardown methods to properly set up test context.
---
 tests/Tile.html | 58 ++++++++++++++++++++++++++++++++++---------------
 1 file changed, 40 insertions(+), 18 deletions(-)

diff --git a/tests/Tile.html b/tests/Tile.html
index ee6a80fb45..9c0743a8d9 100644
--- a/tests/Tile.html
+++ b/tests/Tile.html
@@ -3,11 +3,31 @@
   <script src="OLLoader.js"></script>
   <script type="text/javascript">
     var tile; 
+
+    var map, layer;
+    function setUp() {
+        map = new OpenLayers.Map("map");
+        layer = new OpenLayers.Layer(null, {
+            isBaseLayer: true
+        });
+        map.addLayer(layer)
+        map.setCenter(new OpenLayers.LonLat(0, 0));
+    }
+    
+    function tearDown() {
+        map.destroy();
+        map = null;
+        layer = null;
+    }
+
     
     function test_Tile_constructor (t) {
         t.plan( 12 );
      
-        var layer = {}; // bogus layer
+        setUp();
+        
+        var dummy = {};
+
         var position = new OpenLayers.Pixel(10,20);
         var bounds = new OpenLayers.Bounds(1,2,3,4);
         var url = "bobob";
@@ -15,31 +35,30 @@
         
         tile = new OpenLayers.Tile(layer, position, bounds, url, size);
 
-        t.ok( tile instanceof OpenLayers.Tile, "new OpenLayers.Tile returns Tile object" );
-        t.eq( tile.layer, layer, "tile.layer set correctly");
-        t.ok( tile.position.equals(position), "tile.position set correctly");
-        t.ok( tile.position != position, "tile.position set not by reference");
-        t.ok( tile.bounds.equals(bounds), "tile.bounds set correctly");
-        t.ok( tile.bounds != bounds, "tile.bounds set not by reference");
-        t.eq( tile.url, url, "tile.url set correctly");        
-        t.ok( tile.size.equals(size), "tile.size is set correctly" );
-        t.ok( tile.size != size, "tile.size set not by reference");
+        t.ok(tile instanceof OpenLayers.Tile, "new OpenLayers.Tile returns Tile object");
+        t.ok(tile.layer === layer, "tile.layer set correctly");
+        t.ok(tile.position.equals(position), "tile.position set correctly");
+        t.ok(tile.position != position, "tile.position set not by reference");
+        t.ok(tile.bounds.equals(bounds), "tile.bounds set correctly");
+        t.ok(tile.bounds != bounds, "tile.bounds set not by reference");
+        t.eq(tile.url, url, "tile.url set correctly");        
+        t.ok(tile.size.equals(size), "tile.size is set correctly");
+        t.ok(tile.size != size, "tile.size set not by reference");
 
-        t.ok( tile.id != null, "tile is given an id");
+        t.ok(tile.id != null, "tile is given an id");
         t.ok(OpenLayers.String.startsWith(tile.id, "Tile_"),
              "tile's id starts correctly");
-        t.ok( tile.events != null, "tile's events intitialized");
+        t.ok(tile.events != null, "tile's events intitialized");
+        
+        tearDown();
+        
     }
 
     function test_Tile_destroy(t) {
         t.plan( 6 );
+        
+        setUp();
 
-        var layer = {
-            SUPPORTED_TRANSITIONS: [],
-            events: {
-                unregister: function() {}
-            }
-        }; // bogus layer
         var position = new OpenLayers.Pixel(10,20);
         var bounds = new OpenLayers.Bounds(1,2,3,4);
         var url = "bobob";
@@ -59,6 +78,9 @@
         t.ok(tile.position == null, "tile.position set to null");
         
         t.ok(tile.events == null, "tile.events set to null");
+        
+        tearDown();
+        
     }
 
   </script>

From b4de4027740a6c835389acce8cadc27b3a568a31 Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Tue, 11 Oct 2011 15:22:50 -0600
Subject: [PATCH 30/34] Properly set up and tear down for tests.

---
 tests/Tile/BackBufferable.html | 74 ++++++++++++++++++++++++----------
 tests/Tile/Image.html          | 23 +++++++++--
 2 files changed, 73 insertions(+), 24 deletions(-)

diff --git a/tests/Tile/BackBufferable.html b/tests/Tile/BackBufferable.html
index 22d1a1e3bd..97275891e7 100644
--- a/tests/Tile/BackBufferable.html
+++ b/tests/Tile/BackBufferable.html
@@ -3,41 +3,67 @@
   <script src="../OLLoader.js"></script>
   <script type="text/javascript">
     var tile;
-    var layer = new OpenLayers.Layer.WMS(
+
+    var map, layer;
+    function setUp() {
+        map = new OpenLayers.Map("map");
+        layer = new OpenLayers.Layer.WMS(
             "WMS",
             window.location.href + "#",
             null,
-            {transitionEffect: "resize"}); 
+            {transitionEffect: "resize"}
+        );
+        map.addLayer(layer)
+        map.setCenter(new OpenLayers.LonLat(0, 0));
+    }
+
+    function tearDown() {
+        map.destroy();
+        map = null;
+        layer = null;
+    }
+
+
     var position = new OpenLayers.Pixel(20,30);
     var bounds = new OpenLayers.Bounds(1,2,3,4);
-
     
     function test_initialize (t) {
         t.plan(2);
-        
+        setUp();
+
         tile = new OpenLayers.Tile.Image(layer, position, bounds, null);
         t.eq(tile.backBufferData, {}, "back buffer data initialized");
         t.eq(tile.size.w, 256, "size object with default width created");
+        
+        tearDown();
     }
     
     function test_backBufferMode(t) {
         t.plan(4);
 
         var l;
-
+        
+        var map = new OpenLayers.Map("map");
         l = new OpenLayers.Layer.WMS('', window.location.href + '#');
+        map.addLayer(l);
+        map.zoomToMaxExtent();
+        
         tile = new OpenLayers.Tile.Image(l, position, bounds, null);
         t.eq(tile.backBufferMode, 0,
              'backBufferMode correctly set [tiled]');
 
         l = new OpenLayers.Layer.WMS('', window.location.href + '#',
                                      null, {singleTile: true});
+        map.addLayer(l);
+
+
         tile = new OpenLayers.Tile.Image(l, position, bounds, null);
         t.eq(tile.backBufferMode, 1,
              'backBufferMode correctly set [singleTile]');
 
         l = new OpenLayers.Layer.WMS('', window.location.href + '#',
                                      null, {transitionEffect: 'resize'});
+        map.addLayer(l);
         tile = new OpenLayers.Tile.Image(l, position, bounds, null);
         t.eq(tile.backBufferMode, 2,
              'backBufferMode correctly set [tiled, transition]');
@@ -45,17 +71,18 @@
         l = new OpenLayers.Layer.WMS('', window.location.href + '#',
                                      null, {singleTile: true,
                                             transitionEffect: 'resize'});
+        map.addLayer(l);
         tile = new OpenLayers.Tile.Image(l, position, bounds, null);
         t.eq(tile.backBufferMode, 3,
              'backBufferMode correctly set [singleTile, transition]');
+        map.destroy();
     }
 
     function test_setBackBufferData(t) {
         t.plan(2);
+        
+        setUp();
 
-        var map = new OpenLayers.Map("map");
-        map.addLayer(layer);
-        map.zoomToMaxExtent();
         tile = new OpenLayers.Tile.Image(layer, position, bounds, null);
         tile.draw();
         // moveTo calls setBackBufferData
@@ -65,16 +92,15 @@
              "bounds stored correctly");
         t.eq(tile.backBufferData.resolution, map.getResolution(),
              "resolution stored correctly");
-        map.removeLayer(layer);
-        map.destroy();
+        
+        tearDown();
+        
     }
     
     function test_updateBackBuffer(t) {
         t.plan(1);
-        
-        var map = new OpenLayers.Map("map");
-        map.addLayer(layer);
-        map.zoomToMaxExtent();
+        setUp();
+
         tile = new OpenLayers.Tile.Image(layer, position, bounds, null);
         tile.draw();
         tile.isLoading = false;
@@ -82,15 +108,14 @@
         tile.updateBackBuffer();
         t.eq(tile.backBufferData.tile.style.width, (layer.tileSize.w*2)+"%",
              "backBuffer frame correctly resized");
-        map.removeLayer(layer);
-        map.destroy();
+             
+        tearDown();
     }
     
     function test_removeBackBuffer(t) {
         t.plan(2);
-        var map = new OpenLayers.Map("map");
-        map.addLayer(layer);
-        map.zoomToMaxExtent();
+        setUp();
+
         tile = new OpenLayers.Tile.Image(layer, position, bounds, null);
         tile.draw();
         tile.isLoading = false;
@@ -102,8 +127,8 @@
              "backBuffer reference removed");
         t.ok(backBuffer.parentNode !== layer.div,
              "backBuffer removed from layer");
-        map.removeLayer(layer);
-        map.destroy();
+             
+        tearDown();
     }
         
     function test_updateBackBuffer_scaled_layer(t) {
@@ -118,6 +143,13 @@
         var map = new OpenLayers.Map('map', {
             resolutions: [32, 16, 8, 4, 2, 1]
         });
+        var layer = new OpenLayers.Layer.WMS(
+            "WMS",
+            window.location.href + "#",
+            null,
+            {transitionEffect: "resize"}
+        );
+        
 
         var serverResolitions = layer.serverResolutions;
         layer.serverResolutions = [32, 16, 8];
diff --git a/tests/Tile/Image.html b/tests/Tile/Image.html
index aa6041b9a9..0bfa4ae2ec 100644
--- a/tests/Tile/Image.html
+++ b/tests/Tile/Image.html
@@ -5,12 +5,27 @@
     var isMozilla = (navigator.userAgent.indexOf("compatible") == -1);
     var tile; 
     
+    var map, layer;
+    function setUp() {
+        map = new OpenLayers.Map("map");
+        layer = new OpenLayers.Layer(null, {
+            isBaseLayer: true
+        });
+        map.addLayer(layer)
+        map.setCenter(new OpenLayers.LonLat(0, 0));
+    }
+    
+    function tearDown() {
+        map.destroy();
+        map = null;
+        layer = null;
+    }
+
     function test_Tile_Image_constructor (t) {
         t.plan( 6 );
         
-        var layer = new OpenLayers.Layer.WMS( "OpenLayers WMS", 
-            "http://labs.metacarta.com/wms/vmap0?", {layers: 'basic'}); 
-
+        setUp();
+        
         var position = new OpenLayers.Pixel(20,30);
         var bounds = new OpenLayers.Bounds(1,2,3,4);
         var url = "http://www.openlayers.org/dev/tests/tileimage";
@@ -23,6 +38,8 @@
         t.ok( tile.bounds.equals(bounds), "tile.bounds is set correctly");
         t.eq( tile.url, url, "tile.url is set correctly");
         t.ok( tile.size.equals(size), "tile.size is set correctly");
+        
+        tearDown();
     }
 
     function test_destroy_observers(t) {

From 8a3498bd0f50349663365ff0b8eb3da06c9e0f04 Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Tue, 11 Oct 2011 15:26:51 -0600
Subject: [PATCH 31/34] Setup and teardown for WFS tile tests.  Still need
 work.

---
 tests/Tile/WFS.html | 39 +++++++++++++++++++++++++--------------
 1 file changed, 25 insertions(+), 14 deletions(-)

diff --git a/tests/Tile/WFS.html b/tests/Tile/WFS.html
index ae996ceb5c..3c7fd743e2 100644
--- a/tests/Tile/WFS.html
+++ b/tests/Tile/WFS.html
@@ -3,11 +3,27 @@
   <script src="../OLLoader.js"></script>
   <script type="text/javascript">
     var tile; 
+
+    var map, layer;
+    function setUp() {
+        map = new OpenLayers.Map("map");
+        layer = new OpenLayers.Layer(null, {
+            isBaseLayer: true
+        });
+        map.addLayer(layer)
+        map.setCenter(new OpenLayers.LonLat(0, 0));
+    }
+    
+    function tearDown() {
+        map.destroy();
+        map = null;
+        layer = null;
+    }
     
     function test_Tile_WFS_constructor (t) {
         t.plan( 8 );
+        setUp();
      
-        var layer = {}; // bogus layer
         var position = new OpenLayers.Pixel(10,20);
         var bounds = new OpenLayers.Bounds(1,2,3,4);
         var url = "bobob";
@@ -16,7 +32,7 @@
         tile = new OpenLayers.Tile.WFS(layer, position, bounds, url, size);
 
         t.ok( tile instanceof OpenLayers.Tile.WFS, "new OpenLayers.Tile.WFS returns Tile.WFS object" );
-        t.eq( tile.layer, layer, "tile.layer set correctly");
+        t.ok( tile.layer === layer, "tile.layer set correctly");
         t.ok( tile.position.equals(position), "tile.position set correctly");
         t.ok( tile.bounds.equals(bounds), "tile.bounds set correctly");
         t.eq( tile.url, url, "tile.url set correctly");        
@@ -24,10 +40,13 @@
 
         t.ok( tile.id != null, "tile is given an id");
         t.ok( tile.events != null, "tile's events intitialized");
+        
+        tearDown();
     }
 
     function test_Tile_WFS_requestSuccess(t) {
         t.plan(2);
+        setUp();
 
         var tile = {
             'request': {}
@@ -37,12 +56,6 @@
         
         t.ok(tile.request == null, "request property on tile set to null");
 
-        var layer = {
-            SUPPORTED_TRANSITIONS: [],
-            events: {
-                unregister: function() {}
-            }
-        }; // bogus layer
         var position = new OpenLayers.Pixel(10,20);
         var bounds = new OpenLayers.Bounds(1,2,3,4);
         var url = "bobob";
@@ -53,6 +66,7 @@
         tile.requestSuccess({'requestText': '<xml><foo /></xml>'});
         t.ok(true, "Didn't fail after calling requestSuccess on destroyed tile.");
         
+        tearDown();
     }
     
     function test_Tile_WFS_loadFeaturesForRegion(t) {
@@ -88,13 +102,8 @@
     
     function test_Tile_WFS_destroy(t) {
         t.plan(9);
+        setUp();
 
-        var layer = {
-            SUPPORTED_TRANSITIONS: [],
-            events: {
-                unregister: function() {}
-            }
-        }; // bogus layer
         var position = new OpenLayers.Pixel(10,20);
         var bounds = new OpenLayers.Bounds(1,2,3,4);
         var url = "bobob";
@@ -127,6 +136,8 @@
         
         tile.requestSuccess({'requestText': '<xml><foo /></xml>'});
         t.ok(true, "Didn't fail after calling requestSuccess on destroyed tile.");
+        
+        tearDown();
     }
     function test_nonxml_format(t) {
         t.plan(1);

From ea8404c3bdd182188d9a362811560c0320471f9d Mon Sep 17 00:00:00 2001
From: Tim Schaub <tim.schaub@gmail.com>
Date: Tue, 11 Oct 2011 19:56:42 -0600
Subject: [PATCH 32/34] Fixing up the WFS tile (ack) tests.

---
 tests/Tile/WFS.html | 50 ++++++++++++++++++++++++++++++++++++---------
 1 file changed, 40 insertions(+), 10 deletions(-)

diff --git a/tests/Tile/WFS.html b/tests/Tile/WFS.html
index 3c7fd743e2..3f21ac25bf 100644
--- a/tests/Tile/WFS.html
+++ b/tests/Tile/WFS.html
@@ -140,41 +140,71 @@
         tearDown();
     }
     function test_nonxml_format(t) {
-        t.plan(1);
+        t.plan(2);
+        
+        setUp();
+        
         var data = '{"type":"Feature", "id":"OpenLayers.Feature.Vector_135", "properties":{}, "geometry":{"type":"Point", "coordinates":[118.125, -18.6328125]}, "crs":{"type":"OGC", "properties":{"urn":"urn:ogc:def:crs:OGC:1.3:CRS84"}}}'
         var position = new OpenLayers.Pixel(10,20);
         var bounds = new OpenLayers.Bounds(1,2,3,4);
         var url = "bobob";
         var size = new OpenLayers.Size(5,6);
         
-        var tile = new OpenLayers.Tile.WFS({
-            vectorMode: true, 
+        var log = [];
+        
+        var l = new OpenLayers.Layer(null, {
+            vectorMode: true,
             formatObject: new OpenLayers.Format.GeoJSON(), 
             addFeatures: function(features) { 
-                t.eq(features.length, 1, "GeoJSON format returned a single feature which was added.")
+                log.push(features);
             }
-        }, position, bounds, url, size);
+        })
+        map.addLayer(l);
+
+        var tile = new OpenLayers.Tile.WFS(l, position, bounds, url, size);
+
         tile.requestSuccess({responseText: data});
+
+        t.eq(log.length, 1, "one call logged")
+        t.eq(log[0] && log[0].length, 1, "GeoJSON format returned a single feature which was added.");
+        
+        tearDown();
     }  
      
     function test_xml_string_and_dom(t) {
-        t.plan(2);
+        t.plan(4);
+        setUp();
+        
         var data = '<?xml version="1.0" encoding="ISO-8859-1" ?><wfs:FeatureCollection   xmlns:bsc="http://www.bsc-eoc.org/bsc"   xmlns:wfs="http://www.opengis.net/wfs"   xmlns:gml="http://www.opengis.net/gml"   xmlns:ogc="http://www.opengis.net/ogc"   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   xsi:schemaLocation="http://www.opengis.net/wfs http://schemas.opengeospatial.net//wfs/1.0.0/WFS-basic.xsd                        http://www.bsc-eoc.org/bsc http://www.bsc-eoc.org/cgi-bin/bsc_ows.asp?SERVICE=WFS&amp;VERSION=1.0.0&amp;REQUEST=DescribeFeatureType&amp;TYPENAME=OWLS&amp;OUTPUTFORMAT=XMLSCHEMA">      <gml:boundedBy>        <gml:Box srsName="EPSG:4326">            <gml:coordinates>-94.989723,43.285833 -74.755001,51.709520</gml:coordinates>        </gml:Box>      </gml:boundedBy>    <gml:featureMember>      <bsc:OWLS>        <gml:boundedBy>            <gml:Box srsName="EPSG:4326">                <gml:coordinates>-94.142500,50.992777 -94.142500,50.992777</gml:coordinates>            </gml:Box>        </gml:boundedBy>        <bsc:msGeometry>        <gml:Point srsName="EPSG:4326">          <gml:coordinates>-94.142500,50.992777</gml:coordinates>        </gml:Point>        </bsc:msGeometry>        <bsc:ROUTEID>ON_2</bsc:ROUTEID>        <bsc:ROUTE_NAME>Suffel Road</bsc:ROUTE_NAME>        <bsc:LATITUDE>50.9927770</bsc:LATITUDE>        <bsc:LONGITUDE>-94.1425000</bsc:LONGITUDE>      </bsc:OWLS>    </gml:featureMember></wfs:FeatureCollection>';
         var position = new OpenLayers.Pixel(10,20);
         var bounds = new OpenLayers.Bounds(1,2,3,4);
         var url = "bobob";
         var size = new OpenLayers.Size(5,6);
-        var tile = new OpenLayers.Tile.WFS({
-        }, position, bounds, url, size);
+        
+        var l = new OpenLayers.Layer();
+        map.addLayer(l);
+
+        var tile = new OpenLayers.Tile.WFS(l, position, bounds, url, size);
+        
+        var log = [];
         tile.addResults = function(results) {
-            t.eq(results.length, 1, "results count is correct when passing in XML as a string into non-vectormode");
+            log.push(results);
         } 
         tile.requestSuccess({responseText: data});
         
+        t.eq(log.length, 1, "first call logged");
+        t.eq(log[0] && log[0].length, 1, "results count is correct when passing in XML as a string into non-vectormode");
+        
+        log.length = 0;
         tile.addResults = function(results) {
-            t.eq(results.length, 1, "results count is correct when passing in XML as DOM into non-vectormode");
+            log.push(results);
         } 
         tile.requestSuccess({responseXML: OpenLayers.Format.XML.prototype.read(data)}); 
+
+        t.eq(log.length, 1, "second call logged");
+        t.eq(log[0] && log[0].length, 1, "results count is correct when passing in XML as DOM into non-vectormode");
+
+        tearDown();
     }         
   </script>
 </head>

From 6af8178452dff15fbb670af3fe6277e844a2a481 Mon Sep 17 00:00:00 2001
From: Tim Schaub <tim.schaub@gmail.com>
Date: Tue, 11 Oct 2011 21:14:07 -0600
Subject: [PATCH 33/34] Enforcing existing zoomToExtent behavior.

The Map.html and WrapDateLine.html tests that check zoomToExtent were failing with the changes to this method.  These test changes make the expectations more explicit.  It is inconsistent to call wrapDateLine only in zoomToExtent, but this is the minimum change to get the tests passing again.  It would be more consistent to call wrapDateLine in the setCenter sequence.
---
 lib/OpenLayers/Map.js |   2 +-
 tests/Map.html        | 120 ++++++++++++++++++++++++++----------------
 2 files changed, 77 insertions(+), 45 deletions(-)

diff --git a/lib/OpenLayers/Map.js b/lib/OpenLayers/Map.js
index 6c477046aa..3315494bf3 100644
--- a/lib/OpenLayers/Map.js
+++ b/lib/OpenLayers/Map.js
@@ -2226,7 +2226,7 @@ OpenLayers.Map = OpenLayers.Class({
             // we got from it was wrong. So we take our new bounds and ask it
             // for the center.
             //
-            center = bounds.getCenterLonLat();
+            center = bounds.getCenterLonLat().wrapDateLine(maxExtent);
         }
         this.setCenter(center, this.getZoomForExtent(bounds, closest));
     },
diff --git a/tests/Map.html b/tests/Map.html
index 770daec2d6..4e93f104b6 100644
--- a/tests/Map.html
+++ b/tests/Map.html
@@ -1386,54 +1386,86 @@
     }
     
     function test_Map_zoomToExtent(t) {
-        t.plan(8);
-
+        t.plan(9);
         
-        var m = {
-            'baseLayer': {
-                'wrapDateLine': false      
-            },
-            'setCenter': function(center, zoomLevel) {
-                g_Center = center;
-                g_ZoomLevel = zoomLevel;
-            },
-            'getZoomForExtent': function(bounds, closest) {
-                t.ok(bounds.equals(g_ToCenterBounds), "bounds correctly passed into getZoomForExtent()");
-                t.ok(closest == g_Closest, "closest correctly passed along to getZoomForExtent()");
-                return g_ZoomLevelReturn;
-            }
-        };
-
-    //no wrapDateLine        
-        g_ZoomLevelReturn = {};
-        g_Bounds = new OpenLayers.Bounds(-20,-15,0,5);
-        g_ExpectedCenter = new OpenLayers.LonLat(-10,-5);
-        g_Closest = {};
-        g_ToCenterBounds = g_Bounds;
-        var args = [g_Bounds, g_Closest];
-        OpenLayers.Map.prototype.zoomToExtent.apply(m, args);
+        var map = new OpenLayers.Map("map");
+        var layer = new OpenLayers.Layer(null, {isBaseLayer: true});
+        map.addLayer(layer);
         
-        t.ok(g_Center.equals(g_ExpectedCenter), "setCenter called on correct center");
-        t.ok(g_ZoomLevel == g_ZoomLevelReturn, "correctly passes along zoom level as returned from getZoomForExtent()");
-
-
-    //wrapDateLine
-        m.baseLayer.wrapDateLine = true;
-        m.getMaxExtent = function() { return new OpenLayers.Bounds(-200,-200,200,200); };
-
-        g_ZoomLevelReturn = {};
-        g_BoundsCenter = {};
-        g_Bounds = new OpenLayers.Bounds(160,-60,-60,60);
-        g_ExpectedCenter = new OpenLayers.LonLat(-150,0);
-        g_Closest = {};
-        g_ToCenterBounds = new OpenLayers.Bounds(160,-60,340,60);
-        var args = [g_Bounds, g_Closest];
-        OpenLayers.Map.prototype.zoomToExtent.apply(m, args);
-        t.ok(g_Center.equals(g_ExpectedCenter), "setCenter called on correct center");
-        t.ok(g_ZoomLevel == g_ZoomLevelReturn, "correctly passes along zoom level as returned from getZoomForExtent()");
-
+        var bounds = new OpenLayers.Bounds(-160, 15, -50, 69);
+        var center;
         
+        // default for closest
+        map.zoomToExtent(bounds);
+        center = map.getCenter();
+        t.eq(center.lon, -105, "a) correct x");
+        t.eq(center.lat, 42, "a) correct y");
+        t.eq(map.getZoom(), 2, "a) correct zoom");
+
+        // false for closest
+        map.zoomToExtent(bounds, false);
+        center = map.getCenter();
+        t.eq(center.lon, -105, "b) correct x");
+        t.eq(center.lat, 42, "b) correct y");
+        t.eq(map.getZoom(), 2, "b) correct zoom");
+
+        // true for closest
+        map.zoomToExtent(bounds, true);
+        center = map.getCenter();
+        t.eq(center.lon, -105, "c) correct x");
+        t.eq(center.lat, 42, "c) correct y");
+        t.eq(map.getZoom(), 3, "c) correct zoom");
+        
+        map.destroy();
     }
+
+    function test_Map_zoomToExtent_wrapped(t) {
+        t.plan(9);
+        
+        var map = new OpenLayers.Map("map");
+        var layer = new OpenLayers.Layer(null, {isBaseLayer: true, wrapDateLine: true});
+        map.addLayer(layer);
+        
+        var bounds, center;
+        
+        var cases = [{
+            // real world
+            bbox: [120, -20, 140, 0],
+            center: [130, -10]
+        }, {
+            // one world to the right
+            bbox: [220, -45, 240, 45],
+            center: [-130, 0]
+        }, {
+            // two worlds to the right
+            bbox: [550, -15, 560, 5],
+            center: [-165, -5]
+        }, {
+            // one world to the left
+            bbox: [-240, -15, -220, 5],
+            center: [130, -5]
+        }, {
+            // two worlds to the left
+            bbox: [-600, -15, -580, 5],
+            center: [130, -5]
+        }];
+        
+        var num = cases.length;
+        t.plan(num * 2);
+        
+        var c, bounds, center;
+        for (var i=0; i<num; ++i) {
+            c = cases[i];
+            bounds = OpenLayers.Bounds.fromArray(c.bbox);
+            map.zoomToExtent(bounds);
+            center = map.getCenter();
+            t.eq(center.lon, c.center[0], "y: " + bounds);
+            t.eq(center.lat, c.center[1], "x: " + bounds);
+        }
+        
+        map.destroy();
+    }
+
     
     function test_allOverlays(t) {
         

From 740e3c4d286078692847a4b37029bff6a4631e58 Mon Sep 17 00:00:00 2001
From: ahocevar <andreas.hocevar@gmail.com>
Date: Wed, 12 Oct 2011 08:25:20 +0200
Subject: [PATCH 34/34] Defaults for featureDx and xOffset.

This is mostly done to make SVG and VML tests pass again, but it may also help existing applications that override setExtent or drawFeature without calling the superclass methods properly.
---
 lib/OpenLayers/Renderer.js          | 1 +
 lib/OpenLayers/Renderer/Elements.js | 1 +
 2 files changed, 2 insertions(+)

diff --git a/lib/OpenLayers/Renderer.js b/lib/OpenLayers/Renderer.js
index 685fce3ac8..a1b1a92342 100644
--- a/lib/OpenLayers/Renderer.js
+++ b/lib/OpenLayers/Renderer.js
@@ -79,6 +79,7 @@ OpenLayers.Renderer = OpenLayers.Class({
      * applied to the current feature while rendering (see
      * <calculateFeatureDx>).
      */
+    featureDx: 0,
     
     /**
      * Constructor: OpenLayers.Renderer 
diff --git a/lib/OpenLayers/Renderer/Elements.js b/lib/OpenLayers/Renderer/Elements.js
index 4fe85f8a54..31b9d53c95 100644
--- a/lib/OpenLayers/Renderer/Elements.js
+++ b/lib/OpenLayers/Renderer/Elements.js
@@ -384,6 +384,7 @@ OpenLayers.Renderer.Elements = OpenLayers.Class(OpenLayers.Renderer, {
      * exceeding the world bounds on the left, we need this offset to make sure
      * that the same is true for the renderer extent in pixel space as well.
      */
+    xOffset: 0,
     
     /**
      * Property: rightOfDateLine