OpenLayers OpenLayers

Changeset 5343

Show
Ignore:
Timestamp:
12/04/07 17:13:48 (1 year ago)
Author:
ahocevar
Message:

merging from r5316 to HEAD

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • sandbox/ahocevar/styles/lib/OpenLayers/Control/EditingToolbar.js

    r5002 r5343  
    4545     * Method: draw 
    4646     * calls the default draw, and then activates mouse defaults. 
     47     * 
     48     * Returns: 
     49     * {DOMElement} 
    4750     */ 
    4851    draw: function() { 

  • sandbox/ahocevar/styles/lib/OpenLayers/Control/Scale.js

    r5002 r5343  
    3636     *  
    3737     * Returns: 
    38      * {DOMElemen} 
     38     * {DOMElement} 
    3939     */     
    4040    draw: function() { 

  • sandbox/ahocevar/styles/lib/OpenLayers/Layer/FixedZoomLevels.js

    r4985 r5343  
    106106            var resolutionsIndex = 0; 
    107107            this.resolutions = []; 
    108             for(var i= this.minZoomLevel; i < this.numZoomLevels; i++) { 
     108            for(var i= this.minZoomLevel; i <= this.maxZoomLevel; i++) { 
    109109                this.resolutions[resolutionsIndex++] = this.RESOLUTIONS[i];             
    110110            } 

  • sandbox/ahocevar/styles/lib/OpenLayers/Layer/TileCache.js

    r5128 r5343  
    7272        if (obj == null) { 
    7373            obj = new OpenLayers.Layer.TileCache(this.name, 
    74                                            this.url, 
    75                                            this.options); 
     74                                                 this.url, 
     75                                                 this.layername, 
     76                                                 this.options); 
    7677        } 
    7778 

  • sandbox/ahocevar/styles/lib/OpenLayers/Layer/Vector.js

    r5316 r5343  
    308308    /** 
    309309     * APIMethod: destroyFeatures 
    310      * Erase and estroy features on the layer. 
     310     * Erase and destroy features on the layer. 
    311311     * 
    312312     * Parameters: 

  • sandbox/ahocevar/styles/lib/OpenLayers/Renderer/Elements.js

    r5314 r5343  
    8585     * Method: getNodeType 
    8686     * This function is in charge of asking the specific renderer which type 
    87      *     of node to create for the given geometry. All geometries in an  
    88      *     Elements-based renderer consist of one node and some attributes. We 
    89      *     have the nodeFactory() function which creates a node for us, but it 
    90      *     takes a 'type' as input, and that is precisely what this function  
    91      *     tells us.   
     87     *     of node to create for the given geometry and style. All geometries 
     88     *     in an Elements-based renderer consist of one node and some 
     89     *     attributes. We have the nodeFactory() function which creates a node 
     90     *     for us, but it takes a 'type' as input, and that is precisely what 
     91     *     this function tells us.   
    9292     *   
    9393     * Parameters: 
    9494     * geometry - {<OpenLayers.Geometry>} 
     95     * style - {Object} 
    9596     *  
    9697     * Returns: 
    9798     * {String} The corresponding node type for the specified geometry 
    9899     */ 
    99     getNodeType: function(geometry) { }, 
     100    getNodeType: function(geometry, style) { }, 
    100101 
    101102    /**  
    …… 
    123124 
    124125        //first we create the basic node and add it to the root 
    125         var nodeType = this.getNodeType(geometry); 
     126        var nodeType = this.getNodeType(geometry, style); 
    126127        var node = this.nodeFactory(geometry.id, nodeType); 
    127128        node._featureId = featureId; 
    …… 
    132133        node = this.drawGeometryNode(node, geometry); 
    133134        this.root.appendChild(node); 
     135        this.postDraw(node); 
    134136    }, 
    135137 
    …… 
    183185        return this.setStyle(node, style, options, geometry); 
    184186    }, 
     187     
     188    /** 
     189     * Method: postDraw 
     190     * Things that have do be done after the geometry node is appended 
     191     * to its parent node. To be overridden by subclasses. 
     192     *  
     193     * Parameters: 
     194     * node - {DOMElement} 
     195     */ 
     196    postDraw: function(node) {}, 
    185197     
    186198    /** 

  • sandbox/ahocevar/styles/lib/OpenLayers/Renderer/SVG.js

    r5312 r5343  
    148148     * Parameters: 
    149149     * geometry - {<OpenLayers.Geometry>} 
     150     * style - {Object} 
    150151     *  
    151152     * Returns: 
    152153     * {String} The corresponding node type for the specified geometry 
    153154     */ 
    154     getNodeType: function(geometry) { 
     155    getNodeType: function(geometry, style) { 
    155156        var nodeType = null; 
    156157        switch (geometry.CLASS_NAME) { 
    157158            case "OpenLayers.Geometry.Point": 
    158                 nodeType = "circle"; 
     159                nodeType = style.externalGraphic ? "image" : "circle"; 
    159160                break; 
    160161            case "OpenLayers.Geometry.Rectangle": 
    …… 
    197198        if (node._geometryClass == "OpenLayers.Geometry.Point") { 
    198199            if (style.externalGraphic) { 
    199                 // remove old node 
    200                 var id = node.getAttributeNS(null, "id"); 
    201200                var x = parseFloat(node.getAttributeNS(null, "cx")); 
    202201                var y = parseFloat(node.getAttributeNS(null, "cy")); 
    203                 var _featureId = node._featureId; 
    204                 var _geometryClass = node._geometryClass; 
    205                 var _style = node._style; 
    206202                 
    207                 // create new image node 
    208                 node = this.createNode("image", id); 
    209                 node._featureId = _featureId; 
    210                 node._geometryClass = _geometryClass; 
    211                 node._style = _style; 
    212  
    213                 // now style the new node 
    214203                if (style.graphicWidth && style.graphicHeight) { 
    215204                  node.setAttributeNS(null, "preserveAspectRatio", "none"); 
    …… 
    223212                var yOffset = (style.graphicYOffset != undefined) ? 
    224213                    style.graphicYOffset : -(0.5 * height); 
     214 
    225215                var opacity = style.graphicOpacity || style.fillOpacity; 
    226216                 

  • sandbox/ahocevar/styles/lib/OpenLayers/Renderer/VML.js

    r5316 r5343  
    106106    /** 
    107107     * Method: getNodeType 
    108      * Get the noode type for a geometry 
    109      * 
    110      * Parameters: 
    111      * geometry - {<OpenLayers.Geometry>} 
     108     * Get the node type for a geometry and style 
     109     * 
     110     * Parameters: 
     111     * geometry - {<OpenLayers.Geometry>} 
     112     * style - {Object} 
    112113     * 
    113114     * Returns: 
    114115     * {String} The corresponding node type for the specified geometry 
    115116     */ 
    116     getNodeType: function(geometry) { 
     117    getNodeType: function(geometry, style) { 
    117118        var nodeType = null; 
    118119        switch (geometry.CLASS_NAME) { 
    119120            case "OpenLayers.Geometry.Point": 
    120                 nodeType = "v:oval"; 
     121                nodeType = style.externalGraphic ? "v:rect" : "v:oval"; 
    121122                break; 
    122123            case "OpenLayers.Geometry.Rectangle": 
    …… 
    154155        if (node._geometryClass == "OpenLayers.Geometry.Point") { 
    155156            if (style.externalGraphic) { 
    156                 // remove old node 
    157                 var id = node.id; 
    158                 var _featureId = node._featureId; 
    159                 var _geometryClass = node._geometryClass; 
    160                 var _style = node._style; 
    161                  
    162                 // create new image node 
    163                 node = this.createNode("v:rect", id); 
    164                 var fill = this.createNode("v:fill", id+"_image"); 
    165                 node.appendChild(fill); 
    166                 node._featureId = _featureId; 
    167                 node._geometryClass = _geometryClass; 
    168                 node._style = _style; 
    169                  
    170                 fill.src = style.externalGraphic; 
    171                 fill.type = "frame"; 
    172                 node.style.flip = "y"; 
    173                  
    174                 if (!(style.graphicWidth && style.graphicHeight)) { 
    175                   fill.aspect = "atmost"; 
    176                 } 
    177                  
    178                 // now style the new node 
    179157                var width = style.graphicWidth || style.graphicHeight; 
    180158                var height = style.graphicHeight || style.graphicWidth; 
    …… 
    193171                node.style.height = height;     
    194172                 
    195                 // modify fill style for rect styling below 
     173                // modify style/options for fill and stroke styling below 
    196174                style.fillColor = "none"; 
    197                 style.strokeColor = "none"; 
     175                options.isStroked = false; 
    198176                          
    199177            } else { 
    …… 
    217195            if (!fill) { 
    218196                fill = this.createNode('v:fill', node.id + "_fill"); 
     197 
     198                if (style.fillOpacity) { 
     199                    fill.setAttribute("opacity", style.fillOpacity); 
     200                } 
     201 
     202                if (node._geometryClass == "OpenLayers.Geometry.Point" && 
     203                        style.externalGraphic) { 
     204 
     205                    // override fillOpacity 
     206                    if (style.graphicOpacity) { 
     207                        fill.setAttribute("opacity", style.graphicOpacity); 
     208                    } 
     209                     
     210                    fill.setAttribute("src", style.externalGraphic); 
     211                    fill.setAttribute("type", "frame"); 
     212                    node.style.flip = "y"; 
     213                     
     214                    if (!(style.graphicWidth && style.graphicHeight)) { 
     215                      fill.aspect = "atmost"; 
     216                    } 
     217                } 
    219218                node.appendChild(fill); 
    220             } 
    221             // if graphicOpacity is set use it in priority for external graphic 
    222             if (node._geometryClass == "OpenLayers.Geometry.Point" && 
    223                 style.externalGraphic && 
    224                 style.graphicOpacity) { 
    225                 fill.setAttribute("opacity", style.graphicOpacity); 
    226             } else if (style.fillOpacity) { 
    227                 fill.setAttribute("opacity", style.fillOpacity); 
    228219            } 
    229220        } 
    …… 
    257248        return node; 
    258249    }, 
     250 
     251    /** 
     252     * Method: postDraw 
     253     * Some versions of Internet Explorer seem to be unable to set fillcolor 
     254     * and strokecolor to "none" correctly before the fill node is appended to 
     255     * a visible vml node. This method takes care of that and sets fillcolor 
     256     * and strokecolor again if needed. 
     257     *  
     258     * Parameters: 
     259     * node - {DOMElement} 
     260     */ 
     261    postDraw: function(node) { 
     262        var fillColor = node._style.fillColor; 
     263        var strokeColor = node._style.strokeColor; 
     264        if (fillColor == "none" && 
     265                node.getAttribute("fillcolor") != fillColor) { 
     266            node.setAttribute("fillcolor", fillColor); 
     267        } 
     268        if (strokeColor == "none" && 
     269                node.getAttribute("strokecolor") != strokeColor) { 
     270            node.setAttribute("strokecolor", strokeColor) 
     271        } 
     272    }, 
     273 
    259274 
    260275    /** 
    …… 
    314329     * 
    315330     * Parameters: 
    316      * type - {String} Kind of node to draw 
    317      * id - {String} Id for node 
     331     * node - {DOMElement} An VML element 
     332     * type - {String} Kind of node 
    318333     * 
    319334     * Returns: 

  • sandbox/ahocevar/styles/lib/OpenLayers/Util.js

    r5316 r5343  
    172172    } 
    173173    if (opacity) { 
     174        element.style.filter = 'alpha(opacity=' + (opacity * 100) + ')'; 
    174175        element.style.opacity = opacity; 
    175         element.style.filter = 'alpha(opacity=' + (opacity * 100) + ')'; 
    176176    } 
    177177}; 
    …… 
    335335 
    336336/** 
    337  * Property: onImageLoadErrorColor 
     337 * Property: IMAGE_RELOAD_ATTEMPTS 
    338338 * {Integer} How many times should we try to reload an image before giving up? 
    339339 *           Default is 0 

  • sandbox/ahocevar/styles/tests/Layer/test_FixedZoomLevels.html

    r4059 r5343  
    66 
    77    function test_01_Layer_FixedZoomLevels (t) { 
    8         t.plan( 36 ); 
     8        t.plan( 39 ); 
    99         
    1010        var layer = { 'MIN_ZOOM_LEVEL': 5, 
    …… 
    6868        p_minMaxNum(t, layer, layer.MIN_ZOOM_LEVEL, 10, "min,max(layer.options) wins over (map)"); 
    6969 
     70    // resolutions array 
    7071 
    71  
     72        var resolutions = Array(20); 
     73        for (var i = 0; i < 20; i++) { 
     74            resolutions[i] = Math.random(); 
     75        } 
     76        OpenLayers.Util.extend(layer, {RESOLUTIONS:resolutions}); 
     77        var minZoomLevel = 6; 
     78        var numZoomLevels = 2; 
     79        layer = p_createLayer(layer, {}, {minZoomLevel: minZoomLevel, numZoomLevels: numZoomLevels}); 
     80        t.eq( layer.resolutions.length, numZoomLevels, "length of resolutions array ok"); 
     81        for (var i = 0; i < numZoomLevels; i++) { 
     82            t.eq( layer.resolutions[i], resolutions[i + minZoomLevel], "resolutions array at index " + i + " ok"); 
     83        } 
    7284    } 
    7385 

  • sandbox/ahocevar/styles/tests/Layer/test_TileCache.html

    r5100 r5343  
    1919    } 
    2020 
     21    function test__Layer_TileCache_clone(t) { 
     22        t.plan(3); 
    2123 
     24        layer = new OpenLayers.Layer.TileCache(name, url, layername, options); 
     25 
     26        var clone = layer.clone(); 
     27        t.eq(layer.name, clone.name, "clone() correctly copy the 'name' property"); 
     28        t.eq(layer.url, clone.url, "clone() correctly copy the 'url' property"); 
     29        t.eq(layer.layername, clone.layername, "clone() correctly copy the 'layername' property"); 
     30    } 
    2231 
    2332    function test_03_Layer_TileCache_clearTiles (t) { 

  • sandbox/ahocevar/styles/tests/list-tests.html

    r5274 r5343  
    9494    <li>Handler/test_Polygon.html</li> 
    9595    <li>Handler/test_RegularPolygon.html</li> 
     96    <li>Renderer/test_Elements.html</li> 
     97    <li>Renderer/test_SVG.html</li> 
     98    <li>Renderer/test_VML.html</li> 
    9699    <li>test_Map.html</li> 
    97100</ul> 

  • sandbox/ahocevar/styles/tests/test_Renderer.html

    r4157 r5343  
    44  <script type="text/javascript"> 
    55 
    6     var layer; 
    7  
    8     function test_01_Renderer_drawGeometry(t) { 
    9         t.plan(1);  
     6    function test_Renderer_constructor(t) { 
     7        t.plan(2); 
     8        var el = document.body; 
     9        el.id = "foo"; 
     10        var r = new OpenLayers.Renderer(el.id); 
     11         
     12        t.ok(r instanceof OpenLayers.Renderer, "new OpenLayers.Renderer returns Renderer object" ); 
     13        t.ok(r.container == el, "renderer container is correctly set"); 
     14    } 
     15     
     16    function test_Renderer_supported(t) { 
     17        t.plan(1); 
     18         
    1019        var r = new OpenLayers.Renderer(); 
    11         t.ok( r instanceof OpenLayers.Renderer, "new OpenLayers.Renderer returns REnderer object" ); 
     20        t.eq(r.supported(), false, "supported returns false by default"); 
     21    } 
     22     
     23    function test_Renderer_setextent(t) { 
     24        t.plan(2); 
     25         
     26        var r = new OpenLayers.Renderer(); 
     27        var extent = new OpenLayers.Bounds(1,2,3,4); 
     28        r.resolution = 1; 
     29        r.setExtent(extent); 
     30        t.ok(r.extent.equals(extent), "extent is correctly set"); 
     31        t.eq(r.resolution, null, "resolution nullified"); 
     32    } 
     33     
     34    function test_Renderer_setsize(t) { 
     35        t.plan(2); 
     36         
     37        var r = new OpenLayers.Renderer(); 
     38        var size = new OpenLayers.Size(1,2); 
     39        r.resolution = 1; 
     40        r.setSize(size); 
     41        t.ok(r.size.equals(size), "size is correctly set"); 
     42        t.eq(r.resolution, null, "resolution nullified"); 
     43    } 
     44     
     45    function test_Renderer_getresolution(t) { 
     46        t.plan(2); 
     47         
     48        var r = new OpenLayers.Renderer(); 
     49        var map = new OpenLayers.Map("map"); 
     50        r.map = map; 
     51        var resolution = r.getResolution(); 
     52        t.eq(resolution, map.getResolution(), "resolution matches the map resolution"); 
     53        t.eq(r.resolution, resolution, "resolution is correctly set"); 
    1254    } 
    1355 
    14 /*  
    15 function test_01_Renderer_drawGeometry(t) { 
    16         t.plan(12);  
     56    function test_Renderer_destroy(t) { 
     57        t.plan(5); 
    1758 
    1859        var r = new OpenLayers.Renderer(); 
    19         r.root = document.body; 
    20         r.setStyle = function() {}; 
    21          
    22         var geometry = null;  
    23         var style = null;  
    24      
    25         r.drawGeometry(geometry, style);  
    26         t.ok(true, "didnt do anything on null style"); 
    27          
    28         // point 
    29         var properDraw = false; 
    30         r.drawPoint = function(g) { 
    31             properDraw = true; 
    32             return {}; 
    33         } 
    34         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Point'}; 
    35         style = true;  
    36         r.drawGeometry(geometry, style); 
    37         t.ok(properDraw, "drawGeometry called drawPoint when passed a point"); 
     60        r.container = document.createElement("div"); 
     61        r.extent = new OpenLayers.Bounds(1,2,3,4); 
     62        r.size = new OpenLayers.Size(1,2); 
     63        r.resolution = 1; 
     64        r.map = {}; 
    3865 
    39         // curve 
    40         var properDraw = false; 
    41         r.drawCurve = function(g) { 
    42             properDraw = true; 
    43             return {}; 
    44         }  
    45         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Curve'}; 
    46         style = true;  
    47         r.drawGeometry(geometry, style); 
    48         t.ok(properDraw, "drawGeometry called drawCurve when passed a curve"); 
     66        r.destroy(); 
    4967 
    50         // line segment 
    51         var properDraw = false; 
    52         r.drawLineString = function(g) { 
    53             properDraw = true; 
    54             return {}; 
    55         } 
    56         geometry = {CLASS_NAME: 'OpenLayers.Geometry.LineSegment'}; 
    57         style = true; 
    58         r.drawGeometry(geometry, style); 
    59         t.ok(properDraw, "drawGeometry called drawLineString when passed a line segment"); 
    60  
    61         // line string 
    62         var properDraw = false; 
    63         r.drawLineString = function(g) { 
    64             properDraw = true; 
    65             return {}; 
    66         } 
    67         geometry = {CLASS_NAME: 'OpenLayers.Geometry.LineString'}; 
    68         style = true; 
    69         r.drawGeometry(geometry, style); 
    70         t.ok(properDraw, "drawGeometry called drawLineString when passed a line string"); 
    71  
    72         // linear ring 
    73         var properDraw = false; 
    74         r.drawLinearRing = function(g) { 
    75             properDraw = true; 
    76             return {}; 
    77         } 
    78         geometry = {CLASS_NAME: 'OpenLayers.Geometry.LinearRing'}; 
    79         style = true; 
    80         r.drawGeometry(geometry, style); 
    81         t.ok(properDraw, "drawGeometry called drawLinearRing when passed a linear ring"); 
    82  
    83         // polygon 
    84         var properDraw = false; 
    85         r.drawPolygon = function(g) { 
    86             properDraw = true; 
    87             return {}; 
    88         } 
    89         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Polygon'}; 
    90         style = true; 
    91         r.drawGeometry(geometry, style); 
    92         t.ok(properDraw, "drawGeometry called drawPolygon when passed a polygon"); 
    93  
    94         // surface 
    95         var properDraw = false; 
    96         r.drawSurface = function(g) { 
    97             properDraw = true; 
    98             return {}; 
    99         } 
    100         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Surface'}; 
    101         style = true; 
    102         r.drawGeometry(geometry, style); 
    103         t.ok(properDraw, "drawGeometry called drawSurface when passed a surface"); 
    104  
    105         // rectangle 
    106         var properDraw = false; 
    107         r.drawRectangle = function(g) { 
    108             properDraw = true; 
    109             return {}; 
    110         } 
    111         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Rectangle'}; 
    112         style = true; 
    113         r.drawGeometry(geometry, style); 
    114         t.ok(properDraw, "drawGeometry called drawRectangle when passed a rectangle"); 
    115  
    116         // multi-point 
    117         var properDraw = false; 
    118         r.drawPoint = function(g) { 
    119             properDraw = true; 
    120             return {}; 
    121         } 
    122         geometry = { 
    123             CLASS_NAME: 'OpenLayers.Geometry.MultiPoint', 
    124             components: [{CLASS_NAME: 'OpenLayers.Geometry.Point'}] 
    125         }; 
    126         style = true; 
    127         r.drawGeometry(geometry, style); 
    128         t.ok(properDraw, "drawGeometry called drawPoint when passed a multi-point"); 
    129  
    130         // multi-linestring 
    131         var properDraw = false; 
    132         r.drawLineString = function(g) { 
    133             properDraw = true; 
    134             return {}; 
    135         } 
    136         geometry = { 
    137             CLASS_NAME: 'OpenLayers.Geometry.MultiLineString', 
    138             components: [{CLASS_NAME: 'OpenLayers.Geometry.LineString'}] 
    139         }; 
    140         style = true; 
    141         r.drawGeometry(geometry, style); 
    142         t.ok(properDraw, "drawGeometry called drawLineString when passed a multi-linestring"); 
    143  
    144         // multi-polygon 
    145         var properDraw = false; 
    146         r.drawPolygon = function(g) { 
    147             properDraw = true; 
    148             return {}; 
    149         } 
    150         geometry = { 
    151             CLASS_NAME: 'OpenLayers.Geometry.MultiPolygon', 
    152             components: [{CLASS_NAME: 'OpenLayers.Geometry.Polygon'}] 
    153         }; 
    154         style = true; 
    155         r.drawGeometry(geometry, style); 
    156         t.ok(properDraw, "drawGeometry called drawPolygon when passed a multi-polygon"); 
    157  
     68        t.eq(r.container, null, "container nullified"); 
     69        t.eq(r.extent, null, "extent nullified"); 
     70        t.eq(r.size, null, "size nullified"); 
     71        t.eq(r.resolution, null, "resolution nullified"); 
     72        t.eq(r.map, null, "map nullified"); 
    15873    } 
    159      */ 
    16074 
    16175  </script>