OpenLayers OpenLayers

Changeset 7628

Show
Ignore:
Timestamp:
07/31/08 10:50:34 (5 months ago)
Author:
tschaub
Message:

merge r7489:HEAD from trunk

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • sandbox/vector-behavior/build/full.cfg

    r7489 r7628  
    2020OpenLayers/Lang/it.js 
    2121OpenLayers/Lang/nb.js 
     22OpenLayers/Lang/nl.js 
    2223OpenLayers/Lang/pt-BR.js 
    2324OpenLayers/Lang/sv-SE.js 

  • sandbox/vector-behavior/build/library.cfg

    r7489 r7628  
    5353OpenLayers/Lang/it.js 
    5454OpenLayers/Lang/nb.js 
     55OpenLayers/Lang/nl.js 
    5556OpenLayers/Lang/pt-BR.js 
    5657OpenLayers/Lang/sv-SE.js 

  • sandbox/vector-behavior/doc/authors.txt

    r7489 r7628  
    2929Erik Uzureau 
    3030Ivan Willig 
     31Thomas Wood 
    3132Bill Woodall 
    3233Steve Woodbridge 

  • sandbox/vector-behavior/examples/mapguide.html

    r7161 r7628  
    11<html xmlns="http://www.w3.org/1999/xhtml"> 
    22  <head> 
     3    <title>OpenLayers MapGuide Layer Example</title> 
     4    <link rel="stylesheet" href="../theme/default/style.css" type="text/css" /> 
    35    <link rel="stylesheet" href="style.css" type="text/css" /> 
    46    <style type="text/css"> 
    …… 
    105107  </head> 
    106108  <body onload="initUntiled(); initTiled()"> 
     109    <h1 id="title">MapGuide Layer Example</h1> 
     110 
     111    <div id="tags"> 
     112    </div> 
     113 
     114    <p id="shortdesc"> 
     115        Demonstrates how to create MapGuide tiled and untiled layers. 
     116    </p> 
     117 
    107118    <p>If prompted for a password, username is Anonymous and an empty password</p> 
    108119    <div id="map" class="smallmap"></div> 

  • sandbox/vector-behavior/examples/modify-feature.html

    r7161 r7628  
    3030            map.addControl(new OpenLayers.Control.MousePosition()); 
    3131             
    32             var modifyOptions = { 
    33                 onModificationStart: function(feature) { 
    34                     OpenLayers.Console.log("start modifying", feature.id); 
    35                 }, 
    36                 onModification: function(feature) { 
    37                     OpenLayers.Console.log("modified", feature.id); 
    38                 }, 
    39                 onModificationEnd: function(feature) { 
    40                     OpenLayers.Console.log("end modifying", feature.id); 
    41                 }, 
    42                 onDelete: function(feature) { 
    43                     OpenLayers.Console.log("delete", feature.id); 
    44                 } 
    45             }; 
     32            function report(event) { 
     33                OpenLayers.Console.log(event.type, event.feature.id); 
     34            } 
     35            vectors.events.on({ 
     36                "beforefeaturemodified": report, 
     37                "featuremodified": report, 
     38                "afterfeaturemodified": report 
     39            }); 
    4640            controls = { 
    4741                point: new OpenLayers.Control.DrawFeature(vectors, 
    …… 
    5448                            OpenLayers.Handler.RegularPolygon, 
    5549                            {handlerOptions: {sides: 5}}), 
    56                 modify: new OpenLayers.Control.ModifyFeature(vectors, 
    57                                                              modifyOptions) 
     50                modify: new OpenLayers.Control.ModifyFeature(vectors) 
    5851            }; 
    5952             

  • sandbox/vector-behavior/examples/select-feature.html

    r7161 r7628  
    4242                        multiple: false, hover: false, 
    4343                        toggleKey: "ctrlKey", // ctrl key removes from selection 
    44                         multipleKey: "shiftKey" // shift key adds to selection 
     44                        multipleKey: "shiftKey", // shift key adds to selection 
     45                        box: true 
    4546                    } 
    4647                ) 
    …… 
    7071            var hover = document.getElementById("hover").checked; 
    7172            drawControls.select.hover = hover; 
    72             if(hover && drawControls.select.active) { 
    73                 // turn on/off to clear feature property of handler 
     73            drawControls.select.box = document.getElementById("box").checked; 
     74            if(drawControls.select.active) { 
    7475                drawControls.select.deactivate(); 
    7576                drawControls.select.activate(); 
    …… 
    112113            <ul> 
    113114                <li> 
     115                    <input id="box" type="checkbox" checked="checked" 
     116                           name="box" onchange="update()" /> 
     117                    <label for="box">select features in a box</label> 
     118                </li> 
     119                <li> 
    114120                    <input id="clickout" type="checkbox" 
    115121                           name="clickout" onchange="update()" /> 

  • sandbox/vector-behavior/examples/vector-features.html

    r7161 r7628  
    108108    Shows the use of the shows drawing simple vector features, in different styles. 
    109109</p> 
    110  
    111 <div id="map" class="smallmap"></div> 
    112  
     110<div style="text-align: right"> 
     111    <div id="map" class="smallmap"></div> 
     112</div> 
    113113<div id="docs"> 
    114114    <p>This example shows drawing simple vector features -- point, line, polygon 

  • sandbox/vector-behavior/lib/OpenLayers.js

    r7509 r7628  
    4141          
    4242            var scripts = document.getElementsByTagName('script'); 
    43             for (var i = 0; i < scripts.length; i++) { 
     43            for (var i=0, len=scripts.length; i<len; i++) { 
    4444                var src = scripts[i].getAttribute('src'); 
    4545                if (src) { 
    …… 
    223223            "OpenLayers/Format/Filter/v1.js", 
    224224            "OpenLayers/Format/Filter/v1_0_0.js", 
     225            "OpenLayers/Format/GPX.js", 
    225226            "OpenLayers/Format/SLD.js", 
    226227            "OpenLayers/Format/SLD/v1.js", 
    …… 
    247248        } 
    248249        var host = OpenLayers._getScriptLocation() + "lib/";     
    249         for (var i = 0; i < jsfiles.length; i++) { 
     250        for (var i=0, len=jsfiles.length; i<len; i++) { 
    250251            if (docWrite) { 
    251252                allScriptTags[i] = "<script src='" + host + jsfiles[i] + 

  • sandbox/vector-behavior/lib/OpenLayers/BaseTypes.js

    r7489 r7628  
    8585        var oStringList = str.split('-'); 
    8686        var camelizedString = oStringList[0]; 
    87         for (var i = 1; i < oStringList.length; i++) { 
     87        for (var i=1, len=oStringList.length; i<len; i++) { 
    8888            var s = oStringList[i]; 
    8989            camelizedString += s.charAt(0).toUpperCase() + s.substring(1); 
    …… 
    119119        var tokens = template.split("${"); 
    120120        var item, last, replacement; 
    121         for(var i=1; i<tokens.length; i++) { 
     121        for(var i=1, len=tokens.length; i<len; i++) { 
    122122            item = tokens[i]; 
    123123            last = item.indexOf("}");  

  • sandbox/vector-behavior/lib/OpenLayers/BaseTypes/Class.js

    r6131 r7628  
    3535    var extended = {}; 
    3636    var parent; 
    37     for(var i=0; i<arguments.length; ++i) { 
     37    for(var i=0, len=arguments.length; i<len; ++i) { 
    3838        if(typeof arguments[i] == "function") { 
    3939            // get the prototype of the superclass 
    …… 
    8686    var superClass = arguments[0]; 
    8787    var proto = new superClass(OpenLayers.Class.isPrototype); 
    88     for (var i = 1; i < arguments.length; i++) { 
     88    for (var i=1, len=arguments.length; i<len; i++) { 
    8989        if (typeof arguments[i] == "function") { 
    9090            var mixin = arguments[i]; 

  • sandbox/vector-behavior/lib/OpenLayers/BaseTypes/Element.js

    r7028 r7628  
    2929     */ 
    3030    toggle: function() { 
    31         for (var i = 0; i < arguments.length; i++) { 
     31        for (var i=0, len=arguments.length; i<len; i++) { 
    3232            var element = OpenLayers.Util.getElement(arguments[i]); 
    3333            var display = OpenLayers.Element.visible(element) ? 'hide'  
    …… 
    4646     */ 
    4747    hide: function() { 
    48         for (var i = 0; i < arguments.length; i++) { 
     48        for (var i=0, len=arguments.length; i<len; i++) { 
    4949            var element = OpenLayers.Util.getElement(arguments[i]); 
    5050            element.style.display = 'none'; 
    …… 
    6060     */ 
    6161    show: function() { 
    62         for (var i = 0; i < arguments.length; i++) { 
     62        for (var i=0, len=arguments.length; i<len; i++) { 
    6363            var element = OpenLayers.Util.getElement(arguments[i]); 
    6464            element.style.display = ''; 
    …… 
    125125 
    126126    /** 
     127     * Function: hasClass 
     128     * Tests if an element has the given CSS class name. 
     129     * 
     130     * Parameters: 
     131     * element - {DOMElement} A DOM element node. 
     132     * name - {String} The CSS class name to search for. 
     133     * 
     134     * Returns: 
     135     * {Boolean} The element has the given class name. 
     136     */ 
     137    hasClass: function(element, name) { 
     138        var names = element.className; 
     139        return (!!names && new RegExp("(^|\\s)" + name + "(\\s|$)").test(names)); 
     140    }, 
     141     
     142    /** 
     143     * Function: addClass 
     144     * Add a CSS class name to an element.  Safe where element already has 
     145     *     the class name. 
     146     * 
     147     * Parameters: 
     148     * element - {DOMElement} A DOM element node. 
     149     * name - {String} The CSS class name to add. 
     150     * 
     151     * Returns: 
     152     * {DOMElement} The element. 
     153     */ 
     154    addClass: function(element, name) { 
     155        if(!OpenLayers.Element.hasClass(element, name)) { 
     156            element.className += (element.className ? " " : "") + name; 
     157        } 
     158        return element; 
     159    }, 
     160 
     161    /** 
     162     * Function: removeClass 
     163     * Remove a CSS class name from an element.  Safe where element does not 
     164     *     have the class name. 
     165     * 
     166     * Parameters: 
     167     * element - {DOMElement} A DOM element node. 
     168     * name - {String} The CSS class name to remove. 
     169     * 
     170     * Returns: 
     171     * {DOMElement} The element. 
     172     */ 
     173    removeClass: function(element, name) { 
     174        var names = element.className; 
     175        if(names) { 
     176            element.className = OpenLayers.String.trim( 
     177                names.replace( 
     178                    new RegExp("(^|\\s+)" + name + "(\\s+|$)"), " " 
     179                ) 
     180            ); 
     181        } 
     182        return element; 
     183    }, 
     184 
     185    /** 
     186     * Function: toggleClass 
     187     * Remove a CSS class name from an element if it exists.  Add the class name 
     188     *     if it doesn't exist. 
     189     * 
     190     * Parameters: 
     191     * element - {DOMElement} A DOM element node. 
     192     * name - {String} The CSS class name to toggle. 
     193     * 
     194     * Returns: 
     195     * {DOMElement} The element. 
     196     */ 
     197    toggleClass: function(element, name) { 
     198        if(OpenLayers.Element.hasClass(element, name)) { 
     199            OpenLayers.Element.removeClass(element, name); 
     200        } else { 
     201            OpenLayers.Element.addClass(element, name); 
     202        } 
     203        return element; 
     204    }, 
     205 
     206    /** 
    127207     * APIFunction: getStyle 
    128208     *  

  • sandbox/vector-behavior/lib/OpenLayers/Console.js

    r6131 r7628  
    221221    if(window.console) { 
    222222        var scripts = document.getElementsByTagName("script"); 
    223         for(var i=0; i<scripts.length; ++i) { 
     223        for(var i=0, len=scripts.length; i<len; ++i) { 
    224224            if(scripts[i].src.indexOf("firebug.js") != -1) { 
    225225                OpenLayers.Util.extend(OpenLayers.Console, console); 

  • sandbox/vector-behavior/lib/OpenLayers/Control/ArgParser.js

    r5900 r7628  
    6969 
    7070        //make sure we dont already have an arg parser attached 
    71         for(var i=0; i< this.map.controls.length; i++) { 
     71        for(var i=0, len=this.map.controls.length; i<len; i++) { 
    7272            var control = this.map.controls[i]; 
    7373            if ( (control != this) && 
    …… 
    142142            this.map.events.unregister('addlayer', this, this.configureLayers); 
    143143 
    144             for(var i=0; i < this.layers.length; i++) { 
     144            for(var i=0, len=this.layers.length; i<len; i++) { 
    145145                 
    146146                var layer = this.map.layers[i]; 

  • sandbox/vector-behavior/lib/OpenLayers/Control/Attribution.js

    r6149 r7628  
    7676        var attributions = []; 
    7777        if (this.map && this.map.layers) { 
    78             for(var i=0; i < this.map.layers.length; i++) { 
     78            for(var i=0, len=this.map.layers.length; i<len; i++) { 
    7979                var layer = this.map.layers[i]; 
    8080                if (layer.attribution && layer.getVisibility()) { 

  • sandbox/vector-behavior/lib/OpenLayers/Control/DragPan.js

    r6833 r7628  
    3030     
    3131    /** 
     32     * Property: interval 
     33     * {Integer} The number of milliseconds that should ellapse before 
     34     *     panning the map again. Set this to increase dragging performance. 
     35     *     Defaults to 25 milliseconds. 
     36     */ 
     37    interval: 25,  
     38     
     39    /** 
    3240     * Method: draw 
    3341     * Creates a Drag handler, using <panMap> and 
    …… 
    3543     */     
    3644    draw: function() { 
    37         this.handler = new OpenLayers.Handler.Drag(this, 
    38                             {"move": this.panMap, "done": this.panMapDone}); 
     45        this.handler = new OpenLayers.Handler.Drag(this, { 
     46                "move": this.panMap, 
     47                "done": this.panMapDone 
     48            }, { 
     49                interval: this.interval 
     50            } 
     51        ); 
    3952    }, 
    4053 

  • sandbox/vector-behavior/lib/OpenLayers/Control/DrawFeature.js

    r7210 r7628  
    3131     
    3232    /** 
     33     * Constant: EVENT_TYPES 
     34     * 
     35     * Supported event types: 
     36     *  - *featureadded* Triggered when a feature is added 
     37     */ 
     38    EVENT_TYPES: ["featureadded"], 
     39     
     40    /** 
    3341     * APIProperty: featureAdded 
    3442     * {Function} Called after each feature is added 
    …… 
    5159     */ 
    5260    initialize: function(layer, handler, options) { 
     61         
     62        // concatenate events specific to vector with those from the base 
     63        this.EVENT_TYPES = 
     64            OpenLayers.Control.DrawFeature.prototype.EVENT_TYPES.concat( 
     65            OpenLayers.Control.prototype.EVENT_TYPES 
     66        ); 
     67         
    5368        OpenLayers.Control.prototype.initialize.apply(this, [options]); 
    5469        this.callbacks = OpenLayers.Util.extend({done: this.drawFeature}, 
    …… 
    6782        this.layer.events.triggerEvent("afterfeaturemodified",  
    6883                                       {feature: feature}); 
     84        this.events.triggerEvent("featureadded",{feature : feature}); 
    6985    }, 
    7086 

  • sandbox/vector-behavior/lib/OpenLayers/Control/EditingToolbar.js

    r5614 r7628  
    3737          new OpenLayers.Control.DrawFeature(layer, OpenLayers.Handler.Polygon, {'displayClass': 'olControlDrawFeaturePolygon'}) 
    3838        ]; 
    39         for (var i = 0; i < controls.length; i++) { 
     39        for (var i=0, len=controls.length; i<len; i++) { 
    4040            controls[i].featureAdded = function(feature) { feature.state = OpenLayers.State.INSERT; }; 
    4141        } 

  • sandbox/vector-behavior/lib/OpenLayers/Control/LayerSwitcher.js

    r6313 r7628  
    178178        var layers = this[layersType + "Layers"]; 
    179179        if (layers) { 
    180             for(var i=0; i < layers.length; i++) { 
     180            for(var i=0, len=layers.length; i<len ; i++) { 
    181181                var layer = layers[i]; 
    182182                OpenLayers.Event.stopObservingElement(layer.inputElem); 
    …… 
    202202            redraw = true; 
    203203        } else { 
    204             for (var i=0; i < this.layerStates.length; i++) { 
     204            for (var i=0, len=this.layerStates.length; i<len; i++) { 
    205205                var layerState = this.layerStates[i]; 
    206206                var layer = this.map.layers[i]; 
    …… 
    244244        // we will trigger more visibility changes, and we want to not redraw 
    245245        // and enter an infinite loop. 
    246         this.layerStates = new Array(this.map.layers.length); 
    247         for (var i = 0; i < this.map.layers.length; i++) { 
     246        var len = this.map.layers.length; 
     247        this.layerStates = new Array(len); 
     248        for (var i=0; i <len; i++) { 
    248249            var layer = this.map.layers[i]; 
    249250            this.layerStates[i] = { 
    …… 
    257258        var layers = this.map.layers.slice(); 
    258259        if (!this.ascending) { layers.reverse(); } 
    259         for( var i = 0; i < layers.length; i++) { 
     260        for(var i=0, len=layers.length; i<len; i++) { 
    260261            var layer = layers[i]; 
    261262            var baseLayer = layer.isBaseLayer; 
    …… 
    388389 
    389390        // set the newly selected base layer         
    390         for(var i=0; i < this.baseLayers.length; i++) { 
     391        for(var i=0, len=this.baseLayers.length; i<len; i++) { 
    391392            var layerEntry = this.baseLayers[i]; 
    392393            if (layerEntry.inputElem.checked) { 
    …… 
    396397 
    397398        // set the correct visibilities for the overlays 
    398         for(var i=0; i < this.dataLayers.length; i++) { 
     399        for(var i=0, len=this.dataLayers.length; i<len; i++) { 
    399400            var layerEntry = this.dataLayers[i];    
    400401            layerEntry.layer.setVisibility(layerEntry.inputElem.checked); 

  • sandbox/vector-behavior/lib/OpenLayers/Control/ModifyFeature.js

    r7240 r7628  
    202202        ); 
    203203        this.layer.events.on({ 
     204            "beforefeatureselected": this.beforeSelectFeature, 
    204205            "featureselected": this.selectFeature, 
    205206            "featureunselected": this.unselectFeature, 
    …… 
    240241    destroy: function() { 
    241242        this.layer.events.un({ 
     243            "beforefeatureselected": this.beforeSelectFeature, 
    242244            "featureselected": this.selectFeature, 
    243245            "featureunselected": this.unselectFeature, 
    …… 
    274276        // the return from the controls is unimportant in this case 
    275277        if(OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { 
    276             this.layer.removeFeatures(this.vertices); 
    277             this.layer.removeFeatures(this.virtualVertices); 
     278            this.layer.removeFeatures(this.vertices, {silent: true}); 
     279            this.layer.removeFeatures(this.virtualVertices, {silent: true}); 
    278280            this.vertices = []; 
    279281            this.dragControl.deactivate(); 
    …… 
    288290        return deactivated; 
    289291    }, 
     292     
     293    /** 
     294     * Method: beforeSelectFeature 
     295     * Called before a feature is selected. 
     296     * 
     297     * Parameters: 
     298     * object - {Object} Object with a feature property referencing the 
     299     *     selected feature. 
     300     */ 
     301    beforeSelectFeature: function(object) { 
     302        return this.layer.events.triggerEvent( 
     303            "beforefeaturemodified", {feature: object.feature} 
     304        ); 
     305    }, 
    290306 
    291307    /** 
    …… 
    302318        this.dragControl.activate(); 
    303319        this.onModificationStart(this.feature); 
    304         this.layer.events.triggerEvent("beforefeaturemodified",  
    305                                        {feature: this.feature}); 
    306320    }, 
    307321 
    …… 
    315329     */ 
    316330    unselectFeature: function(object) { 
    317         this.layer.removeFeatures(this.vertices); 
     331        this.layer.removeFeatures(this.vertices, {silent: true}); 
    318332        this.vertices = []; 
    319         this.layer.destroyFeatures(this.virtualVertices); 
     333        this.layer.destroyFeatures(this.virtualVertices, {silent: true}); 
    320334        this.virtualVertices = []; 
    321335        if(this.dragHandle) { 
    322             this.layer.destroyFeatures([this.dragHandle]); 
     336            this.layer.destroyFeatures([this.dragHandle], {silent: true}); 
    323337            delete this.dragHandle; 
    324338        } 
    325339        if(this.radiusHandle) { 
    326             this.layer.destroyFeatures([this.radiusHandle]); 
     340            this.layer.destroyFeatures([this.radiusHandle], {silent: true}); 
    327341            delete this.radiusHandle; 
    328342        } 
    …… 
    414428            } else if(vertex == this.dragHandle) { 
    415429                // dragging a drag handle 
    416                 this.layer.removeFeatures(this.vertices); 
     430                this.layer.removeFeatures(this.vertices, {silent: true}); 
    417431                this.vertices = []; 
    418432                if(this.radiusHandle) { 
    419                     this.layer.destroyFeatures([this.radiusHandle]); 
     433                    this.layer.destroyFeatures([this.radiusHandle], {silent: true}); 
    420434                    this.radiusHandle = null; 
    421435                } 
    …… 
    424438            // dragging a real vertex - no special treatment 
    425439            if(this.virtualVertices.length > 0) { 
    426                 this.layer.destroyFeatures(this.virtualVertices); 
     440                this.layer.destroyFeatures(this.virtualVertices, {silent: true}); 
    427441                this.virtualVertices = []; 
    428442            } 
    …… 
    464478        } 
    465479        if(this.vertices.length > 0) { 
    466             this.layer.removeFeatures(this.vertices); 
     480            this.layer.removeFeatures(this.vertices, {silent: true}); 
    467481            this.vertices = []; 
    468482        } 
    469483        if(this.virtualVertices.length > 0) { 
    470             this.layer.removeFeatures(this.virtualVertices); 
     484            this.layer.removeFeatures(this.virtualVertices, {silent: true}); 
    471485            this.virtualVertices = []; 
    472486        } 
    473487        if(this.dragHandle) { 
    474             this.layer.destroyFeatures([this.dragHandle]); 
     488            this.layer.destroyFeatures([this.dragHandle], {silent: true}); 
    475489            this.dragHandle = null; 
    476490        } 
    477491        if(this.radiusHandle) { 
    478             this.layer.destroyFeatures([this.radiusHandle]); 
     492            this.layer.destroyFeatures([this.radiusHandle], {silent: true}); 
    479493            this.radiusHandle = null; 
    480494        } 
    …… 
    535549        var control = this; 
    536550        function collectComponentVertices(geometry) { 
    537             var i, vertex, component; 
     551            var i, vertex, component, len; 
    538552            if(geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { 
    539553                vertex = new OpenLayers.Feature.Vector(geometry); 
    …… 
    556570                // add virtual vertices in the middle of each edge 
    557571                if(geometry.CLASS_NAME != "OpenLayers.Geometry.MultiPoint") { 
    558                     for(i=0; i<geometry.components.length-1; ++i) { 
     572                    for(i=0, len=geometry.components.length; i<len-1; ++i) { 
    559573                        var prevVertex = geometry.components[i]; 
    560574                        var nextVertex = geometry.components[i + 1]; 

  • sandbox/vector-behavior/lib/OpenLayers/Control/MouseToolbar.js

    r6149 r7628  
    272272            } 
    273273            if (this.mode == "measure" && mode != "measure") { 
    274                 for(var i = 0; i < this.measureDivs.length; i++) { 
     274                for(var i=0, len=this.measureDivs.length; i<len; i++) { 
    275275                    if (this.measureDivs[i]) {  
    276276                        this.map.layerContainerDiv.removeChild(this.measureDivs[i]); 

  • sandbox/vector-behavior/lib/OpenLayers/Control/Navigation.js

    r6462 r7628  
    3131    dragPan: null, 
    3232 
     33    /** 
     34     * APIProprety: dragPanOptions 
     35     * {Object} Options passed to the DragPan control. 
     36     */ 
     37    dragPanOptions: null, 
     38 
    3339