Changeset 5484


Ignore:
Timestamp:
14/07/09 17:03:14 (10 years ago)
Author:
pnorton
Message:

I added a method so that the UI can be called with Request= GetWebMapCapababilities? and this will call the getCapabilities of the given endpoint.

Modified the WMSC.Capabilities object so it would have a .getSubLayers() method, this way it could be used like the other 'WMCS.MapContext?' objects.

Modified the wmcRetriever to retrieve capabilities objects instead of context objects.

Added some code to dynamically populate the Styles dropdown based on the styles mentioned in the 'wmc' object.

Location:
cowsclient/branches/qesdi/cowsclient
Files:
12 edited

Legend:

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

    r5480 r5484  
    1010""" 
    1111 
    12 from cowsclient.lib.base import * 
     12from cowsclient.lib.base import BaseController, g, response, config, request, c, session, render 
     13 
    1314from paste.request import parse_querystring 
    1415#from ows_server.models import Utilities 
    15 from cowsclient.lib.wmc_util import * 
     16from cowsclient.lib.wmc_util import GetWebMapContext, GetWebMapCapabilities, GetLegend 
    1617from cowsclient.model import selectedItem 
    17 from pylons import config, g 
     18 
     19 
     20 
    1821import copy, logging 
    1922log = logging.getLogger(__name__) 
    20 import urllib 
     23import urllib, urllib2 
    2124 
    2225class WmsvizController(BaseController): 
     
    3033        g.helpIcon='layout/icons/help.png'  #needs to go in config 
    3134         
    32  
    3335        self.inputs=dict(parse_querystring(request.environ)) 
    3436        log.info(self.inputs) 
     
    4749                wmc= GetWebMapContext(self) 
    4850                return wmc 
     51            
     52            if self.inputs['REQUEST'] == 'GetWebMapCapabilities': 
     53 
     54                wmcDoc = GetWebMapCapabilities(self.inputs['ENDPOINT']) 
     55                 
     56                response.headers['Content-Type'] = 'text/xml' 
     57                response.write(wmcDoc) 
     58                return            
    4959             
    5060            elif self.inputs['REQUEST'] == 'GetLegend': 
     
    5464        #get server information from config file 
    5565        g.server=config['app_conf']['serverurl'] 
     66     
    5667     
    5768         
     
    8192                    # or an error occurred in the authorization process 
    8293                    # Read response 
    83                     response = e.read() 
     94                     
     95                    xresponse = e.read() 
    8496                    # Send response to user 
    8597                    self.start_response("%d %s" % (e.code, e.msg), e.headers.dict.items()) 
    86                     return response 
     98                    return xresponse 
    8799            self.addViewItem(self.inputs['ENDPOINT']) 
    88100         
  • cowsclient/branches/qesdi/cowsclient/lib/base.py

    r5265 r5484  
    2121        # the request is routed to. This routing information is 
    2222        # available in environ['pylons.routes_dict'] 
     23 
    2324        return WSGIController.__call__(self, environ, start_response) 
    2425 
  • cowsclient/branches/qesdi/cowsclient/lib/wmc_util.py

    r5480 r5484  
    9696    filehandle = urllib2.urlopen(req) 
    9797    return filehandle.read() 
     98 
     99def GetWebMapCapabilities(endpoint): 
     100 
     101     
     102    urlstring=('%s?request=GetCapabilities&service=WMS'%(str(endpoint))) 
     103     
     104    req = urllib2.Request(urlstring) 
     105    req.add_header('Cookie', request.headers.get('Cookie', '')) 
     106    filehandle = urllib2.urlopen(req) 
     107    return filehandle.read()     
     108 
  • cowsclient/branches/qesdi/cowsclient/public/js/capabilities.js

    r5266 r5484  
    1919    for (i=0; i<children.length; i++)  
    2020    { 
    21                 node2 = children[i]; 
    22                 if (node2.nodeName == element)  
    23                         return node2; 
     21        node2 = children[i]; 
     22        if (node2.nodeName == element)  
     23            return node2; 
    2424    } 
    2525    return null; 
     
    2929 
    3030    for (i=0; i<elements.length; i++) { 
    31         node = WMSC._searchElement(node, elements[i]); 
    32         if (node == null) return null; 
     31    node = WMSC._searchElement(node, elements[i]); 
     32    if (node == null) return null; 
    3333    } 
    3434    return node; 
     
    4444}; 
    4545WMSC.Capabilities.prototype = { 
     46         
    4647    evaluate: function(expr, node) { 
    47  
    48         if (node == null) { 
    49             node = this.dom; 
    50         } 
    51         return WMSC.evalXPath(expr, node); 
     48        if (node == null) { 
     49            node = this.dom; 
     50        } 
     51         
     52        return WMSC.evalXPath(expr, node); 
    5253    }, 
    5354 
    5455    getTitle: function() { 
    55         var el = WMSC.traverseWMSDom(this.dom, ['Service', 'Title']); 
    56         if (el.textContent) { 
    57             return el.textContent; 
    58         } 
    59         else { 
    60             return el.text; 
    61         } 
    62     }, 
     56        var el = WMSC.traverseWMSDom(this.dom, ['Service', 'Title']); 
     57        if (el.textContent) { 
     58            return el.textContent; 
     59        } 
     60        else { 
     61            return el.text; 
     62        } 
     63    }, 
     64     
    6365    getAbstract: function() { 
    64         var el = WMSC.traverseWMSDom(this.dom, ['Service', 'Abstract']); 
    65         if (el.textContent) { 
    66             return el.textContent; 
    67         } 
    68         else { 
    69             return el.text; 
    70         } 
    71     }, 
     66        var el = WMSC.traverseWMSDom(this.dom, ['Service', 'Abstract']); 
     67        if (el.textContent) { 
     68            return el.textContent; 
     69        } 
     70        else { 
     71            return el.text; 
     72        } 
     73    }, 
     74     
    7275    getRootLayer: function() { 
    73         var rootLayer = WMSC.traverseWMSDom(this.dom, ['Capability', 'Layer']); 
    74         if (rootLayer == null) return null; 
    75         return new WMSC.Layer(rootLayer); 
    76     }, 
     76        var rootLayer = WMSC.traverseWMSDom(this.dom, ['Capability', 'Layer']); 
     77        if (rootLayer == null) return null; 
     78        return new WMSC.Layer(rootLayer); 
     79    }, 
     80     
    7781    getEndpoint: function() { 
    78         var or = WMSC.traverseWMSDom(this.dom, ['Service', 'OnlineResource']); 
    79         if (or == null) return null; 
    80         var attr = or.getAttribute('href'); 
    81         if (!attr) { 
    82             attr = or.getAttribute('xlink:href'); 
    83         } 
    84         return attr; 
    85     } 
     82        var or = WMSC.traverseWMSDom(this.dom, ['Service', 'OnlineResource']); 
     83        if (or == null) return null; 
     84        var attr = or.getAttribute('href'); 
     85        if (!attr) { 
     86            attr = or.getAttribute('xlink:href'); 
     87        } 
     88        return attr; 
     89    }, 
     90     
     91    getSubLayers: function() { 
     92        return this.getRootLayer().getSubLayers(); 
     93    }, 
     94     
    8695}; 
    8796 
     
    93102    this.node = node; 
    94103}; 
     104 
    95105WMSC.Layer.prototype = { 
    96106    getName: function() { 
    97         var node = WMSC.traverseWMSDom(this.node, ['Name']); 
    98         if (node == null) return null; 
    99         if (node.textContent) { 
    100             return node.textContent; 
    101         } 
    102         else { 
    103             return node.text; 
    104         } 
    105     }, 
     107        var node = WMSC.traverseWMSDom(this.node, ['Name']); 
     108        if (node == null) return null; 
     109        if (node.textContent) { 
     110            return node.textContent; 
     111        } 
     112        else { 
     113            return node.text; 
     114        } 
     115    }, 
     116     
    106117    getTitle: function() { 
    107         var el = WMSC.traverseWMSDom(this.node, ['Title']); 
    108         if (el.textContent) { 
    109             return el.textContent; 
    110         } 
    111         else { 
    112             return el.text; 
    113         } 
    114     }, 
     118        var el = WMSC.traverseWMSDom(this.node, ['Title']); 
     119        if (el.textContent) { 
     120            return el.textContent; 
     121        } 
     122        else { 
     123            return el.text; 
     124        } 
     125    }, 
     126     
    115127    getAbstract: function() { 
    116         var el = WMSC.traverseWMSDom(this.node, ['Abstract']); 
    117         // NB, WMC layers may not have abstracts 
    118         if (!el) 
    119                 return ""; 
    120                  
    121         if (el.textContent) { 
    122             return el.textContent; 
    123         } 
    124         else { 
    125             return el.text; 
    126         } 
    127     }, 
    128     getDimensions: function()  
    129     { 
    130                 var i; 
    131                 var dimObj; 
    132                 var dims = {}; 
    133                 var dimEls = this.node.getElementsByTagName('Dimension'); 
    134                 for (i=0; i<dimEls.length; i++)  
    135                 { 
    136                 dimObj = new WMSC.Dimension(dimEls[i]); 
    137                     dims[dimObj.getName()] = dimObj; 
    138                 } 
    139  
    140                 return dims; 
     128        var el = WMSC.traverseWMSDom(this.node, ['Abstract']); 
     129        // NB, WMC layers may not have abstracts 
     130        if (!el) 
     131            return ""; 
     132             
     133        if (el.textContent) { 
     134            return el.textContent; 
     135        } 
     136        else { 
     137            return el.text; 
     138        } 
     139    }, 
     140     
     141    getDimensions: function() { 
     142        var i; 
     143        var dimObj; 
     144        var dims = {}; 
     145        var dimEls = this.node.getElementsByTagName('Dimension'); 
     146        for (i=0; i<dimEls.length; i++)  
     147        { 
     148            dimObj = new WMSC.Dimension(dimEls[i]); 
     149            dims[dimObj.getName()] = dimObj; 
     150        } 
     151 
     152        return dims; 
    141153    }, 
    142154 
    143155    getSubLayers: function() { 
    144         var i, children, n; 
    145         var layers = []; 
    146  
    147         children = this.node.childNodes; 
    148         for (i=0; i<children.length; i++) { 
    149             n = children[i]; 
    150             if (n.nodeName == 'Layer') { 
    151                 layers[layers.length] = new WMSC.Layer(n); 
    152             } 
    153         } 
    154         return layers; 
     156        var i, children, n; 
     157        var layers = []; 
     158     
     159        children = this.node.childNodes; 
     160        for (i=0; i<children.length; i++) { 
     161            n = children[i]; 
     162            if (n.nodeName == 'Layer') { 
     163                layers[layers.length] = new WMSC.Layer(n); 
     164            } 
     165        } 
     166        return layers; 
    155167    }, 
    156168     
    157169    // if layer is part of a web map context, it should have 
    158170    // an endpoint defined 
    159     getEndpoint: function()  
    160     { 
    161                 var or = WMSC.traverseWMSDom(this.node,  
    162                         ['Server', 'OnlineResource']); 
    163                 if (or == null)  
    164                         return null; 
    165          
    166                 var attr = or.getAttribute('href'); 
    167                 if (!attr) 
    168                     attr = or.getAttribute('xlink:href'); 
    169                 return attr; 
    170     } 
     171    getEndpoint: function() { 
     172        var or = WMSC.traverseWMSDom(this.node, ['Server', 'OnlineResource']); 
     173        if (or == null)  
     174            return null; 
     175     
     176        var attr = or.getAttribute('href'); 
     177        if (!attr) 
     178            attr = or.getAttribute('xlink:href'); 
     179        return attr; 
     180    }, 
     181     
     182    getStyles: function() { 
     183      var styles = []; 
     184       
     185      for (var j=0;j<this.node.getElementsByTagName('Style').length; j++) { 
     186          var styleElt = this.node.getElementsByTagName('Style')[j]; 
     187          var nameElt = styleElt.getElementsByTagName('Name')[0]; 
     188          var titleElt = styleElt.getElementsByTagName('Title')[0]; 
     189           
     190          styles.push(new WMSC.Style(nameElt.textContent, titleElt.textContent)); 
     191      } 
     192       
     193      return styles; 
     194       
     195    }, 
    171196}; 
    172197 
     
    179204    this.node = node; 
    180205}; 
     206 
    181207WMSC.Dimension.prototype = { 
     208         
    182209    getName: function() { 
    183         var attr = this.node.attributes.getNamedItem('name'); 
    184         return attr.value; 
    185     }, 
     210        var attr = this.node.attributes.getNamedItem('name'); 
     211        return attr.value; 
     212    }, 
     213     
    186214    getUnits: function() { 
    187         var attr = this.node.attributes.getNamedItem('units'); 
    188         return attr.value; 
    189     }, 
     215        var attr = this.node.attributes.getNamedItem('units'); 
     216        return attr.value; 
     217    }, 
     218     
    190219    getExtent: function() { 
    191         if (this.node.textContent) { 
    192             return this.node.textContent.split(','); 
    193         } 
    194         else { 
    195             return this.node.text.split(','); 
    196         } 
    197     } 
    198 }; 
    199  
     220        if (this.node.textContent) { 
     221            return this.node.textContent.split(','); 
     222        } 
     223        else { 
     224            return this.node.text.split(','); 
     225        } 
     226    }, 
     227}; 
     228 
     229WMSC.Style = function(name, title) { 
     230    this.name = name; 
     231    this.title = title; 
     232}; 
    200233 
    201234/** 
     
    210243WMSC.WebMapContext.prototype =  
    211244{ 
    212         /** 
    213         * Evaluate an XPATH expression on a specified dom node 
    214         * @param expr: XPATH expression to use 
    215         * @param node: node to evaluate expr on 
    216         */ 
     245    /** 
     246    * Evaluate an XPATH expression on a specified dom node 
     247    * @param expr: XPATH expression to use 
     248    * @param node: node to evaluate expr on 
     249    */ 
    217250    evaluate: function(expr, node)  
    218251    { 
    219                 if (node == null)  
    220                 node = this.dom; 
    221  
    222                 return WMSC.evalXPath(expr, node); 
    223     }, 
    224  
    225         /** 
    226         * Retrieve the general title of the WMC doc 
    227         * @return WMC Title string 
    228         */ 
     252        if (node == null)  
     253            node = this.dom; 
     254 
     255        return WMSC.evalXPath(expr, node); 
     256    }, 
     257 
     258    /** 
     259    * Retrieve the general title of the WMC doc 
     260    * @return WMC Title string 
     261    */ 
    229262    getTitle: function()  
    230263    { 
    231                 var el = WMSC.traverseWMSDom(this.dom, ['General', 'Title']); 
    232                 if (el.textContent)  
    233                 return el.textContent; 
    234                 else 
    235                     return el.text; 
    236     }, 
    237      
    238         /** 
    239         * Retrieve the sublayers of the WMC doc 
    240         * @return array of WMCS.Layer objects 
    241         */ 
     264        var el = WMSC.traverseWMSDom(this.dom, ['General', 'Title']); 
     265        if (el.textContent)  
     266            return el.textContent; 
     267        else 
     268            return el.text; 
     269    }, 
     270     
     271    /** 
     272    * Retrieve the sublayers of the WMC doc 
     273    * @return array of WMCS.Layer objects 
     274    */ 
    242275    getSubLayers: function() 
    243276    { 
    244277        var layerList = WMSC._searchElement(this.dom, 'LayerList'); 
    245278          
    246                 var children = layerList.childNodes; 
    247                 var layers = []; 
    248                 for (var i=0; i<children.length; i++)  
    249                 { 
    250                         if (children[i].nodeName == 'Layer') 
    251                                 layers[layers.length] = new WMSC.Layer(children[i]); 
    252             } 
    253                 return layers; 
     279        var children = layerList.childNodes; 
     280        var layers = []; 
     281        for (var i=0; i<children.length; i++)  
     282        { 
     283            if (children[i].nodeName == 'Layer') 
     284                layers[layers.length] = new WMSC.Layer(children[i]); 
     285        } 
     286        return layers; 
    254287    }  
    255288}; 
  • cowsclient/branches/qesdi/cowsclient/public/js/layerControl.js

    r5480 r5484  
    2626    // number of drag and drop controls created in dragAndDrop.js 
    2727    MAX_LAYER_NO: 10, 
    28      
     28 
    2929    /** 
    3030     * Constructor to initialise layer control 
     
    3434     * @param layerDiv - ID of div element in which to place the layers drag and drop control 
    3535     * @param coordControl - coordinate control to use with layerControl 
    36      *  NB, this control must include a method, updateDomainDiv(OpenLayers.Bounds) 
     36     *     NB, this control must include a method, updateDomainDiv(OpenLayers.Bounds) 
    3737     */ 
    3838    initialize: function(treeDiv, layerDiv, wmcRetriever, newEndpointInputId, addNewEndpointBtnId )  
    3939    { 
    40                 WMSC.log("Initialising Control"); 
    41                 this.treeDiv = treeDiv; 
    42                 this.layerDiv = layerDiv; 
    43                  
    44                 this.wmcRetriever = wmcRetriever; 
    45                  
    46                 this.endpointInputBox = $(newEndpointInputId); 
    47                 this.addNewEndpointBtn = $(addNewEndpointBtnId); 
    48                 this.addNewEndpointBtn.onclick = this.onNewEndpointClick.bindAsEventListener(this); 
    49                  
    50                 this.events = new OpenLayers.Events(this, $(this.treeDiv), 
    51                                             this.EVENT_TYPES); 
    52  
    53                 this._selectedTreeNode = null; 
    54                 this._selectedLayer = null; 
    55                 this._selectedLayerElement = null; 
    56                 this._selectedDims = {}; 
    57                                  
    58                 this.tree = new YAHOO.widget.TreeView($(this.treeDiv)); 
    59                 this.tree.subscribe('labelClick', this._selectTreeNode.bindAsEventListener(this)); 
    60                  
    61                 // Restrict behaviour of tree so that the selected node is always 
    62                 // on the open branch. 
    63                 this.tree.subscribe('expand', function(node)  
    64                 { 
    65                 this._selectTreeNode(node); 
    66                 return true; 
    67                 }.bindAsEventListener(this)); 
    68                  
    69                 this.idIndex = 0; 
    70                  
    71                 this.defaultParams = { 
    72                                 format: 'image/png',  
    73                                 version: '1.3.0',  
    74                                 layers:'tmp',  
    75                                 CRS: 'CRS:84',  
    76                                 transparent: 'true',  
    77                                 styles: 'grid',  
    78                                 cmap: 'jet',  
    79                                 time:'1905-01-15T00:00:00.0' }; 
    80                  
     40        WMSC.log("Initialising Control"); 
     41        this.treeDiv = treeDiv; 
     42        this.layerDiv = layerDiv; 
     43         
     44        this.wmcRetriever = wmcRetriever; 
     45         
     46        this.endpointInputBox = $(newEndpointInputId); 
     47        this.addNewEndpointBtn = $(addNewEndpointBtnId); 
     48        this.addNewEndpointBtn.onclick = this.onNewEndpointClick.bindAsEventListener(this); 
     49         
     50        this.events = new OpenLayers.Events(this, $(this.treeDiv), 
     51                        this.EVENT_TYPES); 
     52 
     53        this._selectedTreeNode = null; 
     54        this._selectedLayer = null; 
     55        this._selectedLayerElement = null; 
     56        this._selectedDims = {}; 
     57                 
     58        this.tree = new YAHOO.widget.TreeView($(this.treeDiv)); 
     59        this.tree.subscribe('labelClick', this._selectTreeNode.bindAsEventListener(this)); 
     60         
     61        // Restrict behaviour of tree so that the selected node is always 
     62        // on the open branch. 
     63        this.tree.subscribe('expand', function(node)  
     64        { 
     65            this._selectTreeNode(node); 
     66            return true; 
     67        }.bindAsEventListener(this)); 
     68         
     69        this.idIndex = 0; 
     70         
     71        this.defaultParams = { 
     72                format: 'image/png',  
     73                version: '1.3.0',  
     74                layers:'tmp',  
     75                CRS: 'CRS:84',  
     76                transparent: 'true',  
     77                styles: 'grid',  
     78                cmap: 'jet',  
     79                time:'1905-01-15T00:00:00.0' }; 
     80         
    8181    }, 
    8282     
     
    8686    destroy: function()  
    8787    { 
    88                 this.events.destroy(); 
    89                 this.tree.unsubscribe(); 
     88        this.events.destroy(); 
     89        this.tree.unsubscribe(); 
    9090    }, 
    9191 
     
    100100    addWMS: function(wmsEndpoint, context, depth)  
    101101    { 
    102                 var treeNode = new YAHOO.widget.MenuNode( 
    103                      {endpoint: wmsEndpoint, 
    104                               label: "...loading"},  
    105                              this.tree.getRoot(), false); 
    106                               
    107                 var f = function(xhr)  
    108                 { 
    109                 var cap = new WMSC.Capabilities(xhr.responseXML.documentElement); 
    110                 var tree = this._addLayerTree( 
    111                         cap.getRootLayer(),  
    112                         treeNode.data,  
    113                         this.tree.getRoot(),  
    114                         treeNode); 
    115                          
    116                 this.tree.draw(); 
    117                 }; 
    118  
    119                 var params = {REQUEST: 'GetCapabilities'}; 
    120                 if (context) params.CONTEXT = context; 
    121                 if (depth) params.DEPTH = depth; 
    122  
    123                 // invoke the GetCapabilities call asynchronously via AJAX 
    124                 new Ajax.Request(wmsEndpoint,  
    125                         {parameters: params, 
    126                 method: "get", 
    127                 onSuccess: f.bindAsEventListener(this) 
    128                         }); 
     102        var treeNode = new YAHOO.widget.MenuNode( 
     103                 {endpoint: wmsEndpoint, 
     104                  label: "...loading"},  
     105                 this.tree.getRoot(), false); 
     106                  
     107        var f = function(xhr)  
     108        { 
     109            var cap = new WMSC.Capabilities(xhr.responseXML.documentElement); 
     110            var tree = this._addLayerTree( 
     111                cap.getRootLayer(),  
     112                treeNode.data,  
     113                this.tree.getRoot(),  
     114                treeNode); 
     115                 
     116            this.tree.draw(); 
     117        }; 
     118 
     119        var params = {REQUEST: 'GetCapabilities'}; 
     120        if (context) params.CONTEXT = context; 
     121        if (depth) params.DEPTH = depth; 
     122 
     123        // invoke the GetCapabilities call asynchronously via AJAX 
     124        new Ajax.Request(wmsEndpoint,  
     125            {parameters: params, 
     126            method: "get", 
     127            onSuccess: f.bindAsEventListener(this) 
     128            }); 
    129129    }, 
    130130     
     
    136136    addListeners: function() 
    137137    { 
    138         for (var i = 0; i < this.tree.getRoot().children.length; i++) 
    139         { 
    140                 var index = this.tree.getRoot().children[i].index; 
    141                 var delIcon = document.getElementById("delIcon_" + index); 
    142                 if (delIcon != null) 
    143                 { 
    144                         delIcon.onclick = this._removeNode.bindAsEventListener(this); 
    145                     } 
    146         } 
     138        for (var i = 0; i < this.tree.getRoot().children.length; i++) 
     139        { 
     140            var index = this.tree.getRoot().children[i].index; 
     141            var delIcon = document.getElementById("delIcon_" + index); 
     142            if (delIcon != null) 
     143            { 
     144                delIcon.onclick = this._removeNode.bindAsEventListener(this); 
     145            } 
     146        } 
    147147    }, 
    148148 
     
    153153    addWebMapContext: function(wmcEndpoint)  
    154154    { 
    155                 var treeNode = new YAHOO.widget.TextNode( 
    156                      {wmcEndpoint: wmcEndpoint},  
    157                              this.tree.getRoot(), false); 
    158                 treeNode.label = this._createNodeLabel("...loading", treeNode.index); 
    159                                               
    160                 var bindDataToTree = function(wmc)  
    161                 { 
    162                 var tree = this._addWMCTree(wmc,  
    163                         treeNode.data,  
    164                         this.tree.getRoot(),  
    165                         treeNode); 
    166  
    167                 this.tree.draw(); 
    168                  
    169                 // Add listener to delete icon to allow node to be removed 
    170                 this.addListeners(); 
    171                 }; 
    172                  
    173                 successFn =bindDataToTree.bindAsEventListener(this); 
    174                  
    175                 this.wmcRetriever.getWMC(wmcEndpoint, successFn); 
    176 //               
    177 //              var params = {REQUEST: 'GetWebMapContext', 
    178 //                                        ENDPOINT: wmcEndpoint}; 
    179 // 
    180 //              // invoke the GetWebMapContext call asynchronously via AJAX 
    181 //              new Ajax.Request('',  
    182 //                      {parameters: params, 
    183 //               method: "get", 
    184 //               onSuccess: bindDataToTree.bindAsEventListener(this) 
    185 //                      }); 
     155        var treeNode = new YAHOO.widget.TextNode( 
     156                 {wmcEndpoint: wmcEndpoint},  
     157                 this.tree.getRoot(), false); 
     158         
     159        treeNode.label = this._createNodeLabel("...loading", treeNode.index); 
     160         
     161        var bindDataToTree = function(wmc)  
     162        { 
     163            var tree = this._addWMCTree(wmc,  
     164                treeNode.data,  
     165                this.tree.getRoot(),  
     166                treeNode); 
     167 
     168            this.tree.draw(); 
     169             
     170            // Add listener to delete icon to allow node to be removed 
     171            this.addListeners(); 
     172        }; 
     173         
     174        successFn =bindDataToTree.bindAsEventListener(this); 
     175         
     176        this.wmcRetriever.getWMC(wmcEndpoint, successFn); 
     177 
    186178    }, 
    187179     
     
    197189    _addLayerTree: function(layer, nodeData, parentNode, treeNode)  
    198190    { 
    199                 nodeData.label = layer.getTitle(); 
    200                 nodeData.layer = layer.getName(); 
    201                 nodeData.abstract = layer.getAbstract(); 
    202                 nodeData.layerData = layer; 
    203             nodeData.title = layer.getAbstract(); //used for tooltips 
    204  
    205                 var subLayers = layer.getSubLayers(); 
    206  
    207                 // When initialising a top-level node it will  
    208                 // already exist (showing loading indicator). 
    209                 // In this case replace data, otherwise create a new node. 
    210                 if (treeNode == null)  
    211                 { 
    212                 var treeNode = new YAHOO.widget.MenuNode( 
    213                         nodeData, parentNode, false); 
    214                 } 
    215                 else  
    216                 { 
    217                 treeNode.data = nodeData; 
    218                 treeNode.label = nodeData.label; 
    219                 } 
    220                  
    221                 for (var i=0; i<subLayers.length; i++)  
    222                 { 
    223                 this._addLayerTree(subLayers[i],  
    224                         {endpoint: nodeData.endpoint}, 
    225                             treeNode); 
    226                 } 
    227                 return treeNode; 
     191        nodeData.label = layer.getTitle(); 
     192        nodeData.layer = layer.getName(); 
     193        nodeData.abstract = layer.getAbstract(); 
     194        nodeData.layerData = layer; 
     195        nodeData.title = layer.getAbstract(); //used for tooltips 
     196 
     197        var subLayers = layer.getSubLayers(); 
     198 
     199        // When initialising a top-level node it will  
     200        // already exist (showing loading indicator). 
     201        // In this case replace data, otherwise create a new node. 
     202        if (treeNode == null)  
     203        { 
     204            var treeNode = new YAHOO.widget.MenuNode( 
     205                nodeData, parentNode, false); 
     206        } 
     207        else  
     208        { 
     209            treeNode.data = nodeData; 
     210            treeNode.label = nodeData.label; 
     211        } 
     212         
     213        for (var i=0; i<subLayers.length; i++)  
     214        { 
     215            this._addLayerTree(subLayers[i],  
     216                {endpoint: nodeData.endpoint}, 
     217                treeNode); 
     218        } 
     219        return treeNode; 
    228220    }, 
    229221     
     
    239231    _addWMCTree: function(wmc, nodeData, parentNode, treeNode)  
    240232    { 
    241                 nodeData.label = wmc.getTitle() + " (" + wmc.getSubLayers()[0].getEndpoint() + ")"; 
    242                 nodeData.layer = wmc.getTitle(); 
    243                 nodeData.abstract = wmc.getTitle(); 
    244  
    245                 var subLayers = wmc.getSubLayers(); 
    246  
    247                 // When initialising a top-level node it will  
    248                 // already exist (showing loading indicator). 
    249                 // In this case replace data, otherwise create a new node. 
    250                 if (treeNode == null)  
    251                 { 
    252                 var treeNode = new YAHOO.widget.MenuNode( 
    253                         nodeData, parentNode, false); 
    254                 } 
    255                 else  
    256                 { 
    257                 treeNode.data = nodeData; 
    258                 // NB, add listener later on since the delete is not currently available in the DOM 
    259                 treeNode.label = this._createNodeLabel(nodeData.label, treeNode.index); 
    260                 } 
    261                  
    262                 for (var i=0; i<subLayers.length; i++)  
    263                 { 
    264                 this._addLayerTree( 
    265                         subLayers[i],  
    266                         {endpoint: nodeData.endpoint, 
    267                         wmcEndpoint: subLayers[i].getEndpoint()}, 
    268                             treeNode); 
    269                 } 
    270                 return treeNode; 
     233        nodeData.label = wmc.getTitle() + " (" + nodeData.wmcEndpoint + ")"; 
     234        nodeData.layer = wmc.getTitle(); 
     235        nodeData.abstract = wmc.getTitle(); 
     236        
     237        var subLayers = wmc.getSubLayers(); 
     238 
     239        // When initialising a top-level node it will  
     240        // already exist (showing loading indicator). 
     241        // In this case replace data, otherwise create a new node. 
     242        if (treeNode == null)  
     243        { 
     244            var treeNode = new YAHOO.widget.MenuNode( 
     245                nodeData, parentNode, false); 
     246        } 
     247        else  
     248        { 
     249            treeNode.data = nodeData; 
     250            // NB, add listener later on since the delete is not currently available in the DOM 
     251            treeNode.label = this._createNodeLabel(nodeData.label, treeNode.index); 
     252        } 
     253         
     254        for (var i=0; i<subLayers.length; i++)  
     255        { 
     256            this._addLayerTree( 
     257                subLayers[i],  
     258                {endpoint: nodeData.endpoint, 
     259                wmcEndpoint: nodeData.wmcEndpoint}, 
     260                treeNode); 
     261        } 
     262        return treeNode; 
    271263    }, 
    272264     
     
    279271    _createNodeLabel: function(nodeLabel, nodeIndex) 
    280272    { 
    281         return '<table><tr><td class="nodeTitle">' +  
    282                         nodeLabel + '</td><td class="delIcon">' + 
    283                         '<img id="delIcon_' + nodeIndex + '" src="js/img/close.gif" /></td></tr></table>'; 
     273        return '<table><tr><td class="nodeTitle">' +  
     274                nodeLabel + '</td><td class="delIcon">' + 
     275                '<img id="delIcon_' + nodeIndex + '" src="js/img/close.gif" /></td></tr></table>'; 
    284276    }, 
    285277      
     
    291283    _removeNode: function(evt) 
    292284    { 
    293                 var delIcon = Event.element(evt); 
    294  
    295                 // get the node name from the icon ID 
    296                 nodeIndex = delIcon.id.substring(delIcon.id.indexOf("_") + 1, delIcon.id.length);                    
    297          
    298         node = this.tree.getNodeByIndex(nodeIndex); 
    299                 var params = {removeItem: node.data.wmcEndpoint}; 
    300         this.tree.removeNode(node) 
    301         // need to redraw to show this change  
    302         this.tree.draw(); 
    303          
    304         var updateView = function(xhr)  
    305                 { 
    306                         // add listeners again to the delete icons; these are lost when the tree redraws 
    307                 this.addListeners(); 
    308                 } 
    309          
    310         new Ajax.Request('removeViewItem',  
    311                         { 
    312                                 parameters: params, 
    313                         method: "get", 
    314                                 onSuccess: updateView.bindAsEventListener(this)                  
    315                         }); 
    316     }, 
    317                                  
    318         /** 
    319          * Respond to a tree node being selected 
    320          * - by highlighting this node and, if the node is 
    321          * a layer, by adding it to the selected layer div 
    322          */ 
    323     _selectTreeNode: function(node)  
    324     { 
    325                 var i, layer; 
    326                 var treeLayer = node.data.layer; 
    327                 var leafDiv; 
    328                 var node1; 
    329  
    330                 node1 = this._selectedTreeNode; 
    331                 while (node1 != null)  
    332                 { 
    333                 if (node1.labelElId)  
    334                 { 
    335                                 $(node1.labelElId).className = this._selectedTreeNode.labelStyle; 
    336                                 node1 = node1.parent; 
    337                 } 
    338                 else  
    339                 { 
    340                                 node1 = null; 
    341                 } 
    342                 } 
    343  
    344                 this._selectedTreeNode = node; 
    345                 node1 = this._selectedTreeNode; 
    346                 while (node1 != null)  
    347                 { 
    348                 if (node1.labelElId)  
    349                 { 
    350                                 $(node1.labelElId).className = 'WMSC_selectedField'; 
    351                                 node1 = node1.parent; 
    352                 } 
    353                 else  
    354                 { 
    355                                 node1 = null; 
    356                 } 
    357                 } 
    358  
    359                 // If this node is a leaf, display the different layers available 
    360                 // NB, need to treat differently depending on whether we're dealing 
    361                 // with a GetCapabilities or a GetWebMapContext call 
    362                 if (node.children.length == 0)  
    363                 { 
    364                         // check this isn't the 'loading...' leaf; escape if it is 
    365                         if (node.label.indexOf("...loading") > -1) 
    366                                 return; 
    367  
    368                 // add the selected layer to the layers panel 
    369                 this._updateLeafLayer(); 
    370                  
    371                 // set the selected layer 
    372                 this._selectedLayer = node; 
    373                          
    374                         // update the selections control to match the selected layer 
    375                 this.coordControl.updateDomainDiv(this._selectedLayer.data.layerData.getDimensions()); 
    376  
    377                         // now refresh the displayed map layers - this is done in the BaseMap.updateVisLayer fn 
    378                 this.events.triggerEvent('changeWMS'); 
    379                 } 
     285        var delIcon = Event.element(evt); 
     286 
     287        // get the node name from the icon ID 
     288        nodeIndex = delIcon.id.substring(delIcon.id.indexOf("_") + 1, delIcon.id.length);             
     289         
     290        node = this.tree.getNodeByIndex(nodeIndex); 
     291        var params = {removeItem: node.data.wmcEndpoint}; 
     292        this.tree.removeNode(node) 
     293        // need to redraw to show this change  
     294        this.tree.draw(); 
     295         
     296        var updateView = function(xhr)  
     297        { 
     298            // add listeners again to the delete icons; these are lost when the tree redraws 
     299            this.addListeners(); 
     300        } 
     301         
     302        new Ajax.Request('removeViewItem',  
     303            { 
     304                parameters: params, 
     305                 method: "get", 
     306                onSuccess: updateView.bindAsEventListener(this)             
     307            }); 
     308    }, 
     309                 
     310    /** 
     311     * Respond to a tree node being selected 
     312     * - by highlighting this node and, if the node is 
     313     * a layer, by adding it to the selected layer div 
     314     */ 
     315    _selectTreeNode: function(node) { 
     316         
     317        var i, layer; 
     318        var treeLayer = node.data.layer; 
     319        var leafDiv; 
     320        var node1; 
     321 
     322        node1 = this._selectedTreeNode; 
     323        while (node1 != null)  
     324        { 
     325            if (node1.labelElId)  
     326            { 
     327                $(node1.labelElId).className = this._selectedTreeNode.labelStyle; 
     328                node1 = node1.parent; 
     329            } 
     330            else  
     331            { 
     332                node1 = null; 
     333            } 
     334        } 
     335 
     336        this._selectedTreeNode = node; 
     337        node1 = this._selectedTreeNode; 
     338        while (node1 != null)  
     339        { 
     340            if (node1.labelElId)  
     341            { 
     342                $(node1.labelElId).className = 'WMSC_selectedField'; 
     343                node1 = node1.parent; 
     344            } 
     345            else  
     346            { 
     347                node1 = null; 
     348            } 
     349        } 
     350 
     351        // If this node is a leaf, display the different layers available 
     352        // NB, need to treat differently depending on whether we're dealing 
     353        // with a GetCapabilities or a GetWebMapContext call 
     354        if (node.children.length == 0)  
     355        { 
     356             
     357            // check this isn't the 'loading...' leaf; escape if it is 
     358            if (node.label.indexOf("...loading") > -1) 
     359                return; 
     360 
     361            // add the selected layer to the layers panel 
     362            this._updateLeafLayer(); 
     363             
     364            // set the selected layer 
     365            this._selectedLayer = node; 
     366             
     367            // update the selections control to match the selected layer 
     368            //this.coordControl.updateDomainDiv(this._selectedLayer.data.layerData.getDimensions()); 
     369 
     370            // now refresh the displayed map layers - this is done in the BaseMap.updateVisLayer fn 
     371            //this.events.triggerEvent('changeWMS'); 
     372        } 
    380373    }, 
    381374     
     
    387380    _removeLayer: function(evt) 
    388381    { 
    389                 var delIcon = Event.element(evt); 
    390  
    391                 // get the layer number from the icon ID 
    392                 layerIndex = delIcon.id.substring(delIcon.id.indexOf("_") + 1, delIcon.id.length);                   
    393          
    394         layer = document.getElementById("li_" + layerIndex); 
    395  
    396                 // hide this layer by changing the style - NB, if the layer is removed, the  
    397                 // associated drag+drop functionality will stop working if the list item is recreated 
    398         layer.className = "hiddenList"; 
    399         layer.innerHTML = ''; 
    400          
    401         // reduce the layer counter 
    402         this.layerNo--; 
    403  
    404             this._updateLeafLayerMessage(); 
    405  
    406         // and reload the maps 
    407         this.events.triggerEvent('changeWMS'); 
     382        var delIcon = Event.element(evt); 
     383 
     384        // get the layer number from the icon ID 
     385        layerIndex = delIcon.id.substring(delIcon.id.indexOf("_") + 1, delIcon.id.length);             
     386         
     387        layer = document.getElementById("li_" + layerIndex); 
     388 
     389        // hide this layer by changing the style - NB, if the layer is removed, the  
     390        // associated drag+drop functionality will stop working if the list item is recreated 
     391        layer.className = "hiddenList"; 
     392        layer.innerHTML = ''; 
     393         
     394        // reduce the layer counter 
     395        this.layerNo--; 
     396 
     397        this._updateLeafLayerMessage(); 
     398 
     399        // and reload the maps 
     400        this.events.triggerEvent('changeWMS'); 
    408401    }, 
    409402     
     
    413406    _updateLeafLayerMessage: function() 
    414407    { 
    415                 message = document.getElementById("layerMessage"); 
    416                 messageText = ''; 
    417  
    418                 if (this.layerNo > 1) 
    419             { 
    420                 messageText = 'Adjust display order of layers by dragging and dropping them.'; 
    421             } 
    422             else if (this.layerNo == 0) 
    423             { 
    424                 messageText = 'Expand a dataset and select a layer to view'; 
    425             } 
    426             message.innerHTML = messageText; 
     408        message = document.getElementById("layerMessage"); 
     409        messageText = ''; 
     410 
     411        if (this.layerNo > 1) 
     412        { 
     413            messageText = 'Adjust display order of layers by dragging and dropping them.'; 
     414        } 
     415        else if (this.layerNo == 0) 
     416        { 
     417            messageText = 'Expand a dataset and select a layer to view'; 
     418        } 
     419        message.innerHTML = messageText; 
    427420    }, 
    428421 
     
    434427     */ 
    435428    _updateLeafLayer: function(xhr)  
    436     {    
    437          
    438         var node = this._selectedTreeNode; 
     429    {     
     430         
     431        var node = this._selectedTreeNode; 
     432         
    439433        var newLayer = this.makeNewLayer(node.data.wmcEndpoint, node.data.layer); 
    440          
     434         
    441435        this.events.triggerEvent("NEW_LAYER", {layer:newLayer}); 
    442          
    443         return; 
    444          
    445             // check this layer isn't already present and visible 
    446                 layers = document.getElementById("layerlist"); 
    447                 for (var i = 0; i < layerList.childNodes.length; i++) 
    448                 { 
    449                         child = layerList.childNodes[i]; 
    450                         if (child.className == "hiddenList") 
    451                                 continue; 
    452                                  
    453                         if (child.nodeName == "LI") 
    454                         { 
    455                                 title = child.getAttribute("title"); 
    456                                 if (title == node.data.label) 
    457                                         return; 
    458                         } 
    459                 }            
    460  
    461         // check what node was selected; if this was a webmapcontext one 
    462         // load this info, if not, load the capabilities 
    463             this.layerNo++; 
    464             if (this.layerNo > this.MAX_LAYER_NO) 
    465             { 
    466                 alert('Can only select 10 layers at once; please delete an existing layer and try again.'); 
    467                 this.layerNo--; 
    468                 return; 
    469             } 
    470              
    471             this._updateLeafLayerMessage(); 
    472                                  
    473                 // Populate the leafLayer div 
    474                 // - check if there are any existing, unused lists first 
    475                 layer = this._getFirstHiddenListElement(); 
    476                  
    477                 listItemNumber = this.layerNo; 
    478                 if (layer == null) 
    479                 { 
    480                     layer = document.createElement('li'); 
    481                 layer.id = "li_" + this.layerNo; 
    482                 } 
    483                 else 
    484                 { 
    485                         // get the listItemNumber - to ensure the delete button matches 
    486                         listItemNumber = layer.id.substring(layer.id.indexOf("_") + 1, layer.id.length); 
    487                 } 
    488             layer.className = "list"; 
    489             layer.setAttribute("title", node.data.label); 
    490             layer.setAttribute("layerName", node.data.layer); 
    491             layer.setAttribute("wmcURL", node.data.wmcEndpoint); 
    492                 layer.dimensions=node.data.layerData.getDimensions();  
    493                 layer.innerHTML =  
    494                         '<table><tr><td class="layerTitle">' + node.data.label + 
    495                 '</td><td class="delIcon"><img id="del_' + listItemNumber + '" src="js/img/close.gif" />' + 
    496                 '</td></tr></table>'; 
    497                  
    498  
    499              
    500             //put layer at top of list  
    501             prependChild(layers, layer); 
    502             //instead of at bottom: 
    503                 //layers.appendChild(layer); 
    504              
    505             // Add listener to delete icon to allow layer to be removed 
    506             deleteIcon = document.getElementById("del_" + listItemNumber); 
    507             deleteIcon.onclick = this._removeLayer.bindAsEventListener(this); 
     436         
     437        return; 
     438         
     439        // check this layer isn't already present and visible 
     440        layers = document.getElementById("layerlist"); 
     441        for (var i = 0; i < layerList.childNodes.length; i++) 
     442        { 
     443            child = layerList.childNodes[i]; 
     444            if (child.className == "hiddenList") 
     445                continue; 
     446                 
     447            if (child.nodeName == "LI") 
     448            { 
     449                title = child.getAttribute("title"); 
     450                if (title == node.data.label) 
     451                    return; 
     452            } 
     453        }         
     454 
     455        // check what node was selected; if this was a webmapcontext one 
     456        // load this info, if not, load the capabilities 
     457        this.layerNo++; 
     458        if (this.layerNo > this.MAX_LAYER_NO) 
     459        { 
     460            alert('Can only select 10 layers at once; please delete an existing layer and try again.'); 
     461            this.layerNo--; 
     462            return; 
     463        } 
     464         
     465        this._updateLeafLayerMessage(); 
     466                 
     467        // Populate the leafLayer div 
     468        // - check if there are any existing, unused lists first 
     469        layer = this._getFirstHiddenListElement(); 
     470         
     471        listItemNumber = this.layerNo; 
     472        if (layer == null) 
     473        { 
     474            layer = document.createElement('li'); 
     475            layer.id = "li_" + this.layerNo; 
     476        } 
     477        else 
     478        { 
     479            // get the listItemNumber - to ensure the delete button matches 
     480            listItemNumber = layer.id.substring(layer.id.indexOf("_") + 1, layer.id.length); 
     481        } 
     482        layer.className = "list"; 
     483        layer.setAttribute("title", node.data.label); 
     484        layer.setAttribute("layerName", node.data.layer); 
     485        layer.setAttribute("wmcURL", node.data.wmcEndpoint); 
     486        layer.dimensions=node.data.layerData.getDimensions();  
     487        layer.innerHTML =  
     488            '<table><tr><td class="layerTitle">' + node.data.label + 
     489            '</td><td class="delIcon"><img id="del_' + listItemNumber + '" src="js/img/close.gif" />' + 
     490            '</td></tr></table>'; 
     491             
     492 
     493         
     494        //put layer at top of list  
     495        prependChild(layers, layer); 
     496        //instead of at bottom: 
     497        //layers.appendChild(layer); 
     498         
     499        // Add listener to delete icon to allow layer to be removed 
     500        deleteIcon = document.getElementById("del_" + listItemNumber); 
     501        deleteIcon.onclick = this._removeLayer.bindAsEventListener(this); 
    508502    }, 
    509503     
    510504    makeNewLayer: function(url, layerName) { 
    511505        var layer = new OpenLayers.Layer.WMS("#" + this.idIndex + " " + layerName,  
    512                         url, this.defaultParams); 
     506                url, this.defaultParams); 
    513507 
    514508        layer.params['LAYERS'] = layerName 
     
    526520    _getFirstHiddenListElement: function() 
    527521    { 
    528         for (var i = 1; i <= this.MAX_LAYER_NO; i++) 
    529         { 
    530                 layer = document.getElementById('li_' + i); 
    531                 if (layer == null) 
    532                         continue; 
    533                 if (layer.className == "hiddenList") 
    534                         return layer; 
    535         } 
    536         return null; 
     522        for (var i = 1; i <= this.MAX_LAYER_NO; i++) 
     523        { 
     524            layer = document.getElementById('li_' + i); 
     525            if (layer == null) 
     526                continue; 
     527            if (layer.className == "hiddenList") 
     528                return layer; 
     529        } 
     530        return null; 
    537531    }, 
    538532 
     
    543537    getDimensionText: function(dim, value)  
    544538    { 
    545                 return value; 
     539        return value; 
    546540    }, 
    547541     
    548542    onNewEndpointClick: function(evt) { 
    549         var element = Event.element(evt); 
    550         this.addWebMapContext(this.endpointInputBox.value); 
     543        var element = Event.element(evt); 
     544        this.addWebMapContext(this.endpointInputBox.value); 
    551545    }, 
    552546     
  • cowsclient/branches/qesdi/cowsclient/public/js/layerList.js

    r5480 r5484  
    7272         
    7373        _onRemoveClick: function(event, target) { 
    74                 this._removeSelectedItem(); 
    75                 this._triggerLayerOrderChange(); 
     74                if (this.getSelectedLayer() != null) { 
     75                        this._removeSelectedItem(); 
     76                        this._triggerLayerOrderChange(); 
     77                        this._triggerSelectedLayerChange();     //selected layer should now be null 
     78                } 
    7679        }, 
    7780         
     
    236239         
    237240        item = this._getSelectedItem(); 
    238          
    239         layer = this._getLayerById(item.id); 
     241        if (item == null) { 
     242                layer = null; 
     243        } else { 
     244                layer = this._getLayerById(item.id); 
     245        } 
    240246        return layer; 
    241247    }, 
  • cowsclient/branches/qesdi/cowsclient/public/js/layerParameters.js

    r5480 r5484  
    6262    onSelectedLayerChanged: function(e) { 
    6363         
    64         alert("selected layer has changed") 
    6564        if (this.currentLayer != null) { 
    6665                this.removeChangedListeners(); 
     
    7170        if (e.layer != null) { 
    7271            this.showControls(); 
    73             this.addChangedListeners(); 
    74             this.selectValuesForCurrentLayer(); 
     72 
    7573        } else { 
    7674            this.hideControls(); 
     
    10098         
    10199        $('layer_url').innerHTML = this.currentLayer.url; 
     100        $('layer_name').innerHTML = this.currentLayer.params['LAYERS']; 
    102101         
    103102    }, 
     
    123122        var wmcLayer = this.searchSubLayers(wmc.getSubLayers()); 
    124123                 
     124        this.buildStyleSelection(wmcLayer); 
     125         
    125126        //build the select controls 
    126127                this.updateDomainDiv(wmcLayer.getDimensions()); 
     128                 
     129        this.addChangedListeners(); 
     130        this.selectValuesForCurrentLayer();              
    127131    }, 
    128132     
     
    143147    updateDomainDiv: function(dims)  
    144148    { 
    145         this.currentDims = dims; 
    146         this._selectedDims={}; //added by domlowe - this clears out any dims left over from previous layers 
    147         this.wmsParams={}; //and same for wms params 
    148                 var dimId, dimText, div, i; 
     149        //this.currentDims = dims; 
     150        //this._selectedDims={}; //added by domlowe - this clears out any dims left over from previous layers 
     151        //this.wmsParams={}; //and same for wms params 
     152                var div, i; 
    149153 
    150154                $(this.dimFormID).innerHTML = ''; 
     
    153157                div = document.createElement('div'); 
    154158                div.innerHTML = '<b>'+dims[id].getName()+'</b> ' 
    155                 select = document.createElement('select'); 
    156                 select.name = id; 
    157                 select.id = 'select_' + id 
     159                 
    158160                extent = dims[id].getExtent(); 
    159  
    160                     this.wmsParams[id] = extent[0]; 
    161                     this._selectedDims[id] = this.getDimensionText(dims[id], extent[0]); 
    162161             
    163                 for (i=0; i<extent.length; i++)  
    164                 { 
    165                                 option = document.createElement('option'); 
    166                                 option.innerHTML = this.getDimensionText(dims[id], extent[i]); 
    167                                 // Required for IE6 
    168                                 option.value = extent[i]; 
    169                                 select.appendChild(option); 
     162                    var values = []; 
     163                    var descriptions = []; 
     164                     
     165                for (i=0; i<extent.length; i++) { 
     166                    descriptions.push(this.getDimensionText(dims[id], extent[i])); 
     167                    values.push(extent[i]); 
    170168                } 
    171169 
     170                var select = this._buildSelect(id, descriptions, values); 
    172171                addHTMLEventListener(select, 'change', this.onSelectionChange, this); 
    173172 
     
    181180    getDimensionText: function(dim, value) { 
    182181        return value; 
    183     }     
     182    }, 
     183     
     184    buildStyleSelection: function(layer) { 
     185         
     186        this.selectionForm.innerHTML = ''; 
     187         
     188        this.selectionForm.innerHTML += "Display Options: <br />"; 
     189         
     190        var div = document.createElement('div'); 
     191        div.innerHTML = '<b>Style:</b> '; 
     192         
     193        var values = []; 
     194        var descriptions = []; 
     195         
     196        for (var i=0;i<layer.getStyles().length; i++) { 
     197            var style = layer.getStyles()[i]; 
     198            values.push(style.name); 
     199            descriptions.push(style.title); 
     200        } 
     201        select = this._buildSelect('styles', descriptions, values); 
     202         
     203         
     204        div.appendChild(select); 
     205        this.selectionForm.appendChild(div); 
     206 
     207        div = document.createElement('div'); 
     208        div.innerHTML = '<b>Cmap:</b> '; 
     209        select = this._buildSelect('cmap', ['jet', 'copper', 'bone', 'gray'], ['jet', 'copper', 'bone', 'gray']); 
     210        div.appendChild(select); 
     211        this.selectionForm.appendChild(div); 
     212         
     213         
     214    }, 
     215     
     216    _buildSelect: function(id, descritptions, values) { 
     217        var select = document.createElement('select'); 
     218        select.name = id; 
     219        select.id = 'select_' + id 
     220         
     221        for(var i=0; i<values.length; i++) { 
     222            option = document.createElement('option'); 
     223            option.innerHTML = descritptions[i]; 
     224            // Required for IE6 
     225            option.value = values[i]; 
     226            select.appendChild(option); 
     227        } 
     228         
     229        return select; 
     230    }, 
    184231} 
  • cowsclient/branches/qesdi/cowsclient/public/js/legendContainer.js

    r5480 r5484  
    1717             
    1818            onSelectedLayerChanged: function(e) { 
    19  
    20                 var url = e.layer.getFullRequestString({ 
    21                                 REQUEST: 'GetLegend', 
    22                 }); 
    23                                  
    24                         var params = {REQUEST: 'GetLegend', 
    25                                           ENDPOINT: url}; 
    2619                 
    27                 new Ajax.Request('',  
    28                                 {parameters: params, 
    29                         method: "get", 
    30                         onSuccess: this.setLegend.bindAsEventListener(this) 
    31                                 }); 
     20                if (e.layer == null) { 
     21                         
     22                        this.clearLegend(); 
     23                         
     24                } else { 
     25                 
     26                        var url = e.layer.getFullRequestString({ 
     27                                        REQUEST: 'GetLegend', 
     28                        }); 
     29                                         
     30                                var params = {REQUEST: 'GetLegend', 
     31                                                  ENDPOINT: url}; 
     32                         
     33                        new Ajax.Request('',  
     34                                        {parameters: params, 
     35                                method: "get", 
     36                                onSuccess: this.setLegend.bindAsEventListener(this) 
     37                                        }); 
     38                } 
    3239                }, 
    3340                 
     
    3946                                this.legendDiv.innerHTML = legendHTML; 
    4047                }, 
     48                 
     49                clearLegend: function(xhr) { 
     50                        this.legendDiv.innerHTML = ''; 
     51                }, 
    4152             
    4253} 
  • cowsclient/branches/qesdi/cowsclient/public/js/mapControl.js

    r5457 r5484  
    444444    drawLayers: function (layers) { 
    445445         
    446         //alert("removing " + this.map.layers.length + " layers"); 
    447446         
    448447         
     
    453452                var removeLayers = []; 
    454453            for (var i=0; i<this.map.layers.length; i++) { 
    455                 if (this.map.layers[i] != this.baseLayer) { 
     454                if (this.map.layers[i] != this.baseLayer && 
     455                    this.map.layers[i] != this.boxesLayer) { 
    456456                        removeLayers.push(this.map.layers[i]); 
    457457                } 
     
    465465        } 
    466466         
    467          
    468467        var lastLayerIndex = 1; 
    469          
    470468        if (layers.length > 0) { 
    471469             
     
    479477 
    480478            } 
    481         } else { 
    482             this.map.addLayer(this.coastLayer); 
    483479        } 
    484480 
    485481        //add the layer for the boxes to be drawn 
    486         this.map.addLayer(this.boxesLayer); 
    487482        this.map.setLayerIndex(this.boxesLayer, lastLayerIndex); 
    488483         
  • cowsclient/branches/qesdi/cowsclient/public/js/wmcRetriever.js

    r5480 r5484  
    2424                        var onRetrieveWMC = function(xhr) { 
    2525                                 
    26                                 var wmc = new WMSC.WebMapContext(xhr.responseXML.documentElement); 
     26                                //var wmc = new WMSC.WebMapContext(xhr.responseXML.documentElement); 
     27                                var wmc = new WMSC.Capabilities(xhr.responseXML.documentElement); 
    2728                                 
    2829                                this.addWMCToLookup(endpoint, wmc); 
     
    3132                                }; 
    3233         
    33                                 var params = {REQUEST: 'GetWebMapContext', 
    34                                                           ENDPOINT: endpoint}; 
     34                                //var params = {REQUEST: 'GetWebMapContext', ENDPOINT: endpoint}; 
     35                                var params = {REQUEST: 'GetWebMapCapabilities', ENDPOINT: endpoint}; 
    3536         
    3637                                // invoke the GetWebMapContext call asynchronously via AJAX 
  • cowsclient/branches/qesdi/cowsclient/public/layout/ddc_vis.css

    r5267 r5484  
    2222DIV#legend { 
    2323  width: 640px; 
     24  height:80px; 
    2425  margin: 1px; 
    2526} 
  • cowsclient/branches/qesdi/cowsclient/templates/wmsviz.html

    r5480 r5484  
    249249            <td class="controlPanel"> 
    250250                            <div id="parameters_select"> 
     251 
     252                URL   : <span id='layer_url'> </span> <br /> 
     253                Layers: <span id='layer_name'> </span> <br /> 
     254                            <br /> 
     255                             
    251256                             
    252257                            <form id='selection_form'> 
    253                              
    254                                URL: <span id='layer_url'> </span> <br /> 
    255                              
    256                                 Layers:     
    257                                <select id="select_layers" disabled="disabled"> 
    258                                     <option value="tmp">Temperature</option> 
    259                                     <option value="pre">Precipitation</option> 
    260                                     <option value="tmx">Max Temp</option> 
    261                                     <option value="cld">Cloud Cover</option> 
    262                                 </select> <br/> 
    263                          
    264                                 Style : 
    265                                 <select id="select_styles"> 
    266                                   <option value="grid">Grid cells</option> 
    267                                   <option value="contour">Contour Lines</option> 
    268                                 </select> <br/> 
    269                          
    270                                 Cmap: 
    271                                 <select id="select_cmap"> 
    272                                     <option value="jet">jet</option> 
    273                                     <option value="bone">bone</option> 
    274                                     <option value="winter">winter</option> 
    275                                     <option value="copper">copper</option> 
    276                                 </select> <br/> 
    277258                            </form> 
    278259                             
    279                          
    280260                            Dimensions: 
    281261                            <form id="WMSC_dimForm"> 
Note: See TracChangeset for help on using the changeset viewer.