OpenLayers OpenLayers

Ticket #995: mapguide.2.patch

File mapguide.2.patch, 34.3 kB (added by crschmidt, 1 year ago)

  • tests/Layer/test_MapGuide.html

    old new  
     1<html> 
     2<head> 
     3    <script type="text/javascript">var oldAlert = window.alert, gMess; window.alert = function(message) {gMess = message; return true;};</script> 
     4    <script src='http://maps.google.com/maps?file=api&amp;v=2&amp;key=ABQIAAAAjpkAC9ePGem0lIq5XcMiuhR_wWLPFku8Ix9i2SXYRVK3e45q1BQUd_beF8dtzKET_EteAjPdGDwqpQ'></script> 
     5    <script type="text/javascript">window.alert = oldAlert;</script> 
     6<script src="../../lib/OpenLayers.js"></script> 
     7  <script type="text/javascript"> 
     8    var isMozilla = (navigator.userAgent.indexOf("compatible") == -1); 
     9    var layer;  
     10 
     11    var name = 'MapGuide Test Layer'; 
     12    var url = "http://demo01.dmsolutions.ca/mapguide/mapagent/mapagent.fcgi"; 
     13    var paramsTiled = { 
     14      mapDefinition: 'Library://Samples/Gmap/Maps/gmapTiled.MapDefinition', 
     15      groupName: "BaseLayerGroup",    
     16      singleTile: false 
     17    } 
     18    var paramsUntiled = { 
     19      mapDefinition: 'Library://Samples/Sheboygan/Maps/Sheboygan.MapDefinition', 
     20      singleTile: true 
     21    }; 
     22 
     23    function test_01_Layer_MapGuide_untiled_constructor (t) { 
     24        t.plan( 8 ); 
     25 
     26        var trans_format = "image/png"; 
     27        if (OpenLayers.Util.alphaHack()) { trans_format = "image/gif"; }  
     28         
     29        layer = new OpenLayers.Layer.MapGuide(name, url, {}, paramsUntiled); 
     30        t.ok( layer instanceof OpenLayers.Layer.MapGuide, "new OpenLayers.Layer.MapGuide returns object" ); 
     31        t.eq( layer.url, "http://demo01.dmsolutions.ca/mapguide/mapagent/mapagent.fcgi", "layer.url is correct (HTTPRequest inited)" ); 
     32        t.eq( layer.params.mapDefinition, "Library://Samples/Sheboygan/Maps/Sheboygan.MapDefinition", "params passed in correctly" ); 
     33 
     34        t.eq( layer.params.operation, "GETMAPIMAGE", "default params set correctly and copied"); 
     35 
     36        t.eq(layer.isBaseLayer, true, "no transparency setting, layer is baselayer"); 
     37 
     38        paramsUntiled.transparent = "true"; 
     39        var layer2 = new OpenLayers.Layer.MapGuide(name, url, {}, paramsUntiled); 
     40        t.eq(layer2.isBaseLayer, false, "transparency == 'true', wms is not baselayer"); 
     41 
     42        paramsUntiled.transparent = true; 
     43        var layer5 = new OpenLayers.Layer.MapGuide(name, url, {}, paramsUntiled); 
     44        t.eq(layer5.isBaseLayer, false, "transparency == true, wms is not baselayer"); 
     45 
     46        paramsUntiled.transparent = false; 
     47        var layer6 = new OpenLayers.Layer.MapGuide(name, url, {}, paramsUntiled); 
     48        t.eq(layer6.isBaseLayer, true, "transparency == false, wms is baselayer"); 
     49    } 
     50     
     51    function test_02_Layer_MapGuide_tiled_constructor (t) { 
     52        t.plan( 6 ); 
     53 
     54        var trans_format = "image/png"; 
     55        if (OpenLayers.Util.alphaHack()) { trans_format = "image/gif"; }  
     56         
     57        layer = new OpenLayers.Layer.MapGuide(name, url, {}, paramsTiled); 
     58        t.ok( layer instanceof OpenLayers.Layer.MapGuide, "new OpenLayers.Layer.MapGuide returns object" ); 
     59        t.eq( layer.url, "http://demo01.dmsolutions.ca/mapguide/mapagent/mapagent.fcgi", "layer.url is correct (HTTPRequest inited)" ); 
     60        t.eq( layer.params.basemaplayergroupname, "BaseLayerGroup", "params passed in correctly" ); 
     61 
     62        t.eq( layer.params.operation, "GETTILEIMAGE", "default params correctly uppercased and copied"); 
     63        t.eq( layer.params.version, "1.2.0", "version params set correctly set"); 
     64        t.eq( layer.gridOrigin, "upperLeft", "grid origin set correctly set"); 
     65    } 
     66    /* 
     67    function test_Layer_MapGuide_bboxEncoding (t) { 
     68        t.plan( 6 ); 
     69     
     70        var url = "http://octo.metacarta.com/cgi-bin/mapserv"; 
     71        layer = new OpenLayers.Layer.MapGuide(name, url, params, {encodeBBOX:true}); 
     72        var map = new OpenLayers.Map('map'); 
     73        map.addLayer(layer); 
     74        var pixel = new OpenLayers.Pixel(5,6); 
     75        var tile = layer.addTile(new OpenLayers.Bounds(1,2,3,4), pixel); 
     76        tile.draw(); 
     77 
     78        var img = tile.imgDiv; 
     79        var tParams = OpenLayers.Util.extend({}, 
     80                        OpenLayers.Util.upperCaseObject(params)); 
     81        tParams = OpenLayers.Util.extend(tParams, { 
     82            SERVICE: "WMS", VERSION: "1.1.1", 
     83            REQUEST: "GetMap", STYLES: "", 
     84            EXCEPTIONS: "application/vnd.ogc.se_inimage", 
     85            SRS: "EPSG:4326", BBOX: "1,2,3,4", 
     86            WIDTH: "256", HEIGHT: "256" 
     87        }); 
     88        t.eq( img.src, 
     89             url + "?" + OpenLayers.Util.getParameterString(tParams), 
     90             "image src is created correctly via addtile" ); 
     91        t.eq( tile.frame.style.top, "6px", "image top is set correctly via addtile" ); 
     92        t.eq( tile.frame.style.left, "5px", "image top is set correctly via addtile" ); 
     93 
     94        var firstChild = layer.div.firstChild.firstChild; 
     95        if (!isMozilla) 
     96            t.ok( true, "skipping element test outside of Mozilla"); 
     97        else 
     98            t.ok( firstChild instanceof HTMLElement, "div first child is an image object" ); 
     99        t.eq( firstChild.src, 
     100             url + "?" + OpenLayers.Util.getParameterString(tParams), 
     101             "div first child is correct image object" ); 
     102        t.eq( tile.position.toString(), "x=5,y=6", "Position of tile is set correctly." ); 
     103        map.destroy(); 
     104    } 
     105    */ 
     106     
     107    function test_03_Layer_MapGuide_inittiles (t) { 
     108        t.plan( 2 ); 
     109        var map = new OpenLayers.Map('map'); 
     110        layer = new OpenLayers.Layer.MapGuide(name, url, paramsTiled); 
     111        map.addLayer(layer); 
     112        map.setCenter(new OpenLayers.LonLat(0,400000),5); 
     113        t.eq( layer.grid.length, 6, "Grid rows is correct." ); 
     114        t.eq( layer.grid[0].length, 6, "Grid cols is correct." ); 
     115        map.destroy(); 
     116    } 
     117 
     118 
     119    function test_04_Layer_MapGuide_clone (t) { 
     120        t.plan(4); 
     121         
     122        var options = {tileSize: new OpenLayers.Size(500,50)}; 
     123        var map = new OpenLayers.Map('map', options); 
     124        layer = new OpenLayers.Layer.MapGuide(name, url, {}, paramsTiled); 
     125        map.addLayer(layer); 
     126 
     127        layer.grid = [ [6, 7],  
     128                       [8, 9]]; 
     129 
     130        var clone = layer.clone(); 
     131 
     132        t.eq( layer.tileSize.w, 300, "layer.tileSize fixed to 300x300"); 
     133        t.ok( clone.grid != layer.grid, "clone does not copy grid"); 
     134 
     135        t.ok( clone.tileSize.equals(layer.tileSize), "tileSize correctly cloned"); 
     136 
     137        layer.tileSize.w += 40; 
     138 
     139        t.eq( clone.alpha, layer.alpha, "alpha copied correctly"); 
     140 
     141        layer.grid = null; 
     142        map.destroy(); 
     143    } 
     144 
     145    function test_05_Layer_MapGuide_isBaseLayer(t) { 
     146        t.plan(3); 
     147         
     148        layer = new OpenLayers.Layer.MapGuide(name, url, {}, paramsUntiled); 
     149        t.ok( layer.isBaseLayer, "baselayer is true by default"); 
     150 
     151        var newParams = OpenLayers.Util.extend({}, paramsUntiled); 
     152        newParams.transparent = "true"; 
     153        layer = new OpenLayers.Layer.MapGuide(name, url, {}, newParams); 
     154        t.ok( !layer.isBaseLayer, "baselayer is false when transparent is set to true"); 
     155 
     156        newParams = OpenLayers.Util.extend({}, paramsUntiled); 
     157        newParams.isBaseLayer = false; 
     158        layer = new OpenLayers.Layer.MapGuide(name, url, {}, newParams); 
     159        t.ok( !layer.isBaseLayer, "baselayer is false when option is set to false" ); 
     160    } 
     161 
     162    function test_06_Layer_MapGuide_mergeNewParams (t) { 
     163        t.plan( 4 ); 
     164 
     165        var map = new OpenLayers.Map("map"); 
     166        layer = new OpenLayers.Layer.MapGuide(name, url, {}, paramsUntiled); 
     167         
     168        var newParams = { mapDefinition: 'Library://Samples/Gmap/Maps/gmap.MapDefinition', 
     169                          chickpeas: 'image/png'}; 
     170 
     171        map.addLayer(layer); 
     172        map.zoomToMaxExtent(); 
     173 
     174        layer.redraw = function() { 
     175            t.ok(true, "layer is redrawn after new params merged"); 
     176        } 
     177 
     178        layer.mergeNewParams(newParams); 
     179         
     180        t.eq( layer.params.mapDefinition, "Library://Samples/Gmap/Maps/gmap.MapDefinition", "mergeNewParams() overwrites well"); 
     181        t.eq( layer.params.chickpeas, "image/png", "mergeNewParams() adds well"); 
     182     
     183        newParams.chickpeas = 151; 
     184 
     185        t.eq( layer.params.chickpeas, "image/png", "mergeNewParams() makes clean copy of hashtable"); 
     186        map.destroy(); 
     187    } 
     188 
     189    /* 
     190    function test_07_Layer_MapGuide_getFullRequestString (t) { 
     191 
     192         
     193        t.plan( 2 ); 
     194        var map = new OpenLayers.Map('map'); 
     195        map.projection = "xx"; 
     196        tUrl = "http://octo.metacarta.com/cgi-bin/mapserv"; 
     197        tParams = { layers: 'basic',  
     198                   format: 'image/png'}; 
     199        var tLayer = new OpenLayers.Layer.MapGuide(name, tUrl, tParams); 
     200        map.addLayer(tLayer); 
     201        str = tLayer.getFullRequestString(); 
     202        var tParams = { 
     203            LAYERS: "basic", FORMAT: "image/png", SERVICE: "WMS", 
     204            VERSION: "1.1.1", REQUEST: "GetMap", STYLES: "", 
     205            EXCEPTIONS: "application/vnd.ogc.se_inimage", SRS: "xx" 
     206        }; 
     207        t.eq(str, 
     208             tUrl + "?" + OpenLayers.Util.getParameterString(tParams), 
     209             "getFullRequestString() adds SRS value"); 
     210         
     211        map.removeLayer(tLayer); 
     212        tLayer.projection = "none"; 
     213        map.addLayer(tLayer); 
     214        str = tLayer.getFullRequestString(); 
     215        delete tParams['SRS']; 
     216        t.eq(str, 
     217             tUrl + "?" + OpenLayers.Util.getParameterString(tParams), 
     218             "getFullRequestString() by default does *not* add SRS value if projection is 'none'"); 
     219        map.destroy(); 
     220  
     221    }*/ 
     222 
     223    function test_99_Layer_MapGuide_destroy (t) { 
     224 
     225        t.plan( 1 ); 
     226 
     227        var map = new OpenLayers.Map('map'); 
     228        layer = new OpenLayers.Layer.MapGuide(name, url, {}, paramsUntiled); 
     229        map.addLayer(layer); 
     230 
     231        map.setCenter(new OpenLayers.LonLat(0,0), 5); 
     232 
     233        //grab a reference to one of the tiles 
     234        var tile = layer.grid[0][0];         
     235 
     236        layer.destroy(); 
     237         
     238    // checks to make sure superclass (grid) destroy() was called     
     239         
     240        t.ok( layer.grid == null, "grid set to null"); 
     241    } 
     242     
     243 
     244  </script> 
     245</head> 
     246<body> 
     247<div id="map" style="width:500px;height:550px"></div> 
     248</body> 
     249</html> 

  • tests/list-tests.html

    old new  
    5959    <li>Layer/test_HTTPRequest.html</li> 
    6060    <li>Layer/test_Image.html</li> 
    6161    <li>Layer/test_KaMap.html</li> 
     62    <li>Layer/test_MapGuide.html</li> 
    6263    <li>Layer/test_MapServer.html</li> 
    6364    <li>Layer/test_Markers.html</li> 
    6465    <li>Layer/test_MultiMap.html</li> 

  • lib/OpenLayers/Layer/Grid.js

    old new  
    5858     * {Integer} How many tiles are still loading? 
    5959     */ 
    6060    numLoadingTiles: 0, 
     61      
     62     /** 
     63     * APIProperty: gridOrigin 
     64     * {String} where to start the 0,0 tile for the grid 
     65     */ 
     66    gridOrigin: 'lowerLeft', 
    6167 
    6268    /** 
    6369     * Constructor: OpenLayers.Layer.Grid 
    …… 
    327333        var tileoffsetx = -tilecolremain * this.tileSize.w; 
    328334        var tileoffsetlon = extent.left + tilecol * tilelon; 
    329335         
    330         var offsetlat = bounds.top - (extent.bottom + tilelat);   
    331         var tilerow = Math.ceil(offsetlat/tilelat) + this.buffer; 
    332         var tilerowremain = tilerow - offsetlat/tilelat; 
    333         var tileoffsety = -tilerowremain * this.tileSize.h; 
    334         var tileoffsetlat = extent.bottom + tilerow * tilelat; 
     336        var offsetlat, tilerow, tilerowremain, tileoffsety, tileoffsetlat; 
     337        if (this.gridOrigin == 'upperLeft') { 
     338          offsetlat = extent.top - bounds.top + tilelat;  
     339          tilerow = Math.floor(offsetlat/tilelat) - this.buffer; 
     340          tilerowremain = tilerow - offsetlat/tilelat; 
     341          tileoffsety = tilerowremain * this.tileSize.h; 
     342          tileoffsetlat = extent.top - tilelat*tilerow; 
     343        } else {    //default lower left 
     344          offsetlat = bounds.top - (extent.bottom + tilelat);   
     345          tilerow = Math.ceil(offsetlat/tilelat) + this.buffer; 
     346          tilerowremain = tilerow - offsetlat/tilelat; 
     347          tileoffsety = -tilerowremain * this.tileSize.h; 
     348          tileoffsetlat = extent.bottom + tilerow * tilelat; 
     349        } 
    335350         
    336351        tileoffsetx = Math.round(tileoffsetx); // heaven help us 
    337352        tileoffsety = Math.round(tileoffsety); 

  • lib/OpenLayers/Layer/MapGuide.js

    old new  
     1/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD 
     2 * licence.  See http://svn.openlayers.org/trunk/openlayers/license.txt for the 
     3 * full text of the license. */ 
     4 
     5/** 
     6 * @requires OpenLayers/Ajax.js 
     7 * @requires OpenLayers/Layer/Grid.js 
     8 * 
     9 * Class: OpenLayers.Layer.MapGuide 
     10 * Instances of OpenLayers.Layer.MapGuide are used to display 
     11 * data from a MapGuide OS instance. 
     12 * 
     13 * Inherits from: 
     14 *  - <OpenLayers.Layer.Grid> 
     15 */ 
     16OpenLayers.Layer.MapGuide = OpenLayers.Class(OpenLayers.Layer.Grid, { 
     17 
     18    /**  
     19     * APIProperty: isBaseLayer 
     20     * {Boolean} Treat this layer as a base layer.  Default is true. 
     21     **/ 
     22    isBaseLayer: true, 
     23     
     24    /**  
     25     * APIProperty: singleTile 
     26     * {Boolean} use tile server or request single tile image 
     27     **/ 
     28    singleTile: false, 
     29     
     30    /** 
     31     * Constant: TILE_PARAMS 
     32     * {Object} Hashtable of default parameter key/value pairs for tiled layer 
     33     */ 
     34    TILE_PARAMS: { 
     35                      operation: 'GETTILEIMAGE', 
     36                      version: '1.2.0' 
     37                  }, 
     38 
     39    /** 
     40     * Constant: SINGLE_TILE_PARAMS 
     41     * {Object} Hashtable of default parameter key/value pairs for untiled layer 
     42     */ 
     43    SINGLE_TILE_PARAMS: { 
     44                      operation: 'GETMAPIMAGE', 
     45                      version: '1.0.0' 
     46                     }, 
     47 
     48    /**  
     49     * Property: session 
     50     * {String} MapGuide session ID  
     51     *            (for untiled overlays layers only) 
     52     **/ 
     53    session: null, 
     54     
     55    /**  
     56     * Property: mapName 
     57     * {String} Name of the map as stored in the MapGuide session. 
     58     *          (for untiled overlay layers only) 
     59     **/ 
     60    mapName: null, 
     61     
     62    /**  
     63     * Property: mapDefinition 
     64     * {String} The MapGuide resource definition 
     65     *            (e.g. Library://Samples/Gmap/Maps/gmapTiled.MapDefinition) 
     66     **/ 
     67    mapDefinition: null, 
     68     
     69    /**  
     70     * Property: groupName 
     71     * {String} GroupName for tiled MapGuide layers 
     72     **/ 
     73    groupName: null, 
     74     
     75    /**  
     76     * Property: format 
     77     * {String} Image format to be returned (for untiled overlay layers only) 
     78     **/ 
     79    format: 'PNG', 
     80     
     81    /**  
     82     * Property: locale 
     83     * {String} Locale setting  
     84     *            (for untiled overlays layers only) 
     85     **/ 
     86    locale: "en", 
     87 
     88    /**  
     89     * Property: defaultSize 
     90     * {<OpenLayers.Size>} Tile size as produced by MapGuide server 
     91     **/ 
     92    defaultSize: new OpenLayers.Size(300,300), 
     93 
     94    /** 
     95     * Constructor: OpenLayers.Layer.MapGuide 
     96     * Create a new Mapguide layer, either tiled or untiled.   
     97     * 
     98     * For tiled layers, the 'groupName' and 'mapDefnition' options  
     99     * must be specified as options. 
     100     * 
     101     * For untiled layers, specify either combination of 'mapName' and 'session',  
     102     * or 'mapDefinition' and 'locale'. 
     103     * 
     104     * The following parameters are typically set on a per request basis using 
     105     * mergeNewParams (or similar), but may also be specified once for the layer: 
     106     * 'showLayers', 'hideLayers', 'showGroups', 'hideGroups', 'selectionXml' 
     107     * 
     108     * Parameters: 
     109     * name - {String} Name of the layer displayed in the interface 
     110     * url - {String} Location of the MapGuide mapagent executable 
     111                  (e.g. http://localhost:8008/mapguide/mapagent/mapagent.fcgi) 
     112     * params - {Object} hashtable of additional parameters to use. Some 
     113     *     parameters may require additional code on the serer. The ones that you 
     114     *     may want to use are:  
     115     *   - showLayers - {String} A comma separated list of GUID's for the layers to display 
     116     *       eg: 'cvc-xcv34,453-345-345sdf'. 
     117     *   - hideLayers - {String} A comma separated list of GUID's for the layers to hide eg: 
     118     *       'cvc-xcv34,453-345-345sdf'. 
     119     *   - showGroups - {String} A comma separated list of GUID's for the groups to display 
     120     *       eg: 'cvc-xcv34,453-345-345sdf'. 
     121     *   - hideGroups - {String} A comma separated list of GUID's for the groups to hide 
     122     *       eg: 'cvc-xcv34,453-345-345sdf' 
     123     *   - selectionXml - {String} A selection xml string Some server plumbing is 
     124     *       required to read such a value. 
     125     * options - {Ojbect} Hashtable of extra options to tag onto the layer;  
     126     *          will vary depending if tiled or untiled maps are being requested 
     127     */ 
     128    initialize: function(name, url, params, options) { 
     129         
     130        OpenLayers.Layer.Grid.prototype.initialize.apply(this, arguments); 
     131 
     132        // unless explicitly set in options, if the layer is transparent,  
     133        // it will be an overlay 
     134        if (options == null || options.isBaseLayer == null) { 
     135            this.isBaseLayer = ((this.transparent != "true") &&  
     136                                (this.transparent != true)); 
     137        } 
     138 
     139        //initialize for untiled layers 
     140        if (this.singleTile) { 
     141            if (this.session && this.mapName) { 
     142                this.params.session = this.session; 
     143                this.params.mapName = this.mapName; 
     144            } else if (this.mapDefinition) { 
     145                this.params.mapDefinition = this.mapDefinition; 
     146                this.params.locale = this.locale; 
     147            } 
     148            this.params.format = this.format; 
     149             
     150            OpenLayers.Util.applyDefaults( 
     151                           this.params, 
     152                           this.SINGLE_TILE_PARAMS 
     153                           ); 
     154        } else { 
     155            //initialize for tiled layers 
     156            this.params.mapDefinition = this.mapDefinition; 
     157            this.params.basemaplayergroupname = this.groupName; 
     158            OpenLayers.Util.applyDefaults( 
     159                           this.params, 
     160                           this.TILE_PARAMS 
     161                           ); 
     162            this.setTileSize(this.defaultSize);  
     163            this.gridOrigin = 'upperLeft'; 
     164        } 
     165    }, 
     166 
     167    /** 
     168     * Method: clone 
     169     * Create a clone of this layer 
     170     * 
     171     * Returns: 
     172     * {<OpenLayers.Layer.MapGuide>} An exact clone of this layer 
     173     */ 
     174    clone: function (obj) { 
     175      if (obj == null) { 
     176            obj = new OpenLayers.Layer.MapGuide(this.name, 
     177                                           this.url, 
     178                                           this.params, 
     179                                           this.options); 
     180      } 
     181      //get all additions from superclasses 
     182      obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); 
     183 
     184      return obj; 
     185    }, 
     186 
     187    /** 
     188     * Method: addTile 
     189     * Creates a tile, initializes it, and adds it to the layer div.  
     190     * 
     191     * Parameters: 
     192     * bounds - {<OpenLayers.Bounds>} 
     193     *  
     194     * Returns: 
     195     * {<OpenLayers.Tile.Image>} The added OpenLayers.Tile.Image 
     196     */ 
     197    addTile:function(bounds,position) { 
     198        return new OpenLayers.Tile.Image(this, position, bounds, null, this.tileSize); 
     199    }, 
     200 
     201    /** 
     202     * Method: getURL 
     203     * Return a query string for this layer 
     204     * 
     205     * Parameters: 
     206     * bounds - {<OpenLayers.Bounds>} A bounds representing the bbox  
     207     *                                for the request 
     208     * 
     209     * Returns: 
     210     * {String} A string with the layer's url and parameters and also  
     211     *          the passed-in bounds and appropriate tile size specified  
     212     *          as parameters. 
     213     */ 
     214    getURL: function (bounds) { 
     215        var url; 
     216        var center = bounds.getCenterLonLat(); 
     217        var mapSize = this.map.getCurrentSize(); 
     218 
     219        if (this.singleTile) { 
     220          //set up the call for GETMAPIMAGE or GETDYNAMICMAPOVERLAY 
     221          var params = {}; 
     222          params.setdisplaydpi = OpenLayers.DOTS_PER_INCH;    
     223          params.setdisplayheight = mapSize.h*this.ratio; 
     224          params.setdisplaywidth = mapSize.w*this.ratio; 
     225          params.setviewcenterx = center.lon; 
     226          params.setviewcentery = center.lat; 
     227          params.setviewscale = this.map.getScale(); 
     228           
     229          if (!this.isBaseLayer) { 
     230            // in this case the main image operation is remapped to this 
     231            this.params.operation = "GETDYNAMICMAPOVERLAYIMAGE"; 
     232             
     233            //but we first need to call GETVISIBLEMAPEXTENT to set the extent 
     234            var getVisParams = {}; 
     235            getVisParams.operation = "GETVISIBLEMAPEXTENT"; 
     236            getVisParams.version = "1.0.0"; 
     237            getVisParams.session = this.session; 
     238            getVisParams.mapName = this.mapName; 
     239            getVisParams.format = 'text/xml'; 
     240            getVisParams = OpenLayers.Util.extend(getVisParams, params); 
     241                 
     242            new OpenLayers.Ajax.Request(this.url,  
     243                  { parameters: getVisParams, 
     244                    method: 'get', 
     245                    asynchronous: false   //must be synchronous call to return control here 
     246                  }); 
     247          } 
     248           
     249          //construct the full URL 
     250          url = this.getFullRequestString( params ); 
     251        } else { 
     252 
     253          //tiled version 
     254          var currentRes = this.map.getResolution(); 
     255          var colidx = Math.floor((bounds.left-this.maxExtent.left)/currentRes); 
     256          colidx = Math.round(colidx/this.tileSize.w); 
     257          var rowidx = Math.floor((this.maxExtent.top-bounds.top)/currentRes); 
     258          rowidx = Math.round(rowidx/this.tileSize.h); 
     259 
     260          url = this.getFullRequestString( 
     261                       { 
     262                           tilecol: colidx, 
     263                           tilerow: rowidx, 
     264                           scaleindex: this.resolutions.length - this.map.zoom - 1 
     265                        }); 
     266         } 
     267         
     268        return url; 
     269    }, 
     270 
     271    /** 
     272     * Method: getFullRequestString 
     273     * getFullRequestString on MapGuide layers is special, because we  
     274     * do a regular expression replace on ',' in parameters to '+'. 
     275     * This is why it is subclassed here. 
     276     * 
     277     * Parameters: 
     278     * altUrl - {String} Alternative base URL to use. 
     279     * 
     280     * Returns: 
     281     * {String} A string with the layer's url appropriately encoded for MapGuide 
     282     */ 
     283    getFullRequestString:function(newParams, altUrl) { 
     284        // use layer's url unless altUrl passed in 
     285        var url = (altUrl == null) ? this.url : altUrl; 
     286         
     287        // if url is not a string, it should be an array of strings,  
     288        //  in which case we will randomly select one of them in order 
     289        //  to evenly distribute requests to different urls. 
     290        if (typeof url == "object") { 
     291            url = url[Math.floor(Math.random()*url.length)]; 
     292        }    
     293        // requestString always starts with url 
     294        var requestString = url;         
     295 
     296        // create a new params hashtable with all the layer params and the  
     297        // new params together. then convert to string 
     298        var allParams = OpenLayers.Util.extend({}, this.params); 
     299        allParams = OpenLayers.Util.extend(allParams, newParams); 
     300        // ignore parameters that are already in the url search string 
     301        var urlParams = OpenLayers.Util.upperCaseObject( 
     302                            OpenLayers.Util.getArgs(url)); 
     303        for(var key in allParams) { 
     304            if(key.toUpperCase() in urlParams) { 
     305                delete allParams[key]; 
     306            } 
     307        } 
     308        var paramsString = OpenLayers.Util.getParameterString(allParams); 
     309         
     310        /* MapGuide needs '+' seperating things like bounds/height/width. 
     311           Since typically this is URL encoded, we use a slight hack: we 
     312           depend on the list-like functionality of getParameterString to 
     313           leave ',' only in the case of list items (since otherwise it is 
     314           encoded) then do a regular expression replace on the , characters 
     315           to '+' */ 
     316        paramsString = paramsString.replace(/,/g, "+"); 
     317         
     318        if (paramsString != "") { 
     319            var lastServerChar = url.charAt(url.length - 1); 
     320            if ((lastServerChar == "&") || (lastServerChar == "?")) { 
     321                requestString += paramsString; 
     322            } else { 
     323                if (url.indexOf('?') == -1) { 
     324                    //serverPath has no ? -- add one 
     325                    requestString += '?' + paramsString; 
     326                } else { 
     327                    //serverPath contains ?, so must already have paramsString at the end 
     328                    requestString += '&' + paramsString; 
     329                } 
     330            } 
     331        } 
     332        return requestString; 
     333    }, 
     334    CLASS_NAME: "OpenLayers.Layer.MapGuide" 
     335}); 

  • lib/OpenLayers.js

    old new  
    103103            "OpenLayers/Layer/Yahoo.js", 
    104104            "OpenLayers/Layer/HTTPRequest.js", 
    105105            "OpenLayers/Layer/Grid.js", 
     106            "OpenLayers/Layer/MapGuide.js", 
    106107            "OpenLayers/Layer/MapServer.js", 
    107108            "OpenLayers/Layer/MapServer/Untiled.js", 
    108109            "OpenLayers/Layer/KaMap.js", 

  • examples/mapguide.html

    old new  
     1<html xmlns="http://www.w3.org/1999/xhtml"> 
     2  <head> 
     3    <style type="text/css"> 
     4        #map { 
     5            width: 800px; 
     6            height: 800px; 
     7            border: 1px solid black; 
     8        } 
     9    </style> 
     10    <script src="../lib/OpenLayers.js"></script> 
     11    <script type="text/javascript"> 
     12     
     13var map, layer; 
     14var url = "http://demo01.dmsolutions.ca/mapguide/mapagent/mapagent.fcgi"; 
     15//var url = "/mapguide/mapagent/mapagent.fcgi"; 
     16 
     17//tiled version 
     18function init(){ 
     19 
     20  OpenLayers.DOTS_PER_INCH = 96; 
     21  var extent = new OpenLayers.Bounds(-3631568.75,-1293815.5,4491139.5833333321,4937122); 
     22  var tempScales = [50000000,23207944.16806,10772173.45016,5000000,2320794.41681,1077217.34502,500000,232079.44168,107721.7345,50000]; 
     23  var mapOptions = { 
     24        maxExtent: extent,  
     25        scales: tempScales, 
     26        units: 'm', 
     27        projection: 'EPSG:42304' 
     28  }; 
     29  map = new OpenLayers.Map( 'map', mapOptions ); 
     30  map.addControl( new OpenLayers.Control.LayerSwitcher() ); 
     31     
     32  var options = { 
     33    mapDefinition: 'Library://Samples/Gmap/Maps/gmapTiled.MapDefinition', 
     34    groupName: "BaseLayerGroup",    
     35    buffer:1, 
     36    singleTile: false,    
     37  } 
     38  var layer = new OpenLayers.Layer.MapGuide( "MapGuide OS tiled layer", url, options ); 
     39  map.addLayer(layer); 
     40   
     41  map.zoomToMaxExtent(); 
     42} 
     43 
     44//un-tiled version 
     45function initUntiled() { 
     46 
     47  OpenLayers.DOTS_PER_INCH = 96; 
     48  var extent = new OpenLayers.Bounds(-87.865114442365922,43.665065564837931,-87.595394059497067,43.823852564430069); 
     49  var mapOptions = { 
     50        maxExtent: extent,  
     51        maxResolution: 'auto' 
     52  }; 
     53  map = new OpenLayers.Map( 'map', mapOptions ); 
     54  map.addControl( new OpenLayers.Control.LayerSwitcher() ); 
     55     
     56  var options = { 
     57    mapDefinition: 'Library://Samples/Sheboygan/Maps/Sheboygan.MapDefinition', 
     58    buffer: 1, 
     59    singleTile: true 
     60  }; 
     61  var layer = new OpenLayers.Layer.MapGuide( "MapGuide OS untiled baselayer", url, options ); 
     62  map.addLayer(layer); 
     63   
     64  //this is how to set up the layer for transparent overlays.  Requires a valid session ID  
     65  //and mapName stored in that session. 
     66  //If the mapagent URL is on a different server than this OL layer, the OpenLayers proxy script 
     67  //must be used since this layer must perform an additional AJAX request before requesting the 
     68  //map  image 
     69  var options = { 
     70    isBaseLayer: false, 
     71    transparent: true, 
     72    mapName: 'Sheboygan', 
     73    session: '0b8cb80e-0000-1000-8003-0017a4e6ff5d_en_C0A802AD0AFC0AFB0AFA', 
     74    buffer: 1, 
     75    singleTile: true 
     76  }; 
     77  layer = new OpenLayers.Layer.MapGuide( "MapGuide OS Overlay layer", url, options ); 
     78  //map.addLayer(layer); 
     79   
     80  map.zoomToMaxExtent(); 
     81} 
     82    </script> 
     83  </head> 
     84  <body onload="initUntiled()"> 
     85    <p>If prompted for a password, username is Anonymous and an empty password</p> 
     86    <div id="map"></div> 
     87  </body> 
     88</html> 
     89<html xmlns="http://www.w3.org/1999/xhtml"> 
     90  <head> 
     91    <style type="text/css"> 
     92        #map { 
     93            width: 800px; 
     94            height: 800px; 
     95            border: 1px solid black; 
     96        } 
     97    </style> 
     98    <script src="../lib/OpenLayers.js"></script> 
     99    <script type="text/javascript"> 
     100     
     101var map, layer; 
     102var url = "http://demo01.dmsolutions.ca/mapguide/mapagent/mapagent.fcgi"; 
     103//var url = "/mapguide/mapagent/mapagent.fcgi"; 
     104 
     105//tiled version 
     106function init(){ 
     107 
     108  OpenLayers.DOTS_PER_INCH = 96; 
     109  var extent = new OpenLayers.Bounds(-3631568.75,-1293815.5,4491139.5833333321,4937122); 
     110  var tempScales = [50000000,23207944.16806,10772173.45016,5000000,2320794.41681,1077217.34502,500000,232079.44168,107721.7345,50000]; 
     111  var mapOptions = { 
     112        maxExtent: extent,  
     113        scales: tempScales, 
     114        units: 'm', 
     115        projection: 'EPSG:42304' 
     116  }; 
     117  map = new OpenLayers.Map( 'map', mapOptions ); 
     118  map.addControl( new OpenLayers.Control.LayerSwitcher() ); 
     119     
     120  var options = { 
     121    mapDefinition: 'Library://Samples/Gmap/Maps/gmapTiled.MapDefinition', 
     122    groupName: "BaseLayerGroup",    
     123    buffer:1, 
     124    singleTile: false,    
     125  } 
     126  var layer = new OpenLayers.Layer.MapGuide( "MapGuide OS tiled layer", url, options ); 
     127  map.addLayer(layer); 
     128   
     129  map.zoomToMaxExtent(); 
     130} 
     131 
     132//un-tiled version 
     133function initUntiled() { 
     134 
     135  OpenLayers.DOTS_PER_INCH = 96; 
     136  var extent = new OpenLayers.Bounds(-87.865114442365922,43.665065564837931,-87.595394059497067,43.823852564430069); 
     137  var mapOptions = { 
     138        maxExtent: extent,  
     139        maxResolution: 'auto' 
     140  }; 
     141  map = new OpenLayers.Map( 'map', mapOptions ); 
     142  map.addControl( new OpenLayers.Control.LayerSwitcher() ); 
     143     
     144  var options = { 
     145    mapDefinition: 'Library://Samples/Sheboygan/Maps/Sheboygan.MapDefinition', 
     146    buffer: 1, 
     147    singleTile: true 
     148  }; 
     149  var layer = new OpenLayers.Layer.MapGuide( "MapGuide OS untiled baselayer", url, options ); 
     150  map.addLayer(layer); 
     151   
     152  //this is how to set up the layer for transparent overlays.  Requires a valid session ID  
     153  //and mapName stored in that session. 
     154  //If the mapagent URL is on a different server than this OL layer, the OpenLayers proxy script 
     155  //must be used since this layer must perform an additional AJAX request before requesting the 
     156  //map  image 
     157  var options = { 
     158    isBaseLayer: false, 
     159    transparent: true, 
     160    mapName: 'Sheboygan', 
     161    session: '0b8cb80e-0000-1000-8003-0017a4e6ff5d_en_C0A802AD0AFC0AFB0AFA', 
     162    buffer: 1, 
     163    singleTile: true 
     164  }; 
     165  layer = new OpenLayers.Layer.MapGuide( "MapGuide OS Overlay layer", url, options ); 
     166  //map.addLayer(layer); 
     167   
     168  map.zoomToMaxExtent(); 
     169} 
     170    </script> 
     171  </head> 
     172  <body onload="initUntiled()"> 
     173    <p>If prompted for a password, username is Anonymous and an empty password</p> 
     174    <div id="map"></div> 
     175  </body> 
     176</html> 
     177<html xmlns="http://www.w3.org/1999/xhtml"> 
     178  <head> 
     179    <style type="text/css"> 
     180        #map { 
     181            width: 800px; 
     182            height: 800px; 
     183            border: 1px solid black; 
     184        } 
     185    </style> 
     186    <script src="../lib/OpenLayers.js"></script> 
     187    <script type="text/javascript"> 
     188     
     189var map, layer; 
     190var url = "http://demo01.dmsolutions.ca/mapguide/mapagent/mapagent.fcgi"; 
     191//var url = "/mapguide/mapagent/mapagent.fcgi"; 
     192 
     193//tiled version 
     194function init(){ 
     195 
     196  OpenLayers.DOTS_PER_INCH = 96; 
     197  var extent = new OpenLayers.Bounds(-3631568.75,-1293815.5,4491139.5833333321,4937122); 
     198  var tempScales = [50000000,23207944.16806,10772173.45016,5000000,2320794.41681,1077217.34502,500000,232079.44168,107721.7345,50000]; 
     199  var mapOptions = { 
     200        maxExtent: extent,  
     201        scales: tempScales, 
     202        units: 'm', 
     203        projection: 'EPSG:42304' 
     204  }; 
     205  map = new OpenLayers.Map( 'map', mapOptions ); 
     206  map.addControl( new OpenLayers.Control.LayerSwitcher() ); 
     207     
     208  var options = { 
     209    mapDefinition: 'Library://Samples/Gmap/Maps/gmapTiled.MapDefinition', 
     210    groupName: "BaseLayerGroup",    
     211    buffer:1, 
     212    singleTile: false,    
     213  } 
     214  var layer = new OpenLayers.Layer.MapGuide( "MapGuide OS tiled layer", url, options ); 
     215  map.addLayer(layer); 
     216   
     217  map.zoomToMaxExtent(); 
     218} 
     219 
     220//un-tiled version 
     221function initUntiled() { 
     222 
     223  OpenLayers.DOTS_PER_INCH = 96; 
     224  var extent = new OpenLayers.Bounds(-87.865114442365922,43.665065564837931,-87.595394059497067,43.823852564430069); 
     225  var mapOptions = { 
     226        maxExtent: extent,  
     227        maxResolution: 'auto' 
     228  }; 
     229  map = new OpenLayers.Map( 'map', mapOptions ); 
     230  map.addControl( new OpenLayers.Control.LayerSwitcher() ); 
     231     
     232  var options = { 
     233    mapDefinition: 'Library://Samples/Sheboygan/Maps/Sheboygan.MapDefinition', 
     234    buffer: 1, 
     235    singleTile: true 
     236  }; 
     237  var layer = new OpenLayers.Layer.MapGuide( "MapGuide OS untiled baselayer", url, options ); 
     238  map.addLayer(layer); 
     239   
     240  //this is how to set up the layer for transparent overlays.  Requires a valid session ID  
     241  //and mapName stored in that session. 
     242  //If the mapagent URL is on a different server than this OL layer, the OpenLayers proxy script 
     243  //must be used since this layer must perform an additional AJAX request before requesting the 
     244  //map  image 
     245  var options = { 
     246    isBaseLayer: false, 
     247    transparent: true, 
     248    mapName: 'Sheboygan', 
     249    session: '0b8cb80e-0000-1000-8003-0017a4e6ff5d_en_C0A802AD0AFC0AFB0AFA', 
     250    buffer: 1, 
     251    singleTile: true 
     252  }; 
     253  layer = new OpenLayers.Layer.MapGuide( "MapGuide OS Overlay layer", url, options ); 
     254  //map.addLayer(layer); 
     255   
     256  map.zoomToMaxExtent(); 
     257} 
     258    </script> 
     259  </head> 
     260  <body onload="initUntiled()"> 
     261    <p>If prompted for a password, username is Anonymous and an empty password</p> 
     262    <div id="map"></div> 
     263  </body> 
     264</html>