Changeset 5979 for cowsclient


Ignore:
Timestamp:
09/11/09 12:07:07 (10 years ago)
Author:
pnorton
Message:

Modified the wcsdown client to accept multiple base layers to re-create the old layer now that the coastwms endpoint has split the outline and landmass into different layers.

Also moved some of the generic display options (like style select) into the display option box rather than the layer info box on the wmsviz page.

Location:
cowsclient/trunk
Files:
2 added
7 edited

Legend:

Unmodified
Added
Removed
  • cowsclient/trunk/cowsclient/controllers/wcsdown.py

    r5836 r5979  
    1919from cowsclient.model.date_time_options import DateTimeOptionsBuilder 
    2020from cowsclient.lib.wmc_util import parseEndpointString 
     21 
     22from cowsclient.lib.layer_config_parser import LayerConfigParser 
    2123 
    2224log = logging.getLogger(__name__) 
     
    9799        g.server=config['app_conf']['serverurl'] 
    98100         
    99         params = {} 
    100         for paramString in config['download_baselayer.params'].split(','): 
    101             key, value = paramString.split(':') 
    102             params[key] = value 
    103          
    104         baseLayerObj = {"url":config['download_baselayer.url'], "params": params } 
    105          
    106         c.baseLayerJSON = utils.toJSON(baseLayerObj)  
     101#        params = {} 
     102#        for paramString in config['download_baselayer.params'].split(','): 
     103#            key, value = paramString.split(':') 
     104#            params[key] = value 
     105#         
     106#        baseLayerObj = {"url":config['download_baselayer.url'], "params": params } 
     107#        buildLayerJSONFromConfig 
     108 
     109        lp = LayerConfigParser(config['outline_layers_file']) 
     110         
     111        layersList = lp.buildLayers('wcsdown') 
     112         
     113        c.baseLayerJSON = utils.toJSON(layersList)  
    107114         
    108115        log.debug("rendering template after %ss" % (time.time() - st,)) 
  • cowsclient/trunk/cowsclient/lib/display_options_config.py

    r5836 r5979  
    2020 
    2121    def build(self): 
    22          
     22 
    2323        self._config.read(self.filePath) 
    2424         
  • cowsclient/trunk/cowsclient/public/js/boundingBoxMapSelect.js

    r5842 r5979  
    66 * @param inputElementId     - the input element that the bbox value will be set in 
    77 */ 
    8 var BoundingBoxMapSelect= function (mapContainerId, controlContainerId, coastlineURL, coastlineParams, inputElementId, stringContainerId) { 
     8var BoundingBoxMapSelect= function (mapContainerId, controlContainerId, baseLayerData, inputElementId, stringContainerId) { 
    99     
    1010    this.events = new OpenLayers.Events(this, null, this.EVENT_TYPES);           
     
    2020         
    2121        var inputValue = document.getElementById(this.inputElementId).value; 
     22         
    2223        if (inputValue !== null && inputValue !== '') { 
    2324            this._bbox = this._getBoundsFromString(inputValue); 
     
    2526    } 
    2627     
    27     this._buildMap(coastlineURL, coastlineParams); 
     28    this._buildMap(baseLayerData); 
    2829    this._buildBoundsControl(); 
    2930    this._updateBBoxString(); 
     
    5051    '</div>\n', 
    5152     
    52     _buildMap: function (coastlineURL, coastlineParams) { 
     53    _buildMap: function (baseLayerData) { 
    5354        // couldn't get the sub-selection to work with the default controls 
    5455        this.map = new OpenLayers.Map('map', {controls:[]}); 
     
    5758        this.map.addControl(new OpenLayers.Control.MousePosition()); 
    5859     
    59         //as it is a baselayer mustn't be transparent 
    60         coastlineParams.transparent = 'false'; 
    61          
    62         var baseLayer = new OpenLayers.Layer.WMS( 
    63                 "Coastline", 
    64                 coastlineURL, 
    65                 coastlineParams, 
    66                 { isBaseLayer: true, maxResolution:"auto", numZoomLevels:5} 
    67         ); 
    68      
    69          
    70         this.map.addLayer(baseLayer); 
     60        // use a transparent baselayer if there are none specified 
     61        if (baseLayerData === null) { 
     62            var baseLayer =  new OpenLayers.Layer.Image( 
     63                    "None", 
     64                    '../layout/images/clear.gif', 
     65                    new OpenLayers.Bounds(-180, -90, 180, 90), 
     66                    new OpenLayers.Size(8, 8), 
     67                    { isBaseLayer: true, maxResolution:"auto", numZoomLevels:5} 
     68                ); 
     69             
     70            this.map.addLayer(baseLayer); 
     71        } 
     72        else { 
     73             
     74            for (i = 0; i < baseLayerData.length; i++) { 
     75                layerData = baseLayerData[i]; 
     76                 
     77                //this is the 'real' baselayer, the others are just for decoration 
     78                if (i === 0) { 
     79                    layerData.params.transparent = 'false'; 
     80                     
     81                    var layer = new OpenLayers.Layer.WMS( 
     82                            "BaseLayer_" + i, 
     83                            layerData.url, 
     84                            layerData.params, 
     85                            { isBaseLayer: true, maxResolution:"auto", numZoomLevels:5} 
     86                    ); 
     87                    var baseLayer = layer; 
     88                } 
     89                else { 
     90                    var layer = new OpenLayers.Layer.WMS( 
     91                            "BaseLayer_" + i, 
     92                            layerData.url, 
     93                            layerData.params, 
     94                            {maxResolution:"auto", numZoomLevels:5} 
     95                    ); 
     96                } 
     97                 
     98 
     99                 
     100                this.map.addLayer(layer); 
     101                                           
     102            } 
     103             
     104        } 
     105         
     106         
     107//        coastlineParams.transparent = 'false'; 
     108//         
     109//        var baseLayer = new OpenLayers.Layer.WMS( 
     110//                "Coastline", 
     111//                coastlineURL, 
     112//                coastlineParams, 
     113//                { isBaseLayer: true, maxResolution:"auto", numZoomLevels:5} 
     114//        ); 
     115//     
     116//         
     117//        this.map.addLayer(baseLayer); 
    71118         
    72119        this.map.zoomToMaxExtent(); 
  • cowsclient/trunk/cowsclient/public/js/layerDisplayOptions.js

    r5776 r5979  
    4646        var target = e.target || e.srcElement; 
    4747 
    48         var param = target.id.substr(7); 
     48        var param = target.id.substr(7);         
    4949        var value = target.value; 
    5050         
     
    6666     */ 
    6767    _onLayerStyleChanged: function (style) { 
    68         this._buildDisplayControls(this.currentWMCLayer); 
     68        this._buildDisplayControls(); 
    6969    }, 
    7070     
     
    7979         
    8080        if (e.wmcLayer !== null && e.olLayer !== null) { 
    81             this._buildDisplayControls(e.wmcLayer); 
     81            this._buildDisplayControls(); 
    8282        } 
    8383         
     
    8787     * Rebuilds all of the display option controls given by the layer 
    8888     */ 
    89     _buildDisplayControls: function (wmcLayer) { 
     89    _buildDisplayControls: function () { 
    9090 
    9191        //add the display options (if set) 
    92         var dispURL = wmcLayer.getDisplayOptionsURL(); 
     92        var dispURL = this.currentWMCLayer.getDisplayOptionsURL(); 
    9393         
    9494        if (dispURL !== null) { 
     
    9696             
    9797            this.displayOptsRetriever.getDisplayOptions(dispURL, successFn); 
     98        } 
     99        else { 
     100            this._buildDisplayOptions(null); 
    98101        } 
    99102         
     
    133136            } 
    134137        } 
    135          
    136         WMSC.log("Hideoptions =" + hideOptions); 
    137          
     138                 
    138139        var fs = document.createElement('fieldset'); 
    139140        var leg = document.createElement('legend'); 
     
    141142        fs.appendChild(leg); 
    142143 
    143         if (displayOptions.common !== undefined) { 
    144                 fs.appendChild(this._buildDisplayOptionsList(displayOptions.common, hideOptions)); 
    145         } 
    146          
    147         // also add the style specific options 
     144        // generic display options 
     145        var layerStyles = this.currentWMCLayer.getStyles(); 
    148146        var currentStyle = this._getCurrentLayerProperty('styles'); 
    149147         
    150         if (currentStyle !== null) { 
    151             if (displayOptions[currentStyle] !== undefined) { 
    152                 fs.appendChild(this._buildDisplayOptionsList(displayOptions[currentStyle], hideOptions)); 
    153             } 
    154         } 
    155          
     148        fs.appendChild(this._buildGenericDisplayOptions(layerStyles, currentStyle)); 
     149         
     150        // are there any additional display options for this endpoint 
     151        if (displayOptions !== null) { 
     152            // display options common to all layers for this endpoint (should appear first) 
     153            if (displayOptions.common !== undefined) { 
     154                fs.appendChild(this._buildDisplayOptionsList(displayOptions.common, hideOptions)); 
     155            } 
     156             
     157            // display options for this particular style 
     158             
     159            if (currentStyle !== null) { 
     160                if (displayOptions[currentStyle] !== undefined) { 
     161                    fs.appendChild(this._buildDisplayOptionsList(displayOptions[currentStyle], hideOptions)); 
     162                } 
     163            } 
     164        } 
     165             
    156166        // this is needed as this function is called via AJAX an might be called 
    157167        // run at the same time as another  
     
    165175        // elements individually. 
    166176        this._handlerLookup = Utils.addHandlerToFormElements(this._form, 'change', this._onSelectionChange, this); 
     177    }, 
     178     
     179    _buildGenericDisplayOptions: function(layerStyles, currentStyle) { 
     180        var div = document.createElement('div'); 
     181         
     182        if (layerStyles.length > 0) { 
     183            div.appendChild(this._buildStyleSelect(layerStyles, currentStyle)); 
     184        } 
     185         
     186        // div.appendChild(this._buildDisplayOptionBool({name:'transparent', title:'Transparent Background', defaultValue:'true'})); 
     187        // div.appendChild(this._buildDisplayOptionValue({name:'bgcolor', title:'Background Colour', defaultValue:null})); 
     188         
     189        return div; 
    167190    }, 
    168191     
     
    286309         
    287310        return title; 
     311    }, 
     312     
     313    _buildStyleSelect: function (styles, currentStyle) { 
     314         
     315        var values = []; 
     316        var descriptions = []; 
     317         
     318        for (var i = 0; i < styles.length; i++) { 
     319            values.push(styles[i].name); 
     320            descriptions.push(styles[i].title); 
     321        } 
     322         
     323        this._styleSelect = Utils.buildSelectBox('styles', descriptions, values, currentStyle); 
     324         
     325        return Utils.buildLabelInputDiv('Style', this._styleSelect, 'layerInfoItem'); 
    288326    } 
     327         
    289328}; 
  • cowsclient/trunk/cowsclient/public/js/layerInformation.js

    r5776 r5979  
    4242 
    4343LayerInfo.prototype = { 
    44     EVENTS_RAISED: ['LAYER_STYLE_CHANGED'], 
    45          
    46     _onStyleChange: function (e) { 
    47         var target = e.target || e.srcElement; 
    48          
    49         this.eventsManager.triggerEvent('LAYER_STYLE_CHANGED',  
    50             {  
    51                 param: 'styles', 
    52                 value: target.value 
    53             } 
    54         ); 
    55          
    56         WMSC.log("triggered LAYER_STYLE_CHANGED"); 
    57     }, 
     44         
     45    EVENTS_RAISED: [], 
    5846     
    5947     /** 
     
    8573        fs.appendChild(this._buildInfoItem('Layer Name', this._getLayerProperty(olLayer, 'layers'))); 
    8674        fs.appendChild(this._buildInfoItem('Layer Abstract', wmcLayer.getAbstract())); 
    87          
    88         var styles = wmcLayer.getStyles(); 
    89          
    90         if (styles.length > 0) { 
    91             var currentStyle = this._getLayerProperty(olLayer, 'styles'); 
    92             fs.appendChild(this._buildStyleSelect(styles, currentStyle)); 
    93             fs.appendChild(document.createTextNode("\n")); 
    94         } 
    95          
     75                 
    9676        if (wmc.supportsRequest('GetFigure')) { 
    9777            fs.appendChild(this._buildGetFigureButton(wmc)); 
     
    10686    }, 
    10787 
    108     _buildStyleSelect: function (styles, currentStyle) { 
    109          
    110         var values = []; 
    111         var descriptions = []; 
    112          
    113         for (var i = 0; i < styles.length; i++) { 
    114             values.push(styles[i].name); 
    115             descriptions.push(styles[i].title); 
    116         } 
    117          
    118         this._styleSelect = Utils.buildSelectBox('styles', descriptions, values, currentStyle); 
    119          
    120         this._selectHandler = Utils.addHTMLEventListener(this._styleSelect, 'change', this._onStyleChange, this); 
    121          
    122         return Utils.buildLabelInputDiv('Style', this._styleSelect, 'layerInfoItem'); 
    123     }, 
    124      
    12588    _clearForm: function () { 
    12689         
  • cowsclient/trunk/cowsclient/public/js/layerParameters.js

    r5776 r5979  
    2020                                hideDisplayOptions, eventsManager) { 
    2121     
    22     this.globalEventsManager = eventsManager; 
     22    this.eventsManager = eventsManager; 
    2323     
    2424    this.propertiesDiv = document.getElementById(propertiesDivId); 
     
    2828    this.wmcRetriever = wmcRetriever; 
    2929     
    30     // trying to keep the contained controls isolated from the global events 
    31     this.internalEvents = new OpenLayers.Events(this, null, this.INTERNAL_EVENTS_RAISED); 
    32  
    33     this.layerInfo = new LayerInfo('layer_info_form', this.internalEvents); 
    34     this.layerDims = new LayerDimensions('WMSC_dimForm', this.internalEvents); 
     30    this.layerInfo = new LayerInfo('layer_info_form', this.eventsManager); 
     31    this.layerDims = new LayerDimensions('WMSC_dimForm', this.eventsManager); 
     32    this.layerDisplay = new LayerDisplayOpts(selectionFormId, hideDisplayOptions, this.eventsManager); 
     33        
     34    // monitor all the parameter changes 
     35    this.eventsManager.register('LAYER_DISPLAY_CHANGED', this, this.onParamChange); 
     36    this.eventsManager.register('LAYER_DIMENSION_CHANGED', this, this.onParamChange); 
    3537     
    36     // monitor all the parameter changes 
    37     this.internalEvents.register('LAYER_DISPLAY_CHANGED', this, this.onParamChange); 
    38     this.internalEvents.register('LAYER_STYLE_CHANGED', this, this.onParamChange); 
    39     this.internalEvents.register('LAYER_DIMENSION_CHANGED', this, this.onParamChange); 
    4038     
    41     this.layerDisplay = new LayerDisplayOpts(selectionFormId, hideDisplayOptions, this.internalEvents); 
    42         
    43     this.globalEventsManager.register("SELECTED_LAYER_CHANGED", this, this.onSelectedLayerChanged); 
     39    this.eventsManager.register("SELECTED_LAYER_CHANGED", this, this.onSelectedLayerChanged); 
    4440     
    4541    WMSC.log("layer parameters created"); 
     
    4844LayerParameters.prototype = { 
    4945         
    50     EVENTS_RAISED: ['LAYER_PROPERTY_CHANGED', 'CURRENT_WMCLAYER_CHANGED'], 
    51      
    52     INTERNAL_EVENTS_RAISED: ['LAYER_PROPERTY_CHANGED', 'CURRENT_WMCLAYER_CHANGED', 
    53                              'LAYER_DISPLAY_CHANGED','LAYER_STYLE_CHANGED','LAYER_DIMENSION_CHANGED'], 
    54      
     46    EVENTS_RAISED: ['LAYER_PROPERTY_CHANGED', 'CURRENT_WMCLAYER_CHANGED', 'LAYER_STYLE_CHANGED'].concat( 
     47            LayerInfo.prototype.EVENTS_RAISED, 
     48            LayerDimensions.prototype.EVENTS_RAISED, 
     49            LayerDisplayOpts.prototype.EVENTS_RAISED), 
     50         
    5551    onParamChange: function (e) { 
    5652 
     
    6056        } 
    6157 
    62         this.globalEventsManager.triggerEvent("LAYER_PROPERTY_CHANGED",  
     58        this.eventsManager.triggerEvent("LAYER_PROPERTY_CHANGED",  
    6359                {layer: this.currentOLLayer, wmcLayer: this.currentWMCLayer});         
    6460         
    65         this.internalEvents.triggerEvent("LAYER_PROPERTY_CHANGED",  
    66                 {layer: this.currentOLLayer, wmcLayer: this.currentWMCLayer}); 
     61        if (e.param.toUpperCase() == 'STYLES') { 
     62            this.eventsManager.triggerEvent("LAYER_STYLE_CHANGED",  
     63                    {style: e.value}); 
     64        } 
    6765         
    6866    },     
     
    130128        } 
    131129         
    132         this.globalEventsManager.triggerEvent('CURRENT_WMCLAYER_CHANGED', eventArgs); 
    133         this.internalEvents.triggerEvent('CURRENT_WMCLAYER_CHANGED', eventArgs); 
    134                
     130        this.eventsManager.triggerEvent('CURRENT_WMCLAYER_CHANGED', eventArgs); 
    135131    }, 
    136132     
  • cowsclient/trunk/cowsclient/templates/wcsdown.html

    r5952 r5979  
    9898        setSingleTime('${c.singleTimePoint}' == 'true'); 
    9999         
    100         var bboxSelect = new BoundingBoxMapSelect('map', 'bounds_control_container', baseLayerData.url, baseLayerData.params,  'bbox_hidden_input', null); 
     100        var bboxSelect = new BoundingBoxMapSelect('map', 'bounds_control_container', baseLayerData,  'bbox_hidden_input', null); 
    101101    </py:if> 
    102102 
Note: See TracChangeset for help on using the changeset viewer.