OpenLayers OpenLayers

Changeset 6125

Show
Ignore:
Timestamp:
02/08/08 14:35:06 (1 year ago)
Author:
tschaub
Message:

merge r6018:HEAD from trunk

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • sandbox/tschaub/events/doc/authors.txt

    r5970 r6125  
    11OpenLayers contributors: 
    22 
     3Seb Benthall 
    34Howard Butler 
    45Bertil Chaupis                                                                
    …… 
    2526James Stembridge 
    2627Erik Uzureau 
     28Ivan Willig 
    2729Bill Woodall 
    2830Steve Woodbridge 
    …… 
    3335Some portions of OpenLayers are used under the MIT license, availabie in  
    3436doc/licenses/MIT-LICENSE.txt. 
     37 
     38Some portions of OpenLayers are Copyright 2001 Robert Penner, and are used  
     39under the BSD license, available in doc/licenses/BSD-LICENSE.txt 

  • sandbox/tschaub/events/examples/click-handler.html

    r5438 r6125  
    3939                    'single': true, 
    4040                    'double': false, 
    41                     'pixelTolerance': null, 
     41                    'pixelTolerance': 0, 
    4242                    'stopSingle': false, 
    4343                    'stopDouble': false 
    …… 
    103103                        } 
    104104                    }), 
    105                     "nodrag": new OpenLayers.Control.Click({ 
     105                    "drag": new OpenLayers.Control.Click({ 
    106106                        handlerOptions: { 
    107107                            "single": true, 
    108                             "pixelTolerance": 1 
     108                            "pixelTolerance": null 
    109109                        } 
    110110                    }), 
    …… 
    205205                    </tr> 
    206206                    <tr> 
    207                         <td>single no drag</td> 
    208                         <td><button id="nodragStatus" onclick="toggle('nodrag')">off</button></td> 
    209                         <td><textarea class="output" id="nodragOutput"></textarea></td> 
     207                        <td>single with drag</td> 
     208                        <td><button id="dragStatus" onclick="toggle('drag')">off</button></td> 
     209                        <td><textarea class="output" id="dragOutput"></textarea></td> 
    210210                    </tr> 
    211211                    <tr> 

  • sandbox/tschaub/events/lib/OpenLayers.js

    r5921 r6125  
    8080            "OpenLayers/BaseTypes/Size.js", 
    8181            "OpenLayers/Console.js", 
     82            "OpenLayers/Tween.js", 
    8283            "Rico/Corner.js", 
    8384            "Rico/Color.js", 

  • sandbox/tschaub/events/lib/OpenLayers/Control.js

    r5910 r6125  
    140140            this.handler = null; 
    141141        } 
     142        if(this.handlers) { 
     143            for(var key in this.handlers) { 
     144                if(this.handlers.hasOwnProperty(key) && 
     145                   typeof this.handlers[key].destroy == "function") { 
     146                    this.handlers[key].destroy(); 
     147                } 
     148            } 
     149            this.handlers = null; 
     150        } 
    142151        if (this.map) { 
    143152            this.map.removeControl(this); 

  • sandbox/tschaub/events/lib/OpenLayers/Control/DragFeature.js

    r5614 r6125  
    7878 
    7979    /** 
    80      * Property: dragHandler 
    81      * {<OpenLayers.Handler.Drag>} 
    82      */ 
    83     dragHandler: null, 
    84  
    85     /** 
    8680     * Property: dragCallbacks 
    8781     * {Object} The functions that are sent to the drag handler for callback. 
    8882     */ 
    8983    dragCallbacks: {}, 
    90  
    91     /** 
    92      * Property: featureHandler 
    93      * {<OpenLayers.Handler.Feature>} 
    94      */ 
    95     featureHandler: null, 
    9684 
    9785    /** 
    …… 
    120108        OpenLayers.Control.prototype.initialize.apply(this, [options]); 
    121109        this.layer = layer; 
    122         this.dragCallbacks = OpenLayers.Util.extend({down: this.downFeature, 
    123                                                      move: this.moveFeature, 
    124                                                      up: this.upFeature, 
    125                                                      out: this.cancel, 
    126                                                      done: this.doneDragging 
    127                                                     }, this.dragCallbacks); 
    128         this.dragHandler = new OpenLayers.Handler.Drag(this, this.dragCallbacks); 
    129         this.featureCallbacks = OpenLayers.Util.extend({over: this.overFeature, 
    130                                                         out: this.outFeature 
    131                                                        }, this.featureCallbacks); 
    132         var handlerOptions = {geometryTypes: this.geometryTypes}; 
    133         this.featureHandler = new OpenLayers.Handler.Feature(this, this.layer, 
    134                                                         this.featureCallbacks, 
    135                                                         handlerOptions); 
     110        this.handlers = { 
     111            drag: new OpenLayers.Handler.Drag( 
     112                this, OpenLayers.Util.extend({ 
     113                    down: this.downFeature, 
     114                    move: this.moveFeature, 
     115                    up: this.upFeature, 
     116                    out: this.cancel, 
     117                    done: this.doneDragging 
     118                }, this.dragCallbacks) 
     119            ), 
     120            feature: new OpenLayers.Handler.Feature( 
     121                this, this.layer, OpenLayers.Util.extend({ 
     122                    over: this.overFeature, 
     123                    out: this.outFeature 
     124                }, this.featureCallbacks), 
     125                {geometryTypes: this.geometryTypes} 
     126            ) 
     127        }; 
    136128    }, 
    137129     
    …… 
    142134    destroy: function() { 
    143135        this.layer = null; 
    144         this.dragHandler.destroy(); 
    145         this.featureHandler.destroy(); 
    146136        OpenLayers.Control.prototype.destroy.apply(this, []); 
    147137    }, 
    …… 
    155145     */ 
    156146    activate: function() { 
    157         return (this.featureHandler.activate() && 
     147        return (this.handlers.feature.activate() && 
    158148                OpenLayers.Control.prototype.activate.apply(this, arguments)); 
    159149    }, 
    …… 
    168158    deactivate: function() { 
    169159        // the return from the handlers is unimportant in this case 
    170         this.dragHandler.deactivate(); 
    171         this.featureHandler.deactivate(); 
     160        this.handlers.drag.deactivate(); 
     161        this.handlers.feature.deactivate(); 
    172162        this.feature = null; 
    173163        this.dragging = false; 
    …… 
    185175     */ 
    186176    overFeature: function(feature) { 
    187         if(!this.dragHandler.dragging) { 
     177        if(!this.handlers.drag.dragging) { 
    188178            this.feature = feature; 
    189             this.dragHandler.activate(); 
     179            this.handlers.drag.activate(); 
    190180            this.over = true; 
    191181            // TBD replace with CSS classes 
    …… 
    239229    upFeature: function(pixel) { 
    240230        if(!this.over) { 
    241             this.dragHandler.deactivate(); 
     231            this.handlers.drag.deactivate(); 
    242232            this.feature = null; 
    243233            // TBD replace with CSS classes 
    …… 
    266256     */ 
    267257    outFeature: function(feature) { 
    268         if(!this.dragHandler.dragging) { 
     258        if(!this.handlers.drag.dragging) { 
    269259            this.over = false; 
    270             this.dragHandler.deactivate(); 
     260            this.handlers.drag.deactivate(); 
    271261            // TBD replace with CSS classes 
    272262            this.map.div.style.cursor = "default"; 
    …… 
    284274     */ 
    285275    cancel: function() { 
    286         this.dragHandler.deactivate(); 
     276        this.handlers.drag.deactivate(); 
    287277        this.over = false; 
    288278    }, 
    …… 
    296286     */ 
    297287    setMap: function(map) { 
    298         this.dragHandler.setMap(map); 
    299         this.featureHandler.setMap(map); 
     288        this.handlers.drag.setMap(map); 
     289        this.handlers.feature.setMap(map); 
    300290        OpenLayers.Control.prototype.setMap.apply(this, arguments); 
    301291    }, 

  • sandbox/tschaub/events/lib/OpenLayers/Control/ModifyFeature.js

    r6064 r6125  
    8484     
    8585    /** 
    86      * Property: keyboardHandler 
    87      * {<OpenLayers.Handler.Keyboard>} 
    88      */ 
    89     keyboardHandler: null, 
     86     * Property: handlers 
     87     * {Object} 
     88     */ 
     89    handlers: null, 
    9090     
    9191    /** 
    …… 
    216216            keypress: this.handleKeypress 
    217217        }; 
    218         this.keyboardHandler = new OpenLayers.Handler.Keyboard( 
    219             this, keyboardOptions 
    220         ); 
     218        this.handlers = { 
     219            keyboard: new OpenLayers.Handler.Keyboard(this, keyboardOptions) 
     220        }; 
    221221    }, 
    222222 
    …… 
    234234        this.selectControl.destroy(); 
    235235        this.dragControl.destroy(); 
    236         this.keyboardHandler.destroy(); 
    237236        OpenLayers.Control.prototype.destroy.apply(this, []); 
    238237    }, 
    …… 
    247246    activate: function() { 
    248247        return (this.selectControl.activate() && 
    249                 this.keyboardHandler.activate() && 
     248                this.handlers.keyboard.activate() && 
    250249                OpenLayers.Control.prototype.activate.apply(this, arguments)); 
    251250    }, 
    …… 
    271270            } 
    272271            this.selectControl.deactivate(); 
    273             this.keyboardHandler.deactivate(); 
     272            this.handlers.keyboard.deactivate(); 
    274273            deactivated = true; 
    275274        } 
    …… 
    359358                                                   [feature]); 
    360359                this.dragControl.lastPixel = pixel; 
    361                 this.dragControl.dragHandler.started = true; 
    362                 this.dragControl.dragHandler.start = pixel; 
    363                 this.dragControl.dragHandler.last = pixel; 
     360                this.dragControl.handlers.drag.started = true; 
     361                this.dragControl.handlers.drag.start = pixel; 
     362                this.dragControl.handlers.drag.last = pixel; 
    364363            } 
    365364        } 
    …… 
    493492            if(vertex && 
    494493               OpenLayers.Util.indexOf(this.vertices, vertex) != -1 && 
    495                !this.dragControl.dragHandler.dragging && 
     494               !this.dragControl.handlers.drag.dragging && 
    496495               vertex.geometry.parent) { 
    497496                // remove the vertex 

  • sandbox/tschaub/events/lib/OpenLayers/Control/Navigation.js

    r5990 r6125  
    3737    zoomBox: null, 
    3838 
    39     /**  
    40      * Property: wheelHandler 
    41      * {<OpenLayers.Handler.MouseWheel>} 
    42      */ 
    43     wheelHandler: null, 
    44  
    4539    /** 
    4640     * Constructor: OpenLayers.Control.Navigation 
    …… 
    5246     */ 
    5347    initialize: function(options) { 
     48        this.handlers = {}; 
    5449        OpenLayers.Control.prototype.initialize.apply(this, arguments); 
    5550    }, 
    …… 
    6257     */ 
    6358    destroy: function() { 
    64         OpenLayers.Control.prototype.destroy.apply(this,arguments); 
    65  
    6659        this.deactivate(); 
    6760 
    …… 
    7164        this.dragPan = null; 
    7265 
    73         if (this.wheelHandler) { 
    74             this.wheelHandler.destroy(); 
    75         } 
    76         this.wheelHandler = null; 
    77  
    78         if (this.clickHandler) { 
    79             this.clickHandler.destroy(); 
    80         } 
    81         this.clickHandler = null; 
    82          
    8366        if (this.zoomBox) { 
    8467            this.zoomBox.destroy(); 
    8568        } 
    8669        this.zoomBox = null; 
     70        OpenLayers.Control.prototype.destroy.apply(this,arguments); 
    8771    }, 
    8872     
    …… 
    9276    activate: function() { 
    9377        this.dragPan.activate(); 
    94         this.wheelHandler.activate(); 
    95         this.clickHandler.activate(); 
     78        this.handlers.wheel.activate(); 
     79        this.handlers.click.activate(); 
    9680        this.zoomBox.activate(); 
    9781        return OpenLayers.Control.prototype.activate.apply(this,arguments); 
    …… 
    10488        this.zoomBox.deactivate(); 
    10589        this.dragPan.deactivate(); 
    106         this.clickHandler.deactivate(); 
    107         this.wheelHandler.deactivate(); 
     90        this.handlers.click.deactivate(); 
     91        this.handlers.wheel.deactivate(); 
    10892        return OpenLayers.Control.prototype.deactivate.apply(this,arguments); 
    10993    }, 
    …… 
    11397     */ 
    11498    draw: function() { 
    115         this.clickHandler = new OpenLayers.Handler.Click(this,  
     99        this.handlers.click = new OpenLayers.Handler.Click(this,  
    116100                                        { 'dblclick': this.defaultDblClick }, 
    117101                                        { 
    …… 
    124108        this.dragPan.draw(); 
    125109        this.zoomBox.draw(); 
    126         this.wheelHandler = new OpenLayers.Handler.MouseWheel( 
     110        this.handlers.wheel = new OpenLayers.Handler.MouseWheel( 
    127111                                    this, {"up"  : this.wheelUp, 
    128112                                           "down": this.wheelDown} ); 

  • sandbox/tschaub/events/lib/OpenLayers/Control/OverviewMap.js

    r6078 r6125  
    9999     
    100100    /** 
    101      * Property: dragHandler 
    102      * {<OpenLayers.Handler.Drag>} A handler for dragging the extent rectangle. 
    103      */ 
    104     dragHandler: null, 
     101     * Property: handlers 
     102     * {Object} 
     103     */ 
     104    handlers: null, 
    105105 
    106106    /** 
    …… 
    115115    initialize: function(options) { 
    116116        this.layers = []; 
     117        this.handlers = {}; 
    117118        OpenLayers.Control.prototype.initialize.apply(this, [options]); 
    118119    }, 
    …… 
    126127            return; 
    127128        } 
    128         this.dragHandler.destroy(); 
    129         this.clickHandler.destroy(); 
     129        this.handlers.click.destroy(); 
    130130 
    131131        this.mapDiv.removeChild(this.extentRectangle); 
    …… 
    283283     */ 
    284284    rectDrag: function(px) { 
    285         var deltaX = this.dragHandler.last.x - px.x; 
    286         var deltaY = this.dragHandler.last.y - px.y; 
     285        var deltaX = this.handlers.drag.last.x - px.x; 
     286        var deltaY = this.handlers.drag.last.y - px.y; 
    287287        if(deltaX != 0 || deltaY != 0) { 
    288288            var rectTop = this.rectPxBounds.top; 
    …… 
    437437        // create the overview map 
    438438        var options = OpenLayers.Util.extend( 
    439                         {controls: [], maxResolution: 'auto'}, this.mapOptions); 
     439                        {controls: [], maxResolution: 'auto',  
     440                         fallThrough: false}, this.mapOptions); 
    440441        this.ovmap = new OpenLayers.Map(this.mapDiv, options); 
    441442         
    …… 
    458459        this.hComp = (this.hComp) ? this.hComp : 2; 
    459460 
    460         this.dragHandler = new OpenLayers.Handler.Drag( 
     461        this.handlers.drag = new OpenLayers.Handler.Drag( 
    461462            this, {move: this.rectDrag, done: this.updateMapToRect}, 
    462463            {map: this.ovmap} 
    463464        ); 
    464         this.clickHandler = new OpenLayers.Handler.Click( 
     465        this.handlers.click = new OpenLayers.Handler.Click( 
    465466            this, { 
    466467                "click": this.mapDivClick 
    …… 
    472473            } 
    473474        ); 
    474         this.clickHandler.activate(); 
     475        this.handlers.click.activate(); 
    475476         
    476477        this.rectEvents = new OpenLayers.Events(this, this.extentRectangle, 
    477478                                                null, true); 
    478479        this.rectEvents.register("mouseover", this, function(e) { 
    479             if(!this.dragHandler.active && !this.map.dragging) { 
    480                 this.dragHandler.activate(); 
     480            if(!this.handlers.drag.active && !this.map.dragging) { 
     481                this.handlers.drag.activate(); 
    481482            } 
    482483        }); 
    483484        this.rectEvents.register("mouseout", this, function(e) { 
    484             if(!this.dragHandler.dragging) { 
    485                 this.dragHandler.deactivate(); 
     485            if(!this.handlers.drag.dragging) { 
     486                this.handlers.drag.deactivate(); 
    486487            } 
    487488        }); 
    …… 
    513514    updateMapToRect: function() { 
    514515        var lonLatBounds = this.getMapBoundsFromRectBounds(this.rectPxBounds); 
    515         this.map.setCenter(lonLatBounds.getCenterLonLat(), this.map.zoom); 
     516        this.map.panTo(lonLatBounds.getCenterLonLat()); 
    516517    }, 
    517518 

  • sandbox/tschaub/events/lib/OpenLayers/Events.js

    r6078 r6125  
    314314     */ 
    315315    unloadCache: function() { 
    316         if (OpenLayers.Event.observers) { 
     316        // check for OpenLayers.Event before checking for observers, because 
     317        // OpenLayers.Event may be undefined in IE if no map instance was 
     318        // created 
     319        if (OpenLayers.Event && OpenLayers.Event.observers) { 
    317320            for (var cacheID in OpenLayers.Event.observers) { 
    318321                var elementObservers = OpenLayers.Event.observers[cacheID]; 

  • sandbox/tschaub/events/lib/OpenLayers/Format/SLD.js

    r5978 r6125  
    344344            for (var i=0; i<filters.length; i++) { 
    345345                if (filters[i].nodeType == 1) { 
    346                     rule.children.push(this.parseFilter(filters[i])); 
     346                    rule.rules.push(this.parseFilter(filters[i])); 
    347347                } 
    348348            } 
    …… 
    358358            for (var i=0; i<filters.length; i++) { 
    359359                if (filters[i].nodeType == 1) { 
    360                     rule.children.push(this.parseFilter(filters[i])); 
     360                    rule.rules.push(this.parseFilter(filters[i])); 
    361361                } 
    362362            } 
    …… 
    369369            var rule = new OpenLayers.Rule.Logical( 
    370370                    {type: OpenLayers.Rule.Logical.NOT}); 
    371             rule.children.push(this.parseFilter(filter[0])); 
     371            rule.rules.push(this.parseFilter(filter[0])); 
    372372            return rule; 
    373373        } 

  • sandbox/tschaub/events/lib/OpenLayers/Format/WFS.js

    r5868 r6125  
    2222     */ 
    2323    wfsns: "http://www.opengis.net/wfs", 
     24     
     25    ogcns: "http://www.opengis.net/ogc", 
    2426     
    2527    /* 
    …… 
    5860     */ 
    5961    write: function(features) { 
    60          
    61         var transaction = this.createElementNS('http://www.opengis.net/wfs', 'wfs:Transaction'); 
     62     
     63        var transaction = this.createElementNS(this.wfsns, 'wfs:Transaction'); 
    6264        transaction.setAttribute("version","1.0.0"); 
    6365        transaction.setAttribute("service","WFS"); 
    …… 
    7577            } 
    7678        } 
    77         return transaction; 
     79         
     80        return OpenLayers.Format.XML.prototype.write.apply(this,[transaction]); 
    7881    }, 
    7982    
    …… 
    9194        featureContainer.appendChild(geomContainer); 
    9295        for(var attr in feature.attributes) { 
    93             var attrText = document.createTextNode(feature.attributes[attr]);  
     96            var attrText = this.createTextNode(feature.attributes[attr]);  
    9497            var nodename = attr; 
    9598            if (attr.search(":") != -1) { 
    …… 
    129132 
    130133        var propertyNode = this.createElementNS(this.wfsns, 'wfs:Property'); 
    131         var nameNode = this.createElementNS('http://www.opengis.net/wfs', 'wfs:Name'); 
     134        var nameNode = this.createElementNS(this.wfsns, 'wfs:Name'); 
    132135         
    133         var txtNode = document.createTextNode(this.geometryName); 
     136        var txtNode = this.createTextNode(this.geometryName); 
    134137        nameNode.appendChild(txtNode); 
    135138        propertyNode.appendChild(nameNode); 
    136139         
    137         var valueNode = this.createElementNS('http://www.opengis.net/wfs', 'wfs:Value'); 
     140        var valueNode = this.createElementNS(this.wfsns, 'wfs:Value'); 
    138141        valueNode.appendChild(this.buildGeometryNode(feature.geometry)); 
    139142         
    …… 
    141144        updateNode.appendChild(propertyNode); 
    142145         
    143         var filterNode = this.createElementNS('http://www.opengis.net/ogc', 'ogc:Filter'); 
    144         var filterIdNode = this.createElementNS('http://www.opengis.net/ogc', 'ogc:FeatureId'); 
     146        var filterNode = this.createElementNS(this.ogcns, 'ogc:Filter'); 
     147        var filterIdNode = this.createElementNS(this.ogcns, 'ogc:FeatureId'); 
    145148        filterIdNode.setAttribute("fid", feature.fid); 
    146149        filterNode.appendChild(filterIdNode); 
    …… 
    165168        deleteNode.setAttribute("typeName", this.layerName); 
    166169 
    167         var filterNode = this.createElementNS('http://www.opengis.net/ogc', 'ogc:Filter'); 
    168         var filterIdNode = this.createElementNS('http://www.opengis.net/ogc', 'ogc:FeatureId'); 
     170        var filterNode = this.createElementNS(this.ogcns, 'ogc:Filter'); 
     171        var filterIdNode = this.createElementNS(this.ogcns, 'ogc:FeatureId'); 
    169172        filterIdNode.setAttribute("fid", feature.fid); 
    170173        filterNode.appendChild(filterIdNode); 

  • sandbox/tschaub/events/lib/OpenLayers/Format/WMC/v1_1_0.js

    r5919 r6125  
    9090         
    9191        // min/max scale denominator elements go before the 4th element in v1 
    92         var minSD = this.createElementNS( 
    93             this.namespaces.sld, "sld:MinScaleDenominator" 
    94         ); 
    95         minSD.appendChild(this.createTextNode(layer.maxScale.toPrecision(10))); 
    96         node.insertBefore(minSD, node.childNodes[3]); 
     92        if(layer.options.resolutions || layer.options.scales || 
     93           layer.options.minResolution || layer.options.maxScale) { 
     94            var minSD = this.createElementNS( 
     95                this.namespaces.sld, "sld:MinScaleDenominator" 
     96            ); 
     97            minSD.appendChild(this.createTextNode(layer.maxScale.toPrecision(10))); 
     98            node.insertBefore(minSD, node.childNodes[3]); 
     99        } 
    97100         
    98         var maxSD = this.createElementNS( 
    99             this.namespaces.sld, "sld:MaxScaleDenominator" 
    100         ); 
    101         maxSD.appendChild(this.createTextNode(layer.minScale.toPrecision(10))); 
    102         node.insertBefore(maxSD, node.childNodes[4]); 
     101        if(layer.options.resolutions || layer.options.scales || 
     102           layer.options.maxResolution || layer.options.minScale) { 
     103            var maxSD = this.createElementNS( 
     104                this.namespaces.sld, "sld:MaxScaleDenominator" 
     105            ); 
     106            maxSD.appendChild(this.createTextNode(layer.minScale.toPrecision(10))); 
     107            node.insertBefore(maxSD, node.childNodes[4]); 
     108        } 
    103109         
    104110        return node; 

  • sandbox/tschaub/events/lib/OpenLayers/Handler/Click.js

    r5698 r6125  
    4646     * APIProperty: pixelTolerance 
    4747     * {Number} Maximum number of pixels between mouseup and mousedown for an 
    48      *     event to be considered a click.  Default is null.  If set to an 
     48     *     event to be considered a click.  Default is 0.  If set to an 
    4949     *     integer value, clicks with a drag greater than the value will be 
    5050     *     ignored.  This property can only be set when the handler is 
    5151     *     constructed. 
    5252     */ 
    53     pixelTolerance: null, 
     53    pixelTolerance: 0, 
    5454     
    5555    /** 
    …… 
    183183    passesTolerance: function(evt) { 
    184184        var passes = true; 
    185         if(this.pixelTolerance && this.down) { 
     185        if(this.pixelTolerance != null && this.down) { 
    186186            var dpx = Math.sqrt( 
    187187                Math.pow(this.down.x - evt.xy.x, 2) + 

  • sandbox/tschaub/events/lib/OpenLayers/Map.js

    r6041 r6125  
    393393            //  Note that this is ok, as updateSize() does nothing if the  
    394394            //  map's size has not actually changed. 
     395            this.updateSizeDestroy = OpenLayers.Function.bind(this.updateSize,  
     396                this); 
    395397            OpenLayers.Event.observe(window, 'resize', 
    396                             OpenLayers.Function.bind(this.updateSize, this)); 
     398                            this.updateSizeDestroy); 
    397399        } 
    398400         
    …… 
    454456     */ 
    455457    unloadDestroy: null, 
     458     
     459    /** 
     460     * Method: updateSizeDestroy 
     461     * When the map is destroyed, we need to stop listening to updateSize 
     462     *    events: this method stores the function we need to unregister in  
     463     *    non-IE browsers. 
     464     */ 
     465    updateSizeDestroy: null, 
    456466 
    457467    /** 
    …… 
    468478        OpenLayers.Event.stopObserving(window, 'unload', this.unloadDestroy); 
    469479        this.unloadDestroy = null; 
     480 
     481        if (this.updateSizeDestroy) { 
     482            OpenLayers.Event.stopObserving(window, 'resize',  
     483                                           this.updateSizeDestroy); 
     484        } else { 
     485            this.events.unregister("resize", this, this.updateSize); 
     486        }     
    470487 
    471488        if (this.layers != null) { 
    …… 
    12531270     * dx - {Integer} 
    12541271     * dy - {Integer} 
    1255      */ 
    1256     pan: function(dx, dy) { 
    1257  
     1272     * options - {Object} Only one at this time: "animate", which uses 
     1273     *    panTo instead of setCenter. Default is true. 
     1274     */ 
     1275    pan: function(dx, dy, options) { 
     1276         
     1277        if (!options) { 
     1278            options = {} 
     1279        }     
    12581280        // getCenter 
    12591281        var centerPx = this.getViewPortPxFromLonLat(this.getCenter()); 
    …… 
    12651287        if (!newCenterPx.equals(centerPx)) { 
    12661288            var newCenterLonLat = this.getLonLatFromViewPortPx(newCenterPx); 
    1267             this.setCenter(newCenterLonLat); 
     1289            if (options.animate) { 
     1290                this.panTo(newCenterLonLat); 
     1291            } else { 
     1292                this.setCenter(newCenterLonLat); 
     1293            }     
    12681294        } 
    12691295 
    12701296   }, 
     1297    
     1298   /**  
     1299     * APIMethod: panTo 
     1300     * Allows user to pan to a new lonlat 
     1301     * If the new lonlat is in the current extent the map will slide smoothly 
     1302     *  
     1303     * Parameters: 
     1304     * lonlat - {<OpenLayers.Lonlat>} 
     1305     */ 
     1306    panTo: function(lonlat) { 
     1307        if (this.getExtent().containsLonLat(lonlat)) { 
     1308            if (!this.panTween) { 
     1309                this.panTween = new OpenLayers.Tween(OpenLayers.Easing.Expo.easeOut); 
     1310            } 
     1311            var center = this.getCenter(); 
     1312            var from = { 
     1313                lon: center.lon, 
     1314                lat: center.lat 
     1315            }; 
     1316            var to = { 
     1317                lon: lonlat.lon, 
     1318                lat: lonlat.lat 
     1319            }; 
     1320            this.panTween.start(from, to, 50, { 
     1321                callbacks: { 
     1322                    start: OpenLayers.Function.bind(function(lonlat) { 
     1323                        this.events.triggerEvent("movestart"); 
     1324                    }, this), 
     1325                    eachStep: OpenLayers.Function.bind(function(lonlat) { 
     1326                        var lonlat = new OpenLayers.LonLat(lonlat.lon, lonlat.lat); 
     1327                        this.moveTo(lonlat, this.zoom, true); 
     1328                    }, this), 
     1329                    done: OpenLayers.Function.bind(function(lonlat) { 
     1330                        this.events.triggerEvent("moveend"); 
     1331                    }, this) 
     1332                } 
     1333            }); 
     1334        } else { 
     1335            this.setCenter(lonlat); 
     1336        } 
     1337    }, 
    12711338 
    12721339    /** 
    …… 
    12831350     * TBD: reconsider forceZoomChange in 3.0 
    12841351     */ 
    1285     setCenter: function (lonlat, zoom, dragging, forceZoomChange) { 
    1286         this.dragging = !!dragging; 
    1287          
     1352    setCenter: function(lonlat, zoom, dragging, forceZoomChange) { 
     1353        this.moveTo(lonlat, zoom, { 
     1354            'dragging': dragging, 
     1355            'forceZoomChange': forceZoomChange, 
     1356            'caller': 'setCenter' 
     1357        }); 
     1358    }, 
     1359 
     1360    /** 
     1361     * Method: moveTo 
     1362     * 
     1363     * Parameters: 
     1364     * lonlat - {<OpenLayers.LonLat>} 
     1365     * zoom - {Integer} 
     1366     * options - {Object} 
     1367     */ 
     1368    moveTo: function(lonlat, zoom, options) { 
     1369        if (!options) {  
     1370            options = {}; 
     1371        }     
     1372        // dragging is false by default 
     1373        var dragging = options.dragging; 
     1374        // forceZoomChange is false by default 
     1375        var forceZoomChange = options.forceZoomChange; 
     1376        // noEvent is false by default 
     1377        var noEvent = options.noEvent; 
     1378 
     1379        if (this.panTween && options.caller == "setCenter") { 
     1380            this.panTween.stop(); 
     1381        }     
     1382              
    12881383        if (!this.center && !this.isValidLonLat(lonlat)) { 
    12891384            lonlat = this.maxExtent.getCenterLonLat(); 
    …… 
    13351430        if (zoomChanged || centerChanged || !dragging) { 
    13361431 
    1337             if (!dragging) { this.events.triggerEvent("movestart"); } 
     1432            if (!dragging && !noEvent) { 
     1433                this.events.triggerEvent("movestart"); 
     1434            } 
    13381435 
    13391436            if (centerChanged) { 
    ……