Changeset 5719


Ignore:
Timestamp:
16/09/09 14:17:02 (10 years ago)
Author:
pnorton
Message:

Did lots of tidying up of the javascript + fixed some IE compatibility issues. Not fully working in IE yet but getting there.

Also changed the baselayer form being an outline to being transparent. The outline is now added as a separate layer which can be moved up and down (it can also have display options set on it).

Location:
cowsclient/trunk
Files:
1 added
19 edited

Legend:

Unmodified
Added
Removed
  • cowsclient/trunk/cowsclient/public/js/boundsControl.js

    r5626 r5719  
    99 */ 
    1010 
     11/*globals WMSC: false, document: false, Utils: false, alert: false, OpenLayers: false 
     12          $: false,*/ 
     13 
    1114WMSC.BoundsControl = OpenLayers.Class.create(); 
     15 
    1216WMSC.BoundsControl.prototype =  
    1317{ 
    14     EVENT_TYPES: ['changeWMS','clearSelection', 'TEXT_SELECTION_CHANGED'], 
    15     GLOBAL_BOUNDS: new OpenLayers.Bounds(-180.0,-90.0,180.0,90.0), 
     18    EVENT_TYPES: ['changeWMS', 'clearSelection', 'TEXT_SELECTION_CHANGED'], 
     19     
     20    GLOBAL_BOUNDS: new OpenLayers.Bounds(-180.0, -90.0, 180.0, 90.0), 
    1621 
    1722    // The WMS domain and layer parameters of the current selection 
     
    2025    formID: 'coordsForm', 
    2126 
    22     controlMarkup:'<div id="WMSC_sel" class="WMSC_domain">'+ 
    23       '<form id="coordsForm"><table>'+ 
    24       '  <tr><td colspan="2"'+ 
    25           '          align="center">'+ 
    26           '    <input type="text" name="bboxN" size="4" value="90"/><br/>N'+ 
    27           '  </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/>'+ 
    33           '    <input type="text" name="bboxS" size="4" value="-90"/>'+ 
    34           '  </td></tr>'+ 
    35       '</table>'+ 
    36       '<input id="WMSC_clear" type="button" value="Reset selection"/>'+ 
     27    controlMarkup: '<div id="WMSC_sel" class="WMSC_domain">' + 
     28      '<form id="coordsForm"><table>' + 
     29      '  <tr><td colspan="2"' + 
     30          '          align="center">' + 
     31          '    <input type="text" name="bboxN" size="4" value="90"/><br/>N' + 
     32          '  </td></tr>' + 
     33      '  <tr>' + 
     34      '   <td><input type="text" name="bboxW" size="4" value="-180"/> W</td>' + 
     35      '   <td>E <input type="text" name="bboxE" size="4" value="180"/></td>' + 
     36      '  </tr>' + 
     37      '  <tr><td colspan="2" align="center">S<br/>' + 
     38          '    <input type="text" name="bboxS" size="4" value="-90"/>' + 
     39          '  </td></tr>' + 
     40      '</table>' + 
     41      '<input id="WMSC_clear" type="button" value="Reset selection"/>' + 
    3742      '</form></div>', 
    3843 
     
    4651     *    is not set, a default markup is used 
    4752     */ 
    48     initialize: function(domainDivID, initialBounds, formID, controlMarkup)  
     53    initialize: function (domainDivID, initialBounds, formID, controlMarkup)  
    4954    { 
    5055        this.domainDivID = domainDivID; 
    51         if (formID) 
     56        if (formID) { 
    5257            this.formID = formID; 
    53         if (controlMarkup) 
     58        } 
     59        if (controlMarkup) { 
    5460            this.controlMarkup = controlMarkup; 
     61        } 
    5562        this.events = new OpenLayers.Events(this, this.selectionForm, 
    5663                        this.EVENT_TYPES); 
     
    6471        this._initDomainDiv(); 
    6572         
    66         if (initialBounds != null) { 
     73        if (initialBounds !== null) { 
    6774            this.setSelection(initialBounds); 
    6875        } 
     
    7683     * - important for IE. 
    7784     */ 
    78     destroy: function()  
     85    destroy: function ()  
    7986    { 
    8087        this.events.destroy(); 
     
    8491     * Listener to trigger a change selection event 
    8592     */ 
    86     _selectionListener: function()  
     93    _selectionListener: function ()  
    8794    { 
    8895        var selection = this.getSelection(); 
    8996        WMSC.log("triggering TEXT_SELECTION_CHANGED, selection = " + selection); 
    90         this.events.triggerEvent('TEXT_SELECTION_CHANGED', {selection:selection}); 
     97        this.events.triggerEvent('TEXT_SELECTION_CHANGED', {selection: selection}); 
    9198         
    9299        // this will be picked up by the map control, this map control will 
     
    100107     * - including specifying event listeners and handlers 
    101108     */ 
    102     _initDomainDiv: function()  
     109    _initDomainDiv: function ()  
    103110    { 
    104111        var domainDiv = $(this.domainDivID);  
     
    107114        // NB, not all controls may have a clear button 
    108115        var clearButton = $(this.clearButtonID); 
    109         if (clearButton) 
     116        if (clearButton) { 
    110117            clearButton.onclick = this._clearSelection.bindAsEventListener(this); 
     118        } 
    111119             
    112120        var listener = this._selectionListener.bindAsEventListener(this); 
     
    114122        this.selectionForm = $(this.formID); 
    115123 
    116         for (var i=0; i < this.selectionForm.elements.length; i++)  
     124        for (var i = 0; i < this.selectionForm.elements.length; i++)  
    117125        { 
    118126            this.selectionForm.elements[i].onchange = listener; 
     
    126134     * Reset displayed coords to full global bounds 
    127135     */ 
    128     _clearSelection: function()  
     136    _clearSelection: function ()  
    129137    { 
    130138        this.events.triggerEvent('clearSelection'); 
     
    134142     * Retrieve selected coord data 
    135143     */ 
    136     getSelection: function()  
     144    getSelection: function ()  
    137145    { 
    138146        return new OpenLayers.Bounds(this.selectionForm.bboxW.value, 
     
    149157     * @param bbox - openlayers bounds object 
    150158     */ 
    151     setSelection: function(bbox)  
     159    setSelection: function (bbox)  
    152160    { 
    153161        //alert("Set selection bbox="+ bbox + " noCascade = " + noCascade); 
     
    155163 
    156164        // Validation.  negative tests required to catch NaN 
    157         if (!(bbox.left >= -180.0 && bbox.left < 180.0)) 
     165        if (!(bbox.left >= -180.0 && bbox.left < 180.0)) { 
    158166            bbox.left = old_b.left; 
    159  
    160         if (!(bbox.right > -180.0 && bbox.right <= 180.0)) 
     167        } 
     168        if (!(bbox.right > -180.0 && bbox.right <= 180.0)) { 
    161169            bbox.right = old_b.right; 
    162      
    163         if (!(bbox.top > -90.0 && bbox.top <= 90.0)) 
     170        } 
     171        if (!(bbox.top > -90.0 && bbox.top <= 90.0)) { 
    164172            bbox.top = old_b.top; 
    165      
    166         if (!(bbox.bottom >= -90.0 && bbox.bottom < 90.0)) 
     173        } 
     174        if (!(bbox.bottom >= -90.0 && bbox.bottom < 90.0)) { 
    167175            bbox.bottom = old_b.bottom; 
    168      
     176        } 
     177         
     178        var t; 
    169179        if (bbox.left > bbox.right)  
    170180        { 
    171             var t = bbox.left;  
     181            t = bbox.left;  
    172182            bbox.left = bbox.right;  
    173183            bbox.right = t; 
     
    176186        if (bbox.bottom > bbox.top)  
    177187        { 
    178             var t = bbox.bottom;  
     188            t = bbox.bottom;  
    179189            bbox.bottom = bbox.top;  
    180190            bbox.top = t; 
     
    191201     * Need to listen for dragging of the selection box on the map itself 
    192202     */ 
    193     addMapSelectionChanged: function(events) { 
     203    addMapSelectionChanged: function (events) { 
    194204        events.register('MAP_SELECTION_CHANGED', this, this._onMapSelectionChanged);         
    195205    }, 
     
    202212     * called if the selection box text is changed. 
    203213     */ 
    204     _onMapSelectionChanged: function(e) { 
     214    _onMapSelectionChanged: function (e) { 
    205215        this.setSelection(e.selection); 
    206     }, 
    207      
     216    } 
    208217}; 
    209218 
  • cowsclient/trunk/cowsclient/public/js/capabilities.js

    r5671 r5719  
    55 */ 
    66 
     7/*globals WMSC: false*/ 
     8 
     9/*jslint white: false, eqeqeq: false*/ 
     10 
    711// For resolving XML Namespaces in XPath expressions 
    812WMSC.nsMap = { 
     
    2024    { 
    2125        node2 = children[i]; 
    22         if (node2.nodeName == element)  
     26        if (node2.nodeName == element) {  
    2327            return node2; 
     28        } 
    2429    } 
    2530    return null; 
     
    2934 
    3035    for (i=0; i<elements.length; i++) { 
    31     node = WMSC._searchElement(node, elements[i]); 
    32     if (node == null) return null; 
    33     } 
     36        node = WMSC._searchElement(node, elements[i]); 
     37     
     38        if (node === null) { 
     39            return null; 
     40        } 
     41    } 
     42     
    3443    return node; 
     44}; 
     45 
     46WMSC.getTextContent = function (el) { 
     47    if (el.textContent) { 
     48        return el.textContent; 
     49    } 
     50    else { 
     51        return el.text; 
     52    } 
    3553}; 
    3654 
     
    4664         
    4765    evaluate: function(expr, node) { 
    48         if (node == null) { 
     66        if (node === null) { 
    4967            node = this.dom; 
    5068        } 
     
    5573    getTitle: function() { 
    5674        var el = WMSC.traverseWMSDom(this.dom, ['Service', 'Title']); 
    57         if (el.textContent) { 
    58             return el.textContent; 
    59         } 
    60         else { 
    61             return el.text; 
    62         } 
     75        return WMSC.getTextContent(el); 
    6376    }, 
    6477     
    6578    getAbstract: function() { 
    6679        var el = WMSC.traverseWMSDom(this.dom, ['Service', 'Abstract']); 
    67         if (el.textContent) { 
    68             return el.textContent; 
    69         } 
    70         else { 
    71             return el.text; 
    72         } 
     80        return WMSC.getTextContent(el);         
    7381    }, 
    7482     
    7583    getRootLayer: function() { 
    7684        var rootLayer = WMSC.traverseWMSDom(this.dom, ['Capability', 'Layer']); 
    77         if (rootLayer == null) return null; 
     85        if (rootLayer === null) { 
     86            return null; 
     87        } 
    7888        return new WMSC.Layer(rootLayer); 
    7989    }, 
     
    8191    getEndpoint: function() { 
    8292        var or = WMSC.traverseWMSDom(this.dom, ['Service', 'OnlineResource']); 
    83         if (or == null) return null; 
     93        if (or === null) { 
     94            return null; 
     95        } 
    8496        var attr = or.getAttribute('href'); 
    8597        if (!attr) { 
     
    94106     
    95107    getAllRequests: function() { 
     108        var reqs; 
     109         
    96110        var standardReqs = WMSC.traverseWMSDom(this.dom, ['Capability', 'Request']); 
    97         var reqs = this._getRequestsFromNode(standardReqs); 
     111         
     112        reqs = this._getRequestsFromNode(standardReqs); 
     113         
    98114        var extendedReqs = WMSC.traverseWMSDom(this.dom, ['Capability', '_ExtendedCapabilities', 'Request']); 
    99         if (extendedReqs != null) { 
     115         
     116        if (extendedReqs !== null) { 
    100117            reqs = reqs.concat(this._getRequestsFromNode(extendedReqs)); 
    101118        } 
     
    119136     
    120137    _getRequestFormats: function(node) { 
     138        var i; 
     139         
     140        WMSC.log("WMSC.Capabilities._getRequestFormats: node = " + node + " node.tagName =" + node.tagName); 
     141 
     142        if (node.tagName === 'GetFigure') { 
     143            //Utils.logAtts(node); 
     144            WMSC.log("node.textContent" + node.textContent + " node.innerText =" + node.innerText); 
     145            for (i=0; i<node.childNodes.length; i++) { 
     146                var c = node.childNodes[i]; 
     147                WMSC.log("c.nodeType = " + c.nodeType + " c.tagName = " + c.tagName + " c.textContent = " + c.textContent + " c.innerText = " + c.innerText + " c.innerHTML = " + c.innerHTML); 
     148                WMSC.log("c.childNodes.length = " + c.childNodes.length); 
     149                for (var j = 0; j < c.childNodes.length; j++) { 
     150                    var gc = c.childNodes[j]; 
     151                    WMSC.log("gc.nodeType = " + gc.nodeType + " gc.tagName = " + gc.tagName + " gc.textContent = " + gc.textContent + " gc.innerText = " + gc.innerText + " gc.innerHTML = " + gc.innerHTML); 
     152                } 
     153            } 
     154        } 
     155        //Utils.logAtts(node); 
     156         
    121157        var formats = []; 
    122158        for (var i=0; i<node.childNodes.length; i++) { 
    123159            var child = node.childNodes[i]; 
    124160             
     161            //WMSC.log("WMSC.Capabilities._getRequestFormats: i = " + i + " child.nodeName=" + child.nodeName + " child.textContent =" + child.textContent + " child.innerText =" + child.innerText); 
     162             
    125163            if (child.nodeName.toUpperCase() == 'FORMAT') { 
    126                 formats.push(child.textContent); 
     164                formats.push(WMSC.getTextContent(child)); 
    127165            } 
    128166        }  
     
    141179     
    142180    supportsRequest: function(name) { 
    143         return this.getRequest(name) != null; 
    144     }, 
     181        return this.getRequest(name) !== null; 
     182    } 
    145183}; 
    146184 
     
    156194    getName: function() { 
    157195        var node = WMSC.traverseWMSDom(this.node, ['Name']); 
    158         if (node == null) return null; 
    159         if (node.textContent) { 
    160             return node.textContent; 
    161         } 
    162         else { 
    163             return node.text; 
    164         } 
     196        if (node === null) { 
     197            return null; 
     198        } 
     199        return WMSC.getTextContent(node); 
    165200    }, 
    166201     
    167202    getTitle: function() { 
    168203        var el = WMSC.traverseWMSDom(this.node, ['Title']); 
    169         if (el.textContent) { 
    170             return el.textContent; 
    171         } 
    172         else { 
    173             return el.text; 
    174         } 
     204        return WMSC.getTextContent(el); 
    175205    }, 
    176206     
     
    178208        var el = WMSC.traverseWMSDom(this.node, ['Abstract']); 
    179209        // NB, WMC layers may not have abstracts 
    180         if (!el) 
     210        if (!el) { 
    181211            return ""; 
     212        } 
    182213             
    183         if (el.textContent) { 
    184             return el.textContent; 
    185         } 
    186         else { 
    187             return el.text; 
    188         } 
     214        return WMSC.getTextContent(el); 
    189215    }, 
    190216     
     
    221247    getEndpoint: function() { 
    222248        var or = WMSC.traverseWMSDom(this.node, ['Server', 'OnlineResource']); 
    223         if (or == null)  
    224             return null; 
     249        if (or === null) { 
     250            return null; 
     251        } 
    225252     
    226253        var attr = or.getAttribute('href'); 
    227         if (!attr) 
     254        if (!attr) { 
    228255            attr = or.getAttribute('xlink:href'); 
     256        } 
    229257        return attr; 
    230258    }, 
     
    238266          var titleElt = styleElt.getElementsByTagName('Title')[0]; 
    239267           
    240           styles.push(new WMSC.Style(nameElt.textContent, titleElt.textContent)); 
     268          var nameStr = WMSC.getTextContent(nameElt); 
     269          var titleStr = WMSC.getTextContent(titleElt); 
     270          styles.push(new WMSC.Style(nameStr, titleStr)); 
    241271      } 
    242272       
     
    246276         
    247277    getLegendURL: function(style) { 
    248         if (style == null || style == "") { 
    249                 style = undefined; 
    250         } 
    251          
    252         var styles = this.getStyles(); 
    253          
    254         //can't get the legend URL if there are no styles 
    255         if (styles.length == 0) { 
    256                 return null; 
    257         } 
    258          
    259         //!TODO: check that the style is in the layers styles 
    260          
    261         //if no style specified just return the first 
    262         if (style == undefined) { 
    263                 return this._getLegendURLForStyle(styles[0].name); 
    264         } 
    265         else { 
    266                 return this._getLegendURLForStyle(style); 
    267         } 
    268          
     278        if (style === null || style === "") { 
     279            style = undefined; 
     280        } 
     281         
     282        var styles = this.getStyles(); 
     283         
     284        //can't get the legend URL if there are no styles 
     285        if (styles.length === 0) { 
     286            return null; 
     287        } 
     288         
     289        //!TODO: check that the style is in the layers styles 
     290         
     291        //if no style specified just return the first 
     292        if (style === undefined) { 
     293            return this._getLegendURLForStyle(styles[0].name); 
     294        } 
     295        else { 
     296            return this._getLegendURLForStyle(style); 
     297        } 
    269298    }, 
    270299     
    271300    _getLegendURLForStyle: function(style) { 
    272         var url = null; 
    273          for (var j=0;j<this.node.getElementsByTagName('Style').length; j++) { 
    274                  var styleElt = this.node.getElementsByTagName('Style')[j]; 
    275              var styleName = styleElt.getElementsByTagName('Name')[0].textContent; 
     301        var url = null; 
     302         
     303        for (var j = 0; j < this.node.getElementsByTagName('Style').length; j++) { 
    276304              
    277              if (styleName == style) { 
    278                  var legendElt = this.node.getElementsByTagName('LegendURL')[0]; 
    279                  var onlineRes = legendElt.getElementsByTagName('OnlineResource')[0]; 
    280                  url = onlineRes.getAttribute('xlink:href'); 
    281                  break; 
    282              } 
    283          } 
    284           
    285          return url; 
     305            var styleElt = this.node.getElementsByTagName('Style')[j]; 
     306            var styleName = styleElt.getElementsByTagName('Name')[0].textContent; 
     307              
     308            if (styleName == style) { 
     309                var legendElt = this.node.getElementsByTagName('LegendURL')[0]; 
     310                var onlineRes = legendElt.getElementsByTagName('OnlineResource')[0]; 
     311                url = onlineRes.getAttribute('xlink:href'); 
     312                break; 
     313            } 
     314        } 
    286315          
     316        return url; 
    287317    }, 
    288318     
     
    290320        var displayOpts = null; 
    291321         
    292         for (var i=0; i<this.node.getElementsByTagName('MetadataURL').length; i++) 
     322        for (var i = 0; i < this.node.getElementsByTagName('MetadataURL').length; i++) { 
    293323            var metaURL = this.node.getElementsByTagName('MetadataURL')[i]; 
    294324 
    295             if (metaURL != undefined && metaURL.getAttribute('type') == 'display_options') { 
     325            if (metaURL !== undefined && metaURL.getAttribute('type') == 'display_options') { 
    296326                var olr = metaURL.getElementsByTagName('OnlineResource')[0]; 
    297327                displayOpts = olr.getAttribute('xlink:href'); 
    298328            } 
     329        } 
    299330         
    300331        return displayOpts; 
     
    330361            return this.node.text.split(','); 
    331362        } 
    332     }, 
     363    } 
    333364}; 
    334365 
     
    362393    evaluate: function(expr, node)  
    363394    { 
    364         if (node == null)  
     395        if (node === null) {  
    365396            node = this.dom; 
     397        } 
    366398 
    367399        return WMSC.evalXPath(expr, node); 
     
    375407    { 
    376408        var el = WMSC.traverseWMSDom(this.dom, ['General', 'Title']); 
    377         if (el.textContent)  
    378             return el.textContent; 
    379         else 
    380             return el.text; 
     409        return WMSC.getTextContent(el); 
    381410    }, 
    382411     
     
    393422        for (var i=0; i<children.length; i++)  
    394423        { 
    395             if (children[i].nodeName == 'Layer') 
     424            if (children[i].nodeName == 'Layer') { 
    396425                layers[layers.length] = new WMSC.Layer(children[i]); 
     426            } 
    397427        } 
    398428        return layers; 
  • cowsclient/trunk/cowsclient/public/js/displayOptionsRetriever.js

    r5626 r5719  
    11 
    2 DisplayOptionsRetriever = function(){ 
     2/*globals WMSC: false, Ajax: false, JSON: false*/ 
     3 
     4var DisplayOptionsRetriever = function () { 
    35    this._lookup = {};             
    4 } 
     6}; 
    57 
    68DisplayOptionsRetriever.prototype = { 
    79 
    8         getDisplayOptions: function(url, onSuccessFunction) { 
     10    getDisplayOptions: function (url, onSuccessFunction) { 
    911             
    10             if (this.isCached(url)) { 
    11                 onSuccessFunction(this._lookup[url]); 
     12        if (this.isCached(url)) { 
     13            onSuccessFunction(this._lookup[url]); 
     14             
     15        } else { 
     16             
     17            var onRetrieve = function (resp) { 
     18                var obj = null; 
    1219                 
    13             } else { 
     20                try { 
     21                    obj = JSON.parse(resp.responseText); 
     22                } 
     23                catch (e) { 
     24                    var msg = "Error occurred parsing JSON.\n Description:" + e.stack + "\n"; 
     25                    WMSC.log(msg); 
     26                } 
    1427                 
    15                 var onRetrieve = function(resp) { 
    16                      
    17                     try { 
    18                        var obj = JSON.parse(resp.responseText); 
     28                this.addToLookup(url, obj); 
     29                 
     30                onSuccessFunction(obj); 
     31            }; 
     32 
     33            var params = {REQUEST: 'GetDisplayOptions', URL: url}; 
     34 
     35            // invoke the GetWebMapContext call asynchronously via AJAX 
     36            var req = new Ajax.Request('',  
     37                { 
     38                    parameters: params, 
     39                    method: "get", 
     40                    onSuccess: onRetrieve.bindAsEventListener(this), 
     41                    onException : function (resp, e) {    
     42                        WMSC.log("Exception:" + e);  
    1943                    } 
    20                     catch(e) { 
    21                         var msg="Error occurred parsing JSON.\n Description:" + e.stack + "\n"; 
    22                         WMSC.log(msg); 
    23                     } 
    24                      
    25                     this.addToLookup(url, obj); 
    26                     onSuccessFunction(obj); 
    27                 }; 
     44                }); 
     45        } 
     46    }, 
    2847     
    29                 var params = {REQUEST: 'GetDisplayOptions', URL: url}; 
     48    addToLookup: function (url, obj) { 
     49        this._lookup[url] = obj; 
     50    }, 
    3051     
    31                 // invoke the GetWebMapContext call asynchronously via AJAX 
    32                 new Ajax.Request('',  
    33                     {parameters: params, 
    34                      method: "get", 
    35                      onSuccess: onRetrieve.bindAsEventListener(this), 
    36                       onException : function(resp, e) {   WMSC.log("Exception:" + e); }, 
    37                     }); 
     52    isCached: function (url) { 
     53         
     54        for (var l in this._lookup) { 
     55            if (l === url) { 
     56                return true; 
    3857            } 
    39         }, 
     58        } 
    4059         
    41         addToLookup: function(url, obj){ 
    42             this._lookup[url] = obj; 
    43         }, 
    44          
    45         isCached: function(url) { 
    46             for (l in this._lookup) { 
    47                 if (l == url) { 
    48                     return true; 
    49                 } 
    50             } 
    51             return false; 
    52         } 
    53 } 
     60        return false; 
     61    } 
     62}; 
  • cowsclient/trunk/cowsclient/public/js/figureBuilder.js

    r5709 r5719  
    11 
    2 FigureBuilder = function(formId, buttonId, initialBounds) { 
     2/*globals WMSC: false, document: false, Utils: false, alert: false*/ 
     3 
     4var FigureBuilder = function (formId, buttonId, initialBounds) { 
    35        this._form = document.getElementById(formId); 
    46        this._button = document.getElementById(buttonId); 
     
    1113         
    1214        this._currentSelection = initialBounds; 
    13 } 
     15}; 
    1416 
    1517FigureBuilder.prototype = { 
     
    2426        }, 
    2527 
    26         addMapSelectionChangedHandlers: function(events) { 
     28        addMapSelectionChangedHandlers: function (events) { 
    2729                events.register('MAP_SELECTION_CHANGED', this, this.onChangeSelection); 
    2830        }, 
     
    3133         * When the layer order changes update the current layers 
    3234         */ 
    33         onLayerOrderChanged: function(e) { 
     35        onLayerOrderChanged: function (e) { 
    3436        this._currentLayers = e.layers; 
    3537        }, 
    3638         
    37         onChangeSelection: function(e) { 
     39        onChangeSelection: function (e) { 
    3840                this._currentSelection = e.selection; 
    3941                WMSC.log("this._currentSelection = " + this._currentSelection); 
     
    4143         
    4244        //add the div to contain the hidden elements 
    43         buildHiddenControlsDiv: function() { 
     45        buildHiddenControlsDiv: function () { 
    4446                var div = document.createElement('div'); 
    4547                div.style.display = 'none'; 
     
    4850        }, 
    4951         
    50         createFigure: function() { 
     52        createFigure: function () { 
    5153                this._hiddenControlsDiv.innerHTML = ""; 
    52                 if (this._currentLayers == null || this._currentLayers.length == 0) { 
     54                if (this._currentLayers === null || this._currentLayers.length === 0) { 
    5355                        alert("No layer found."); 
    5456                } 
    5557                else { 
    5658                         
    57                         for (var i=0; i<this._currentLayers.length; i++) { 
     59                        for (var i = 0; i < this._currentLayers.length; i++) { 
    5860                                var layer = this._currentLayers[i]; 
    5961                                this._hiddenControlsDiv.appendChild(this._buildLayerInputs(i + 1, layer)); 
    6062                        } 
    6163                         
    62                         var bboxString = this._currentSelection.left + "," + this._currentSelection.bottom + "," + this._currentSelection.right+ "," + this._currentSelection.top; 
     64                        var bboxString = this._currentSelection.left + "," + this._currentSelection.bottom + "," + this._currentSelection.right + "," + this._currentSelection.top; 
    6365                         
    6466                        this._hiddenControlsDiv.appendChild(this._buildInputElement('BBOX', bboxString)); 
     
    7173        }, 
    7274         
    73         _buildLayerInputs: function(ind, layer) { 
     75        _buildLayerInputs: function (ind, layer) { 
    7476                var div = document.createElement('div'); 
    7577                div.appendChild(this._buildInputElement(ind + '_ENDPOINT', layer.url)); 
     
    8082        }, 
    8183         
    82         _buildInputElement: function(name, value) { 
     84        _buildInputElement: function (name, value) { 
    8385                var input = document.createElement('input'); 
    8486                input.type = "hidden"; 
     
    8890        }, 
    8991         
    90         destroy: function() { 
    91                 if (this._handler != null) { 
     92        destroy: function () { 
     93                if (this._handler !== null) { 
    9294                        Utils.removeHTMLEventListener(this._button, 'click', this._handler); 
    9395                } 
    94         }, 
     96        } 
    9597 
    96 } 
     98}; 
  • cowsclient/trunk/cowsclient/public/js/layerControl.js

    r5709 r5719  
    88 * @author C Byrom 
    99 */ 
     10 
     11/*global document:false, WMSC:false, Utils:false, OpenLayers:false, YAHOO:false,  
     12         $:false, LayerDefaultSetter:false, alert:false, window:false, Event:false */ 
     13 
    1014WMSC.VisAppLayers = OpenLayers.Class.create(); 
     15 
    1116WMSC.VisAppLayers.prototype = { 
    1217    EVENT_TYPES: ['changeWMS', 'changeSelection', "NEW_LAYER"], 
     
    2934     *     NB, this control must include a method, updateDomainDiv(OpenLayers.Bounds) 
    3035     */ 
    31     initialize: function(treeDiv, layerDiv, wmcRetriever, newEndpointInputId, addNewEndpointBtnId, defaultOptionsList )  
     36    initialize: function (treeDiv, layerDiv, wmcRetriever, newEndpointInputId, addNewEndpointBtnId, defaultOptionsList)  
    3237    { 
    3338        WMSC.log("Initialising Control"); 
     
    4853                 
    4954        this.tree = new YAHOO.widget.TreeView(this.treeDiv); 
    50         this.tree.subscribe('labelClick', this._selectTreeNode.bindAsEventListener(this)); 
     55         
     56        // the label click event doesn't occurr if the selected node is clicked on 
     57        // because someone might want to add multiple copies of one layer  
     58        // (to compare different dimesnions maybe) using the simple clickEvent which is always called 
     59        //this.tree.subscribe('labelClick', this._selectTreeNode.bindAsEventListener(this)); 
     60        this.tree.subscribe('clickEvent', this._onTreeClick.bindAsEventListener(this)); 
    5161         
    5262        // Restrict behaviour of tree so that the selected node is always 
    5363        // on the open branch. 
    54         this.tree.subscribe('expand', function(node)  
     64        this.tree.subscribe('expand', function (node)  
    5565        { 
    5666            this._selectTreeNode(node); 
     
    6070        this.idIndex = 0; 
    6171         
    62         globalDefaultParams = { 
    63                 format: 'image/png',  
    64                 version: '1.3.0',  
    65                 CRS: 'CRS:84',  
    66                 transparent: 'true'}; 
     72        var globalDefaultParams = { 
     73            format: 'image/png',  
     74            version: '1.3.0',  
     75            CRS: 'CRS:84',  
     76            transparent: 'true' 
     77        }; 
    6778         
    6879        this.defaultSetter = new LayerDefaultSetter(globalDefaultParams, defaultOptionsList); 
     
    7889     * Cleaning up is important for IE. 
    7990     */ 
    80     destroy: function()  
     91    destroy: function ()  
    8192    { 
    8293        this.events.destroy(); 
     
    89100     * need to constantly refresh this list 
    90101     */ 
    91     addListeners: function() 
     102    addListeners: function () 
    92103    { 
    93104        for (var i = 0; i < this.tree.getRoot().children.length; i++) 
     
    95106            var index = this.tree.getRoot().children[i].index; 
    96107            var delIcon = document.getElementById("delIcon_" + index); 
    97             if (delIcon != null) 
     108            if (delIcon !== null) 
    98109            { 
    99110                this._delIconHandlers[delIcon.id] = Utils.addHTMLEventListener(delIcon,  
     
    107118     * should happen right before the tree is re-drawn. 
    108119     */ 
    109     removeListeners: function() { 
     120    removeListeners: function () { 
    110121        Utils.removeEventHandlersFromLookup(this._delIconHandlers); 
    111122        this._delIconHandlers = {}; 
     
    116127     * to be re-applied after the tree is re-drawn. 
    117128     */ 
    118     redrawTree: function() { 
     129    redrawTree: function () { 
    119130        this.removeListeners(); 
    120131        this.tree.draw(); 
     
    124135         
    125136        //re apply the selected node (as the html will have been re-built 
    126         if (this._selectedTreeNode != null) { 
     137        if (this._selectedTreeNode !== null) { 
    127138            if (this._selectedTreeNode.labelElId) { 
    128139                var selectedElt = $(this._selectedTreeNode.labelElId); 
    129                 if (selectedElt == null) { 
     140                if (selectedElt === null) { 
    130141                    this._selectedTreeNode = null; 
    131142                } 
     
    141152     * @param wmsEndpoint - endpoint to retrieve the WMC doc from - NB, this is typically the localhost 
    142153     */ 
    143     addWebMapContext: function(wmcEndpoint)  
     154    addWebMapContext: function (wmcEndpoint)  
    144155    { 
    145156        var root = this.tree.getRoot(); 
    146157        var loadingLabel = '<table><tr><td class="nodeTitle">...loading</td></tr></table>'; 
    147         var loadingNode = new YAHOO.widget.TextNode({label:loadingLabel}, root, false); 
     158        var loadingNode = new YAHOO.widget.TextNode({label: loadingLabel}, root, false); 
    148159                 
    149         var bindDataToTree = function(wmc)  
     160        var bindDataToTree = function (wmc)  
    150161        { 
    151162            this.tree.removeNode(loadingNode); 
     
    154165            this.redrawTree(); 
    155166             
    156             if (this.layersToSelect[wmcEndpoint] != undefined) { 
     167            if (this.layersToSelect[wmcEndpoint] !== undefined) { 
    157168                this._selectEndpointLayers(wmcEndpoint, this.layersToSelect[wmcEndpoint]); 
    158169                this.layersToSelect[wmcEndpoint] = undefined; 
     
    162173         
    163174         
    164         var onSecurityFail=function(resp){ 
     175        var onSecurityFail = function (resp) { 
     176            this.tree.removeNode(loadingNode); 
     177            this.redrawTree(); 
     178            alert('Login was unsucessful'); 
     179            return false; 
     180        }; 
     181 
     182        var onRetriveWMCFail = function (resp) { 
     183            if (resp.status === "302") { 
     184                 
     185                //If the user's browser can show a modal dialog window and not 
     186                //block it with a popup blocker, then show it 
     187     
     188                if (!IsPopupBlocker()) {     
     189                    window.showModalDialog('./securityredirect', 'please log in', 'dialogHeight=350px', 'dialogWidth=500px'); 
     190                 
     191                    //when logged in and new window closed, try again: 
     192                    var successFn = bindDataToTree.bindAsEventListener(this); 
     193                    var failureFn = onSecurityFail.bindAsEventListener(this); 
     194                    this.wmcRetriever.getWMC(wmcEndpoint, successFn, failureFn); 
     195                } 
     196                else { 
     197                    alert('Please enable popups for this site to login to the secure WMS'); 
     198                } 
     199                
     200     
     201            } 
     202            else { 
     203                alert("Attempt to retrive endpoint " + wmcEndpoint + " failed, response.status = " + resp.status + " (" + resp.statusText + ")" + "."); 
    165204                this.tree.removeNode(loadingNode); 
    166205                this.redrawTree(); 
    167                 alert('Login was unsucessful'); 
    168                 return false; 
    169         } 
    170  
    171         var onRetriveWMCFail = function(resp) { 
    172             if(resp.status=="302"){ 
    173              
    174             //If the user's browser can show a modal dialog window and not 
    175             //block it with a popup blocker, then show it 
    176  
    177             if (!IsPopupBlocker()){     
    178                    window.showModalDialog('./securityredirect', 'please log in', 'dialogHeight=350px', 'dialogWidth=500px'); 
    179                  
    180                    //when logged in and new window closed, try again: 
    181                    successFn =bindDataToTree.bindAsEventListener(this); 
    182                    failureFn = onSecurityFail.bindAsEventListener(this); 
    183                    this.wmcRetriever.getWMC(wmcEndpoint, successFn, failureFn); 
    184            } 
    185            else{ 
    186                alert('Please enable popups for this site to login to the secure WMS'); 
    187            } 
    188             
    189  
    190             } 
    191            else{ 
    192             alert("Attempt to retrive endpoint " + wmcEndpoint + " failed, response.status = " + resp.status + " (" + resp.statusText+ ")" + "."); 
    193             this.tree.removeNode(loadingNode); 
    194             this.redrawTree(); 
    195             WMSC.log("Attempt to retrive endpoint " + wmcEndpoint + " failed, response.status = " + resp.status + " (" + resp.statusText+ ")" + ".") 
     206                WMSC.log("Attempt to retrive endpoint " + wmcEndpoint + " failed, response.status = " + resp.status + " (" + resp.statusText + ")" + "."); 
    196207            }  
    197             } 
    198          
     208        }; 
    199209         
    200210        this.redrawTree(); 
    201211         
    202         successFn =bindDataToTree.bindAsEventListener(this); 
    203         failureFn = onRetriveWMCFail.bindAsEventListener(this); 
     212        var successFn = bindDataToTree.bindAsEventListener(this); 
     213        var failureFn = onRetriveWMCFail.bindAsEventListener(this); 
    204214                 
    205215        this.wmcRetriever.getWMC(wmcEndpoint, successFn, failureFn); 
     
    214224     * @param parentNode - parent node in treeview 
    215225     */ 
    216     _addWMCTree: function(wmc, wmcEndpoint, parentNode)  
     226    _addWMCTree: function (wmc, wmcEndpoint, parentNode)  
    217227    { 
    218228         
     
    232242        var subLayers = wmc.getSubLayers(); 
    233243         
    234         for (var i=0; i<subLayers.length; i++)  
    235         { 
    236             this._addLayerTree( subLayers[i], wmcEndpoint, wmcTreeNode); 
     244        for (var i = 0; i < subLayers.length; i++)  
     245        { 
     246            this._addLayerTree(subLayers[i], wmcEndpoint, wmcTreeNode); 
    237247        } 
    238248         
     
    248258     * @param parentNode - parent node in treeview 
    249259     */ 
    250     _addLayerTree: function(layer, wmcEndpoint, parentNode) { 
     260    _addLayerTree: function (layer, wmcEndpoint, parentNode) { 
    251261         
    252262        var labelText = layer.getAbstract(); 
    253263         
    254         if (labelText == null || labelText == "") { 
     264        if (labelText === null || labelText === "") { 
    255265            labelText = layer.getTitle(); 
    256266        } 
    257267         
    258         nodeData = {}; 
     268        var nodeData = {}; 
    259269        nodeData.wmcEndpoint = wmcEndpoint; 
    260270        nodeData.label = labelText; 
     
    268278        var subLayers = layer.getSubLayers(); 
    269279         
    270         for (var i=0; i<subLayers.length; i++) { 
    271              this._addLayerTree(subLayers[i], wmcEndpoint, treeNode); 
     280        for (var i = 0; i < subLayers.length; i++) { 
     281            this._addLayerTree(subLayers[i], wmcEndpoint, treeNode); 
    272282        } 
    273283          
     
    281291     * @param nodeIndex - index in tree of label - used to identify the delete event 
    282292     */ 
    283     _createNodeLabel: function(nodeLabel, nodeIndex) 
     293    _createNodeLabel: function (nodeLabel, nodeIndex) 
    284294    { 
    285295        return '<table><tr><td class="nodeTitle">' +  
     
    293303     * @param evt 
    294304     */ 
    295     _removeNode: function(evt) 
     305    _removeNode: function (evt) 
    296306    { 
    297307        var delIcon = Event.element(evt); 
    298308 
    299309        // get the node name from the icon ID 
    300         nodeIndex = delIcon.id.substring(delIcon.id.indexOf("_") + 1, delIcon.id.length);             
    301          
    302         node = this.tree.getNodeByIndex(nodeIndex); 
     310        var nodeIndex = delIcon.id.substring(delIcon.id.indexOf("_") + 1, delIcon.id.length);             
     311         
     312        var node = this.tree.getNodeByIndex(nodeIndex); 
    303313        var params = {removeItem: node.data.wmcEndpoint}; 
    304         this.tree.removeNode(node) 
     314         
     315        this.tree.removeNode(node); 
     316         
    305317        // need to redraw to show this change  
    306318        this.redrawTree(); 
    307319    }, 
    308                  
     320     
     321    /** 
     322     * Called when a tree node is clicked on, because the clickEvent arguments  
     323     * are slightly different to the labelClick or Expand events just pulling out 
     324     * the node and then calling _selectedTreeNode.  
     325     */ 
     326    _onTreeClick: function (args) { 
     327        var event = args.event; 
     328        var node = args.node; 
     329        this._selectTreeNode(node); 
     330    }, 
     331     
    309332    /** 
    310333     * Respond to a tree node being selected 
     
    312335     * a layer, by adding it to the selected layer div 
    313336     */ 
    314     _selectTreeNode: function(node) { 
     337    _selectTreeNode: function (node) { 
    315338         
    316339        var i, layer; 
     
    321344        // clear the already selected node 
    322345        node1 = this._selectedTreeNode; 
    323         while (node1 != null)  
     346        while (node1 !== null)  
    324347        { 
    325348            if (node1.labelElId)  
     
    338361         
    339362        // select the new nodes 
    340         while (node1 != null)  
     363        while (node1 !== null)  
    341364        { 
    342365            if (node1.labelElId)  
     
    354377        // NB, need to treat differently depending on whether we're dealing 
    355378        // with a GetCapabilities or a GetWebMapContext call 
    356         if (node.children.length == 0)  
     379        if (node.children.length === 0)  
    357380        { 
    358381             
    359382            // check this isn't the 'loading...' leaf; escape if it is 
    360             if (node.label.indexOf("...loading") > -1) 
     383            if (node.label.indexOf("...loading") > -1) { 
    361384                return; 
     385            } 
    362386 
    363387            //add the selected layer to the layers panel 
     
    372396     * Add a new Layer to the layer list 
    373397     */ 
    374     _addLayer: function(node)  
     398    _addLayer: function (node)  
    375399    {     
    376400         
     
    378402        var newLayer = this.makeNewLayer(node.data.wmcEndpoint, node.data.layer); 
    379403         
    380         this.events.triggerEvent("NEW_LAYER", {layer:newLayer}); 
     404        this.events.triggerEvent("NEW_LAYER", {layer: newLayer}); 
    381405         
    382406        return; 
     
    391415     * index to ensure that it is unique for each layer 
    392416     */ 
    393     makeNewLayer: function(url, layerName) { 
    394          
    395         var defaultParams = this.defaultSetter.getDefaults(url, layerName)  
     417    makeNewLayer: function (url, layerName) { 
     418         
     419        var defaultParams = this.defaultSetter.getDefaults(url, layerName);  
    396420         
    397421        var layer = new OpenLayers.Layer.WMS("#" + this.idIndex + " " + layerName,  
    398422                url, defaultParams); 
    399423 
    400         layer.params['LAYERS'] = layerName 
     424        layer.params['LAYERS'] = layerName; 
    401425        layer.id = url + "_" + layer.name + "_" + this.idIndex; 
    402426 
     
    409433     * Event handler for the new endpoint button click 
    410434     */ 
    411     onNewEndpointClick: function(evt) { 
     435    onNewEndpointClick: function (evt) { 
    412436        var element = Event.element(evt); 
    413437        this.addWebMapContext(this.endpointInputBox.value); 
     
    418442     * loaded. 
    419443     */ 
    420     addLayersToSelect: function(endpoint, layers) { 
     444    addLayersToSelect: function (endpoint, layers) { 
    421445        this.layersToSelect[endpoint] = layers; 
    422446    }, 
     
    426450     * the initial selection when the page is loaded. 
    427451     */ 
    428     _selectEndpointLayers: function(endpointURL, layers) { 
     452    _selectEndpointLayers: function (endpointURL, layers) { 
    429453         
    430454        var endpointNode = this._getNodeForEndpoint(endpointURL); 
    431455         
    432         if (endpointNode == null) { 
     456        if (endpointNode === null) { 
    433457            WMSC.log("No node found for endpoint " + endpointURL); 
    434             return 
    435         } 
    436          
    437         if (endpointNode.expanded == false) { 
     458            return; 
     459        } 
     460         
     461        if (endpointNode.expanded === false) { 
    438462            endpointNode.expand(); 
    439463        } 
    440464         
    441         for (var i=0;i<layers.length;i++){ 
     465        for (var i = 0; i < layers.length; i++) { 
    442466            var layerName = layers[i]; 
    443467            var layerNode = this._getChildNodeForLayer(endpointNode, layerName); 
    444468             
    445             if (layerNode == null) { 
    446                 WMSC.log("No node found for layer " + layerName +" in endpoint " + endpointURL); 
     469            if (layerNode === null) { 
     470                WMSC.log("No node found for layer " + layerName + " in endpoint " + endpointURL); 
    447471                continue; 
    448472            } 
     
    456480     * Retrieve a node form the tree vieew that corresponds to a given endpoint 
    457481     */ 
    458     _getNodeForEndpoint: function(endpointURL) { 
     482    _getNodeForEndpoint: function (endpointURL) { 
    459483        var endpointNodes = this.tree.root.children; 
    460         for (var i=0;i<endpointNodes.length;i++){ 
     484         
     485        for (var i = 0; i < endpointNodes.length; i++) { 
    461486            var node = endpointNodes[i]; 
    462             if (node.data.wmcEndpoint == endpointURL) { 
     487            if (node.data.wmcEndpoint === endpointURL) { 
    463488                return node; 
    464489            } 
     
    470495     * Find the child node that matches the layerName given for a endpoint's node. 
    471496     */ 
    472     _getChildNodeForLayer: function(endpointNode, layerName) { 
    473         for (var i=0; i<endpointNode.children.length; i++) { 
     497    _getChildNodeForLayer: function (endpointNode, layerName) { 
     498         
     499        for (var i = 0; i < endpointNode.children.length; i++) { 
    474500            var child = endpointNode.children[i]; 
    475501             
    476             if (child.data.layer == layerName) { 
     502            if (child.data.layer === layerName) { 
    477503                return child; 
    478504            } 
    479505        } 
    480506        return null; 
    481     }, 
    482      
    483      
    484 } 
     507    } 
     508     
     509}; 
    485510 
    486511 
     
    490515} 
    491516 
    492  
    493  
    494517function IsPopupBlocker() { 
    495 var oWin = window.open("./","testpopupblocker"); 
    496  
    497 if (oWin==null || typeof(oWin)=="undefined") { 
    498 return true; 
    499 } else { 
    500 oWin.close(); 
    501 return false; 
    502 } 
     518    var oWin = window.open("./", "testpopupblocker"); 
     519 
     520    if (oWin === null || typeof(oWin) === "undefined") { 
     521        return true; 
     522    } else { 
     523        oWin.close(); 
     524        return false; 
     525    } 
    503526} 
    504527    
  • cowsclient/trunk/cowsclient/public/js/layerDimensions.js

    r5709 r5719  
    11/** 
    22 * @requires Openlayer.Event 
    3  * @requires DisplayOptionsRetriever 
    43 * @requires utils 
    54 *  
    65 */ 
    76 
     7/*globals WMSC: false, OpenLayers: false, document: false, Utils: false*/ 
     8 
     9 
    810/** 
    911 * @constructor 
    1012 */ 
    11 LayerDimensions = function(layerDimensionsFormId) { 
    12      
     13var LayerDimensions = function (layerDimensionsFormId) { 
    1314    this._form = document.getElementById(layerDimensionsFormId); 
    1415    this.events = new OpenLayers.Events(this, null, this.EVENTS_RAISED); 
    15      
    1616    this._handler  = null; 
    17      
    18 } 
     17}; 
    1918 
    2019LayerDimensions.prototype = { 
     
    2524     * Adds the handler for the CURRENT_LAYER_CHANGED event 
    2625     */ 
    27     addCurrentWMCLayerChangedHandlers: function(events) { 
     26    addCurrentWMCLayerChangedHandlers: function (events) { 
    2827        events.register('CURRENT_WMCLAYER_CHANGED', this, this._onCurrentLayerChanged); 
    2928    }, 
    3029     
    31     _onCurrentLayerChanged: function(e) { 
     30    _onCurrentLayerChanged: function (e) { 
    3231        this._clearForm(); 
    3332         
    34         if (e.wmcLayer != null && e.olLayer != null) { 
     33        if (e.wmcLayer !== null && e.olLayer !== null) { 
    3534            this._buildForm(e.wmcLayer, e.olLayer); 
    3635        } 
    3736    }, 
    3837     
    39     _clearForm: function(){ 
     38    _clearForm: function () { 
    4039         
    41         if (this._handler != null) { 
    42                 Utils.removeHTMLEventListener(this._form.getElementsByTagName('fieldset')[0], 'change', this._handler) 
     40        if (this._handler !== null) { 
     41                Utils.removeHTMLEventListener(this._form.getElementsByTagName('fieldset')[0], 'change', this._handler); 
    4342                this._handler = null; 
    4443        } 
     
    4746    },     
    4847     
    49     _buildForm: function(wmcLayer, olLayer) { 
     48    _buildForm: function (wmcLayer, olLayer) { 
    5049        var div, i; 
    5150        var dims = wmcLayer.getDimensions(); 
     
    5554        fs.appendChild(leg); 
    5655         
    57         for (id in dims) {  
     56        for (var id in dims) {  
    5857             
    59             extent = dims[id].getExtent(); 
     58            var extent = dims[id].getExtent(); 
    6059         
    6160            var values = []; 
    6261            var descriptions = []; 
    6362             
    64             for (i=0; i<extent.length; i++) { 
     63            for (i = 0; i < extent.length; i++) { 
    6564                descriptions.push(this.getDimensionText(dims[id], extent[i])); 
    6665                values.push(extent[i]); 
     
    7069            var select = Utils.buildSelectBox(id, descriptions, values, defaultVal); 
    7170 
    72             var div = Utils.buildLabelInputDiv(dims[id].getName(), select, 'layerDimItem') 
     71            div = Utils.buildLabelInputDiv(dims[id].getName(), select, 'layerDimItem'); 
    7372             
    7473            fs.appendChild(div); 
     
    8584     */ 
    8685    _onSelectionChange: function (e) { 
    87         param = e.target.id.substr(7); 
     86        var param = e.target.id.substr(7); 
    8887 
    89         this.events.triggerEvent("LAYER_DIMENSION_CHANGED", {param:param, 
    90                                                              value:e.target.value}); 
     88        this.events.triggerEvent("LAYER_DIMENSION_CHANGED", {param: param, 
     89                                                             value: e.target.value}); 
    9190    }, 
    9291 
     
    9493     * Given a dimension and a value return the display text 
    9594     */ 
    96     getDimensionText: function(dim, value) { 
     95    getDimensionText: function (dim, value) { 
    9796        return value; 
    9897    }, 
    9998         
    100     _getLayerProperty: function(olLayer, id) { 
     99    _getLayerProperty: function (olLayer, id) { 
    101100        var val = null; 
    102101         
    103         if (olLayer != null) { 
     102        if (olLayer !== null) { 
    104103            val = olLayer.params[id.toUpperCase()]; 
    105104        } 
     
    108107    }, 
    109108 
    110     getSelectedDimensions: function() { 
     109    getSelectedDimensions: function () { 
    111110        var dims = {}; 
    112111         
    113         for (var i=0; i< this._form.elements.length; i++) { 
     112        for (var i = 0; i < this._form.elements.length; i++) { 
    114113                var element = this._form.elements[i]; 
    115114                 
    116                 if (element.name != null) { 
     115                if (element.name !== null) { 
    117116                    // get rid of the 'selected_' from the start of the element name 
    118117                        dims[element.name.substr(7)] = element.value; 
     
    121120         
    122121        return dims; 
    123     }, 
    124      
    125 } 
     122    } 
     123}; 
  • cowsclient/trunk/cowsclient/public/js/layerDisplayOptions.js

    r5709 r5719  
    44 */ 
    55 
     6/*globals WMSC: false, document: false, Utils:false, OpenLayers:false  
     7          DisplayOptionsRetriever:false*/ 
    68 
    79/** 
     
    2426 * @constructor 
    2527 */ 
    26 LayerDisplayOpts = function(layerDisplayOptionsFormId, hideDisplayOptions) { 
     28var LayerDisplayOpts = function (layerDisplayOptionsFormId, hideDisplayOptions) { 
    2729     
    2830    this._form = document.getElementById(layerDisplayOptionsFormId); 
     
    3335    this.currentOLLayer = null; 
    3436    this._handler = null; 
    35 } 
     37}; 
    3638 
    3739LayerDisplayOpts.prototype = { 
    38         EVENTS_RAISED: ['LAYER_DISPLAY_CHANGED'], 
    39          
    40         /** 
    41          * Adds the handler for the LAYER_STYLE_CHANGED event 
    42          */ 
    43         addStyleChangedEvent: function(events) { 
    44             events.register("LAYER_STYLE_CHANGED", this, this._onLayerStyleChanged); 
    45         }, 
    46  
    47         /** 
    48          * Adds the handler for the CURRENT_LAYER_CHANGED event 
    49          */ 
    50         addCurrentWMCLayerChangedHandlers: function(events) { 
    51             events.register('CURRENT_WMCLAYER_CHANGED', this, this._onCurrentLayerChanged); 
    52         }, 
    53  
    54         _onSelectionChange: function(e) { 
    55             var param = e.target.id.substr(7); 
    56             var value = e.target.value; 
    57              
    58             if (e.target.type == "checkbox") { 
    59                 value = (e.target.checked) ? 'True' : 'False'; 
    60             } 
    61              
    62             this.events.triggerEvent('LAYER_DISPLAY_CHANGED', {param:param,  
    63                                                                value:value}); 
    64         }, 
    65  
    66         /** 
    67          * Handler for the layer style changed event, re-creates the display options 
    68          * for the new style. 
    69          */ 
    70         _onLayerStyleChanged: function(style) { 
    71           this._buildDisplayControls(this.currentWMCLayer); 
    72         }, 
    73          
    74          /** 
    75           * handler for the current layer changed event 
    76           */ 
    77         _onCurrentLayerChanged: function(e) { 
    78             this._clearForm(); 
    79              
    80             this.currentWMCLayer = e.wmcLayer; 
    81             this.currentOLLayer = e.olLayer; 
    82              
    83             if (e.wmcLayer != null && e.olLayer != null) { 
    84                 this._buildDisplayControls(e.wmcLayer); 
    85             } 
    86              
    87         }, 
    88          
    89         /** 
    90          * Rebuilds all of the display option controls given by the layer 
    91          */ 
    92         _buildDisplayControls: function(wmcLayer) { 
    93  
    94             //add the display options (if set) 
    95             var dispURL = wmcLayer.getDisplayOptionsURL(); 
    96              
    97             if (dispURL != null) { 
    98                 successFn =this._buildDisplayOptions.bindAsEventListener(this); 
     40    EVENTS_RAISED: ['LAYER_DISPLAY_CHANGED'], 
     41         
     42    /** 
     43     * Adds the handler for the LAYER_STYLE_CHANGED event 
     44     */ 
     45    addStyleChangedEvent: function (events) { 
     46        events.register("LAYER_STYLE_CHANGED", this, this._onLayerStyleChanged); 
     47    }, 
     48 
     49    /** 
     50     * Adds the handler for the CURRENT_LAYER_CHANGED event 
     51     */ 
     52    addCurrentWMCLayerChangedHandlers: function (events) { 
     53        events.register('CURRENT_WMCLAYER_CHANGED', this, this._onCurrentLayerChanged); 
     54    }, 
     55 
     56    _onSelectionChange: function (e) { 
     57        var param = e.target.id.substr(7); 
     58        var value = e.target.value; 
     59         
     60        if (e.target.type === "checkbox") { 
     61                value = (e.target.checked) ? 'True' : 'False'; 
     62        } 
     63         
     64        this.events.triggerEvent('LAYER_DISPLAY_CHANGED',  
     65            { 
     66                param: param,  
     67                value: value 
     68            } 
     69        ); 
     70    }, 
     71 
     72    /** 
     73     * Handler for the layer style changed event, re-creates the display options 
     74     * for the new style. 
     75     */ 
     76    _onLayerStyleChanged: function (style) { 
     77        this._buildDisplayControls(this.currentWMCLayer); 
     78    }, 
     79     
     80     /** 
     81      * handler for the current layer changed event 
     82      */ 
     83    _onCurrentLayerChanged: function (e) { 
     84        this._clearForm(); 
     85         
     86        this.currentWMCLayer = e.wmcLayer; 
     87        this.currentOLLayer = e.olLayer; 
     88         
     89        if (e.wmcLayer !== null && e.olLayer !== null) { 
     90            this._buildDisplayControls(e.wmcLayer); 
     91        } 
     92         
     93    }, 
     94     
     95    /** 
     96     * Rebuilds all of the display option controls given by the layer 
     97     */ 
     98    _buildDisplayControls: function (wmcLayer) { 
     99 
     100        //add the display options (if set) 
     101        var dispURL = wmcLayer.getDisplayOptionsURL(); 
     102         
     103        if (dispURL !== null) { 
     104            var successFn = this._buildDisplayOptions.bindAsEventListener(this); 
     105             
     106            this.displayOptsRetriever.getDisplayOptions(dispURL, successFn); 
     107        } 
     108         
     109    }, 
     110 
     111    _clearForm: function () { 
     112         
     113        if (this._handler !== null) { 
     114             
     115                Utils.removeHTMLEventListener(this._form.getElementsByTagName('fieldset')[0], 'change', this._handler); 
     116                this._handler = null; 
     117        } 
     118         
     119        this._form.innerHTML = ""; 
     120    },     
     121     
     122    /** 
     123     * Given a display options object builds a list of display options inputs for 
     124     * the currently selected layer. 
     125     */ 
     126    _buildDisplayOptions: function (displayOptions) { 
     127         
     128        this._clearForm(); 
     129         
     130        var endpoint = this.currentOLLayer.url; 
     131        var hideOptions = []; 
     132         
     133        if (this.hideDisplayOptions !== null) { 
     134            for (var i = 0; i < this.hideDisplayOptions.length; i++) { 
     135                 
     136                if (Utils.reMatch(this.hideDisplayOptions[i].endpoint, endpoint)) { 
     137                    for (var j = 0; j < this.hideDisplayOptions[i].options.length; j++) { 
     138                        hideOptions.push(this.hideDisplayOptions[i].options[j]); 
     139                    } 
     140                } 
     141                 
     142            } 
     143        } 
     144         
     145        WMSC.log("Hideoptions =" + hideOptions); 
     146         
     147        var fs = document.createElement('fieldset'); 
     148        var leg = document.createElement('legend'); 
     149        leg.innerHTML = 'Display Options'; 
     150        fs.appendChild(leg); 
     151 
     152        if (displayOptions.common !== undefined) { 
     153                fs.appendChild(this._buildDisplayOptionsList(displayOptions.common, hideOptions)); 
     154        } 
     155         
     156        // also add the style specific options 
     157        var currentStyle = this._getCurrentLayerProperty('styles'); 
     158         
     159        if (currentStyle !== null) { 
     160            if (displayOptions[currentStyle] !== undefined) { 
     161                fs.appendChild(this._buildDisplayOptionsList(displayOptions[currentStyle], hideOptions)); 
     162            } 
     163        } 
     164         
     165        // this is needed as this function is called via AJAX an might be called 
     166        // run at the same time as another  
     167        this._form.innerHTML = ""; 
     168         
     169        this._form.appendChild(fs); 
     170        this._handler = Utils.addHTMLEventListener(fs, 'change', this._onSelectionChange, this); 
     171    }, 
     172     
     173    /** 
     174     * Given a list of display options builds the corresponding html inputs. 
     175     *  
     176     * @returns a div object containing all the inputs objects 
     177     */ 
     178    _buildDisplayOptionsList: function (optionsList, hideOptions) { 
     179        var div = document.createElement('div'); 
     180 
     181        for (var i = 0; i < optionsList.length; i++) { 
     182            var opt = optionsList[i]; 
     183             
     184            if (Utils.isValueInList(opt.name, hideOptions)) { 
     185                continue; 
     186            } 
     187 
     188            if (opt.type === 'select') { 
     189                div.appendChild(this._buildDisplayOptionSelect(opt)); 
     190            }  
     191            else if (opt.type === 'value') { 
     192                div.appendChild(this._buildDisplayOptionValue(opt)); 
     193            } 
     194            else if (opt.type === 'bool') { 
     195                div.appendChild(this._buildDisplayOptionBool(opt)); 
     196            } 
     197        } 
     198         
     199        return div; 
     200    }, 
     201     
     202    _buildDisplayOptionSelect: function (opt) { 
     203        var title = this._getDisplayOptionTitle(opt); 
     204         
     205        var defaultVal =  this._getDefaultValue(opt); 
     206        var select = Utils.buildSelectBox(opt.name, opt.options, opt.options, defaultVal); 
     207         
     208        var div = Utils.buildLabelInputDiv(title, select, 'displayOptionItem'); 
     209        return div; 
     210    }, 
     211         
     212    _buildDisplayOptionValue: function (opt) { 
     213         
     214        var title = this._getDisplayOptionTitle(opt); 
     215         
     216        var input = document.createElement('input'); 
     217        input.id = 'select_' + opt.name; 
     218        input.name = 'select_' + opt.name; 
     219        input.type = 'text'; 
     220        input.value = this._getDefaultValue(opt); 
     221         
     222        Utils.addHTMLEventListener(input, 'keypress', Utils.disableEnterKey, this); 
     223         
     224        var div = Utils.buildLabelInputDiv(title, input, 'displayOptionItem'); 
     225        return div; 
     226    }, 
     227     
     228    _buildDisplayOptionBool: function (opt) { 
     229         
     230        var title = this._getDisplayOptionTitle(opt); 
     231         
     232        var input = document.createElement('input'); 
     233        input.id = 'select_' + opt.name; 
     234        input.name = 'select_' + opt.name; 
     235        input.type = 'checkbox'; 
     236        input.onClick = ""; 
     237         
     238        var defaultVal = this._getDefaultValue(opt); 
     239         
     240        if (String(defaultVal).toUpperCase() === "TRUE") { 
     241                input.checked = true; 
     242        } 
     243                     
     244        var div = Utils.buildLabelInputDiv(title, input, 'displayOptionItem'); 
     245        return div; 
     246    }, 
     247     
     248    _getDefaultValue: function (opt) { 
     249        var val = this._getCurrentLayerProperty(opt.name); 
     250         
     251        if (val === null) { 
     252                if (opt.defaultVal === undefined || opt.defaultVal === null) { 
     253                        val = ''; 
     254                } 
     255                else { 
     256                        val = opt.defaultVal; 
     257                } 
     258        } 
     259         
     260        return val; 
     261    }, 
     262     
     263    _getCurrentLayerProperty: function (id) { 
     264        var val = null; 
     265         
     266        if (this.currentOLLayer !== null) { 
     267            val = this.currentOLLayer.params[id.toUpperCase()]; 
     268             
     269            if (val === "" && id.toUpperCase() === 'STYLES') { 
    99270                 
    100                 this.displayOptsRetriever.getDisplayOptions(dispURL, successFn ); 
    101             } 
    102              
    103         }, 
    104  
    105         _clearForm: function(){ 
    106              
    107             if (this._handler != null) { 
    108                 Utils.removeHTMLEventListener(this._form.getElementsByTagName('fieldset')[0], 'change', this._handler) 
    109                 this._handler = null; 
    110             } 
    111              
    112             this._form.innerHTML = ""; 
    113         },     
    114          
    115         /** 
    116          * Given a display options object builds a list of display options inputs for 
    117          * the currently selected layer. 
    118          */ 
    119         _buildDisplayOptions: function(displayOptions) { 
    120              
    121                 this._clearForm(); 
    122                  
    123                 var endpoint = this.currentOLLayer.url; 
    124                 var hideOptions = []; 
    125                  
    126                 if (this.hideDisplayOptions != null) { 
    127                     for (var i=0;i<this.hideDisplayOptions.length;i++) { 
    128                          
    129                         if (Utils.reMatch(this.hideDisplayOptions[i].endpoint, endpoint)) { 
    130                             for (var j=0;j<this.hideDisplayOptions[i].options.length;j++) { 
    131                                 hideOptions.push(this.hideDisplayOptions[i].options[j]); 
    132                             } 
    133                         } 
    134                          
    135                     } 
    136                 } 
    137                  
    138                 WMSC.log("Hideoptions =" + hideOptions) 
    139                  
    140             var fs = document.createElement('fieldset'); 
    141             var leg = document.createElement('legend'); 
    142             leg.innerHTML = 'Display Options'; 
    143             fs.appendChild(leg); 
    144  
    145             if (displayOptions.common != undefined) { 
    146                 fs.appendChild(this._buildDisplayOptionsList(displayOptions.common, hideOptions)); 
    147             } 
    148              
    149             // also add the style specific options 
    150             var currentStyle = this._getCurrentLayerProperty('styles'); 
    151              
    152             if (currentStyle != null) { 
    153                 if (displayOptions[currentStyle] != undefined) { 
    154                     fs.appendChild(this._buildDisplayOptionsList(displayOptions[currentStyle], hideOptions)); 
     271                //assume that the first sytle is the default one 
     272                var styles = this.currentWMCLayer.getStyles(); 
     273                 
     274                if (styles.length > 0) { 
     275                    val = styles[0].name; 
    155276                } 
    156             } 
    157              
    158             // this is needed as this function is called via AJAX an might be called 
    159             // run at the same time as another  
    160             this._form.innerHTML = ""; 
    161              
    162             this._form.appendChild(fs); 
    163             this._handler = Utils.addHTMLEventListener(fs, 'change', this._onSelectionChange, this); 
    164         }, 
    165          
    166         /** 
    167          * Given a list of display options builds the corresponding html inputs. 
    168          *  
    169          * @returns a div object containing all the inputs objects 
    170          */ 
    171         _buildDisplayOptionsList: function(optionsList, hideOptions) { 
    172             var div = document.createElement('div'); 
    173  
    174             for (var i=0; i< optionsList.length; i++) { 
    175                 var opt = optionsList[i]; 
    176277                 
    177                 if (Utils.isValueInList(opt.name, hideOptions)) { 
    178                     continue; 
    179                 } 
    180  
    181                 if (opt.type == 'select') { 
    182                     div.appendChild(this._buildDisplayOptionSelect(opt)); 
    183                 }  
    184                 else if (opt.type == 'value') { 
    185                     div.appendChild(this._buildDisplayOptionValue(opt)); 
    186                 } 
    187                 else if (opt.type == 'bool') { 
    188                         div.appendChild(this._buildDisplayOptionBool(opt)); 
    189                 } 
    190             } 
    191              
    192             return div 
    193         }, 
    194          
    195         _buildDisplayOptionSelect: function(opt) { 
    196             var title = this._getDisplayOptionTitle(opt); 
    197              
    198             var defaultVal =  this._getDefaultValue(opt); 
    199             select = Utils.buildSelectBox(opt.name , opt.options, opt.options, defaultVal); 
    200              
    201             var div = Utils.buildLabelInputDiv(title, select, 'displayOptionItem') 
    202             return div 
    203         }, 
    204          
    205         _buildDisplayOptionValue: function(opt) { 
    206              
    207             var title = this._getDisplayOptionTitle(opt); 
    208              
    209             var input = document.createElement('input'); 
    210             input.id = 'select_' + opt.name; 
    211             input.name = 'select_' + opt.name; 
    212             input.type = 'text'; 
    213              
    214             input.value = this._getDefaultValue(opt); 
    215             var div = Utils.buildLabelInputDiv(title, input, 'displayOptionItem'); 
    216             return div; 
    217         }, 
    218          
    219         _buildDisplayOptionBool: function(opt) { 
    220              
    221             var title = this._getDisplayOptionTitle(opt); 
    222              
    223             var input = document.createElement('input'); 
    224             input.id = 'select_' + opt.name; 
    225             input.name = 'select_' + opt.name; 
    226             input.type = 'checkbox'; 
    227             input.onClick = ""; 
    228              
    229             var defaultVal = this._getDefaultValue(opt); 
    230             if (String(defaultVal).toUpperCase() == "TRUE") { 
    231                 input.checked = true; 
    232             } 
    233                          
    234             var div = Utils.buildLabelInputDiv(title, input, 'displayOptionItem'); 
    235             return div; 
    236         }, 
    237          
    238         _getDefaultValue: function(opt) { 
    239             val = this._getCurrentLayerProperty(opt.name); 
    240              
    241             if (val == null){ 
    242                 if (opt.defaultVal == undefined || opt.defaultVal == null ) { 
    243                         val = ''; 
    244                 } 
    245                 else { 
    246                         val = opt.defaultVal; 
    247                 } 
    248             } 
    249              
    250             return val; 
    251         }, 
    252          
    253         _getCurrentLayerProperty: function(id) { 
    254             var val = null; 
    255              
    256             if (this.currentOLLayer != null) { 
    257                 val = this.currentOLLayer.params[id.toUpperCase()]; 
    258                  
    259                 if (val == "" && id.toUpperCase() == 'STYLES') { 
    260                      
    261                     //assume that the first sytle is the default one 
    262                     var styles = this.currentWMCLayer.getStyles(); 
    263                      
    264                     if (styles.length > 0) { 
    265                         val = styles[0].name; 
    266                     } 
    267                      
    268                 } 
    269             } 
    270              
    271             return val; 
    272         }, 
    273          
    274         _getDisplayOptionTitle: function(opt) { 
    275             title = opt.title; 
    276              
    277             if (title == undefined) { 
    278                 title = opt.name; 
    279             } 
    280              
    281             return title; 
    282         }, 
    283          
    284 } 
     278            } 
     279        } 
     280         
     281        return val; 
     282    }, 
     283     
     284    _getDisplayOptionTitle: function (opt) { 
     285        var title = opt.title; 
     286         
     287        if (title === undefined) { 
     288            title = opt.name; 
     289        } 
     290         
     291        return title; 
     292    } 
     293}; 
  • cowsclient/trunk/cowsclient/public/js/layerInformation.js

    r5709 r5719  
    44 */ 
    55 
     6/*globals WMSC: false, document:false, OpenLayers: false, 
     7         DisplayOptionsRetriever: false, Utils: false*/ 
    68 
    79/** 
     
    2022 * @constructor 
    2123 */ 
    22 LayerInfo = function(layerInfoFormId) { 
     24var LayerInfo = function (layerInfoFormId) { 
    2325     
    2426    this._form = document.getElementById(layerInfoFormId); 
     
    3436    this._styleSelect = null; 
    3537     
    36     this._currentSelection =  new OpenLayers.Bounds(-180,-90,180,90); 
    37 } 
     38    this._currentSelection =  new OpenLayers.Bounds(-180, -90, 180, 90); 
     39}; 
    3840 
    3941LayerInfo.prototype = { 
     
    4345     * Adds the handler for the CURRENT_LAYER_CHANGED event 
    4446     */ 
    45     addCurrentWMCLayerChangedHandlers: function(events) { 
     47    addCurrentWMCLayerChangedHandlers: function (events) { 
    4648        events.register('CURRENT_WMCLAYER_CHANGED', this, this._onCurrentLayerChanged); 
    4749    }, 
    4850 
    4951     
    50     _onStyleChange: function(e) { 
    51         this.events.triggerEvent('LAYER_STYLE_CHANGED', {param:'styles', 
    52                                                          value:e.target.value}); 
     52    _onStyleChange: function (e) { 
     53        this.events.triggerEvent('LAYER_STYLE_CHANGED',  
     54            {  
     55                param: 'styles', 
     56                value: e.target.value 
     57            } 
     58        ); 
    5359    }, 
    5460     
     
    5662      * handler for the current layer changed event 
    5763      */ 
    58     _onCurrentLayerChanged: function(e) { 
     64    _onCurrentLayerChanged: function (e) { 
    5965         
    6066        this._clearForm(); 
    6167         
    62         if (e.wmcLayer != null && e.olLayer != null) { 
     68        if (e.wmcLayer !== null && e.olLayer !== null) { 
    6369            this._buildInfo(e.wmcLayer, e.olLayer, e.wmc); 
    6470        } 
     
    7177     * Rebuilds all of the display option controls given by the layer 
    7278     */ 
    73     _buildInfo: function(wmcLayer, olLayer, wmc) { 
     79    _buildInfo: function (wmcLayer, olLayer, wmc) { 
    7480         
    7581        var fs = document.createElement('fieldset'); 
     
    102108    }, 
    103109 
    104     _buildStyleSelect: function(styles, currentStyle) { 
     110    _buildStyleSelect: function (styles, currentStyle) { 
    105111         
    106112        var values = []; 
    107113        var descriptions = []; 
    108114         
    109         for (var i=0;i<styles.length; i++) { 
     115        for (var i = 0; i < styles.length; i++) { 
    110116            values.push(styles[i].name); 
    111117            descriptions.push(styles[i].title); 
     
    119125    }, 
    120126     
    121     _clearForm: function(){ 
     127    _clearForm: function () { 
    122128         
    123129        // remove the event handler before deleting the element 
    124         if (this._styleSelect != null && this._selectHandler != null) { 
     130        if (this._styleSelect !== null && this._selectHandler !== null) { 
    125131            Utils.removeHTMLEventListener(this._styleSelect, 'change', this._selectHandler); 
    126132        } 
    127133         
    128134        // remove the get figure event handler 
    129         if (this._getFigureButton != null && this._getFigureHandler != null) { 
     135        if (this._getFigureButton !== null && this._getFigureHandler !== null) { 
    130136            Utils.removeHTMLEventListener(this._getFigureButton, 'click', this._getFigureHandler); 
    131137        } 
     
    140146    }, 
    141147     
    142     _getLayerProperty: function(olLayer, id) { 
     148    _getLayerProperty: function (olLayer, id) { 
    143149        var val = null; 
    144150         
    145         if (olLayer != null) { 
     151        if (olLayer !== null) { 
    146152            val = olLayer.params[id.toUpperCase()]; 
    147153        } 
     
    150156    }, 
    151157     
    152     _buildInfoItem: function(name, value) { 
     158    _buildInfoItem: function (name, value) { 
    153159        var span = document.createElement('span'); 
    154160        span.innerHTML = value; 
     
    158164    }, 
    159165     
    160     _buildGetFigureButton: function(wmc) { 
     166    _buildGetFigureButton: function (wmc) { 
     167        var i; 
    161168        var div = document.createElement('div'); 
    162169         
    163170        var req = wmc.getRequest('GetFigure'); 
    164          
    165         var formatDescriptions= []; 
     171        WMSC.log("req = " + req); 
     172         
     173        var formatDescriptions = []; 
    166174        var formatValues = []; 
    167175        var formatList = req.formats; 
    168                            
    169         for (var i=0;i<formatList.length;i++) { 
    170              
     176         
     177        WMSC.log("formatList.length = " + formatList.length); 
     178        for (i = 0; i < formatList.length; i++) { 
     179            WMSC.log("formatList[i] = " + formatList[i]); 
     180        } 
     181         
     182        for (i = 0; i < formatList.length; i++) { 
     183         
    171184            formatValues.push(formatList[i]); 
    172185             
    173             if (formatList[i] == 'image/svg+xml') { 
     186            if (formatList[i] === 'image/svg+xml') { 
    174187                formatDescriptions.push('SVG'); 
    175188            } 
    176             else if (formatList[i].indexOf('image/') == 0) { 
     189            else if (formatList[i].indexOf('image/') === 0) { 
    177190                formatDescriptions.push(formatList[i].slice(6, formatList[i].length).toUpperCase()); 
    178191            } 
    179             else if (formatList[i] == 'application/postscript') { 
     192            else if (formatList[i] === 'application/postscript') { 
    180193                formatDescriptions.push('PS'); 
    181194            } 
    182             else if (formatList[i] == 'application/pdf') { 
     195            else if (formatList[i] === 'application/pdf') { 
    183196                formatDescriptions.push('PDF'); 
    184197            }             
     
    189202         
    190203        var inputs = Utils.buildSelect(null, 'format', formatDescriptions, formatValues); 
     204         
    191205        div.appendChild(inputs); 
    192206         
    193207        this._getFigureButton = document.createElement('input'); 
    194         this._getFigureButton .type = 'button'; 
    195         this._getFigureButton .value = "Get Figure"; 
     208        this._getFigureButton.type = 'button'; 
     209        this._getFigureButton.value = "Get Figure"; 
    196210         
    197211        this._getFigureHandler = Utils.addHTMLEventListener(this._getFigureButton,  
     
    202216    }, 
    203217     
    204     _onGetFigureClick: function(e) { 
     218    _onGetFigureClick: function (e) { 
    205219        WMSC.log("_onGetFigureClick running"); 
    206220        this._addHiddenInputItems(); 
    207221         
    208         this._form.action=this.currentOLLayer.url;  
    209         this._form.method="get";  
    210         this._form.target="_blank"; 
     222        this._form.action = this.currentOLLayer.url;  
     223        this._form.method = "get";  
     224        this._form.target = "_blank"; 
    211225        this._form.submit(); 
    212226    }, 
    213227     
    214     _addHiddenInputItems: function() { 
     228    _addHiddenInputItems: function () { 
    215229         
    216230        // clear any old hidden inputs 
     
    218232         
    219233        for (var p in this.currentOLLayer.params) { 
    220             if (p.toUpperCase() == 'REQUEST') { 
     234            if (p.toUpperCase() === 'REQUEST') { 
    221235                this._hiddenInputContainer.appendChild(Utils.buildHiddenInputElement('REQUEST', 'GetFigure')); 
    222236            } 
    223             else if (p.toUpperCase() == 'FORMAT') { 
     237            else if (p.toUpperCase() === 'FORMAT') { 
    224238                //ignore the format parameter 
    225239            } 
    226240            else { 
    227                 this._hiddenInputContainer.appendChild(Utils.buildHiddenInputElement(p, layer.params[p])); 
    228             } 
    229         } 
    230          
    231         var bboxString = this._currentSelection.left + "," + this._currentSelection.bottom + "," + this._currentSelection.right+ "," + this._currentSelection.top; 
     241                this._hiddenInputContainer.appendChild(Utils.buildHiddenInputElement(p, this.currentOLLayer.params[p])); 
     242            } 
     243        } 
     244         
     245        var bboxString = this._currentSelection.left + "," + this._currentSelection.bottom + "," + this._currentSelection.right + "," + this._currentSelection.top; 
    232246         
    233247        this._hiddenInputContainer.appendChild(Utils.buildHiddenInputElement('BBOX', bboxString)); 
     
    236250    }, 
    237251    
    238     addMapSelectionChangedHandlers: function(events) { 
     252    addMapSelectionChangedHandlers: function (events) { 
    239253        events.register('MAP_SELECTION_CHANGED', this, this.onChangeSelection); 
    240254    }, 
    241255     
    242     onChangeSelection: function(e) { 
     256    onChangeSelection: function (e) { 
    243257        this._currentSelection = e.selection; 
    244     }, 
    245      
    246 } 
     258    } 
     259     
     260}; 
  • cowsclient/trunk/cowsclient/public/js/layerList.js

    r5709 r5719  
    1212 */ 
    1313 
     14/*globals WMSC: false, YAHOO: false, OpenLayers: false, document: false,  
     15          Utils:false, alert:false*/ 
     16 
    1417 
    1518var DDM = YAHOO.util.DragDropMgr; 
    1619 
    17 LayerList= OpenLayers.Class.create(); 
     20var LayerList = OpenLayers.Class.create(); 
    1821 
    1922LayerList.prototype = { 
     
    2528    EVENTS_RAISED: ['SELECTED_LAYER_CHANGED', 'LAYER_ORDER_CHANGED'], 
    2629 
    27     MAX_LAYERS:10, 
     30    MAX_LAYERS: 10, 
    2831     
    2932    /** 
     
    4043     * @param dragListId - ID of the ul that is being used for the drag list 
    4144     */ 
    42     initialize: function(dragListId) { 
     45    initialize: function (dragListId) { 
    4346                this._dragList = document.getElementById(dragListId); 
    4447            this._layers = []; 
     
    4750            this.target = new YAHOO.util.DDTarget(dragListId); 
    4851            this.removeLayerBtn = document.getElementById('btn_remove_selected_layer'); 
    49             Utils.addHTMLEventListener( this.removeLayerBtn, 'click', this._onRemoveClick, this); 
     52            Utils.addHTMLEventListener(this.removeLayerBtn, 'click', this._onRemoveClick, this); 
    5053        }, 
    5154     
     
    5457         * Adds the this._onItemClick event handler to all the current list items.  
    5558         */ 
    56         _addOnClickListeners: function() { 
     59        _addOnClickListeners: function () { 
    5760                var currentItems = this._getCurrentListItems(); 
    58                 for (var i=0; i<currentItems.length; i++) { 
    59                         Utils.addHTMLEventListener( currentItems[i], 'click', this._onItemClick, this); 
     61                for (var i = 0; i < currentItems.length; i++) { 
     62                        Utils.addHTMLEventListener(currentItems[i], 'click', this._onItemClick, this); 
    6063                } 
    6164        }, 
     
    6568         * clicked on 
    6669         */ 
    67         _onItemClick: function(event, target) { 
     70        _onItemClick: function (event, target) { 
    6871                this._selectItem(target); 
    6972        }, 
     
    7376         * being dragged. 
    7477         */ 
    75         _onDragEnd: function(item){ 
     78        _onDragEnd: function (item) { 
    7679                this._selectItem(item); 
    7780                this._triggerLayerOrderChange(); 
     
    8285         * selected layer (if there is a currently selected layer). 
    8386         */ 
    84         _onRemoveClick: function(event, target) { 
    85                 if (this.getSelectedLayer() != null) { 
     87        _onRemoveClick: function (event, target) { 
     88                if (this.getSelectedLayer() !== null) { 
    8689                        this._removeSelectedItem(); 
    8790                         
     
    99102         * Selects a given list item, does nothing if the item is already selected 
    100103         */ 
    101         _selectItem: function(item) { 
     104        _selectItem: function (item) { 
    102105 
    103106                if (! this._isSelected(item)) { 
     
    112115         * unselects all of the current items in the list 
    113116         */ 
    114         _unselectAll: function() { 
     117        _unselectAll: function () { 
    115118                var currentItems = this._getCurrentListItems(); 
    116119                for (var i in currentItems) { 
     
    123126         * item.className property. Does nothing if the item isn't selected. 
    124127         */ 
    125         _unselectItem: function(item) { 
     128        _unselectItem: function (item) { 
    126129 
    127130                if (this._isSelected(item)) { 
     
    135138         * the SELECTED_CLASS class. 
    136139         */ 
    137         _isSelected: function(item) { 
    138             if (item.className != undefined) { 
    139                 return item.className.slice(0,this.SELECTED_CLASS.length) == this.SELECTED_CLASS; 
     140        _isSelected: function (item) { 
     141            if (item.className !== undefined) { 
     142                return item.className.slice(0, this.SELECTED_CLASS.length) === this.SELECTED_CLASS; 
    140143            } 
    141144            return false; 
     
    147150         * it comes across. 
    148151         */ 
    149         _getSelectedItem: function() { 
     152        _getSelectedItem: function () { 
    150153 
    151154                var currentItems = this._getCurrentListItems(); 
    152155                for (var i in currentItems) { 
    153                         if (this._isSelected(currentItems[i]) ) { 
     156                        if (this._isSelected(currentItems[i])) { 
    154157                                return currentItems[i]; 
    155158                        } 
     
    161164         * Removes the currently selected item from the list 
    162165         */ 
    163         _removeSelectedItem: function() { 
     166        _removeSelectedItem: function () { 
    164167                var item = this._getSelectedItem(); 
    165168                this._removeItem(item); 
     
    169172         * Removes a given item from the drag list 
    170173         */ 
    171         _removeItem: function (item){ 
    172                 if (item != null) { 
    173                         x = DDM.getDDById(item.id); 
    174                         x.unreg();                       
     174        _removeItem: function (item) { 
     175                if (item !== null) { 
     176                        var x = DDM.getDDById(item.id); 
     177                        if (x !== null) { 
     178                            x.unreg(); 
     179                        } 
    175180                        this._removeLayer(item.id); 
    176181                        this._dragList.removeChild(item); 
     
    181186         * removes the openlayers layer with the given layerId from the layer list. 
    182187         */ 
    183         _removeLayer: function(layerId) { 
     188        _removeLayer: function (layerId) { 
    184189                var oldLayers = this._layers; 
    185190                var newLayers = []; 
    186                 for (var i=0; i<oldLayers.length;i++) { 
    187                         layer = oldLayers[i]; 
    188                         if (layer.id == layerId) { 
     191                for (var i = 0; i < oldLayers.length; i++) { 
     192                     
     193                        var layer = oldLayers[i]; 
     194                         
     195                        if (layer.id === layerId) { 
    189196                                delete layer;  
    190197                        } else { 
     
    200207     * @param layerId - the id of the layer that this list item will correspond to 
    201208     */ 
    202         _addListItem: function(layer) { 
    203  
    204                 currentItems = this._getCurrentListItems(); 
    205          
    206                 var itemNumber =  currentItems.length + 1; 
     209        _addListItem: function (layer) { 
     210 
     211                var currentItems = this._getCurrentListItems(); 
     212         
     213                var itemNumber = currentItems.length + 1; 
    207214                 
    208215                var onDrag = Utils.buildScopedFunction(this._onDragEnd, this); 
    209216                 
    210                 new YAHOO.example.DDList(layer.id, onDrag); 
     217                var lItem = new YAHOO.example.DDList(layer.id, onDrag); 
    211218                 
    212219                var li = document.createElement('li'); 
    213220                 
    214221                var firstItem = this._dragList.firstChild; 
    215                 this._dragList.insertBefore( li, firstItem); 
     222                this._dragList.insertBefore(li, firstItem); 
    216223                 
    217224                li.className = "list"; 
     
    227234         * Element objects corresponding to the '<li>' items in the list. 
    228235         */ 
    229         _getCurrentListItems: function() { 
     236        _getCurrentListItems: function () { 
    230237                var items = []; 
    231                 for (var i=0; i<this._dragList.childNodes.length; i++){ 
    232                         child = this._dragList.childNodes[i]; 
    233                         if (child.nodeType == 1 && child.nodeName == 'LI') { 
     238                for (var i = 0; i < this._dragList.childNodes.length; i++) { 
     239                     
     240                        var child = this._dragList.childNodes[i]; 
     241                         
     242                        if (child.nodeType === 1 && child.nodeName === 'LI') { 
    234243                                items.push(child); 
    235244                        } 
     
    242251         * Adds the onNewLayer handler tot he NEW_LAYER event. 
    243252         */ 
    244     addSelectorHandlers: function(events) { 
    245        events.register("NEW_LAYER", this, this.onNewLayer); 
     253    addSelectorHandlers: function (events) { 
     254            events.register("NEW_LAYER", this, this.onNewLayer); 
    246255    }, 
    247256 
     
    249258     * Handles the NEW_LAYER event, adds the new layer to the list 
    250259     */ 
    251     onNewLayer: function(e) { 
     260    onNewLayer: function (e) { 
    252261         
    253262        if (this._layers.length >= this.MAX_LAYERS) { 
    254           
    255             alert("Can't have more than " + this.MAX_LAYERS + " layers in the list.") 
     263            alert("Can't have more than " + this.MAX_LAYERS + " layers in the list."); 
    256264        } 
    257265        else { 
     
    265273     * and adds the openlayers layer to the layer list. 
    266274     */ 
    267     _addLayer: function(layer) { 
     275    _addLayer: function (layer) { 
    268276 
    269277        this._layers.push(layer); 
     
    278286     * of the layers in the list has been changed. 
    279287     */ 
    280     _triggerLayerOrderChange: function() { 
    281         this.events.triggerEvent("LAYER_ORDER_CHANGED", {layers:this._getOrderedLayers()});      
     288    _triggerLayerOrderChange: function () { 
     289        this.events.triggerEvent("LAYER_ORDER_CHANGED", {layers: this._getOrderedLayers()});     
    282290    }, 
    283291     
     
    286294     * layer has been selected.  
    287295     */ 
    288     _triggerSelectedLayerChange: function() { 
    289         this.events.triggerEvent("SELECTED_LAYER_CHANGED", {layer:this.getSelectedLayer()}); 
     296    _triggerSelectedLayerChange: function () { 
     297        this.events.triggerEvent("SELECTED_LAYER_CHANGED", {layer: this.getSelectedLayer()}); 
    290298    }, 
    291299 
     
    298306     * layers using the id. 
    299307     */ 
    300     _getOrderedLayers: function() { 
     308    _getOrderedLayers: function () { 
    301309        var currentItems = this._getCurrentListItems(); 
    302310         
    303311        var layers = []; 
    304                 for (var i=0; i<currentItems.length; i++){ 
    305                          
    306                         var layerId =currentItems[i].id; 
     312                for (var i = 0; i < currentItems.length; i++) { 
     313                        var layerId = currentItems[i].id; 
    307314                        layers.push(this._getLayerById(layerId)); 
    308                  
    309                 } 
     315                } 
     316 
    310317                return layers; 
    311318    }, 
     
    314321     * Gets a openlayers layer form the layer list with the given id. 
    315322     */ 
    316     _getLayerById: function(id) { 
    317         for (var i=0; i<this._layers.length; i++)  { 
    318                 if (this._layers[i].id == id) { 
     323    _getLayerById: function (id) { 
     324        for (var i = 0; i < this._layers.length; i++)  { 
     325                if (this._layers[i].id === id) { 
    319326                        return this._layers[i]; 
    320327                } 
     
    327334     * list item. 
    328335     */ 
    329     getSelectedLayer: function() { 
     336    getSelectedLayer: function () { 
    330337         
    331         item = this._getSelectedItem(); 
    332         if (item == null) { 
     338        var item = this._getSelectedItem(); 
     339        var layer; 
     340         
     341        if (item === null) { 
    333342                layer = null; 
    334343        } else { 
     
    338347    }, 
    339348 
    340         destroy: function() { 
     349        destroy: function () { 
    341350        this.events.destroy(); 
    342351        this.target.unreg(); 
     
    347356         * Removes all the items from the drag list. 
    348357         */ 
    349         _removeAllItems: function() { 
     358        _removeAllItems: function () { 
    350359        var currentItems = this._getCurrentListItems(); 
    351360         
    352                 for (var i=0; i<currentItems.length; i++) { 
    353                         this._removeItem(currentItems[i].id); 
     361                for (var i = 0; i < currentItems.length; i++) { 
     362                        this._removeItem(currentItems[i]); 
    354363                }        
    355         }, 
    356          
    357 } 
     364        } 
     365}; 
  • cowsclient/trunk/cowsclient/public/js/layerParameters.js

    r5698 r5719  
    55 *  
    66 */ 
     7 
     8/*globals WMSC: false, OpenLayers: false, LayerDisplayOpts: false, 
     9          LayerInfo: false, LayerDimensions: false, document: false*/ 
    710 
    811/** 
     
    1417 * @constructor 
    1518 */ 
    16 LayerParameters = function(propertiesDivId, selectionFormId, wmcRetriever, hideDisplayOptions) { 
     19var LayerParameters = function (propertiesDivId, selectionFormId, wmcRetriever, hideDisplayOptions) { 
    1720     
    1821     
     
    4144    this.layerDisplay.addStyleChangedEvent(this.layerInfo.events); 
    4245    WMSC.log("layer parameters created"); 
    43 } 
     46}; 
    4447 
    4548LayerParameters.prototype = { 
     
    4952    onParamChange: function (e) { 
    5053 
    51         if (this.currentOLLayer != null) { 
     54        if (this.currentOLLayer !== null) { 
    5255            this.currentOLLayer.params[e.param.toUpperCase()] = e.value; 
    5356            this.currentOLLayer.redraw(); 
    5457        } 
    5558 
    56         this.events.triggerEvent("LAYER_PROPERTY_CHANGED", {layer:this.currentOLLayer, 
    57                                                          wmcLayer:this.currentWMCLayer}); 
     59        this.events.triggerEvent("LAYER_PROPERTY_CHANGED", {layer: this.currentOLLayer, 
     60                                                         wmcLayer: this.currentWMCLayer}); 
    5861         
    5962    },     
     
    7376     * This also updates the this.currentLayer property. 
    7477     */ 
    75     onSelectedLayerChanged: function(e) { 
     78    onSelectedLayerChanged: function (e) { 
    7679                 
    7780        this.currentOLLayer = e.layer; 
    7881        this.currentWMCLayer = null; 
    7982         
    80         if (e.layer == null) { 
    81             this.events.triggerEvent('CURRENT_WMCLAYER_CHANGED', {wmc:null, 
    82                                                                   olLayer:null, 
    83                                                                   wmcLayer:null}); 
     83        if (e.layer === null) { 
     84            this.events.triggerEvent('CURRENT_WMCLAYER_CHANGED', {wmc: null, 
     85                                                                  olLayer: null, 
     86                                                                  wmcLayer: null}); 
    8487        } else { 
    8588            this.updateControls(); 
     
    9194     * Hides the properties div 
    9295     */ 
    93     hideControls: function() { 
     96    hideControls: function () { 
    9497        this.propertiesDiv.style.display = 'none'; 
    9598    }, 
     
    98101     * Shows the properties div and re-builds all of the controls in it 
    99102     */ 
    100     showControls: function() { 
     103    showControls: function () { 
    101104        this.propertiesDiv.style.display = 'block'; 
    102105    }, 
    103106     
    104     updateControls: function() { 
    105         successFn =this.buildControls.bindAsEventListener(this);    
     107    updateControls: function () { 
     108        var successFn = this.buildControls.bindAsEventListener(this);    
    106109        this.wmcRetriever.getWMC(this.currentOLLayer.url, successFn); 
    107110    }, 
     
    111114     * object. 
    112115     */ 
    113     buildControls: function(wmc) { 
     116    buildControls: function (wmc) { 
    114117         
    115118        //find the dimensions for the layer 
    116119        var wmcLayer = this.searchSubLayers(wmc.getSubLayers()); 
    117120        this.currentWMCLayer = wmcLayer; 
    118         this.events.triggerEvent('CURRENT_WMCLAYER_CHANGED', {wmc:wmc, 
    119                                                               olLayer:this.currentOLLayer, 
    120                                                               wmcLayer:this.currentWMCLayer}) 
     121        this.events.triggerEvent('CURRENT_WMCLAYER_CHANGED', {wmc: wmc, 
     122                                                              olLayer: this.currentOLLayer, 
     123                                                              wmcLayer: this.currentWMCLayer}); 
    121124    }, 
    122125     
     
    127130     * @returns The WMC.Layer object corresponding to the currently selected layer 
    128131     */ 
    129     searchSubLayers: function(subLayers){ 
     132    searchSubLayers: function (subLayers) { 
    130133        var wmcLayer = null; 
    131134         
    132         for (var i=0; i<subLayers.length; i++) { 
     135        for (var i = 0; i < subLayers.length; i++) { 
    133136            var layer = subLayers[i]; 
    134137             
    135             if (layer.getName() == this.currentOLLayer.params['LAYERS']){ 
     138            if (layer.getName() === this.currentOLLayer.params.LAYERS) { 
    136139                wmcLayer = layer; 
    137140                break; 
     
    142145                wmcLayer = this.searchSubLayers(layer.getSubLayers()); 
    143146                 
    144                 if (wmcLayer != null) { 
     147                if (wmcLayer !== null) { 
    145148                    break; 
    146149                } 
     
    152155         
    153156        return wmcLayer; 
    154     }, 
    155  
    156 } 
     157    } 
     158}; 
  • cowsclient/trunk/cowsclient/public/js/legendContainer.js

    r5709 r5719  
    1 LegendContainer = OpenLayers.Class.create(); 
     1 
     2/*globals WMSC: false, OpenLayers: false, document: false, AjaxRetriever: false, Utils: false*/ 
     3 
     4var LegendContainer = OpenLayers.Class.create(); 
    25 
    36LegendContainer.prototype = { 
    47                 
    5                 initialize: function(legendDivId) { 
    6                         this.legendDiv = document.getElementById(legendDivId); 
    7                         this._retriever = new AjaxRetriever(); 
    8                 }, 
     8        initialize: function (legendDivId) { 
     9                this.legendDiv = document.getElementById(legendDivId); 
     10                this._retriever = new AjaxRetriever(); 
     11        }, 
    912 
    10                 /** 
    11                 * add the handler for the layerParemeters events, LAYER_PROPERTY_CHANGED and CURRENT_WMCLAYER_CHANGED 
    12                 */ 
    13             addLayerParametersHandlers: function(events) { 
    14                 events.register("LAYER_PROPERTY_CHANGED", this, this.onLayerPropertyChanged); 
    15                 events.register("CURRENT_WMCLAYER_CHANGED", this, this.onLayerChanged); 
    16                  
    17             }, 
     13        /** 
     14        * add the handler for the layerParemeters events, LAYER_PROPERTY_CHANGED and CURRENT_WMCLAYER_CHANGED 
     15        */ 
     16    addLayerParametersHandlers: function (events) { 
     17        events.register("LAYER_PROPERTY_CHANGED", this, this.onLayerPropertyChanged); 
     18        events.register("CURRENT_WMCLAYER_CHANGED", this, this.onLayerChanged); 
     19         
     20    }, 
    1821 
    19             /** 
    20              * handles the CURRENT_WMCLAYER_CHANGED event, replaces the legend 
    21              * with one correponding to the new layer (if the new layer isn't null. 
    22              */ 
    23             onLayerChanged: function(e) { 
    24             this.setLegendForLayer(e.olLayer, e.wmcLayer); 
    25             }, 
     22    /** 
     23     * handles the CURRENT_WMCLAYER_CHANGED event, replaces the legend 
     24     * with one correponding to the new layer (if the new layer isn't null. 
     25     */ 
     26    onLayerChanged: function (e) { 
     27        this.setLegendForLayer(e.olLayer, e.wmcLayer); 
     28    }, 
     29     
     30    /** 
     31     * handles the LAYER_PROPERTY_CHANGED event. A property on the layer has  
     32     * changed, need to re-draw the legend 
     33     */ 
     34    onLayerPropertyChanged: function (e) { 
     35        this.setLegendForLayer(e.layer, e.wmcLayer); 
     36        }, 
     37         
     38         
     39        setLegendForLayer: function (olLayer, wmcLayer) { 
    2640             
    27             /** 
    28              * handles the LAYER_PROPERTY_CHANGED event. A property on the layer has  
    29              * changed, need to re-draw the legend 
    30              */ 
    31             onLayerPropertyChanged: function(e) { 
    32                 this.setLegendForLayer(e.layer, e.wmcLayer); 
    33                 }, 
    34                  
    35                  
    36                 setLegendForLayer: function(olLayer, wmcLayer) { 
    37                      
    38                     var legendLoaded = false; 
    39                      
    40                     if (wmcLayer != null && olLayer != null) { 
     41            var legendLoaded = false; 
     42             
     43            if (wmcLayer !== null && olLayer !== null) { 
     44             
     45            var style = olLayer.params.STYLES; 
     46            var url = wmcLayer.getLegendURL(style); 
     47             
     48            WMSC.log("Legend url = " + url); 
     49             
     50            if (url !== null) { 
    4151                 
    42                 var style = olLayer.params['STYLES']; 
    43                 var url = wmcLayer.getLegendURL(style); 
     52                // add the current openlayers layer parameters 
     53                // to the GetLegend url 
     54                url = Utils.addParamsToUrl(url, olLayer.params); 
     55                                 
     56                this.loadNewLegend(url); 
    4457                 
    45                 WMSC.log("Legend url = " + url); 
    46                  
    47                 if (url != null) { 
    48                      
    49                     // add the current openlayers layer parameters 
    50                     // to the GetLegend url 
    51                     url = Utils.addParamsToUrl(url, olLayer.params) 
    52                                      
    53                     this.loadNewLegend(url); 
    54                      
    55                     legendLoaded = true; 
    56                 } 
     58                legendLoaded = true; 
    5759            } 
    58                      
    59                     if (legendLoaded == false) { 
    60                         this.clearLegend(); 
    61                     } 
    62                 }, 
    63                  
    64                  
    65                 /** 
    66                  * Loads a new legend from the given url, this uses the legendRetriver  
    67                  * to get the new legend html using AJAX and then calls the .setLegend 
    68                  * function.  
    69                  */ 
    70                 loadNewLegend: function(url) { 
    71                                  
    72             WMSC.log("getting legend url = " + url); 
    73              
    74                     var onSuccessFn = this.setLegend.bindAsEventListener(this) 
    75                      
    76                     var params = {REQUEST: 'GetLegend', ENDPOINT: url}; 
    77              
    78             this._retriever.getResponse(params, onSuccessFn) 
    79                 }, 
    80                  
    81                 /** 
    82                  * Takes the xhr response text and places it inside the legend div. 
    83                  * The response text should be a valid <img> element. 
    84                  */ 
    85                 setLegend: function (xhr) { 
    86                         WMSC.log("setting legend at" +new Date()); 
    87                 this.legendDiv.innerHTML = ''; 
    88                 var legendHTML =xhr.responseText; 
    89                         if (legendHTML) 
    90                                 this.legendDiv.innerHTML = legendHTML; 
    91                 }, 
    92                  
    93                 /** 
    94                  * clears the content from the legendDiv 
    95                  */ 
    96                 clearLegend: function(xhr) { 
    97                         this.legendDiv.innerHTML = ''; 
    98                 }, 
     60        } 
    9961             
    100 } 
     62            if (legendLoaded === false) { 
     63                this.clearLegend(); 
     64            } 
     65        }, 
     66         
     67         
     68        /** 
     69         * Loads a new legend from the given url, this uses the legendRetriver  
     70         * to get the new legend html using AJAX and then calls the .setLegend 
     71         * function.  
     72         */ 
     73        loadNewLegend: function (url) { 
     74                         
     75        WMSC.log("getting legend url = " + url); 
     76         
     77            var onSuccessFn = this.setLegend.bindAsEventListener(this); 
     78             
     79            var params = {REQUEST: 'GetLegend', ENDPOINT: url}; 
     80         
     81        this._retriever.getResponse(params, onSuccessFn); 
     82        }, 
     83         
     84        /** 
     85         * Takes the xhr response text and places it inside the legend div. 
     86         * The response text should be a valid <img> element. 
     87         */ 
     88        setLegend: function (xhr) { 
     89                WMSC.log("setting legend at" + new Date()); 
     90        this.legendDiv.innerHTML = ''; 
     91        var legendHTML = xhr.responseText; 
     92                if (legendHTML) { 
     93                        this.legendDiv.innerHTML = legendHTML; 
     94                } 
     95        }, 
     96         
     97        /** 
     98         * clears the content from the legendDiv 
     99         */ 
     100        clearLegend: function (xhr) { 
     101                this.legendDiv.innerHTML = ''; 
     102        } 
     103}; 
  • cowsclient/trunk/cowsclient/public/js/mapControl.js

    r5709 r5719  
    5454        ); 
    5555         
     56         
    5657        this.boxesLayer = new OpenLayers.Layer.Boxes("Sub-selection"); 
    5758 
     
    7374                baseLayerURL, 
    7475                baseLayerParams); 
    75          
    76 //        var lyrBaseClear = new OpenLayers.Layer.Image( 
    77 //                "None", 
    78 //                '../layout/images/clear.gif', 
    79 //                new OpenLayers.Bounds(-180,-90,180,90), 
    80 //                new OpenLayers.Size(8, 8), 
    81 //                {isBaseLayer: true} 
    82 //            ); 
    83 //        this.baseLayer = lyrBaseClear; 
    84          
     76          
     77        // {'maxResolution':'auto'} 
     78         
     79        var lyrBaseClear = new OpenLayers.Layer.Image( 
     80                "None", 
     81                '../layout/images/clear.gif', 
     82                new OpenLayers.Bounds(-180, -90, 180, 90), 
     83                new OpenLayers.Size(8, 8), 
     84                {isBaseLayer: true, 
     85                 resolutions: resolutions} 
     86            ); 
     87         
     88        this.baseLayer = lyrBaseClear; 
    8589         
    8690        this.map.addLayer(this.baseLayer); 
     
    102106        // retain the correct bounds. 
    103107        this.map.resolution = this.map.getResolutionForZoom(this.map.zoom); 
    104         WMSC.log("this.map resolution = " + this.map.resolution + " zoom=" + this.map.zoom + " maxExtent: b=" + this.map.maxExtent.bottom + " l=" + this.map.maxExtent.left + " t=" + this.map.maxExtent.top + " r=" + this.map.maxExtent.right); 
     108          
     109        WMSC.log("this.map resolution= " + this.map.getResolution() +  
     110                               " zoom=" + this.map.zoom +  
     111                               " maxExtent(b,l,t,r)=" + this.map.maxExtent.bottom + "," + this.map.maxExtent.left + "," + this.map.maxExtent.top + "," + this.map.maxExtent.right +  
     112                               " center(lat,lon)=" + this.map.getCenter().lat + "," + this.map.getCenter().lon +  
     113                               " size=" + this.map.getSize().w + "," + this.map.getSize().h +  
     114                               " bounds(b,l,t,r)=" + this.map.calculateBounds().bottom + "," + this.map.calculateBounds().left + "," + this.map.calculateBounds().top + "," + this.map.calculateBounds().right); 
    105115         
    106116        // Enter selection mode 
  • cowsclient/trunk/cowsclient/public/js/openlayers-x.js

    r5626 r5719  
    44*/ 
    55 
    6 SubSelectionMouseToolbar = OpenLayers.Class.create(); 
     6/*global OpenLayers:false */ 
     7 
     8var SubSelectionMouseToolbar = OpenLayers.Class.create(); 
     9 
    710SubSelectionMouseToolbar.prototype = 
    811    OpenLayers.Class.inherit(OpenLayers.Control.MouseToolbar, { 
    9         initialize: function(position, direction, boxesLayer) { 
     12        initialize: function (position, direction, boxesLayer) { 
    1013            OpenLayers.Control.MouseToolbar.prototype.initialize.apply(this, 
    1114                                                                       [position, direction]); 
     
    1417            this._initSubsel(); 
    1518        }, 
    16         zoomBoxEnd: function(evt) { 
     19        zoomBoxEnd: function (evt) { 
    1720 
    1821            if (this.mouseDragStart) { 
     
    3033 
    3134 
    32         setSubSel: function(bounds) { 
     35        setSubSel: function (bounds) { 
    3336            this.activateSubsel(bounds); 
    3437            this.map.zoomToExtent(bounds); 
    3538        }, 
    3639 
    37         activateSubsel: function(bounds) { 
     40        activateSubsel: function (bounds) { 
    3841            this.subselBox.bounds = bounds; 
    3942            this.subselBox.display(true); 
     
    4245            this.boxesLayer.moveTo(null, true); 
    4346        }, 
    44         deactivateSubsel: function() { 
     47        deactivateSubsel: function () { 
    4548            this.subselBox.display(false); 
    4649            this.isSubselActive = false; 
     
    5053         * I can't figure out how to do it. 
    5154         */ 
    52         defaultMouseUp: function(evt) { 
     55        defaultMouseUp: function (evt) { 
    5356            OpenLayers.Control.MouseToolbar.prototype.defaultMouseUp.apply(this, [evt]); 
    5457            /* Check the subselection hasn't been panned out of the viewport */ 
     
    5861             
    5962        }, 
    60         defaultWheelUp: function(evt) { 
     63        defaultWheelUp: function (evt) { 
    6164            OpenLayers.Control.MouseToolbar.prototype.defaultWheelUp.apply(this, [evt]); 
    6265            this.checkSubselVisibility(this.map.getExtent()); 
     
    6467         
    6568        /** Get either the subselection or the complete viewport bounds  */ 
    66         getActiveBounds: function() { 
     69        getActiveBounds: function () { 
    6770            if (this.isSubselActive) { 
    6871                return this.subselBox.bounds; 
     
    7376        }, 
    7477 
    75         _initSubsel: function() { 
     78        _initSubsel: function () { 
    7679            var subsel = new OpenLayers.Bounds(-180,-90, 180, 90); 
    7780            this.subselBox = new OpenLayers.Marker.Box(subsel); 
     
    8285        }, 
    8386        /** Check the subselection is within bounds and deactivate if not. */ 
    84         checkSubselVisibility: function(bounds) { 
     87        checkSubselVisibility: function (bounds) { 
    8588            if (!this.isSubselActive) { return; } 
    8689 
     
    9497        } 
    9598 
    96     }); 
     99}); 
    97100 
     101var DDCVisMap = OpenLayers.Class.create(); 
    98102 
    99  
    100  
    101 DDCVisMap = OpenLayers.Class.create(); 
    102103DDCVisMap.prototype = OpenLayers.Class.inherit(OpenLayers.Map, { 
    103104                setCenter: function(center, zoom, dragging) { 
     
    135136                 
    136137                OpenLayers.Map.prototype.setCenter.apply(this, [center, zoom, dragging]); 
    137     }, 
    138      
    139      
     138    } 
    140139     
    141140}); 
  • cowsclient/trunk/cowsclient/public/js/utils.js

    r5709 r5719  
     1 
     2/*globals WMSC: false, document: false, YAHOO: false, setTimeout: false 
     3          alert: false, window: false */ 
     4 
    15 
    26var Utils = {}; 
    37 
    4 Utils.addHTMLEventListener = function(element, eventName, eventHandler, scope) { 
    5  
    6     var scopedEventHandler = function(e) { 
    7 //        try { 
    8             eventHandler.apply(scope, [e, this]); 
    9 //        } 
    10 //        catch (e) { 
    11 //            Utils.alertErrorMessage(e, e.fileName ,e.lineNumber); 
    12 //            throw e; // Allow existing code to handle 
    13 //        } 
    14          
    15     } 
    16  
    17     if(element.addEventListener) { 
     8Utils.addHTMLEventListener = function (element, eventName, eventHandler, scope) { 
     9 
     10    var scopedEventHandler = function (e) { 
     11        eventHandler.apply(scope, [e, this]); 
     12    }; 
     13 
     14    if (element.addEventListener) { 
    1815        element.addEventListener(eventName, scopedEventHandler, false); 
    19     } else if(element.attachEvent) { 
    20         element.attachEvent("on"+eventName, scopedEventHandler); 
     16    }  
     17    else if (element.attachEvent) { 
     18        element.attachEvent("on" + eventName, scopedEventHandler); 
    2119    } 
    2220     
    2321    return scopedEventHandler; // this is useful if you want to remove the handler later 
    24 } 
    25  
    26 Utils.removeHTMLEventListener = function(element, eventName, handler) { 
    27  
    28     if(element.removeEventListener) { 
     22}; 
     23 
     24Utils.removeHTMLEventListener = function (element, eventName, handler) { 
     25 
     26    if (element.removeEventListener) { 
    2927        element.removeEventListener(eventName, handler, false); 
    30     } else if(element.detachEvent) { 
    31         element.detachEvent("on"+eventName, scopedEventHandler); 
    32     } 
    33 } 
    34  
    35 Utils.buildScopedFunction = function(fn, scope) { 
    36         return function(e) {fn.apply(scope,[e]); } 
    37 } 
    38  
    39  
    40 Utils.buildSelectBox = function(id, descritptions, values, defaultVal) { 
     28    }  
     29    else if (element.detachEvent) { 
     30        element.detachEvent("on" + eventName, handler); 
     31    } 
     32}; 
     33 
     34Utils.buildScopedFunction = function (fn, scope) { 
     35        return function (e) { 
     36            fn.apply(scope, [e]);  
     37        }; 
     38}; 
     39 
     40 
     41Utils.buildSelectBox = function (id, descritptions, values, defaultVal) { 
    4142    return Utils.buildSelect('select_' + id, 'select_' + id, descritptions, values, defaultVal); 
    42 } 
    43  
    44 Utils.buildSelect = function(id, name, descritptions, values, defaultVal) { 
     43}; 
     44 
     45Utils.buildSelect = function (id, name, descritptions, values, defaultVal) { 
     46    var i; 
     47     
    4548    var select = document.createElement('select'); 
    46     if (name != null) { 
     49    if (name !== null) { 
    4750        select.name = name; 
    4851    } 
    4952     
    50     if (id != null) { 
     53    if (id !== null) { 
    5154        select.id =  id; 
    5255    } 
    5356     
    54     for(var i=0; i<values.length; i++) { 
    55         option = document.createElement('option'); 
     57    for (i = 0; i < values.length; i++) { 
     58        var option = document.createElement('option'); 
    5659        option.innerHTML = descritptions[i]; 
    5760        // Required for IE6 
     
    6164                 
    6265    // select the default value 
    63     if (defaultVal != null && defaultVal != undefined) { 
    64         for (var i=0; i<values.length; i++) { 
    65             if (values[i] == defaultVal) { 
     66    if (defaultVal !== null && defaultVal !== undefined) { 
     67        for (i = 0; i < values.length; i++) { 
     68            if (values[i] === defaultVal) { 
    6669                select.selectedIndex = i; 
    6770                break; 
     
    7174     
    7275    return select;   
    73 } 
    74  
    75 Utils.buildLabel = function(labelText, atts) { 
     76}; 
     77 
     78Utils.buildLabel = function (labelText, atts) { 
    7679    var label = document.createElement("label"); 
    7780    label.innerHTML = labelText; 
     
    8184    } 
    8285     
    83     return label 
    84 } 
    85  
    86 Utils.buildLabelInputDiv = function(labelText, inputElement, divClass, labelClass) { 
     86    return label; 
     87}; 
     88 
     89Utils.buildLabelInputDiv = function (labelText, inputElement, divClass, labelClass) { 
    8790    var div = document.createElement("div"); 
    88     if (divClass != undefined) { 
     91    if (divClass !== undefined) { 
    8992        div.className = divClass; 
    9093    } 
    9194     
    9295    var label = document.createElement("label"); 
    93     if (labelClass != undefined) { 
     96    if (labelClass !== undefined) { 
    9497        label.className = labelClass; 
    9598    } 
     
    100103     
    101104    return div; 
    102 } 
    103  
    104 Utils.addHandlerToFormElements = function(form, eventName, handlerFunction, scope) { 
     105}; 
     106 
     107Utils.addHandlerToFormElements = function (form, eventName, handlerFunction, scope) { 
    105108    var handlerLookup = {}; 
    106109     
    107     for (var i=0; i< form.elements.length; i++) { 
     110    for (var i = 0; i < form.elements.length; i++) { 
    108111        var element = form.elements[i]; 
    109112 
     
    113116     
    114117    return handlerLookup; 
    115 } 
    116  
    117 Utils.removeEventHandlersFromLookup = function(lookup) { 
    118      
    119     for (id in lookup) { 
    120         if (id == "") { 
     118}; 
     119 
     120Utils.removeEventHandlersFromLookup = function (lookup) { 
     121     
     122    for (var id in lookup) { 
     123        if (id === "") { 
    121124                continue; 
    122125        } 
    123         element = document.getElementById(id); 
    124          
    125         if (element == "") { 
     126         
     127        var element = document.getElementById(id); 
     128         
     129        if (element === null || element === "") { 
    126130                WMSC.log("Element not found for id=" + id); 
    127131        } 
    128132         
    129         handler = lookup[id]; 
    130          
    131         if (handler != null) { 
     133        var handler = lookup[id]; 
     134         
     135        if (handler !== null) { 
    132136            Utils.removeHTMLEventListener(element, 'change', handler); 
    133137        } 
    134138    } 
    135139 
    136 } 
    137  
    138 Utils.removeItems = function(array, item) { 
     140}; 
     141 
     142Utils.removeItems = function (array, item) { 
    139143    var i = 0; 
    140144    while (i < array.length) { 
    141         if (array[i] == item) { 
     145        if (array[i] === item) { 
    142146            array.splice(i, 1); 
    143147        } else { 
     
    146150    } 
    147151    return array; 
    148 } 
    149  
    150 Utils.buildHiddenInputElement = function(name, value, id) { 
     152}; 
     153 
     154Utils.buildHiddenInputElement = function (name, value, id) { 
    151155    var input = document.createElement('input'); 
    152156    input.type = "hidden"; 
    153157    input.name = name; 
    154158    input.value = value; 
    155     if (id != undefined) { input.id = id;} 
     159     
     160    if (id !== undefined) {  
     161        input.id = id; 
     162    } 
     163     
    156164    return input; 
    157165}; 
     
    172180 * @param {function} [changeHandler] on text changed event handler 
    173181 */ 
    174 Utils.makeCombobox = function(inputId, toggleId, optionsContainerId, dataList, changeHandler ) { 
     182Utils.makeCombobox = function (inputId, toggleId, optionsContainerId, dataList, changeHandler) { 
    175183 
    176184    // Instantiate AutoCompletes 
     
    180188        queryDelay: 0, 
    181189        minQueryLength: 0, 
    182         animVert: .01, 
    183         maxResultsDisplayed:25 
    184     } 
     190        animVert: 0.01, 
     191        maxResultsDisplayed: 25 
     192    }; 
    185193 
    186194    var DS = new YAHOO.util.LocalDataSource(dataList); 
     
    188196    var AC = new YAHOO.widget.AutoComplete(inputId, optionsContainerId, DS, oConfigs); 
    189197     
    190     if (changeHandler != null) { 
     198    if (changeHandler !== null && changeHandler !== undefined) { 
    191199        AC.textboxChangeEvent.subscribe(changeHandler); 
    192200    } 
    193201     
    194202    var lToggler = document.getElementById(toggleId); 
    195     var oPushButtonL = new YAHOO.widget.Button({container:lToggler}); 
    196     var toggleL = function(e) { 
     203    var oPushButtonL = new YAHOO.widget.Button({container: lToggler}); 
     204    var toggleL = function (e) { 
    197205        YAHOO.util.Event.stopEvent(e); 
    198         if(!YAHOO.util.Dom.hasClass(lToggler, "open")) { 
    199             YAHOO.util.Dom.addClass(lToggler, "open") 
     206        if (!YAHOO.util.Dom.hasClass(lToggler, "open")) { 
     207            YAHOO.util.Dom.addClass(lToggler, "open"); 
    200208        } 
    201209 
    202210        // Is open 
    203         if(AC.isContainerOpen()) { 
     211        if (AC.isContainerOpen()) { 
    204212            AC.collapseContainer(); 
    205213        } 
     
    207215        else { 
    208216            AC.getInputEl().focus(); // Needed to keep widget active 
    209             setTimeout(function() { // For IE 
     217            setTimeout(function () { // For IE 
    210218                AC.sendQuery(""); 
    211             },0); 
    212         } 
    213     } 
     219            }, 0); 
     220        } 
     221    }; 
     222     
    214223    //oPushButtonL.on("click", toggleL); 
    215224    oPushButtonL.on("mousedown", toggleL); 
    216     AC.containerCollapseEvent.subscribe(function(){YAHOO.util.Dom.removeClass(lToggler, "open")}); 
     225    AC.containerCollapseEvent.subscribe(function () { 
     226            YAHOO.util.Dom.removeClass(lToggler, "open"); 
     227        } 
     228    ); 
    217229 
    218230}; 
     
    226238 *      be added, so that params[paramName] = paramValue. 
    227239 */ 
    228 Utils.addParamsToUrl = function(url, params) { 
    229      
    230      
    231      
     240Utils.addParamsToUrl = function (url, params) { 
     241        
    232242    // build a list of uppercase params already on the url 
    233243    var urlParams = Utils.getParamsFromURL(url); 
    234244 
    235     existingParams = [] 
    236     for (pName in urlParams){ 
     245    var existingParams = []; 
     246    for (var pName in urlParams) { 
    237247        existingParams.push(pName.toUpperCase()); 
    238248    } 
     
    248258         
    249259        // if the paramer is already on the list then ignore it 
    250         if ( Utils.isValueInList(p.toUpperCase(), existingParams) ) { 
     260        if (Utils.isValueInList(p.toUpperCase(), existingParams)) { 
    251261            continue; 
    252262        } 
    253          
     263 
    254264        // build up a string of the new parameters  
    255         if (first == true) { 
     265        if (first === true) { 
    256266            paramsStr += "?"; 
    257267            first = false; 
     
    274284 * @returns bool indicating if the value was found 
    275285 */ 
    276 Utils.isValueInList = function(value, list) { 
     286Utils.isValueInList = function (value, list) { 
    277287    var included = false; 
    278288     
    279     for (var i=0; i<list.length; i++) { 
    280         if (value == list[i]) { 
     289    for (var i = 0; i < list.length; i++) { 
     290        if (value === list[i]) { 
    281291            included = true; 
    282292            break; 
     
    295305 *      (like a dictionary, obj[paramName] = paramValue) 
    296306 */ 
    297 Utils.getParamsFromURL = function(url) { 
     307Utils.getParamsFromURL = function (url) { 
    298308    var params = {}; 
    299309    if (url.indexOf('?') > 0) { 
    300310        var paramsStr = url.substr(url.indexOf('?') + 1); 
    301311         
    302         for (var i=0; i<2000;i++){ 
     312        for (var i = 0; i < 2000; i++) { 
    303313             
    304314            var pName = paramsStr.substring(0, paramsStr.indexOf('=')); 
     
    306316            params[pName] = pValue; 
    307317             
    308             if (paramsStr.indexOf('&') < 0) { break; } 
     318            if (paramsStr.indexOf('&') < 0) {  
     319                break;  
     320            } 
    309321             
    310322            paramsStr = paramsStr.substr(paramsStr.indexOf('&') + 1); 
     
    313325     
    314326    return params; 
    315 } 
     327}; 
    316328 
    317329Utils.findPos = function (obj) { 
     
    319331    var curtop = 0; 
    320332    if (obj.offsetParent) { 
     333         
    321334        do { 
    322335            curleft += obj.offsetLeft; 
    323336            curtop += obj.offsetTop; 
    324             WMSC.log(" obj, height, width , left, top= " + obj + "," + obj.offsetHeight + "," + obj.offsetWidth +","+ obj.offsetLeft + "," + obj.offsetTop); 
    325         } while (obj = obj.offsetParent); 
    326          
    327         return [curleft,curtop]; 
    328     } 
    329 } 
     337            WMSC.log(" obj, height, width , left, top= " + obj + "," + obj.offsetHeight + "," + obj.offsetWidth + "," + obj.offsetLeft + "," + obj.offsetTop); 
     338            obj = obj.offsetParent; 
     339        } while (obj); 
     340         
     341        return [curleft, curtop]; 
     342    } 
     343}; 
    330344 
    331345Utils.reMatch = function (expression, txt) { 
     
    337351 
    338352Utils.alertErrorMessage = function (msg, u, l) { 
    339     txt ="Error: " + msg + "\n"; 
    340     txt+="URL: " + u + "\n"; 
    341     txt+="Line: " + l + "\n\n"; 
     353    var txt = "Error: " + msg + "\n"; 
     354    txt += "URL: " + u + "\n"; 
     355    txt += "Line: " + l + "\n\n"; 
    342356    alert(txt); 
    343357}; 
     358 
     359Utils.disableEnterKey = function (e) { 
     360    var key;      
     361    if (window.event) { 
     362        key = window.event.keyCode; // for IE 
     363    } 
     364    else { 
     365        key = e.which; // for FF  
     366    } 
     367     
     368    var allow; 
     369    if (key === 13) { 
     370        WMSC.log("Enter detected"); 
     371        allow = false; 
     372        e.preventDefault(); 
     373    } 
     374    else { 
     375        allow = true; 
     376    } 
     377     
     378    return allow; 
     379}; 
     380 
     381Utils.logAtts = function (obj) { 
     382    for (var x in obj) { 
     383        if (typeof(obj[x]) === 'function') { 
     384            WMSC.log(" " + x + " method"); 
     385        } 
     386        else { 
     387            WMSC.log(" " + x + " = " + obj[x]); 
     388        } 
     389    } 
     390}; 
  • cowsclient/trunk/cowsclient/public/layout/control.css

    r5626 r5719  
    2121    border: 1px solid #222277; 
    2222    padding: 6px; 
     23    vertical-align:top; 
    2324} 
    2425tr.controlHeadings th { 
     
    6061  //background-color: lightgray; 
    6162  font-weight: bold; 
    62   cursor: pointer;                       
     63  cursor: pointer;                
    6364  font-size: 12px; 
     65} 
     66 
     67.ygtvcontent { 
     68cursor:pointer; 
    6469} 
    6570 
  • cowsclient/trunk/cowsclient/public/layout/open_layers_map.css

    r5626 r5719  
    11div#map { 
     2  /* if you change the width make sure the javascript code in wmsviz is also changed */ 
    23  width: 640px; 
    3   height: 300px; 
     4  /* This should always be set to 1/2 the width */ 
     5  height: 320px; 
    46  background-color: white; 
    57  margin: 1px; 
  • cowsclient/trunk/cowsclient/public/test/capabilities_test.html

    r5626 r5719  
    22 
    33<head> 
     4 
     5 
     6<script type='text/javascript'  
     7        src='http://getfirebug.com/releases/lite/1.2/firebug-lite-compressed.js'></script> 
    48 
    59    <script src="../js/wmsc.js"></script> 
     
    1115    function init() { 
    1216 
    13                 console.log("started at" +new Date()); 
     17                WMSC.log("started at" +new Date()); 
    1418 
    15                 document.getElementById('response').value = "..."; 
     19        document.getElementById('response').value = "..."; 
    1620        document.getElementById('capabilities').value = "..."; 
     21        document.getElementById('test').value = "..."; 
    1722         
     23                 
    1824//        var params = {REQUEST: 'GetWebMapContext', 
    1925//                      ENDPOINT: 'http://localhost:5000/clim_10/wms'}; 
     
    2733//            }); 
    2834 
     35 
    2936        var params = {REQUEST: 'GetWebMapCapabilities', 
    30                 ENDPOINT: 'http://localhost:5000/clim_10/wms'}; 
    31          
    32         new Ajax.Request('http://localhost:5005/wmsviz',  
     37                ENDPOINT: 'http://ice.badc.rl.ac.uk:5000/clim_10/wms'}; 
     38                 
     39        var req = new Ajax.Request('http://ice.badc.rl.ac.uk:5005/wmsviz',  
    3340           {parameters: params, 
    3441            method: "get", 
    3542            onSuccess: onRetrieveWMCapabilities, 
    36             onException : function(resp, e) {   alert("Exception:" + e); }, 
     43            onException : function(resp, e) {   alert("Exception:" + e); } 
    3744           }); 
    3845 
    39         console.log("Finished."); 
     46        WMSC.log("Finished."); 
    4047         
    4148        } 
     
    4754 
    4855    function onRetrieveWMCapabilities(xhr) { 
    49          
    50         document.getElementById('response').value = xhr.responseText; 
     56        WMSC.log("xhr = " + xhr); 
     57        var respElt = document.getElementById('response'); 
     58        respElt.value = "xhr.responseText = " + xhr.responseText +  
     59                        "\n\nxhr.responseXML = " + xhr.responseXML ; 
    5160         
    5261        var wmc = new WMSC.Capabilities(xhr.responseXML.documentElement); 
    5362 
    5463        writeCapabilities(wmc); 
     64 
     65        testParse(xhr.responseXML.documentElement); 
    5566         
    5667    } 
     
    8091        document.getElementById('capabilities').value = s; 
    8192    } 
    82      
     93 
     94    function testParse (respDoc) { 
     95        var i, j; 
     96        var s = ""; 
     97 
     98        s += "respDoc.tagName = " + respDoc.tagName+"\n"; 
     99 
     100        for (j = 0; j < respDoc.attributes.length; j++) { 
     101            var att = respDoc.attributes[j]; 
     102            s += "-> att = " + att + " att.name = " + att.name  + " att.value = " + att.value + "\n"; 
     103        } 
     104 
     105        // won't work in IE 
     106        try { 
     107            s += "respDoc.attributes['version'].value = " + respDoc.attributes['version'].value+"\n"; 
     108            s += "respDoc.attributes.version.value = " + respDoc.attributes.version.value+"\n"; 
     109        } 
     110        catch (e) { 
     111            s += e.message + "\n"; 
     112        } 
     113         
     114        s += "respDoc.attributes[2].value = " + respDoc.attributes[2].value+"\n"; 
     115        s += "respDoc.getAttribute('version') = " + respDoc.getAttribute('version')+"\n"; 
     116         
     117        for (i=0; i<respDoc.childNodes.length; i++) { 
     118            var c = respDoc.childNodes[i]; 
     119            s += "c.nodeType = " + c.nodeType + " c.tagName = " + c.tagName + "\n"; 
     120 
     121            for (var j = 0; j < c.childNodes.length; j++) { 
     122                var gc = c.childNodes[j]; 
     123                s += "gc.nodeType = " + gc.nodeType + " gc.tagName = " + gc.tagName + " getText = " + getText(gc) + "\n"; 
     124                s += "gc.innerText = " + gc.innerText + " gc.textContent = " + gc.textContent + " gc.nodeValue = " + gc.nodeValue + " gc.innerHTML = " + gc.innerHTML + "\n"; 
     125                s += "gc.text = " + gc.text + "\n"; 
     126                if (j > 4) { 
     127                    break; 
     128                } 
     129            } 
     130        } 
     131 
     132         
     133        document.getElementById('test').value = s; 
     134    } 
     135 
     136    function getText (node) { 
     137         
     138        if (node.textContent) { 
     139            return node.textContent; 
     140        }  
     141        else if (node.innerText) { 
     142            return node.innerText; 
     143        } 
     144        else if (node.nodeValue) { 
     145            return node.innerText; 
     146        }         
     147        else if (node.innerHTML) { 
     148            return node.innerHTML; 
     149        } 
     150        else { 
     151            return ""; 
     152        } 
     153    } 
    83154     
    84155    </script> 
     
    93164    <textarea id="response" name="response" rows="20" cols="120" >...</textarea> 
    94165    <br /> 
     166     
     167    Test:<br /> 
     168    <textarea id="test" name="test" rows="20" cols="120" >...</textarea> 
     169    <br /> 
    95170</body> 
    96171 
  • cowsclient/trunk/cowsclient/templates/wmsviz.html

    r5709 r5719  
    1414 
    1515<head> 
     16 
     17<link type="text/css" rel="stylesheet" href="$g.server/layout/ndg2.css"/> 
    1618<link type="text/css" rel="stylesheet" href="$g.server/layout/ddc_style.css"/> 
    1719<link type="text/css" rel="stylesheet" href="$g.server/layout/ddc_vis.css"/> 
    18 <link type="text/css" rel="stylesheet" href="$g.server/layout/ndg2.css"/> 
    1920<link type="text/css" rel="stylesheet" href="$g.server/layout/temp_fix.css"/> 
    20  
    2121<link type="text/css" rel="stylesheet" href="$g.server/layout/open_layers_map.css"/> 
    2222 
    23 <!-- <script type='text/javascript'  
    24         src='http://getfirebug.com/releases/lite/1.2/firebug-lite-compressed.js'></script> --> 
     23<script type='text/javascript'  
     24        src='http://getfirebug.com/releases/lite/1.2/firebug-lite-compressed.js'></script>  
    2525 
    2626 
     
    3939<link rel="stylesheet" type="text/css" href="$g.server/js/yui/treeview/assets/treeview-menu.css"/>  
    4040 
    41  
    4241<link rel="stylesheet" type="text/css" href="$g.server/js/yui_2.7.0b/fonts/fonts.css" /> 
    4342 
     
    7877<script src="$g.server/js/LoadingPanel.js"></script> 
    7978 
     79<script src="$g.server/js/utils.js"></script> 
    8080 
    8181<script src="$g.server/js/openlayers-x.js"/> 
     
    8787 
    8888<script src="$g.server/js/displayOptionsRetriever.js"></script> 
    89 <script src="$g.server/js/legendRetriever.js"></script> 
    9089<script src="$g.server/js/json2.js"></script> 
    9190 
     
    108107<script src="$g.server/js/legendContainer.js"></script> 
    109108<script src="$g.server/js/boundsControl.js"></script> 
    110 <script src="$g.server/js/utils.js"></script> 
    111109<script src="$g.server/js/wmcRetriever.js"></script> 
    112110<script src="$g.server/js/ajaxRetriever.js"></script> 
     
    181179    var initialEndpoints = JSON.parse(initialSetupJSON); 
    182180 
     181    var baseLayer = new OpenLayers.Layer.WMS( 
     182          'Outline', 
     183          baseLayerData.url,  
     184          baseLayerData.params, 
     185          {isBaseLayer:false}); 
     186 
     187    // must set these parameters or the map wil not draw 
     188    baseLayer.params.CRS = 'CRS:84'; 
     189    baseLayer.params.FORMAT = 'image/png'; 
     190    baseLayer.params.VERSION = '1.3.0'; 
     191    baseLayer.params.TRANSPARENT = 'true'; 
     192    // can't use the default id as there is already an element with that 
     193    // id on the page. 
     194    baseLayer.id = "outline_0";  
     195             
     196     
     197    layerList._addLayer(baseLayer); 
     198 
     199     
    183200    for (var i=0;i&lt;initialEndpoints.length;i++) { 
    184201        var endpoint = initialEndpoints[i]; 
     
    193210    // build endpoint autocomplete 
    194211    Utils.makeCombobox("new_endpoint", "endpoint_toggle", "endpoint_options", defaultEndpoints); 
     212     
    195213} 
    196214 
     
    228246 
    229247<div id="visBody"> 
     248    <!--  <input type="button" value="debug" id="dbg"></input>  --> 
    230249        <table> 
    231250          <tr> 
  • cowsclient/trunk/endpoints.txt

    r5690 r5719  
    22 
    33[WMS] 
    4 http://localhost:5000/clim_10/wms 
    5 http://localhost:5000/clim_30/wms 
    6 http://localhost:5000/cru_tmc/wms 
    7 http://localhost:5000/ccip/wms 
    8 http://localhost:5000/coastwms 
    9 http://localhost:5000/globalpop/wms 
    10 http://localhost:5000/modis/wms 
    11 http://localhost:5000/islscp_soil/wms 
    12 http://localhost:5000/landtype/wms3 
     4http://ice.badc.rl.ac.uk:5000/clim_10/wms 
     5http://ice.badc.rl.ac.uk:5000/clim_30/wms 
     6http://ice.badc.rl.ac.uk:5000/cru_tmc/wms 
     7http://ice.badc.rl.ac.uk:5000/ccip/wms 
     8http://ice.badc.rl.ac.uk:5000/coastwms 
     9http://ice.badc.rl.ac.uk:5000/globalpop/wms 
     10http://ice.badc.rl.ac.uk:5000/modis/wms 
     11http://ice.badc.rl.ac.uk:5000/islscp_soil/wms 
     12http://ice.badc.rl.ac.uk:5000/landtype/wms3 
    1313http://labs.metacarta.com/wms/vmap0 
    1414http://ndg3beta.badc.rl.ac.uk/cows/demo_hadcm3/wms 
    1515 
    1616[WCS] 
    17 http://localhost:5000/clim_10/wcs 
    18 http://localhost:5000/clim_30/wcs 
    19 http://localhost:5000/cru_tmc/wcs 
    20 http://localhost:5000/ccip/wcs 
     17http://ice.badc.rl.ac.uk:5000/clim_10/wcs 
     18http://ice.badc.rl.ac.uk:5000/clim_30/wcs 
     19http://ice.badc.rl.ac.uk:5000/cru_tmc/wcs 
     20http://ice.badc.rl.ac.uk:5000/ccip/wcs 
    2121http://motherlode.ucar.edu:8080/thredds/wcs/fmrc/NCEP/NAM/CONUS_40km/conduit/NCEP-NAM-CONUS_40km-conduit_best.ncd 
Note: See TracChangeset for help on using the changeset viewer.