From 118479aebcf74174fa180561d9d457a9abda1c87 Mon Sep 17 00:00:00 2001
From: ahocevar <andreas.hocevar@gmail.com>
Date: Mon, 27 Feb 2012 09:36:55 +0100
Subject: [PATCH 1/3] Allow map and layer coordinates to be provided as
 latitude and longitude

---
 lib/OpenLayers/BaseTypes/Bounds.js | 29 +++++++++++++++++++----
 lib/OpenLayers/BaseTypes/LonLat.js | 12 ++++++++++
 lib/OpenLayers/Layer.js            |  5 ++--
 lib/OpenLayers/Map.js              | 11 +++++----
 tests/BaseTypes/Bounds.html        | 12 +++++++++-
 tests/BaseTypes/LonLat.html        |  9 +++++++-
 tests/Layer.html                   | 37 ++++++++++++++++++++++++++----
 tests/Map.html                     | 35 +++++++++++++++++++++++++++-
 8 files changed, 131 insertions(+), 19 deletions(-)

diff --git a/lib/OpenLayers/BaseTypes/Bounds.js b/lib/OpenLayers/BaseTypes/Bounds.js
index a4fee70554..5295f8b43f 100644
--- a/lib/OpenLayers/BaseTypes/Bounds.js
+++ b/lib/OpenLayers/BaseTypes/Bounds.js
@@ -5,6 +5,7 @@
 
 /**
  * @requires OpenLayers/BaseTypes/Class.js
+ * @requires OpenLayers/Projection.js
  */
 
 /**
@@ -72,10 +73,30 @@ OpenLayers.Bounds = OpenLayers.Class({
      */
     initialize: function(left, bottom, right, top) {
         if (OpenLayers.Util.isArray(left)) {
-            top = left[3];
-            right = left[2];
-            bottom = left[1];
-            left = left[0];
+            if (left[0] && typeof left[0] === "object" && left[0].lon) {
+                var transform = arguments[arguments.length-1];
+                top = left[1].lat;
+                right = left[1].lon;
+                bottom = left[0].lat;
+                left = left[0].lon;
+                if (transform instanceof OpenLayers.Projection) {
+                    var bl = OpenLayers.Projection.transform(
+                        {x: left, y: bottom}, "EPSG:4326", transform
+                    );
+                    var tr = OpenLayers.Projection.transform(
+                        {x: right, y: top}, "EPSG:4326", transform
+                    );
+                    top = tr.y;
+                    right = tr.x;
+                    bottom = bl.y;
+                    left = bl.x;
+                }
+            } else {
+                top = left[3];
+                right = left[2];
+                bottom = left[1];
+                left = left[0];
+            }
         }
         if (left != null) {
             this.left = OpenLayers.Util.toFloat(left);
diff --git a/lib/OpenLayers/BaseTypes/LonLat.js b/lib/OpenLayers/BaseTypes/LonLat.js
index ed274225c4..957c0bf3e0 100644
--- a/lib/OpenLayers/BaseTypes/LonLat.js
+++ b/lib/OpenLayers/BaseTypes/LonLat.js
@@ -5,6 +5,7 @@
 
 /**
  * @requires OpenLayers/BaseTypes/Class.js
+ * @requires OpenLayers/Projection.js
  */
 
 /**
@@ -45,6 +46,17 @@ OpenLayers.LonLat = OpenLayers.Class({
         if (OpenLayers.Util.isArray(lon)) {
             lat = lon[1];
             lon = lon[0];
+        } else if (lon && typeof lon === "object" && lon.lon) {
+            var transform = arguments[arguments.length-1];
+            lat = lon.lat;
+            lon = lon.lon;
+            if (transform instanceof OpenLayers.Projection) {
+                var xy = OpenLayers.Projection.transform(
+                    {x: lon, y: lat}, "EPSG:4326", transform
+                );
+                lat = xy.y;
+                lon = xy.x;
+            }
         }
         this.lon = OpenLayers.Util.toFloat(lon);
         this.lat = OpenLayers.Util.toFloat(lat);
diff --git a/lib/OpenLayers/Layer.js b/lib/OpenLayers/Layer.js
index cbaf8e5c16..432844f332 100644
--- a/lib/OpenLayers/Layer.js
+++ b/lib/OpenLayers/Layer.js
@@ -482,11 +482,12 @@ OpenLayers.Layer = OpenLayers.Class({
                     OpenLayers.Projection.defaults[newOptions.projection.getCode()]);
             }
             // allow array for extents
+            var srs = this.projection || newOptions.projection;
             if (newOptions.maxExtent && !(newOptions.maxExtent instanceof OpenLayers.Bounds)) {
-                newOptions.maxExtent = new OpenLayers.Bounds(newOptions.maxExtent);
+                newOptions.maxExtent = new OpenLayers.Bounds(newOptions.maxExtent, srs);
             }
             if (newOptions.minExtent && !(newOptions.minExtent instanceof OpenLayers.Bounds)) {
-                newOptions.minExtent = new OpenLayers.Bounds(newOptions.minExtent);
+                newOptions.minExtent = new OpenLayers.Bounds(newOptions.minExtent, srs);
             }
         }
 
diff --git a/lib/OpenLayers/Map.js b/lib/OpenLayers/Map.js
index 02507ad00f..51cdbb723e 100644
--- a/lib/OpenLayers/Map.js
+++ b/lib/OpenLayers/Map.js
@@ -519,17 +519,18 @@ OpenLayers.Map = OpenLayers.Class({
         OpenLayers.Util.applyDefaults(this, OpenLayers.Projection.defaults[projCode]);
         
         // allow extents and center to be arrays
+        var srs = new OpenLayers.Projection(projCode);
         if (this.maxExtent && !(this.maxExtent instanceof OpenLayers.Bounds)) {
-            this.maxExtent = new OpenLayers.Bounds(this.maxExtent);
+            this.maxExtent = new OpenLayers.Bounds(this.maxExtent, srs);
         }
         if (this.minExtent && !(this.minExtent instanceof OpenLayers.Bounds)) {
             this.minExtent = new OpenLayers.Bounds(this.minExtent);
         }
         if (this.restrictedExtent && !(this.restrictedExtent instanceof OpenLayers.Bounds)) {
-            this.restrictedExtent = new OpenLayers.Bounds(this.restrictedExtent);
+            this.restrictedExtent = new OpenLayers.Bounds(this.restrictedExtent, srs);
         }
         if (this.center && !(this.center instanceof OpenLayers.LonLat)) {
-            this.center = new OpenLayers.LonLat(this.center);
+            this.center = new OpenLayers.LonLat(this.center, srs);
         }
 
         // initialize layers array
@@ -1798,7 +1799,7 @@ OpenLayers.Map = OpenLayers.Class({
      */
     moveTo: function(lonlat, zoom, options) {
         if (!(lonlat instanceof OpenLayers.LonLat)) {
-            lonlat = new OpenLayers.LonLat(lonlat);
+            lonlat = new OpenLayers.LonLat(lonlat, this.getProjectionObject());
         }
         if (!options) { 
             options = {};
@@ -2319,7 +2320,7 @@ OpenLayers.Map = OpenLayers.Class({
      */
     zoomToExtent: function(bounds, closest) {
         if (!(bounds instanceof OpenLayers.Bounds)) {
-            bounds = new OpenLayers.Bounds(bounds);
+            bounds = new OpenLayers.Bounds(bounds, this.getProjectionObject());
         }
         var center = bounds.getCenterLonLat();
         if (this.baseLayer.wrapDateLine) {
diff --git a/tests/BaseTypes/Bounds.html b/tests/BaseTypes/Bounds.html
index a1497cf6da..52a216d8f4 100644
--- a/tests/BaseTypes/Bounds.html
+++ b/tests/BaseTypes/Bounds.html
@@ -4,7 +4,7 @@
   <script type="text/javascript">
     var bounds; 
     function test_Bounds_constructor (t) {
-        t.plan( 26 );
+        t.plan( 31 );
         
         bounds = new OpenLayers.Bounds();
         t.ok( bounds instanceof OpenLayers.Bounds, "new OpenLayers.Bounds returns Bounds object" );
@@ -53,6 +53,16 @@
         t.eq(bounds.right, 180, "(array) right");
         t.eq(bounds.top, 90, "(array) top");
         
+        // allow construction from a latlon object and transform
+        bounds = new OpenLayers.Bounds(
+            [{lon: -180, lat: -85.0511287798066}, {lon: 180, lat: 85.0511287798066}],
+            new OpenLayers.Projection("EPSG:3857")
+        );
+        t.ok(bounds instanceof OpenLayers.Bounds, "(array latlon) correct instance");
+        t.eq(bounds.left, -20037508.34, "(array latlon) left");
+        t.eq(bounds.bottom, -20037508.34, "(array latlon) bottom");
+        t.eq(bounds.right, 20037508.34, "(array latlon) right");
+        t.eq(bounds.top, 20037508.34, "(array latlon) top");
     }
 
     function test_Bounds_constructorFromStrings(t) {
diff --git a/tests/BaseTypes/LonLat.html b/tests/BaseTypes/LonLat.html
index a1801f6c6b..1050327c6b 100644
--- a/tests/BaseTypes/LonLat.html
+++ b/tests/BaseTypes/LonLat.html
@@ -6,7 +6,7 @@
     var lonlat; 
 
     function test_LonLat_constructor (t) {
-        t.plan( 8 );
+        t.plan( 10 );
         lonlat = new OpenLayers.LonLat(6, 5);
         t.ok( lonlat instanceof OpenLayers.LonLat, "new OpenLayers.LonLat returns LonLat object" );
         t.eq( lonlat.CLASS_NAME, "OpenLayers.LonLat", "lonlat.CLASS_NAME is set correctly");
@@ -23,6 +23,13 @@
         t.eq(lonlat.lon, 1, "lon from array");
         t.eq(lonlat.lat, 2, "lat from array");
         
+        // allow construction from single latlon arg with transform
+        lonlat = new OpenLayers.LonLat(
+            {lon: 180, lat: -85.0511287798066},
+            new OpenLayers.Projection("EPSG:3857")
+        );
+        t.eq(lonlat.lon, 20037508.34, "lon from latlon object");
+        t.eq(lonlat.lat, -20037508.34, "lat from latlon object");
     }
     
     function test_LonLat_constructorFromStrings (t) {
diff --git a/tests/Layer.html b/tests/Layer.html
index eb2c9270f7..7feabe2c44 100644
--- a/tests/Layer.html
+++ b/tests/Layer.html
@@ -198,7 +198,7 @@
     }
     
     function test_maxExtent(t) {
-        t.plan(5);
+        t.plan(10);
         
         var layer = new OpenLayers.Layer(
             null, {maxExtent: [-180, 0, 0, 90]}
@@ -206,27 +206,54 @@
         
         t.ok(layer.maxExtent instanceof OpenLayers.Bounds, "(array) bounds instance");
         t.eq(layer.maxExtent.left, -180, "(array) bounds left");
-        t.eq(layer.maxExtent.bottom, 0, "(array) bounds left");
+        t.eq(layer.maxExtent.bottom, 0, "(array) bounds bottom");
         t.eq(layer.maxExtent.right, 0, "(array) bounds right");
         t.eq(layer.maxExtent.top, 90, "(array) bounds top");
         
         layer.destroy();
+
+        layer = new OpenLayers.Layer(
+            null, {projection: "EPSG:3857", maxExtent: [{lon: -180, lat: 45}, {lon: 0, lat: 85}]}
+        );
+        
+        t.ok(layer.maxExtent instanceof OpenLayers.Bounds, "(lat/lon array) bounds instance");
+        t.eq(layer.maxExtent.left, -20037508.34, "(lat/lon array) bounds left");
+        t.eq(layer.maxExtent.bottom, 5621521.4854095, "(lat/lon array) bounds bottom");
+        t.eq(layer.maxExtent.right, 0, "(lat/lon array) bounds right");
+        t.eq(layer.maxExtent.top, 19971868.877628, "(lat/lon array) bounds top");
+        
+        layer.destroy();
     }
 
     function test_minExtent(t) {
-        t.plan(5);
+        t.plan(10);
         
+        // projection below is only set to make sure that the minExtent is not
+        // transformed
         var layer = new OpenLayers.Layer(
-            null, {minExtent: [-180, 0, 0, 90]}
+            null, {projection: "EPSG:3857", minExtent: [-180, 0, 0, 90]}
         );
         
         t.ok(layer.minExtent instanceof OpenLayers.Bounds, "(array) bounds instance");
         t.eq(layer.minExtent.left, -180, "(array) bounds left");
-        t.eq(layer.minExtent.bottom, 0, "(array) bounds left");
+        t.eq(layer.minExtent.bottom, 0, "(array) bounds bottom");
         t.eq(layer.minExtent.right, 0, "(array) bounds right");
         t.eq(layer.minExtent.top, 90, "(array) bounds top");
         
         layer.destroy();
+
+        // projection below is set to get the minExtent transformed
+        layer = new OpenLayers.Layer(
+            null, {projection: "EPSG:3857", minExtent: [{lon: -180, lat: 45}, {lon: 0, lat: 85}]}
+        );
+        
+        t.ok(layer.minExtent instanceof OpenLayers.Bounds, "(lat/lon array) bounds instance");
+        t.eq(layer.minExtent.left, -20037508.34, "(lat/lon array) bounds left");
+        t.eq(layer.minExtent.bottom, 5621521.4854095, "(lat/lon array) bounds bottom");
+        t.eq(layer.minExtent.right, 0, "(lat/lon array) bounds right");
+        t.eq(layer.minExtent.top, 19971868.877628, "(lat/lon array) bounds top");
+        
+        layer.destroy();
     }
 
 
diff --git a/tests/Map.html b/tests/Map.html
index ee8b8e7fb2..7151740c75 100644
--- a/tests/Map.html
+++ b/tests/Map.html
@@ -53,7 +53,7 @@
     }
     
     function test_Map_constructor_convenience(t) {
-        t.plan(13);
+        t.plan(26);
         var map = new OpenLayers.Map({
             maxExtent: [-170, -80, 170, 80],
             restrictedExtent: [-120, -65, 120, 65],
@@ -85,6 +85,39 @@
         t.eq(map.getZoom(), 3, "zoom");
         
         map.destroy();
+
+        map = new OpenLayers.Map({
+            projection: "EPSG:3857",
+            maxExtent: [{lon: -170, lat: -80}, {lon: 170, lat: 80}],
+            restrictedExtent: [{lon: -120, lat: -65}, {lon: 120, lat: 65}],
+            layers: [
+                new OpenLayers.Layer(null, {isBaseLayer: true})
+            ],
+            center: {lon: -111, lat: 45},
+            zoom: 3
+        });
+        
+        // maxExtent from latlon array
+        t.ok(map.maxExtent instanceof OpenLayers.Bounds, "maxExtent bounds");
+        t.eq(map.maxExtent.left, -18924313.432222, "maxExtent left");
+        t.eq(map.maxExtent.bottom, -15538711.094146, "maxExtent bottom");
+        t.eq(map.maxExtent.right, 18924313.432222, "maxExtent right");
+        t.eq(map.maxExtent.top, 15538711.094146, "maxExtent top");
+
+        // restrictedExtent from latlon object
+        t.ok(map.restrictedExtent instanceof OpenLayers.Bounds, "restrictedExtent bounds");
+        t.eq(map.restrictedExtent.left, -13358338.893333, "restrictedExtent left");
+        t.eq(map.restrictedExtent.bottom, -9608371.5085962, "restrictedExtent bottom");
+        t.eq(map.restrictedExtent.right, 13358338.893333, "restrictedExtent right");
+        t.eq(map.restrictedExtent.top, 9608371.5085962, "restrictedExtent top");
+        
+        center = map.getCenter();
+        t.eq(center.lon, -12356463.476333, "center lon");
+        t.eq(center.lat, 5621521.4854095, "center lat");
+        
+        t.eq(map.getZoom(), 3, "zoom");
+
+        map.destroy();
     }
     
     function test_Map_constructor_late_rendering(t) {

From 9d7ac39887debb817a7dc92a25e606ec79e28c85 Mon Sep 17 00:00:00 2001
From: ahocevar <andreas.hocevar@gmail.com>
Date: Mon, 27 Feb 2012 14:03:50 +0100
Subject: [PATCH 2/3] Adding API documentation.

---
 lib/OpenLayers/Layer.js |  2 +-
 lib/OpenLayers/Map.js   | 51 ++++++++++++++++++++++++++++++-----------
 2 files changed, 39 insertions(+), 14 deletions(-)

diff --git a/lib/OpenLayers/Layer.js b/lib/OpenLayers/Layer.js
index 432844f332..acd9090643 100644
--- a/lib/OpenLayers/Layer.js
+++ b/lib/OpenLayers/Layer.js
@@ -333,7 +333,7 @@ OpenLayers.Layer = OpenLayers.Class({
      *
      * Parameters:
      * name - {String} The layer name
-     * options - {Object} Hashtable of extra options to tag onto the layer
+     * options - {Object} Hashtable of extra options to tag onto the layer.
      */
     initialize: function(name, options) {
 
diff --git a/lib/OpenLayers/Map.js b/lib/OpenLayers/Map.js
index 51cdbb723e..901a7be1dc 100644
--- a/lib/OpenLayers/Map.js
+++ b/lib/OpenLayers/Map.js
@@ -443,9 +443,8 @@ OpenLayers.Map = OpenLayers.Class({
      * options - {Object} Optional object with properties to tag onto the map.
      *
      * Valid options (in addition to the listed API properties):
-     * center - {<OpenLayers.LonLat>|Array} The default initial center of the map.
-     *     If provided as array, the first value is the x coordinate,
-     *     and the 2nd value is the y coordinate.
+     * center - {<OpenLayers.LonLat>|Array|Object} The initial center of the
+     *     map. See <setCenter> for supported values.
      *     Only specify if <layers> is provided.
      *     Note that if an ArgParser/Permalink control is present,
      *     and the querystring contains coordinates, center will be set
@@ -455,9 +454,9 @@ OpenLayers.Map = OpenLayers.Class({
      *     Note that if an ArgParser/Permalink control is present,
      *     and the querystring contains a zoom level, zoom will be set
      *     by that, and this option will be ignored.
-     * extent - {<OpenLayers.Bounds>|Array} The initial extent of the map.
-     *     If provided as an array, the array should consist of
-     *     four values (left, bottom, right, top).
+     * extent - {<OpenLayers.Bounds>|Array} The initial extent of the map. Only
+     *     specify if <center> and <zoom> are not provided. See <zoomToExtent>
+     *     for supported values.
      *     Only specify if <center> and <zoom> are not provided.
      * 
      * Examples:
@@ -1688,20 +1687,32 @@ OpenLayers.Map = OpenLayers.Class({
      * Set the map center (and optionally, the zoom level).
      * 
      * Parameters:
-     * lonlat - {<OpenLayers.LonLat>|Array} The new center location.
-     *     If provided as array, the first value is the x coordinate,
-     *     and the 2nd value is the y coordinate.
+     * center - {<OpenLayers.LonLat>|Array|Object} The new center location. If
+     *     provided as <OpenLayers.LonLat> or Array, coordinates are expected
+     *     to be in the map's <projection>. If provided as array, the first
+     *     value is the x coordinate, and the 2nd value is the y coordinate. If
+     *     provided as object, latitude and longitude in WGS84 are expected as
+     *     lat and lon properties. See example below.
      * zoom - {Integer} Optional zoom level.
      * dragging - {Boolean} Specifies whether or not to trigger 
      *                      movestart/end events
      * forceZoomChange - {Boolean} Specifies whether or not to trigger zoom 
      *                             change events (needed on baseLayer change)
      *
+     * On a map with projection set to "EPSG:3857", the following three
+     * statements are equivalent:
+     *
+     * (code)
+     * map.setCenter({lat: 45, lon: -111});
+     * map.setCenter([-12356463.476333, 5621521.4854095]);
+     * map.setCenter(new OpenLayers.LonLat(-12356463.476333, 5621521.4854095));
+     * (end)
+     *
      * TBD: reconsider forceZoomChange in 3.0
      */
-    setCenter: function(lonlat, zoom, dragging, forceZoomChange) {
+    setCenter: function(center, zoom, dragging, forceZoomChange) {
         this.panTween && this.panTween.stop();             
-        this.moveTo(lonlat, zoom, {
+        this.moveTo(center, zoom, {
             'dragging': dragging,
             'forceZoomChange': forceZoomChange
         });
@@ -2310,13 +2321,27 @@ OpenLayers.Map = OpenLayers.Class({
      * Zoom to the passed in bounds, recenter
      * 
      * Parameters:
-     * bounds - {<OpenLayers.Bounds>|Array} If provided as an array, the array
-     *     should consist of four values (left, bottom, right, top).
+     * bounds - {<OpenLayers.Bounds>|Array}. If provided as an array of four
+     *     values or as <OpenLayers.Bounds>, coordinates are expected to be in
+     *     the map's <projection>. If provided as array of four values, the
+     *     order of the values is left, bottom, right, top. The bounds can
+     *     also be provided as an array of two values. In this case the first
+     *     value is an object literal with lat and lon (WGS84 latitude and
+     *     longitude) for the bottom left corner, and another one for the top
+     *     right corner. See example below.
      * closest - {Boolean} Find the zoom level that most closely fits the 
      *     specified bounds. Note that this may result in a zoom that does 
      *     not exactly contain the entire extent.
      *     Default is false.
      * 
+     * On a map with projection set to "EPSG:3857", the following three
+     * statements are equivalent:
+     *
+     * (code)
+     * map.zoomToExtent({lat: -80, lon: -170}, {lat: 80, lon: 170});
+     * map.zoomToExtent([-18924313.432222, -15538711.094146, 18924313.432222, 15538711.094146]);
+     * map.zoomToExtent(new OpenLayers.Bounds(-18924313.432222, -15538711.094146, 18924313.432222, 15538711.094146));
+     * (end)
      */
     zoomToExtent: function(bounds, closest) {
         if (!(bounds instanceof OpenLayers.Bounds)) {

From c35e8afeb42de46e26b324cb27c07a6eca9136d3 Mon Sep 17 00:00:00 2001
From: Peter Robins <github@peterrobins.co.uk>
Date: Wed, 29 Feb 2012 12:04:25 +0000
Subject: [PATCH 3/3] Revised docs for passing coordinates as array/lonlat
 object

---
 lib/OpenLayers/Layer.js | 23 ++++++++++++++++++-----
 lib/OpenLayers/Map.js   | 18 +++++++++---------
 2 files changed, 27 insertions(+), 14 deletions(-)

diff --git a/lib/OpenLayers/Layer.js b/lib/OpenLayers/Layer.js
index acd9090643..5280e427d8 100644
--- a/lib/OpenLayers/Layer.js
+++ b/lib/OpenLayers/Layer.js
@@ -229,9 +229,23 @@ OpenLayers.Layer = OpenLayers.Class({
     
     /**
      * APIProperty: maxExtent
-     * {<OpenLayers.Bounds>|Array} If provided as an array, the array
-     *     should consist of four values (left, bottom, right, top).
-     *     The maximum extent for the layer.  Defaults to null.
+     * {<OpenLayers.Bounds>|Array} If provided as an array of four
+     *     values or as <OpenLayers.Bounds>, coordinates are expected to be in
+     *     the layer's <projection>. If provided as array of four values, the
+     *     order of the values is left, bottom, right, top. The bounds can
+     *     also be provided as an array of two values. In this case the first
+     *     value is an object literal with lat and lon (WGS84 latitude and
+     *     longitude) for the bottom left corner, and another one for the top
+     *     right corner.
+     * 
+     *     On a layer with projection set to "EPSG:3857", the following three
+     *     statements are equivalent:
+     *
+     *     (code)
+     *     maxExtent: [{lat: -80, lon: -170}, {lat: 80, lon: 170}]
+     *     maxExtent: [-18924313.432222, -15538711.094146, 18924313.432222, 15538711.094146]
+     *     maxExtent: new OpenLayers.Bounds(-18924313.432222, -15538711.094146, 18924313.432222, 15538711.094146)
+     *     (end)
      * 
      *     The center of these bounds will not stray outside
      *     of the viewport extent during panning.  In addition, if
@@ -242,8 +256,7 @@ OpenLayers.Layer = OpenLayers.Class({
     
     /**
      * APIProperty: minExtent
-     * {<OpenLayers.Bounds>|Array} If provided as an array, the array
-     *     should consist of four values (left, bottom, right, top).
+     * {<OpenLayers.Bounds>|Array}  See <maxExtent> for supported values.
      *     The minimum extent for the layer.  Defaults to null.
      */
     minExtent: null,
diff --git a/lib/OpenLayers/Map.js b/lib/OpenLayers/Map.js
index 901a7be1dc..db96a672d3 100644
--- a/lib/OpenLayers/Map.js
+++ b/lib/OpenLayers/Map.js
@@ -307,8 +307,7 @@ OpenLayers.Map = OpenLayers.Class({
 
     /**
      * APIProperty: maxExtent
-     * {<OpenLayers.Bounds>|Array} If provided as an array, the array
-     *     should consist of four values (left, bottom, right, top).
+     * {<OpenLayers.Bounds>|Array}  See <zoomToExtent> for supported values.
      *     The maximum extent for the map.  Defaults to the
      *     whole world in decimal degrees (-180, -90, 180, 90).  Specify a 
      *     different extent in the map options if you are not using a geographic
@@ -320,16 +319,14 @@ OpenLayers.Map = OpenLayers.Class({
     
     /**
      * APIProperty: minExtent
-     * {<OpenLayers.Bounds>|Array} If provided as an array, the array
-     *     should consist of four values (left, bottom, right, top).
+     * {<OpenLayers.Bounds>|Array}  See <zoomToExtent> for supported values.
      *     The minimum extent for the map.  Defaults to null.
      */
     minExtent: null,
     
     /**
      * APIProperty: restrictedExtent
-     * {<OpenLayers.Bounds>|Array} If provided as an array, the array
-     *     should consist of four values (left, bottom, right, top).
+     * {<OpenLayers.Bounds>|Array}  See <zoomToExtent> for supported values.
      *     Limit map navigation to this extent where possible.
      *     If a non-null restrictedExtent is set, panning will be restricted
      *     to the given bounds.  In addition, zooming to a resolution that
@@ -482,10 +479,13 @@ OpenLayers.Map = OpenLayers.Class({
      *     center: [-12356463.476333, 5621521.4854095]
      * });
      *
-     * // create a map without a reference to a container - call render later
+     * // create a map without a reference to a container - call render later.
+     * // use latitude/longitude objects for bounds and center
      * var map = new OpenLayers.Map({
      *     projection: "EPSG:3857",
-     *     maxExtent: new OpenLayers.Bounds(-200000, -200000, 200000, 200000)
+     *     maxExtent: [{lat: -80, lon: -170}, {lat: 80, lon: 170}],
+     *     restrictedExtent: [{lat: -65, lon: -120}, {lat: 65, lon: 120}],
+     *     center: {lat: 45, lon: -111}
      * });
      * (end)
      */    
@@ -523,7 +523,7 @@ OpenLayers.Map = OpenLayers.Class({
             this.maxExtent = new OpenLayers.Bounds(this.maxExtent, srs);
         }
         if (this.minExtent && !(this.minExtent instanceof OpenLayers.Bounds)) {
-            this.minExtent = new OpenLayers.Bounds(this.minExtent);
+            this.minExtent = new OpenLayers.Bounds(this.minExtent, srs);
         }
         if (this.restrictedExtent && !(this.restrictedExtent instanceof OpenLayers.Bounds)) {
             this.restrictedExtent = new OpenLayers.Bounds(this.restrictedExtent, srs);