docs: function(lonlat, zoom, options) {
          if (lonlat != null && !(lonlat instanceof OpenLayers.LonLat)) {
              lonlat = new OpenLayers.LonLat(lonlat);
          }
          if (!options) { 
              options = {};
          }
          if (zoom != null) {
              zoom = parseFloat(zoom);
              if (!this.fractionalZoom) {
                  zoom = Math.round(zoom);
              }
          }
          var requestedZoom = zoom;
          zoom = this.adjustZoom(zoom);
          if (zoom !== requestedZoom) {
              // zoom was adjusted, so keep old lonlat to avoid panning
              lonlat = this.getCenter();
          }
          // dragging is false by default
          var dragging = options.dragging || this.dragging;
          // forceZoomChange is false by default
          var forceZoomChange = options.forceZoomChange;
  
          if (!this.getCachedCenter() && !this.isValidLonLat(lonlat)) {
              lonlat = this.maxExtent.getCenterLonLat();
              this.center = lonlat.clone();
          }
  
          if(this.restrictedExtent != null) {
              // In 3.0, decide if we want to change interpretation of maxExtent.
              if(lonlat == null) { 
                  lonlat = this.center; 
              }
              if(zoom == null) { 
                  zoom = this.getZoom(); 
              }
              var resolution = this.getResolutionForZoom(zoom);
              var extent = this.calculateBounds(lonlat, resolution); 
              if(!this.restrictedExtent.containsBounds(extent)) {
                  var maxCenter = this.restrictedExtent.getCenterLonLat(); 
                  if(extent.getWidth() > this.restrictedExtent.getWidth()) { 
                      lonlat = new OpenLayers.LonLat(maxCenter.lon, lonlat.lat); 
                  } else if(extent.left < this.restrictedExtent.left) {
                      lonlat = lonlat.add(this.restrictedExtent.left -
                                          extent.left, 0); 
                  } else if(extent.right > this.restrictedExtent.right) { 
                      lonlat = lonlat.add(this.restrictedExtent.right -
                                          extent.right, 0); 
                  } 
                  if(extent.getHeight() > this.restrictedExtent.getHeight()) { 
                      lonlat = new OpenLayers.LonLat(lonlat.lon, maxCenter.lat); 
                  } else if(extent.bottom < this.restrictedExtent.bottom) { 
                      lonlat = lonlat.add(0, this.restrictedExtent.bottom -
                                          extent.bottom); 
                  } 
                  else if(extent.top > this.restrictedExtent.top) { 
                      lonlat = lonlat.add(0, this.restrictedExtent.top -
                                          extent.top); 
                  } 
              }
          }
          
          var zoomChanged = forceZoomChange || (
                              (this.isValidZoomLevel(zoom)) && 
                              (zoom != this.getZoom()) );
  
          var centerChanged = (this.isValidLonLat(lonlat)) && 
                              (!lonlat.equals(this.center));
  
          // if neither center nor zoom will change, no need to do anything
          if (zoomChanged || centerChanged || dragging) {
              dragging || this.events.triggerEvent("movestart", {
                  zoomChanged: zoomChanged
              });
  
              if (centerChanged) {
                  if (!zoomChanged && this.center) { 
                      // if zoom hasnt changed, just slide layerContainer
                      //  (must be done before setting this.center to new value)
                      this.centerLayerContainer(lonlat);
                  }
                  this.center = lonlat.clone();
              }
  
              var res = zoomChanged ?
                  this.getResolutionForZoom(zoom) : this.getResolution();
              // (re)set the layerContainerDiv's location
              if (zoomChanged || this.layerContainerOrigin == null) {
                  this.layerContainerOrigin = this.getCachedCenter();
                  this.layerContainerOriginPx.x = 0;
                  this.layerContainerOriginPx.y = 0;
                  this.applyTransform();
                  var maxExtent = this.getMaxExtent({restricted: true});
                  var maxExtentCenter = maxExtent.getCenterLonLat();
                  var lonDelta = this.center.lon - maxExtentCenter.lon;
                  var latDelta = maxExtentCenter.lat - this.center.lat;
                  var extentWidth = Math.round(maxExtent.getWidth() / res);
                  var extentHeight = Math.round(maxExtent.getHeight() / res);
                  this.minPx = {
                      x: (this.size.w - extentWidth) / 2 - lonDelta / res,
                      y: (this.size.h - extentHeight) / 2 - latDelta / res
                  };
                  this.maxPx = {
                      x: this.minPx.x + Math.round(maxExtent.getWidth() / res),
                      y: this.minPx.y + Math.round(maxExtent.getHeight() / res)
                  };
              }
  
              if (zoomChanged) {
                  this.zoom = zoom;
                  this.resolution = res;
              }    
              
              var bounds = this.getExtent();
              
              //send the move call to the baselayer and all the overlays    
  
              if(this.baseLayer.visibility) {
                  this.baseLayer.moveTo(bounds, zoomChanged, options.dragging);
                  options.dragging || this.baseLayer.events.triggerEvent(
                      "moveend", {zoomChanged: zoomChanged}
                  );
              }
              
              bounds = this.baseLayer.getExtent();
              
              for (var i=this.layers.length-1; i>=0; --i) {
                  var layer = this.layers[i];
                  if (layer !== this.baseLayer && !layer.isBaseLayer) {
                      var inRange = layer.calculateInRange();
                      if (layer.inRange != inRange) {
                          // the inRange property has changed. If the layer is
                          // no longer in range, we turn it off right away. If
                          // the layer is no longer out of range, the moveTo
                          // call below will turn on the layer.
                          layer.inRange = inRange;
                          if (!inRange) {
                              layer.display(false);
                          }
                          this.events.triggerEvent("changelayer", {
                              layer: layer, property: "visibility"
                          });
                      }
                      if (inRange && layer.visibility) {
                          layer.moveTo(bounds, zoomChanged, options.dragging);
                          options.dragging || layer.events.triggerEvent(
                              "moveend", {zoomChanged: zoomChanged}
                          );
                      }
                  }                
              }
              
              this.events.triggerEvent("move");
              dragging || this.events.triggerEvent("moveend");
  
              if (zoomChanged) {
                  //redraw popups
                  for (var i=0, len=this.popups.length; i<len; i++) {
                      this.popups[i].updatePosition();
                  }
                  this.events.triggerEvent("zoomend");
              }
          }
      }