Changeset 5563


Ignore:
Timestamp:
05/08/09 15:10:04 (10 years ago)
Author:
pnorton
Message:

Moved the base layer definition into the developemnt.ini file rather than havning it hard coded in the .js file.

Also fixed a problem with retrieving a parameter from a layer not directly under the root layer.

Location:
cowsclient/branches/qesdi
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • cowsclient/branches/qesdi/cowsclient/controllers/wmsviz.py

    r5557 r5563  
    144144        c.initialSetupJSON = json.dumps(initialSetup).replace('"', '\\"')  
    145145 
     146         
     147        params = {} 
     148        for paramString in config['baselayer.params'].split(','): 
     149            key, value = paramString.split(':') 
     150            params[key] = value 
     151         
     152        baseLayerObj = {"url":config['baselayer.url'], "params": params } 
     153         
     154        c.baseLayerJSON = json.dumps(baseLayerObj).replace('"', '\\"')  
     155         
     156 
    146157        return render('wmsviz') 
    147158 
  • cowsclient/branches/qesdi/cowsclient/public/js/boundsControl.js

    r5557 r5563  
    1212WMSC.BoundsControl.prototype =  
    1313{ 
    14     EVENT_TYPES: ['changeWMS','changeSelection','clearSelection', 'TEXT_SELECTION_CHANGED'], 
     14    EVENT_TYPES: ['changeWMS','clearSelection', 'TEXT_SELECTION_CHANGED'], 
    1515    GLOBAL_BOUNDS: new OpenLayers.Bounds(-180.0,-90.0,180.0,90.0), 
    1616 
    1717    // The WMS domain and layer parameters of the current selection 
    1818    wmsParams: null, 
    19         clearButtonID: 'WMSC_clear', 
    20         formID: 'coordsForm', 
     19    clearButtonID: 'WMSC_clear', 
     20    formID: 'coordsForm', 
    2121 
    2222    controlMarkup:'<div id="WMSC_sel" class="WMSC_domain">'+ 
    23           '<form id="coordsForm"><table>'+ 
    24           '  <tr><td colspan="2"'+ 
     23      '<form id="coordsForm"><table>'+ 
     24      '  <tr><td colspan="2"'+ 
    2525          '          align="center">'+ 
    2626          '    <input type="text" name="bboxN" size="4" value="90"/><br/>N'+ 
    2727          '  </td></tr>'+ 
    28           '  <tr>'+ 
    29           '   <td><input type="text" name="bboxW" size="4" value="-180"/> W</td>'+ 
    30           '   <td>E <input type="text" name="bboxE" size="4" value="180"/></td>'+ 
    31           '  </tr>'+ 
    32           '  <tr><td colspan="2" align="center">S<br/>'+ 
     28      '  <tr>'+ 
     29      '   <td><input type="text" name="bboxW" size="4" value="-180"/> W</td>'+ 
     30      '   <td>E <input type="text" name="bboxE" size="4" value="180"/></td>'+ 
     31      '  </tr>'+ 
     32      '  <tr><td colspan="2" align="center">S<br/>'+ 
    3333          '    <input type="text" name="bboxS" size="4" value="-90"/>'+ 
    3434          '  </td></tr>'+ 
    35           '</table>'+ 
    36           '<input id="WMSC_clear" type="button" value="Reset selection"/>'+ 
    37           '</form></div>', 
    38  
    39          
    40         /** 
    41         * Constructor to create dimensionControl object 
    42         * 
    43         * @param domainDivID - ID of div element to use for domain control 
    44         * @param formID - ID of form which features the coordinate selection control 
    45         * @controlMarkup - HTML defining the coordinate selection control; NB, if this 
    46          *      is not set, a default markup is used 
    47         */ 
     35      '</table>'+ 
     36      '<input id="WMSC_clear" type="button" value="Reset selection"/>'+ 
     37      '</form></div>', 
     38 
     39     
     40    /** 
     41    * Constructor to create dimensionControl object 
     42    * 
     43    * @param domainDivID - ID of div element to use for domain control 
     44    * @param formID - ID of form which features the coordinate selection control 
     45    * @controlMarkup - HTML defining the coordinate selection control; NB, if this 
     46     *    is not set, a default markup is used 
     47    */ 
    4848    initialize: function(domainDivID, formID, controlMarkup)  
    4949    { 
    50         this.domainDivID = domainDivID; 
    51         if (formID) 
    52                 this.formID = formID; 
    53                 if (controlMarkup) 
    54                         this.controlMarkup = controlMarkup; 
    55                 this.events = new OpenLayers.Events(this, this.selectionForm, 
    56                                             this.EVENT_TYPES); 
    57                 this.wmsParams = {}; 
    58  
    59                 // store of the selected dimensions; not used currently, but useful if we're producing output data 
    60                 this._selectedDims = {}; 
    61                  
    62                 this._lastSelection = null; 
    63                  
    64         this._initDomainDiv(); 
    65     }, 
    66  
    67         /** 
    68         * Clean up object 
     50        this.domainDivID = domainDivID; 
     51        if (formID) 
     52            this.formID = formID; 
     53        if (controlMarkup) 
     54            this.controlMarkup = controlMarkup; 
     55        this.events = new OpenLayers.Events(this, this.selectionForm, 
     56                        this.EVENT_TYPES); 
     57        this.wmsParams = {}; 
     58 
     59        // store of the selected dimensions; not used currently, but useful if we're producing output data 
     60        this._selectedDims = {}; 
     61         
     62        this._lastSelection = null; 
     63         
     64        this._initDomainDiv(); 
     65    }, 
     66 
     67    /** 
     68    * Clean up object 
    6969     * - important for IE. 
    7070     */ 
    7171    destroy: function()  
    7272    { 
    73                 this.events.destroy(); 
     73        this.events.destroy(); 
    7474    }, 
    7575 
     
    7979    _selectionListener: function()  
    8080    { 
    81         var selection = this.getSelection(); 
    82         WMSC.log("triggering TEXT_SELECTION_CHANGED, selection = " + selection); 
    83         this.events.triggerEvent('TEXT_SELECTION_CHANGED', {selection:selection}); 
    84          
    85         // this will be picked up by the map control, this map control will 
    86         // then raise the MAP_SELECTION_CHANGED event (cannot be supressed as is 
    87         // called by openlayers internals) which will call the changeSelection. 
     81        var selection = this.getSelection(); 
     82        WMSC.log("triggering TEXT_SELECTION_CHANGED, selection = " + selection); 
     83        this.events.triggerEvent('TEXT_SELECTION_CHANGED', {selection:selection}); 
     84         
     85        // this will be picked up by the map control, this map control will 
     86        // then raise the MAP_SELECTION_CHANGED event (couldn't find a way to  
     87        // suppress is) which will be picked up by this bounds control and 
     88        // run setSelection again. 
    8889    }, 
    8990     
     
    9495    _initDomainDiv: function()  
    9596    { 
    96         var domainDiv = $(this.domainDivID);  
    97                 domainDiv.innerHTML = this.controlMarkup; 
    98  
    99                 // NB, not all controls may have a clear button 
    100                 var clearButton = $(this.clearButtonID); 
    101                 if (clearButton) 
    102                         clearButton.onclick = this._clearSelection.bindAsEventListener(this); 
    103                          
    104                 var listener = this._selectionListener.bindAsEventListener(this); 
    105  
    106                 this.selectionForm = $(this.formID); 
    107  
    108                 for (var i=0; i < this.selectionForm.elements.length; i++)  
    109                 { 
    110                     this.selectionForm.elements[i].onchange = listener; 
    111                 } 
    112          
    113                 this.setSelection(this.GLOBAL_BOUNDS); 
     97        var domainDiv = $(this.domainDivID);  
     98        domainDiv.innerHTML = this.controlMarkup; 
     99 
     100        // NB, not all controls may have a clear button 
     101        var clearButton = $(this.clearButtonID); 
     102        if (clearButton) 
     103            clearButton.onclick = this._clearSelection.bindAsEventListener(this); 
     104             
     105        var listener = this._selectionListener.bindAsEventListener(this); 
     106 
     107        this.selectionForm = $(this.formID); 
     108 
     109        for (var i=0; i < this.selectionForm.elements.length; i++)  
     110        { 
     111            this.selectionForm.elements[i].onchange = listener; 
     112        } 
     113     
     114        this.setSelection(this.GLOBAL_BOUNDS); 
    114115    }, 
    115116     
     
    120121    _clearSelection: function()  
    121122    { 
    122         //alert("RAISED clearSelection"); 
    123                 this.events.triggerEvent('clearSelection'); 
     123        this.events.triggerEvent('clearSelection'); 
    124124    }, 
    125125     
     
    129129    getSelection: function()  
    130130    { 
    131                 return new OpenLayers.Bounds(this.selectionForm.bboxW.value, 
    132                                      this.selectionForm.bboxS.value, 
    133                                      this.selectionForm.bboxE.value, 
    134                                      this.selectionForm.bboxN.value); 
    135     }, 
    136                  
    137         /** 
    138          * Update displayed coordinate selection - mapping to the 
    139          * bounding box displayed in the map layer 
    140          * NB, data is validated, to flip negative area selections, before being set 
    141          * 
    142          * @param bbox - openlayers bounds object 
    143          * @param noCascade - if false trigger a changeSelection event  
    144          */ 
     131        return new OpenLayers.Bounds(this.selectionForm.bboxW.value, 
     132                     this.selectionForm.bboxS.value, 
     133                     this.selectionForm.bboxE.value, 
     134                     this.selectionForm.bboxN.value); 
     135    }, 
     136         
     137    /** 
     138     * Update displayed coordinate selection - mapping to the 
     139     * bounding box displayed in the map layer 
     140     * NB, data is validated, to flip negative area selections, before being set 
     141     * 
     142     * @param bbox - openlayers bounds object 
     143     */ 
    145144    setSelection: function(bbox)  
    146145    { 
    147         //alert("Set selection bbox="+ bbox + " noCascade = " + noCascade); 
    148                 var old_b = this.getSelection(); 
    149  
    150                 // Validation.  negative tests required to catch NaN 
    151                 if (!(bbox.left >= -180.0 && bbox.left < 180.0)) 
    152                     bbox.left = old_b.left; 
    153  
    154                 if (!(bbox.right > -180.0 && bbox.right <= 180.0)) 
    155                     bbox.right = old_b.right; 
    156          
    157                 if (!(bbox.top > -90.0 && bbox.top <= 90.0)) 
    158                     bbox.top = old_b.top; 
    159          
    160                 if (!(bbox.bottom >= -90.0 && bbox.bottom < 90.0)) 
    161                     bbox.bottom = old_b.bottom; 
    162          
    163                 if (bbox.left > bbox.right)  
    164                 { 
    165                 var t = bbox.left;  
    166                 bbox.left = bbox.right;  
    167                 bbox.right = t; 
    168                 } 
    169          
    170                 if (bbox.bottom > bbox.top)  
    171                 { 
    172                 var t = bbox.bottom;  
    173                 bbox.bottom = bbox.top;  
    174                 bbox.top = t; 
    175                 } 
    176                  
    177                 this.selectionForm.bboxW.value = bbox.left.toFixed(1); 
    178                 this.selectionForm.bboxS.value = bbox.bottom.toFixed(1); 
    179                 this.selectionForm.bboxE.value = bbox.right.toFixed(1); 
    180                 this.selectionForm.bboxN.value = bbox.top.toFixed(1); 
     146        //alert("Set selection bbox="+ bbox + " noCascade = " + noCascade); 
     147        var old_b = this.getSelection(); 
     148 
     149        // Validation.  negative tests required to catch NaN 
     150        if (!(bbox.left >= -180.0 && bbox.left < 180.0)) 
     151            bbox.left = old_b.left; 
     152 
     153        if (!(bbox.right > -180.0 && bbox.right <= 180.0)) 
     154            bbox.right = old_b.right; 
     155     
     156        if (!(bbox.top > -90.0 && bbox.top <= 90.0)) 
     157            bbox.top = old_b.top; 
     158     
     159        if (!(bbox.bottom >= -90.0 && bbox.bottom < 90.0)) 
     160            bbox.bottom = old_b.bottom; 
     161     
     162        if (bbox.left > bbox.right)  
     163        { 
     164            var t = bbox.left;  
     165            bbox.left = bbox.right;  
     166            bbox.right = t; 
     167        } 
     168     
     169        if (bbox.bottom > bbox.top)  
     170        { 
     171            var t = bbox.bottom;  
     172            bbox.bottom = bbox.top;  
     173            bbox.top = t; 
     174        } 
     175         
     176        this.selectionForm.bboxW.value = bbox.left.toFixed(1); 
     177        this.selectionForm.bboxS.value = bbox.bottom.toFixed(1); 
     178        this.selectionForm.bboxE.value = bbox.right.toFixed(1); 
     179        this.selectionForm.bboxN.value = bbox.top.toFixed(1); 
    181180 
    182181    }, 
     
    186185     */ 
    187186    addMapSelectionChanged: function(events) { 
    188         events.register('MAP_SELECTION_CHANGED', this, this._onMapSelectionChanged);             
     187        events.register('MAP_SELECTION_CHANGED', this, this._onMapSelectionChanged);         
    189188    }, 
    190189     
     
    197196     */ 
    198197    _onMapSelectionChanged: function(e) { 
    199         this.setSelection(e.selection); 
     198        this.setSelection(e.selection); 
    200199    }, 
    201200     
  • cowsclient/branches/qesdi/cowsclient/public/js/layerParameters.js

    r5551 r5563  
    4444 
    4545LayerParameters.prototype = { 
    46          
    47         EVENTS_RAISED: ['LAYER_PROPERTY_CHANGED', 'CURRENT_WMCLAYER_CHANGED'], 
    48          
     46     
     47    EVENTS_RAISED: ['LAYER_PROPERTY_CHANGED', 'CURRENT_WMCLAYER_CHANGED'], 
     48     
    4949    onParamChange: function (e) { 
    5050 
     
    5555 
    5656        this.events.triggerEvent("LAYER_PROPERTY_CHANGED", {layer:this.currentOLLayer, 
    57                                                              wmcLayer:this.currentWMCLayer}); 
     57                                                         wmcLayer:this.currentWMCLayer}); 
    5858         
    5959    },     
     
    7474     */ 
    7575    onSelectedLayerChanged: function(e) { 
    76                  
     76                 
    7777        this.currentOLLayer = e.layer; 
    7878        this.currentWMCLayer = null; 
     
    113113         
    114114        //find the dimensions for the layer 
    115         var wmcLayer = this.searchSubLayers(wmc.getSubLayers()); 
     115        var wmcLayer = this.searchSubLayers(wmc.getSubLayers()); 
    116116        this.currentWMCLayer = wmcLayer; 
    117117        this.events.triggerEvent('CURRENT_WMCLAYER_CHANGED', {olLayer:this.currentOLLayer, 
     
    126126     */ 
    127127    searchSubLayers: function(subLayers){ 
    128         var wmcLayer = null; 
    129          
    130         for (var i=0; i<subLayers.length; i++) { 
    131                  
    132                         if (subLayers[i].getName() == this.currentOLLayer.params['LAYERS']){ 
    133                                 wmcLayer = subLayers[i]; 
    134                                 break; 
    135                         } 
    136                 } 
    137          
    138         return wmcLayer; 
     128        var wmcLayer = null; 
     129         
     130        for (var i=0; i<subLayers.length; i++) { 
     131            var layer = subLayers[i]; 
     132             
     133            if (layer.getName() == this.currentOLLayer.params['LAYERS']){ 
     134                wmcLayer = layer; 
     135                break; 
     136            } 
     137             
     138            // the desired layer may be a child of this layer so search any sublayers 
     139            if (layer.getSubLayers().length > 0) { 
     140                wmcLayer = this.searchSubLayers(layer.getSubLayers()); 
     141                 
     142                if (wmcLayer != null) { 
     143                    break; 
     144                } 
     145            } 
     146             
     147                 
     148             
     149        } 
     150         
     151        return wmcLayer; 
    139152    }, 
    140153 
  • cowsclient/branches/qesdi/cowsclient/public/js/mapControl.js

    r5557 r5563  
    1414WMSC.VisApp.prototype =  
    1515{ 
    16         EVENT_TYPES: ['MAP_SELECTION_CHANGED'], 
    17          
     16    EVENT_TYPES: ['MAP_SELECTION_CHANGED'], 
     17     
    1818    /** 
    1919     * Constructor to set up object 
     
    2525     * @param showCoast - true - display coastline, otherwise not 
    2626     */ 
    27     initialize: function(div, numZoomLevels, mapWidth, showCoast)  
    28     { 
    29                 this.figureCounter = 1; 
    30                 this.showCoast = showCoast; 
    31  
    32                 this.events = new OpenLayers.Events(this, div, this.EVENT_TYPES);                
    33                  
    34                 // NB, can't override both numZoomLevels and minResolution with 
    35                 // the current OpenLayers code.  Instead calculate resolutions 
    36                 // directly. 
    37                 var maxResolution = 360.0 / mapWidth; 
    38                 var resolutions = new Array(); 
    39                 for (var i=0; i < numZoomLevels; i++)  
    40                 { 
    41                 resolutions.push(maxResolution / Math.pow(1.4, i)); 
    42                 } 
    43  
    44                 // set up the map control 
    45                 this.map = new DDCVisMap(div,  
    46                         {  
    47                         resolutions: resolutions, 
    48                         controls: [] 
    49                     } 
    50                 ); 
    51                  
    52                 this.boxesLayer = new OpenLayers.Layer.Boxes("Sub-selection"); 
    53  
    54                 this.subselControl = new SubSelectionMouseToolbar(new OpenLayers.Pixel(mapWidth-40,10), 
    55                                                    'vertical', this.boxesLayer); 
    56  
    57                 this.map.addControl(new OpenLayers.Control.PanZoomBar()); 
    58                 this.map.addControl(this.subselControl); 
    59                 this.map.addControl(new OpenLayers.Control.MousePosition()); 
    60  
    61                  
    62             this.baseLayer = new OpenLayers.Layer.WMS( 
    63                     "Coastline", 
    64                     "http://localhost:5000/coastwms", 
    65                     { layers: 'l', format: 'image/png', transparent: 'false' } 
    66                 ); 
    67              
    68 //          var lyrBaseClear = new OpenLayers.Layer.Image( 
    69 //                      "None", 
    70 //                      '../layout/images/clear.gif', 
    71 //                      new OpenLayers.Bounds(-180,-90,180,90), 
    72 //                      new OpenLayers.Size(8, 8), 
    73 //                      {isBaseLayer: true} 
    74 //              ); 
    75 //          this.baseLayer = lyrBaseClear; 
    76              
    77              
    78             this.map.addLayer(this.baseLayer); 
    79             this.map.setLayerIndex(this.baseLayer, 0); 
    80              
    81             this.map.addLayer(this.boxesLayer); 
    82             this.map.setLayerIndex(this.boxesLayer, 1); 
    83              
    84                  
    85 //              // Setup the map - initially with the basic openlayers map + coastline + boxes 
    86 //              this.updateVisLayer(); 
    87  
    88                 this.maxExtent = new OpenLayers.Bounds(-180,-90,180,90); 
    89                 this.map.zoomToExtent(this.maxExtent);   
    90                  
    91                 this.map.zoom = 0; 
    92                  
    93                 // force the resolution to be set, this is needed so that layers added 
    94                 // retain the correct bounds. 
    95                 WMSC.log("this.map.maxExtent: bottom=" + this.map.maxExtent.bottom +" left=" + this.map.maxExtent.left + " top=" + this.map.maxExtent.top + " right="+ this.map.maxExtent.right); 
    96                 WMSC.log("this.map.zoom = " + this.map.zoom); 
    97                 this.map.resolution = this.map.getResolutionForZoom(this.map.zoom); 
    98                 WMSC.log("this.map.resolution = " + this.map.resolution); 
    99              
    100                 // Enter selection mode 
    101                 this.subselControl.switchModeTo('zoombox'); 
    102                  
    103     }, 
    104      
    105           /** 
    106           * Specify a dimension control to use with the map 
    107           * @param dimControl - a suitable dimension control 
    108           * - this must include an attribute, wmsParams and a method 
    109           * getSelection retuning an OpenLayers.Bounds object 
    110           */ 
    111          addBoundsControl: function(control) 
    112          { 
    113                 this.boundsControl = control; 
    114                 this.boundsControl.events.register('TEXT_SELECTION_CHANGED', this, this.updateSelectionBox); 
    115                 this.boundsControl.events.register('changeWMS', this, this.updateVisLayer); 
    116                 this.boundsControl.events.register('clearSelection', this, this.resetMapCoords); 
    117          
    118                 this.map.events.register('moveend', this, this.updateBoundsControl); 
    119                 this.map.events.register('zoomend', this, this.updateBoundsBoundsControl); 
    120          },     
    121      
    122  
     27    initialize: function(div, numZoomLevels, mapWidth, showCoast,  
     28                         baseLayerURL, baseLayerParams )  
     29    { 
     30        this.figureCounter = 1; 
     31        this.showCoast = showCoast; 
     32 
     33        this.events = new OpenLayers.Events(this, div, this.EVENT_TYPES);         
     34         
     35        // NB, can't override both numZoomLevels and minResolution with 
     36        // the current OpenLayers code.  Instead calculate resolutions 
     37        // directly. 
     38        var maxResolution = 360.0 / mapWidth; 
     39        var resolutions = new Array(); 
     40        for (var i=0; i < numZoomLevels; i++)  
     41        { 
     42            resolutions.push(maxResolution / Math.pow(1.4, i)); 
     43        } 
     44 
     45        // set up the map control 
     46        this.map = new DDCVisMap(div,  
     47            {  
     48                resolutions: resolutions, 
     49                controls: [] 
     50            } 
     51        ); 
     52         
     53        this.boxesLayer = new OpenLayers.Layer.Boxes("Sub-selection"); 
     54 
     55        this.subselControl = new SubSelectionMouseToolbar(new OpenLayers.Pixel(mapWidth-40,10), 
     56                           'vertical', this.boxesLayer); 
     57 
     58        this.map.addControl(new OpenLayers.Control.PanZoomBar()); 
     59        this.map.addControl(this.subselControl); 
     60        this.map.addControl(new OpenLayers.Control.MousePosition()); 
     61 
     62        //Force no transparency 
     63        baseLayerParams.transparent = false; 
     64         
     65        this.baseLayer = new OpenLayers.Layer.WMS( 
     66                'BaseLayer', 
     67                baseLayerURL, 
     68                baseLayerParams ); 
     69         
     70//        var lyrBaseClear = new OpenLayers.Layer.Image( 
     71//                "None", 
     72//                '../layout/images/clear.gif', 
     73//                new OpenLayers.Bounds(-180,-90,180,90), 
     74//                new OpenLayers.Size(8, 8), 
     75//                {isBaseLayer: true} 
     76//            ); 
     77//        this.baseLayer = lyrBaseClear; 
     78         
     79         
     80        this.map.addLayer(this.baseLayer); 
     81        this.map.setLayerIndex(this.baseLayer, 0); 
     82         
     83        this.map.addLayer(this.boxesLayer); 
     84        this.map.setLayerIndex(this.boxesLayer, 1); 
     85         
     86         
     87//        // Setup the map - initially with the basic openlayers map + coastline + boxes 
     88//        this.updateVisLayer(); 
     89 
     90        this.maxExtent = new OpenLayers.Bounds(-180,-90,180,90); 
     91        this.map.zoomToExtent(this.maxExtent);     
     92         
     93        this.map.zoom = 0; 
     94         
     95        // force the resolution to be set, this is needed so that layers added 
     96        // retain the correct bounds. 
     97        this.map.resolution = this.map.getResolutionForZoom(this.map.zoom); 
     98        WMSC.log("this.map.maxExtent: bottom=" + this.map.maxExtent.bottom +" left=" + this.map.maxExtent.left + " top=" + this.map.maxExtent.top + " right="+ this.map.maxExtent.right); 
     99        WMSC.log("this.map.zoom = " + this.map.zoom);         
     100        WMSC.log("this.map.resolution = " + this.map.resolution); 
     101         
     102        // Enter selection mode 
     103        this.subselControl.switchModeTo('zoombox'); 
     104         
     105    }, 
     106     
     107      /** 
     108      * Specify a dimension control to use with the map 
     109      * @param dimControl - a suitable dimension control 
     110      * - this must include an attribute, wmsParams and a method 
     111      * getSelection retuning an OpenLayers.Bounds object 
     112      */ 
     113     addBoundsControl: function(control) 
     114     { 
     115         this.boundsControl = control; 
     116        this.boundsControl.events.register('TEXT_SELECTION_CHANGED', this, this.updateSelectionBox); 
     117        this.boundsControl.events.register('changeWMS', this, this.updateVisLayer); 
     118        this.boundsControl.events.register('clearSelection', this, this.resetMapCoords); 
     119      
     120        this.map.events.register('moveend', this, this.updateBoundsControl); 
     121        this.map.events.register('zoomend', this, this.updateBoundsBoundsControl); 
     122     },     
     123     
     124    updateBoundsBoundsControl: function(events) { 
     125         WMSC.log("updateBoundsBoundsControl"); 
     126         
     127         WMSC.log("this.map.maxExtent: bottom=" + this.map.maxExtent.bottom +" left=" + this.map.maxExtent.left + " top=" + this.map.maxExtent.top + " right="+ this.map.maxExtent.right); 
     128         WMSC.log("this.map.zoom = " + this.map.zoom);         
     129         WMSC.log("this.map.resolution = " + this.map.resolution); 
     130    }, 
    123131 
    124132    addLayersHandlers: function (events) { 
     
    127135 
    128136    onLayerOrderChanged: function (e) { 
    129         this.drawLayers(e.layers); 
     137        this.drawLayers(e.layers); 
    130138    }, 
    131139     
     
    134142    destroy: function()  
    135143    { 
    136         if (this.dimControl) 
    137                 this.dimControl.destroy(); 
    138  
    139                 if (this.layerControl) 
    140                         this.layerControl.destroy(); 
    141                 this.subselControl.destroy(); 
    142     }, 
    143  
    144         /** 
    145         * Set up coast layer using the specified layer name 
    146         */ 
     144        if (this.dimControl) 
     145            this.dimControl.destroy(); 
     146 
     147        if (this.layerControl) 
     148            this.layerControl.destroy(); 
     149        this.subselControl.destroy(); 
     150    }, 
     151 
     152    /** 
     153    * Set up coast layer using the specified layer name 
     154    */ 
    147155    _initCoast: function(layerName)  
    148156    { 
    149                 // check if coast layer is loaded or if a different coast layer has been specified; reload, if so 
    150         if (!this.coastLayer || this.coastLayer.params.LAYERS != layerName)  
    151         { 
    152                         this.coastLayer = new OpenLayers.Layer.WMS("Coastline", 
    153                                            "http://labs.metacarta.com/wms/vmap0", 
    154                                            {layers: layerName, format: 'image/gif', 
    155                                             transparent: 'true'}); 
    156         } 
    157                 this.map.addLayer(this.coastLayer); 
    158     }, 
    159  
    160         /** 
    161         * Determine whether any layers have been added to the layerlist; if so, add these one by one 
    162         * to the map 
    163         * NB, the layers are initially removed to ensure they are not duplicated 
    164         */ 
     157        // check if coast layer is loaded or if a different coast layer has been specified; reload, if so 
     158        if (!this.coastLayer || this.coastLayer.params.LAYERS != layerName)  
     159        { 
     160            this.coastLayer = new OpenLayers.Layer.WMS("Coastline", 
     161                       "http://labs.metacarta.com/wms/vmap0", 
     162                       {layers: layerName, format: 'image/gif', 
     163                        transparent: 'true'}); 
     164        } 
     165        this.map.addLayer(this.coastLayer); 
     166    }, 
     167 
     168    /** 
     169    * Determine whether any layers have been added to the layerlist; if so, add these one by one 
     170    * to the map 
     171    * NB, the layers are initially removed to ensure they are not duplicated 
     172    */ 
    165173    updateVisLayer: function()  
    166174    { 
    167                  
    168         // firstly, remove any existing layers 
    169         j = this.map.getNumLayers(); 
    170                 for (var i = 0; i < j; i++) 
    171                 { 
    172                 this.map.removeLayer(this.map.layers[0]); 
    173                 } 
    174                  
    175         // Setup an initial baselayer - NB, without this, the transparent layers will not display 
    176         if (!this.visLayer) 
    177         { 
    178                 this.visLayer = new OpenLayers.Layer.WMS("OpenLayers WMS", 
    179                              "http://labs.metacarta.com/wms/vmap0", 
    180                              {layers: 'basic',format: 'image/png'}); 
    181                          
    182                         // add extra parameters, if specified by layer control 
    183                         this._mergeDimParams(this.visLayer); 
    184         } 
    185          
    186                 this.map.addLayer(this.visLayer); 
    187                  
    188                 // retrieve the elements of the layer list and add these to the map 
    189                 layerList = document.getElementById("layerlist"); 
    190  
    191                 if (layerList != null) { 
    192                         //Changed by domlowe: reversed the order these layers are added to the map. Dragging and dropping the 
    193                         // layer you want to be on top to the bottom of the list was counter intuitive. 
    194                         //old code: 
    195                         //for (var i = 0; layerList && i < layerList.childNodes.length; i++) 
    196                         //now in revese order: 
    197                         for (var i=layerList.childNodes.length-1; layerList && i>=0; i--) 
    198                         { 
    199                                 child = layerList.childNodes[i]; 
    200                                 // ignore any hidden list values 
    201                                 if (child.className == "hiddenList") 
    202                                         continue; 
    203                                  
    204                                 if (child.nodeName == "LI") 
    205                                 { 
    206                                         // extract the required info and load the map 
    207                                         // NB, these values are set in the layerControl._updateLeafLayer() method 
    208                                         // NB, for transparancy to be fully supported, the format must be gif 
    209                                         // - png is only partially supported and jpg not at all 
    210                                         endpoint = child.getAttribute("wmcURL"); 
    211                                         title = child.getAttribute("title"); 
    212                                         layerName = child.getAttribute("layerName"); 
    213  
    214                                 mapLayer = new OpenLayers.Layer.WMS( 
    215                                                         title, 
    216                                                         endpoint, 
    217                                                              {format: 'image/gif', 
    218                                                               version: '1.3.0',  
    219                                                               CRS: 'CRS:84', 
    220                                                               layers: layerName, 
    221                                                               styles:'', 
    222                                                           transparent: 'true' 
    223                                                              }); 
    224                                         // add extra parameters, if specified by layer control 
    225                                         this._mergeDimParams(mapLayer); 
    226                                 this.map.addLayer(mapLayer); 
    227                                 } 
    228                         } 
    229                 } 
    230                          
    231                 // add the coast outline, if required 
    232         if (this.showCoast) 
    233                 this._initCoast('coastline_01'); 
    234  
    235                 // add layer to represent the subselection box on the layer              
    236                 this.map.addLayer(this.boxesLayer); 
    237                  
    238                 // if there is legend data available, display this under the map 
    239                 this.loadLegend(); 
     175         
     176        // firstly, remove any existing layers 
     177        j = this.map.getNumLayers(); 
     178        for (var i = 0; i < j; i++) 
     179        { 
     180            this.map.removeLayer(this.map.layers[0]); 
     181        } 
     182         
     183        // Setup an initial baselayer - NB, without this, the transparent layers will not display 
     184        if (!this.visLayer) 
     185        { 
     186            this.visLayer = new OpenLayers.Layer.WMS("OpenLayers WMS", 
     187                 "http://labs.metacarta.com/wms/vmap0", 
     188                 {layers: 'basic',format: 'image/png'}); 
     189             
     190            // add extra parameters, if specified by layer control 
     191            this._mergeDimParams(this.visLayer); 
     192           } 
     193         
     194        this.map.addLayer(this.visLayer); 
     195         
     196        // retrieve the elements of the layer list and add these to the map 
     197        layerList = document.getElementById("layerlist"); 
     198 
     199        if (layerList != null) { 
     200            //Changed by domlowe: reversed the order these layers are added to the map. Dragging and dropping the 
     201            // layer you want to be on top to the bottom of the list was counter intuitive. 
     202            //old code: 
     203            //for (var i = 0; layerList && i < layerList.childNodes.length; i++) 
     204            //now in revese order: 
     205            for (var i=layerList.childNodes.length-1; layerList && i>=0; i--) 
     206            { 
     207                child = layerList.childNodes[i]; 
     208                // ignore any hidden list values 
     209                if (child.className == "hiddenList") 
     210                    continue; 
     211                 
     212                if (child.nodeName == "LI") 
     213                { 
     214                    // extract the required info and load the map 
     215                    // NB, these values are set in the layerControl._updateLeafLayer() method 
     216                    // NB, for transparancy to be fully supported, the format must be gif 
     217                    // - png is only partially supported and jpg not at all 
     218                    endpoint = child.getAttribute("wmcURL"); 
     219                    title = child.getAttribute("title"); 
     220                    layerName = child.getAttribute("layerName"); 
     221 
     222                    mapLayer = new OpenLayers.Layer.WMS( 
     223                                title, 
     224                                endpoint, 
     225                                 {format: 'image/gif', 
     226                                  version: '1.3.0',  
     227                                  CRS: 'CRS:84', 
     228                                  layers: layerName, 
     229                                  styles:'', 
     230                                  transparent: 'true' 
     231                                 }); 
     232                    // add extra parameters, if specified by layer control 
     233                    this._mergeDimParams(mapLayer); 
     234                       this.map.addLayer(mapLayer); 
     235                } 
     236            } 
     237        } 
     238             
     239        // add the coast outline, if required 
     240        if (this.showCoast) 
     241            this._initCoast('coastline_01'); 
     242 
     243        // add layer to represent the subselection box on the layer         
     244        this.map.addLayer(this.boxesLayer); 
     245         
     246        // if there is legend data available, display this under the map 
     247        this.loadLegend(); 
    240248    }, 
    241249     
     
    247255    _mergeDimParams: function(mapLayer) 
    248256    { 
    249         if (this.dimControl && this.dimControl.wmsParams) 
    250         { 
    251                         mapLayer.mergeNewParams(this.dimControl.wmsParams); 
    252         } 
    253                 mapLayer.setZIndex(300); 
    254     },   
    255  
    256         /** 
    257         * Reset the map to display the full global bounds - and update 
    258         * the coordinate selections to reflect this 
    259         */ 
     257        if (this.dimControl && this.dimControl.wmsParams) 
     258        { 
     259            mapLayer.mergeNewParams(this.dimControl.wmsParams); 
     260        } 
     261        mapLayer.setZIndex(300); 
     262    },     
     263 
     264    /** 
     265    * Reset the map to display the full global bounds - and update 
     266    * the coordinate selections to reflect this 
     267    */ 
    260268    resetMapCoords: function()  
    261269    { 
    262 //      alert("resetMapCoords"); 
    263                 this.subselControl.deactivateSubsel(); 
    264                 this.map.zoomToExtent(this.maxExtent); 
    265                 this.updateBoundsControl(); 
    266     }, 
    267  
    268         /** 
    269         * Check if a legend element is available; if so, check 
    270         * if the topmost layer isn't a default one; if so, attempt 
    271         * to load and display legend data for this layer 
    272         */ 
     270        WMSC.log("resetMapCoords"); 
     271        this.subselControl.deactivateSubsel(); 
     272        this.map.zoomToExtent(this.maxExtent); 
     273        this.updateBoundsControl(); 
     274    }, 
     275 
     276    /** 
     277    * Check if a legend element is available; if so, check 
     278    * if the topmost layer isn't a default one; if so, attempt 
     279    * to load and display legend data for this layer 
     280    */ 
    273281    loadLegend: function()  
    274282    { 
    275         var legend = $('legend'); 
    276         if (!legend) 
    277                 return; 
    278                  
    279                 var setLegend = function (xhr)  
    280                 { 
    281                 $('legend').innerHTML = ''; 
    282                 var legendHTML =xhr.responseText; 
    283                         if (legendHTML) 
    284                         $('legend').innerHTML = legendHTML; 
    285                 }; 
    286  
    287                 var failure = function (xhr)  
    288                 { 
    289                 //alert('Error: could not load legend data for the last selected layer.'); 
    290                 }; 
    291  
    292                 // set the legend to be the topmost layer that has been picked 
    293                 // NB, there are initially three layers - for the subselection box, coastline and base map 
    294                 // - so ignore legend if only three layers 
    295                 var layerNo = this.map.layers.length; 
    296                 if (layerNo < 4) 
    297                 { 
    298                 legend.innerHTML = ''; 
    299                         return; 
    300                 } 
    301                          
    302                 var topLayer = this.map.layers[layerNo - 3]; 
    303                  
    304                 if (topLayer.url == null)  
    305                 { 
    306                 legend.innerHTML = ''; 
    307                 } 
    308                 else  
    309                 { 
    310                 var url = topLayer.getFullRequestString({ 
    311                                 REQUEST: 'GetLegend', 
    312                                 //FORMAT: 'text/html' 
    313                 }); 
    314  
    315                         var params = {REQUEST: 'GetLegend', 
    316                                           ENDPOINT: url}; 
    317                  
    318                 new Ajax.Request('',  
    319                                 {parameters: params, 
    320                         method: "get", 
    321                         onSuccess: setLegend.bindAsEventListener(this), 
    322                         onFailure: failure.bindAsEventListener(this) 
    323                                 }); 
    324                 } 
     283        var legend = $('legend'); 
     284        if (!legend) 
     285            return; 
     286             
     287        var setLegend = function (xhr)  
     288        { 
     289            $('legend').innerHTML = ''; 
     290            var legendHTML =xhr.responseText; 
     291            if (legendHTML) 
     292                $('legend').innerHTML = legendHTML; 
     293        }; 
     294 
     295        var failure = function (xhr)  
     296        { 
     297            //alert('Error: could not load legend data for the last selected layer.'); 
     298        }; 
     299 
     300        // set the legend to be the topmost layer that has been picked 
     301        // NB, there are initially three layers - for the subselection box, coastline and base map 
     302        // - so ignore legend if only three layers 
     303        var layerNo = this.map.layers.length; 
     304        if (layerNo < 4) 
     305        { 
     306            legend.innerHTML = ''; 
     307            return; 
     308        } 
     309             
     310        var topLayer = this.map.layers[layerNo - 3]; 
     311         
     312        if (topLayer.url == null)  
     313        { 
     314            legend.innerHTML = ''; 
     315        } 
     316        else  
     317        { 
     318            var url = topLayer.getFullRequestString({ 
     319                REQUEST: 'GetLegend', 
     320                //FORMAT: 'text/html' 
     321            }); 
     322 
     323            var params = {REQUEST: 'GetLegend', 
     324                      ENDPOINT: url}; 
     325             
     326            new Ajax.Request('',  
     327                {parameters: params, 
     328                method: "get", 
     329                onSuccess: setLegend.bindAsEventListener(this), 
     330                onFailure: failure.bindAsEventListener(this) 
     331                }); 
     332        } 
    325333    }, 
    326334 
     
    332340    updateBoundsControl: function()  
    333341    { 
    334 //      alert("UpdateBoundsControl"); 
    335                 var b = this.subselControl.getActiveBounds(); 
    336                  
    337                 WMSC.log("triggering MAP_SELECTION_CHANGED, selection = " + b); 
    338                 this.events.triggerEvent('MAP_SELECTION_CHANGED', {selection:b}); 
    339                  
    340 //              // Switch to higerres coasts if needed 
    341 //              var coastLayer = 'coastline_01'; 
    342 //              if (this.map.getZoom() > 5) 
    343 //                  coastLayer = 'coastline_02'; 
    344 //       
    345 //              if (this.showCoast && this.coastLayer.params.LAYERS != coastLayer)  
    346 //              { 
    347 //              this._initCoast(coastLayer); 
    348 //              } 
    349     }, 
    350  
    351         /** 
    352          * Update the selection box displayed on the map 
    353          * - taking the values from the input coord control 
    354          */ 
     342//        alert("UpdateBoundsControl"); 
     343        var b = this.subselControl.getActiveBounds(); 
     344         
     345 
     346 
     347        WMSC.log("triggering MAP_SELECTION_CHANGED, selection = " + b); 
     348        this.events.triggerEvent('MAP_SELECTION_CHANGED', {selection:b}); 
     349         
     350//        // Switch to higerres coasts if needed 
     351//        var coastLayer = 'coastline_01'; 
     352//        if (this.map.getZoom() > 5) 
     353//            coastLayer = 'coastline_02'; 
     354//     
     355//        if (this.showCoast && this.coastLayer.params.LAYERS != coastLayer)  
     356//        { 
     357//            this._initCoast(coastLayer); 
     358//        } 
     359    }, 
     360 
     361    /** 
     362     * Update the selection box displayed on the map 
     363     * - taking the values from the input coord control 
     364     */ 
    355365    updateSelectionBox: function(e)  
    356366    { 
    357         WMSC.log("started update selection box"); 
    358          
    359                 var old_b = this.subselControl.getActiveBounds(); 
    360                 var new_b = e.selection; 
    361                  
    362                 // Validation.  negative tests required to catch NaN 
    363                 if (!(new_b.left > -180.0 && new_b.left < 180.0))  
    364                 { 
    365                 new_b.left = old_b.left; 
    366                 } 
    367                 if (!(new_b.right > -180.0 && new_b.right < 180.0))  
    368                 { 
    369                 new_b.right = old_b.right; 
    370                 } 
    371                 if (!(new_b.top > -90.0 && new_b.top < 90.0))  
    372                 { 
    373                 new_b.top = old_b.top; 
    374                 } 
    375                 if (!(new_b.bottom > -90.0 && new_b.bottom < 90.0))  
    376                 { 
    377                 new_b.bottom = old_b.bottom; 
    378                 } 
    379                 if (new_b.left > new_b.right)  
    380                 { 
    381                 var t = new_b.left;  
    382                 new_b.left = new_b.right;  
    383                 new_b.right = t; 
    384                 } 
    385                 if (new_b.bottom > new_b.top)  
    386                 { 
    387                 var t = new_b.bottom;  
    388                 new_b.bottom = new_b.top;  
    389                 new_b.top = t; 
    390                 } 
    391                  
    392                 // this command triggers the moveend map event. 
    393                 this.subselControl.setSubSel(new_b); 
    394                 WMSC.log("finished update selection box"); 
     367        WMSC.log("started update selection box"); 
     368         
     369        var old_b = this.subselControl.getActiveBounds(); 
     370        var new_b = e.selection; 
     371         
     372        // Validation.  negative tests required to catch NaN 
     373        if (!(new_b.left > -180.0 && new_b.left < 180.0))  
     374        { 
     375            new_b.left = old_b.left; 
     376        } 
     377        if (!(new_b.right > -180.0 && new_b.right < 180.0))  
     378        { 
     379            new_b.right = old_b.right; 
     380        } 
     381        if (!(new_b.top > -90.0 && new_b.top < 90.0))  
     382        { 
     383            new_b.top = old_b.top; 
     384        } 
     385        if (!(new_b.bottom > -90.0 && new_b.bottom < 90.0))  
     386        { 
     387            new_b.bottom = old_b.bottom; 
     388        } 
     389        if (new_b.left > new_b.right)  
     390        { 
     391            var t = new_b.left;  
     392            new_b.left = new_b.right;  
     393            new_b.right = t; 
     394        } 
     395        if (new_b.bottom > new_b.top)  
     396        { 
     397            var t = new_b.bottom;  
     398            new_b.bottom = new_b.top;  
     399            new_b.top = t; 
     400        } 
     401         
     402        // this command triggers the moveend map event. 
     403        this.subselControl.setSubSel(new_b); 
     404        WMSC.log("finished update selection box"); 
    395405    }, 
    396406 
     
    398408 
    399409    drawLayers: function (layers) { 
    400          
    401          
    402          
    403          
     410         
     411         
     412         
     413         
    404414        //remove the old layers 
    405415        if (this.map.layers.length > 0) { 
    406                  
    407                 var removeLayers = []; 
     416             
     417            var removeLayers = []; 
    408418            for (var i=0; i<this.map.layers.length; i++) { 
    409                 if (this.map.layers[i] != this.baseLayer && 
    410                     this.map.layers[i] != this.boxesLayer) { 
    411                         removeLayers.push(this.map.layers[i]); 
    412                 } 
     419                if (this.map.layers[i] != this.baseLayer && 
     420                    this.map.layers[i] != this.boxesLayer) { 
     421                    removeLayers.push(this.map.layers[i]); 
     422                } 
    413423            } 
    414424             
    415425            for (var i=0; i<removeLayers.length; i++) { 
    416                 layer = removeLayers[i]; 
     426                layer = removeLayers[i]; 
    417427                //alert("Removing layer id=" + layer.id + " name=" + layer.name); 
    418428                this.map.removeLayer(layer); 
  • cowsclient/branches/qesdi/development.ini

    r5551 r5563  
    1919use = egg:cowsclient 
    2020full_stack = true 
     21#cache_dir = %(here)s/data 
    2122cache_dir = /data/pnorton/ui_cache/  
    2223beaker.session.key = cowsclient 
     
    2425serverurl=http://localhost:5005 
    2526 
     27#baselayer.url = http://labs.metacarta.com/wms/vmap0 
     28#baselayer.params = layers:coastline_01,format:image/png 
     29#baselayer.params = layers:basic,format:image/png 
     30 
     31baselayer.url = http://localhost:5000/coastwms 
     32baselayer.params = layers:l,format:image/png 
     33 
    2634 
    2735# If you'd like to fine-tune the individual locations of the cache data dirs 
    2836# for the Cache data, or the Session saves, un-comment the desired settings 
    2937# here: 
     38#beaker.cache.data_dir = %(here)s/data/cache 
     39#beaker.session.data_dir = %(here)s/data/sessions 
     40 
    3041beaker.cache.data_dir = /data/pnorton/beaker_cache_ui 
    3142beaker.session.data_dir = /data/pnorton/beaker_session_ui 
     
    3445# Debug mode will enable the interactive debugging tool, allowing ANYONE to 
    3546# execute malicious code after an exception is raised. 
    36 set debug = false 
     47# set debug = false 
    3748 
    3849 
     
    6576format = %(asctime)s,%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s 
    6677datefmt = %H:%M:%S 
     78 
Note: See TracChangeset for help on using the changeset viewer.