docs: function(bounds, zoomChanged, dragging) {
  
          OpenLayers.Layer.HTTPRequest.prototype.moveTo.apply(this, arguments);
  
          bounds = bounds || this.map.getExtent();
  
          if (bounds != null) {
               
              // if grid is empty or zoom has changed, we *must* re-tile
              var forceReTile = !this.grid.length || zoomChanged;
              
              // total bounds of the tiles
              var tilesBounds = this.getTilesBounds();            
  
              // the new map resolution
              var resolution = this.map.getResolution();
  
              // the server-supported resolution for the new map resolution
              var serverResolution = this.getServerResolution(resolution);
  
              if (this.singleTile) {
                  
                  // We want to redraw whenever even the slightest part of the 
                  //  current bounds is not contained by our tile.
                  //  (thus, we do not specify partial -- its default is false)
  
                  if ( forceReTile ||
                       (!dragging && !tilesBounds.containsBounds(bounds))) {
  
                      // In single tile mode with no transition effect, we insert
                      // a non-scaled backbuffer when the layer is moved. But if
                      // a zoom occurs right after a move, i.e. before the new
                      // image is received, we need to remove the backbuffer, or
                      // an ill-positioned image will be visible during the zoom
                      // transition.
  
                      if(zoomChanged && this.transitionEffect !== 'resize') {
                          this.removeBackBuffer();
                      }
  
                      if(!zoomChanged || this.transitionEffect === 'resize') {
                          this.applyBackBuffer(resolution);
                      }
  
                      this.initSingleTile(bounds);
                  }
              } else {
  
                  // if the bounds have changed such that they are not even 
                  // *partially* contained by our tiles (e.g. when user has 
                  // programmatically panned to the other side of the earth on
                  // zoom level 18), then moveGriddedTiles could potentially have
                  // to run through thousands of cycles, so we want to reTile
                  // instead (thus, partial true).  
                  forceReTile = forceReTile ||
                      !tilesBounds.intersectsBounds(bounds, {
                          worldBounds: this.map.baseLayer.wrapDateLine &&
                              this.map.getMaxExtent()
                      });
  
                  if(forceReTile) {
                      if(zoomChanged && (this.transitionEffect === 'resize' ||
                                            this.gridResolution === resolution)) {
                          this.applyBackBuffer(resolution);
                      }
                      this.initGriddedTiles(bounds);
                  } else {
                      this.moveGriddedTiles();
                  }
              }
          }
      }