Ticket #3062: openlayers-3062.2.patch

File openlayers-3062.2.patch, 21.2 KB (added by ahocevar, 6 years ago)
  • tests/Layer/Google/v3.html

     
    266266
    267267         t.plan(8);
    268268
    269          var origPrecision = OpenLayers.Util.DEFAULT_PRECISION;
    270          // GMaps v3 seems to use a default precision of 13, which is lower
    271          // than what we use in OpenLayers.
    272          // See http://trac.osgeo.org/openlayers/ticket/3059
    273          OpenLayers.Util.DEFAULT_PRECISION = 13;
    274 
    275269         var map = new OpenLayers.Map('map', {allOverlays: true});
    276270
    277271         var gmap = new OpenLayers.Layer.Google("Google Streets");
     
    316310         t.eq(center.lat, origin.lat, "y panning with Google invisible " + (-dx) + ", " + (-dy));
    317311
    318312         map.destroy();
    319          OpenLayers.Util.DEFAULT_PRECISION = origPrecision;
    320313     }
    321314     
    322315     function test_wrapDateLine(t) {
  • tests/Map.html

     
    797797        map.destroy();
    798798    }
    799799
    800     function test_Map_setBaseLayer_after_pan (t) {
    801         t.plan(1);
     800    function test_Map_setBaseLayer_containerdiv (t) {
     801        t.plan(4);
    802802
    803803        map = new OpenLayers.Map('map');
    804         var wmsLayer = new OpenLayers.Layer.WMS( "OpenLayers WMS",
    805             "http://labs.metacarta.com/wms/vmap0", {layers: 'basic'} );
    806         var tmsLayer = new OpenLayers.Layer.TMS("TMS",
    807                                     "http://labs.metacarta.com/wms-c/Basic.py/",
    808                                     {'layername':'basic', 'type':'png'});
    809         map.addLayers([wmsLayer,tmsLayer]);
    810         map.setBaseLayer(wmsLayer);
     804        map.addLayer(new OpenLayers.Layer(null, {isBaseLayer: true}));
    811805        map.zoomToMaxExtent();
    812         map.setBaseLayer(tmsLayer);
     806        var res = map.getResolution();
     807        t.eq(map.layerContainerDiv.style.top, (150-90/res)+"px", "layerContainer.style.top is correct");
     808        t.eq(map.layerContainerDiv.style.left, (300-180/res)+"px", "layerContainer.style.left is correct");
    813809        map.zoomIn();
    814         map.pan(0, -200, {animate:false});
    815         map.setBaseLayer(wmsLayer);
    816         t.eq(map.layerContainerDiv.style.top, "0px", "layerContainer is recentered after setBaseLayer");
     810        map.pan(50, -200, {animate:false});
     811        var res = map.getResolution();
     812        t.eq(map.layerContainerDiv.style.top, (350-90/res)+"px", "layerContainer.style.top is correct");
     813        t.eq(map.layerContainerDiv.style.left, (250-180/res)+"px", "layerContainer.style.left is correct");
    817814       
    818815        map.destroy();
    819816    }
     
    13181315       
    13191316        var m = {
    13201317            'baseLayer': { 'units': {} },
    1321             'getSize': function() { return {'w': 10, 'h': 15}; },
    1322             'getCenter': function() { return {'lon': -5, 'lat': -25}; },
     1318            'size': {'w': 10, 'h': 15},
     1319            'center': {'lon': -5, 'lat': -25},
    13231320            'zoomToExtent': function(extent, closest) {
    13241321                t.ok(extent.equals(g_ExpectedExtent), "extent correctly calculated for zoomToExtent()");
    13251322                t.ok(closest == g_Closest, "closest correctly passed on to zoomToExtent()");
  • lib/OpenLayers/Map.js

     
    166166    size: null,
    167167   
    168168    /**
     169     * Property: extent
     170     * {<OpenLayers.Bounds>} Cached extent.
     171     */
     172    extent: null,
     173   
     174    /**
    169175     * Property: viewPortDiv
    170176     * {HTMLDivElement} The element that represents the map viewport
    171177     */
    172178    viewPortDiv: null,
    173179
    174180    /**
    175      * Property: layerContainerOrigin
    176      * {<OpenLayers.LonLat>} The lonlat at which the later container was
    177      *                       re-initialized (on-zoom)
    178      */
    179     layerContainerOrigin: null,
    180 
    181     /**
    182181     * Property: layerContainerDiv
    183182     * {HTMLDivElement} The element that contains the layers.
    184183     */
     
    233232     * {Integer} The current zoom level of the map
    234233     */
    235234    zoom: 0,   
    236 
     235   
    237236    /**
    238237     * Property: panRatio
    239238     * {Float} The ratio of the current extent within
     
    11151114            if (OpenLayers.Util.indexOf(this.layers, newBaseLayer) != -1) {
    11161115
    11171116                // preserve center and scale when changing base layers
    1118                 var center = this.getCenter();
     1117                var center = this.center;
    11191118                var newResolution = OpenLayers.Util.getResolutionFromScale(
    11201119                    this.getScale(), newBaseLayer.units
    11211120                );
     
    13631362        var newSize = this.getCurrentSize();
    13641363        if (newSize && !isNaN(newSize.h) && !isNaN(newSize.w)) {
    13651364            this.events.clearMouseCache();
    1366             var oldSize = this.getSize();
     1365            var oldSize = this.size;
    13671366            if (oldSize == null) {
    13681367                this.size = oldSize = newSize;
    13691368            }
     
    13771376                    this.layers[i].onMapResize();               
    13781377                }
    13791378   
    1380                 var center = this.getCenter();
     1379                var center = this.center;
    13811380   
    13821381                if (this.baseLayer != null && center != null) {
    1383                     var zoom = this.getZoom();
     1382                    var zoom = this.zoom;
    13841383                    this.zoom = null;
    13851384                    this.setCenter(center, zoom);
    13861385                }
     
    14281427        var extent = null;
    14291428       
    14301429        if (center == null) {
    1431             center = this.getCenter();
     1430            center = this.center;
    14321431        }               
    14331432        if (resolution == null) {
    1434             resolution = this.getResolution();
     1433            resolution = this.resolution;
    14351434        }
    14361435   
    14371436        if ((center != null) && (resolution != null)) {
    14381437
    1439             var size = this.getSize();
     1438            var size = this.size;
    14401439            var w_deg = size.w * resolution;
    14411440            var h_deg = size.h * resolution;
    14421441       
     
    15021501            animate: true,
    15031502            dragging: false
    15041503        });
     1504       
    15051505        // getCenter
    15061506        var centerPx = this.getViewPortPxFromLonLat(this.getCenter());
    15071507
     
    15291529     * lonlat - {<OpenLayers.Lonlat>}
    15301530     */
    15311531    panTo: function(lonlat) {
    1532         if (this.panMethod && this.getExtent().scale(this.panRatio).containsLonLat(lonlat)) {
     1532        if (this.panMethod && this.extent.scale(this.panRatio).containsLonLat(lonlat)) {
    15331533            if (!this.panTween) {
    15341534                this.panTween = new OpenLayers.Tween(this.panMethod);
    15351535            }
    1536             var center = this.getCenter();
     1536            var center = this.center;
    15371537
    15381538            // center will not change, don't do nothing
    15391539            if (lonlat.lon == center.lon &&
     
    16091609        if (!options) {
    16101610            options = {};
    16111611        }
    1612         if (zoom != null) {
    1613             zoom = parseFloat(zoom);
    1614             if (!this.fractionalZoom) {
    1615                 zoom = Math.round(zoom);
    1616             }
    1617         }
    16181612        // dragging is false by default
    16191613        var dragging = options.dragging;
    16201614        // forceZoomChange is false by default
    16211615        var forceZoomChange = options.forceZoomChange;
    16221616        // noEvent is false by default
    16231617        var noEvent = options.noEvent;
    1624 
     1618       
    16251619        if (this.panTween && options.caller == "setCenter") {
    16261620            this.panTween.stop();
    16271621        }   
    1628              
    1629         if (!this.center && !this.isValidLonLat(lonlat)) {
    1630             lonlat = this.maxExtent.getCenterLonLat();
    1631         }
    16321622
    1633         if(this.restrictedExtent != null) {
    1634             // In 3.0, decide if we want to change interpretation of maxExtent.
    1635             if(lonlat == null) {
    1636                 lonlat = this.getCenter();
     1623        var zoomChanged = forceZoomChange;
     1624        if (zoom != null) {
     1625            if (typeof zoom != "number") {
     1626                zoom = parseFloat(zoom);
    16371627            }
    1638             if(zoom == null) {
    1639                 zoom = this.getZoom();
     1628            if (!this.fractionalZoom) {
     1629                zoom = Math.round(zoom);
    16401630            }
    1641             var resolution = this.getResolutionForZoom(zoom);
    1642             var extent = this.calculateBounds(lonlat, resolution);
    1643             if(!this.restrictedExtent.containsBounds(extent)) {
    1644                 var maxCenter = this.restrictedExtent.getCenterLonLat();
    1645                 if(extent.getWidth() > this.restrictedExtent.getWidth()) {
    1646                     lonlat = new OpenLayers.LonLat(maxCenter.lon, lonlat.lat);
    1647                 } else if(extent.left < this.restrictedExtent.left) {
    1648                     lonlat = lonlat.add(this.restrictedExtent.left -
    1649                                         extent.left, 0);
    1650                 } else if(extent.right > this.restrictedExtent.right) {
    1651                     lonlat = lonlat.add(this.restrictedExtent.right -
    1652                                         extent.right, 0);
    1653                 }
    1654                 if(extent.getHeight() > this.restrictedExtent.getHeight()) {
    1655                     lonlat = new OpenLayers.LonLat(lonlat.lon, maxCenter.lat);
    1656                 } else if(extent.bottom < this.restrictedExtent.bottom) {
    1657                     lonlat = lonlat.add(0, this.restrictedExtent.bottom -
    1658                                         extent.bottom);
    1659                 }
    1660                 else if(extent.top > this.restrictedExtent.top) {
    1661                     lonlat = lonlat.add(0, this.restrictedExtent.top -
    1662                                         extent.top);
    1663                 }
    1664             }
    16651631        }
     1632        zoomChanged = zoomChanged ||
     1633            zoom != this.zoom && this.isValidZoomLevel(zoom);
     1634        var res;
     1635        if (zoomChanged) {
     1636            res = this.resolution = this.getResolutionForZoom(zoom);
     1637        } else {
     1638            res = this.resolution = this.getResolution();
     1639        }
    16661640       
    1667         var zoomChanged = forceZoomChange || (
    1668                             (this.isValidZoomLevel(zoom)) &&
    1669                             (zoom != this.getZoom()) );
     1641        if (lonlat) {
     1642            if (this.restrictedExtent) {
     1643                var extent = this.calculateBounds(lonlat, res);
     1644                if (!this.restrictedExtent.containsBounds(extent)) {
     1645                    var maxCenter = this.restrictedExtent.getCenterLonLat();
     1646                    if (extent.getWidth() > this.restrictedExtent.getWidth()) {
     1647                        lonlat = new OpenLayers.LonLat(maxCenter.lon, lonlat.lat);
     1648                    } else if (extent.left < this.restrictedExtent.left) {
     1649                        lonlat = lonlat.add(this.restrictedExtent.left -
     1650                                            extent.left, 0);
     1651                    } else if (extent.right > this.restrictedExtent.right) {
     1652                        lonlat = lonlat.add(this.restrictedExtent.right -
     1653                                            extent.right, 0);
     1654                    }
     1655                    if (extent.getHeight() > this.restrictedExtent.getHeight()) {
     1656                        lonlat = new OpenLayers.LonLat(lonlat.lon, maxCenter.lat);
     1657                    } else if (extent.bottom < this.restrictedExtent.bottom) {
     1658                        lonlat = lonlat.add(0, this.restrictedExtent.bottom -
     1659                                            extent.bottom);
     1660                    }
     1661                    else if (extent.top > this.restrictedExtent.top) {
     1662                        lonlat = lonlat.add(0, this.restrictedExtent.top -
     1663                                            extent.top);
     1664                    }
     1665                }
     1666            }
     1667        }
    16701668
    1671         var centerChanged = (this.isValidLonLat(lonlat)) &&
    1672                             (!lonlat.equals(this.center));
    1673 
    1674 
     1669        if (zoomChanged) {
     1670            var maxExtent = this.getMaxExtent();
     1671            this.layerContainerDiv.style.width =
     1672                Math.round(maxExtent.getWidth() / res) + "px";
     1673            this.layerContainerDiv.style.height  =
     1674                Math.round(maxExtent.getHeight() / res) + "px";
     1675            this.zoom = zoom;
     1676            // zoom level has changed, increment viewRequestID.
     1677            this.viewRequestID++;
     1678        }
     1679       
     1680        var centerChanged =
     1681            this.isValidLonLat(lonlat) && !lonlat.equals(this.center);
     1682        if (centerChanged || !this.center) {
     1683            if (!this.center && !this.isValidLonLat(lonlat)) {
     1684                lonlat = this.maxExtent.getCenterLonLat();
     1685            }
     1686            this.centerLayerContainer(lonlat);
     1687            this.center = lonlat;
     1688        }
     1689       
    16751690        // if neither center nor zoom will change, no need to do anything
    16761691        if (zoomChanged || centerChanged || !dragging) {
    16771692
    16781693            if (!this.dragging && !noEvent) {
    16791694                this.events.triggerEvent("movestart");
    16801695            }
    1681 
    1682             if (centerChanged) {
    1683                 if ((!zoomChanged) && (this.center)) {
    1684                     // if zoom hasnt changed, just slide layerContainer
    1685                     //  (must be done before setting this.center to new value)
    1686                     this.centerLayerContainer(lonlat);
    1687                 }
    1688                 this.center = lonlat.clone();
    1689             }
    1690 
    1691             // (re)set the layerContainerDiv's location
    1692             if ((zoomChanged) || (this.layerContainerOrigin == null)) {
    1693                 this.layerContainerOrigin = this.center.clone();
    1694                 this.layerContainerDiv.style.left = "0px";
    1695                 this.layerContainerDiv.style.top  = "0px";
    1696             }
    1697 
    1698             if (zoomChanged) {
    1699                 this.zoom = zoom;
    1700                 this.resolution = this.getResolutionForZoom(zoom);
    1701                 // zoom level has changed, increment viewRequestID.
    1702                 this.viewRequestID++;
    1703             }   
    17041696           
    1705             var bounds = this.getExtent();
     1697            this.extent = this.baseLayer.getExtent();
    17061698           
    17071699            //send the move call to the baselayer and all the overlays   
    1708 
    17091700            if(this.baseLayer.visibility) {
    1710                 this.baseLayer.moveTo(bounds, zoomChanged, dragging);
     1701                this.baseLayer.moveTo(this.extent, zoomChanged, dragging);
    17111702                if(dragging) {
    17121703                    this.baseLayer.events.triggerEvent("move");
    17131704                } else {
     
    17161707                    );
    17171708                }
    17181709            }
    1719            
    1720             bounds = this.baseLayer.getExtent();
    1721            
     1710                                   
    17221711            for (var i=0, len=this.layers.length; i<len; i++) {
    17231712                var layer = this.layers[i];
    17241713                if (layer !== this.baseLayer && !layer.isBaseLayer) {
     
    17371726                        });
    17381727                    }
    17391728                    if (inRange && layer.visibility) {
    1740                         layer.moveTo(bounds, zoomChanged, dragging);
     1729                        layer.moveTo(this.extent, zoomChanged, dragging);
    17411730                        if(dragging) {
    17421731                            layer.events.triggerEvent("move");
    17431732                        } else {
     
    17791768     * lonlat - {<OpenLayers.LonLat>}
    17801769     */
    17811770    centerLayerContainer: function (lonlat) {
    1782 
    1783         var originPx = this.getViewPortPxFromLonLat(this.layerContainerOrigin);
    1784         var newPx = this.getViewPortPxFromLonLat(lonlat);
    1785 
    1786         if ((originPx != null) && (newPx != null)) {
    1787             this.layerContainerDiv.style.left = Math.round(originPx.x - newPx.x) + "px";
    1788             this.layerContainerDiv.style.top  = Math.round(originPx.y - newPx.y) + "px";
    1789         }
     1771        var res = this.resolution;
     1772        var center = this.getMaxExtent().getCenterLonLat();
     1773        var lonDelta = lonlat.lon - center.lon;
     1774        var latDelta = center.lat - lonlat.lat;
     1775        var halfExtentWidth = parseInt(this.layerContainerDiv.style.width) / 2;
     1776        var halfExtentHeight = parseInt(this.layerContainerDiv.style.height) / 2;
     1777        var halfViewPortWidth = this.size.w / 2;
     1778        var halfViewPortHeight = this.size.h / 2;
     1779        var left = halfViewPortWidth - halfExtentWidth - lonDelta / res;
     1780        var top = halfViewPortHeight - halfExtentHeight - latDelta / res;
     1781        this.layerContainerDiv.style.left = Math.round(left) + "px";
     1782        this.layerContainerDiv.style.top  = Math.round(top) + "px";
    17901783    },
    17911784
    17921785    /**
     
    19551948     */
    19561949    getExtent: function () {
    19571950        var extent = null;
    1958         if (this.baseLayer != null) {
    1959             extent = this.baseLayer.getExtent();
     1951        if (this.extent != null) {
     1952            extent = this.extent.clone();
    19601953        }
    19611954        return extent;
    19621955    },
     
    21092102     * zoom - {int}
    21102103     */
    21112104    zoomIn: function() {
    2112         this.zoomTo(this.getZoom() + 1);
     2105        this.zoomTo(this.zoom + 1);
    21132106    },
    21142107   
    21152108    /**
     
    21192112     * zoom - {int}
    21202113     */
    21212114    zoomOut: function() {
    2122         this.zoomTo(this.getZoom() - 1);
     2115        this.zoomTo(this.zoom - 1);
    21232116    },
    21242117
    21252118    /**
     
    21972190    zoomToScale: function(scale, closest) {
    21982191        var res = OpenLayers.Util.getResolutionFromScale(scale,
    21992192                                                         this.baseLayer.units);
    2200         var size = this.getSize();
     2193        var size = this.size;
    22012194        var w_deg = size.w * res;
    22022195        var h_deg = size.h * res;
    2203         var center = this.getCenter();
     2196        var center = this.center;
    22042197
    22052198        var extent = new OpenLayers.Bounds(center.lon - w_deg / 2,
    22062199                                           center.lat - h_deg / 2,
     
    23122305     * {<OpenLayers.Size>} The geodesic size of the pixel in kilometers.
    23132306     */
    23142307    getGeodesicPixelSize: function(px) {
    2315         var lonlat = px ? this.getLonLatFromPixel(px) : (this.getCenter() ||
     2308        var lonlat = px ? this.getLonLatFromPixel(px) : (this.center ||
    23162309            new OpenLayers.LonLat(0, 0));
    23172310        var res = this.getResolution();
    23182311        var left = lonlat.add(-res / 2, 0);
     
    23532346    getViewPortPxFromLayerPx:function(layerPx) {
    23542347        var viewPortPx = null;
    23552348        if (layerPx != null) {
    2356             var dX = parseInt(this.layerContainerDiv.style.left);
    2357             var dY = parseInt(this.layerContainerDiv.style.top);
    2358             viewPortPx = layerPx.add(dX, dY);           
     2349            var res = this.resolution;
     2350            var center = this.getMaxExtent().getCenterLonLat();
     2351            var deltaX = Math.round(center.lon / res - this.center.lon / res);
     2352            var deltaY = Math.round(this.center.lat / res - center.lat / res);
     2353            viewPortPx = layerPx.add(deltaX, deltaY);
    23592354        }
    23602355        return viewPortPx;
    23612356    },
     
    23732368    getLayerPxFromViewPortPx:function(viewPortPx) {
    23742369        var layerPx = null;
    23752370        if (viewPortPx != null) {
    2376             var dX = -parseInt(this.layerContainerDiv.style.left);
    2377             var dY = -parseInt(this.layerContainerDiv.style.top);
    2378             layerPx = viewPortPx.add(dX, dY);
    2379             if (isNaN(layerPx.x) || isNaN(layerPx.y)) {
    2380                 layerPx = null;
    2381             }
     2371            var res = this.resolution;
     2372            var center = this.getMaxExtent().getCenterLonLat();
     2373            var deltaX = Math.round(this.center.lon / res - center.lon / res);
     2374            var deltaY = Math.round(center.lat / res - this.center.lat / res);
     2375            layerPx = viewPortPx.add(deltaX, deltaY);
    23822376        }
    23832377        return layerPx;
    23842378    },
  • lib/OpenLayers/Layer.js

     
    12341234    getViewPortPxFromLonLat: function (lonlat) {
    12351235        var px = null;
    12361236        if (lonlat != null) {
    1237             var resolution = this.map.getResolution();
    1238             var extent = this.map.getExtent();
    1239             px = new OpenLayers.Pixel(
    1240                 (1/resolution * (lonlat.lon - extent.left)),
    1241                 (1/resolution * (extent.top - lonlat.lat))
    1242             );   
     1237            var res = this.map.resolution;
     1238            var center = this.map.extent.getCenterLonLat();
     1239            var lonDelta = lonlat.lon - center.lon;
     1240            var latDelta = center.lat - lonlat.lat;
     1241            var halfViewPortWidth = this.map.size.w / 2;
     1242            var halfViewPortHeight = this.map.size.h / 2;
     1243            var left = halfViewPortWidth + lonDelta / res;
     1244            var top = halfViewPortHeight + latDelta / res;
     1245            px = new OpenLayers.Pixel(left, top);
    12431246        }
    12441247        return px;
    12451248    },
  • lib/OpenLayers/Layer/Grid.js

     
    665665        var shifted = true;
    666666        var buffer = this.buffer || 1;
    667667        var tlLayer = this.grid[0][0].position;
    668         var tlViewPort = this.map.getViewPortPxFromLayerPx(tlLayer);
     668        var offsetX = parseInt(this.map.layerContainerDiv.style.left);
     669        var offsetY = parseInt(this.map.layerContainerDiv.style.top);
     670        tlViewPort = tlLayer.add(offsetX, offsetY);
    669671        if (tlViewPort.x > -this.tileSize.w * (buffer - 1)) {
    670672            this.shiftColumn(true);
    671673        } else if (tlViewPort.x < -this.tileSize.w * buffer) {