Changeset 5709


Ignore:
Timestamp:
14/09/09 09:04:11 (10 years ago)
Author:
pnorton
Message:

Modified the legendContainer to use a generic ajax retriever instead of one just for legends, hopefully this can be reused in other places.

Also fixed a problem with the template that caused invalid JSON to be created if the python object was None or an empty string.

Did some tidying up of the jsvascript files using jslint.

Location:
cowsclient/trunk/cowsclient
Files:
1 added
1 deleted
15 edited

Legend:

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

    r5702 r5709  
    147147        if 'HideOptions' in displayOptsConfig: 
    148148            c.hideDisplayOptions = utils.toJSON(displayOptsConfig['HideOptions']) 
    149         else: 
    150             c.hideDisplayOptions = "" 
    151149 
    152150        if 'DefaultOptions' in displayOptsConfig: 
    153151            c.defaultOptions = utils.toJSON(displayOptsConfig['DefaultOptions']) 
    154         else: 
    155             c.defaultOptions = "" 
    156152         
    157153        log.debug("c.defaultOptions = %s" % (c.defaultOptions,)) 
  • cowsclient/trunk/cowsclient/public/js/figureBuilder.js

    r5626 r5709  
    88        this._hiddenControlsDiv = this.buildHiddenControlsDiv(); 
    99         
    10         this._handler = addHTMLEventListener(this._button, 'click', this.createFigure, this); 
     10        this._handler = Utils.addHTMLEventListener(this._button, 'click', this.createFigure, this); 
    1111         
    1212        this._currentSelection = initialBounds; 
     
    9090        destroy: function() { 
    9191                if (this._handler != null) { 
    92                         removeHTMLEventListener(this._button, 'click', this._handler); 
     92                        Utils.removeHTMLEventListener(this._button, 'click', this._handler); 
    9393                } 
    9494        }, 
  • cowsclient/trunk/cowsclient/public/js/layerControl.js

    r5698 r5709  
    9797            if (delIcon != null) 
    9898            { 
    99                 this._delIconHandlers[delIcon.id] = addHTMLEventListener(delIcon,  
     99                this._delIconHandlers[delIcon.id] = Utils.addHTMLEventListener(delIcon,  
    100100                        'click', this._removeNode, this);                 
    101101            } 
     
    108108     */ 
    109109    removeListeners: function() { 
    110         removeEventHandlersFromLookup(this._delIconHandlers); 
     110        Utils.removeEventHandlersFromLookup(this._delIconHandlers); 
    111111        this._delIconHandlers = {}; 
    112112    }, 
  • cowsclient/trunk/cowsclient/public/js/layerDefaultSetter.js

    r5698 r5709  
    77 * @constructor 
    88 */ 
    9 LayerDefaultSetter = function(globalDefaults, defaultOptionsList) { 
     9 
     10var LayerDefaultSetter = function (globalDefaults, defaultOptionsList) { 
    1011    this.globalDefaults = globalDefaults; 
    1112    this.defaultOptionsList = defaultOptionsList; 
    12         
    13 } 
     13}; 
    1414 
    1515LayerDefaultSetter.prototype = { 
    1616     
    1717     
    18     getDefaults: function(endpoint, layer) { 
    19      
     18    getDefaults: function (endpoint, layer) { 
     19         
    2020        var defaults = {}; 
    21  
     21         
    2222        this._setValues(defaults, this.globalDefaults); 
    2323 
    24         for (var i=0;i<this.defaultOptionsList.length;i++) { 
    25             var testEndpoint = this.defaultOptionsList[i].endpoint; 
    26              
    27             if (testEndpoint == endpoint) { 
    28                  
    29                 for (var j=0;j<this.defaultOptionsList[i].layers.length;j++) { 
    30                     var testLayer = this.defaultOptionsList[i].layers[j]; 
    31                      
    32                     if (testLayer == layer){ 
    33                         this._setValues(defaults, this.defaultOptionsList[i].values) 
    34                     } 
    35                 }                 
    36             } 
     24        if (this.defaultOptionsList !== null && this.defaultOptionsList !== "") { 
     25            this._addDefaultsFromOptionsList(defaults, endpoint, layer); 
    3726        } 
    3827         
     
    4130    }, 
    4231     
    43     _setValues: function(defaults, obj) { 
     32    _addDefaultsFromOptionsList: function (defaults, endpoint, layer) { 
     33         
     34        for (var i = 0; i < this.defaultOptionsList.length; i++) { 
     35            var testEndpoint = this.defaultOptionsList[i].endpoint; 
     36             
     37            if (testEndpoint === endpoint) { 
     38                 
     39                for (var j = 0; j < this.defaultOptionsList[i].layers.length; j++) { 
     40                    var testLayer = this.defaultOptionsList[i].layers[j]; 
     41                     
     42                    if (testLayer === layer) { 
     43                        this._setValues(defaults, this.defaultOptionsList[i].values); 
     44                    } 
     45                }                 
     46            } 
     47        } 
     48    }, 
     49     
     50    _setValues: function (defaults, obj) { 
    4451         
    4552        for (var k in obj) { 
    4653            defaults[k] = obj[k]; 
    4754        } 
    48     }, 
     55    } 
    4956     
    50 } 
     57}; 
  • cowsclient/trunk/cowsclient/public/js/layerDimensions.js

    r5630 r5709  
    4040         
    4141        if (this._handler != null) { 
    42                 removeHTMLEventListener(this._form.getElementsByTagName('fieldset')[0], 'change', this._handler) 
     42                Utils.removeHTMLEventListener(this._form.getElementsByTagName('fieldset')[0], 'change', this._handler) 
    4343                this._handler = null; 
    4444        } 
     
    6868 
    6969            var defaultVal = this._getLayerProperty(olLayer, id); 
    70             var select = buildSelectBox(id, descriptions, values, defaultVal); 
     70            var select = Utils.buildSelectBox(id, descriptions, values, defaultVal); 
    7171 
    72             var div = buildLabelInputDiv(dims[id].getName(), select, 'layerDimItem') 
     72            var div = Utils.buildLabelInputDiv(dims[id].getName(), select, 'layerDimItem') 
    7373             
    7474            fs.appendChild(div); 
     
    7777        this._form.appendChild(fs); 
    7878         
    79         this._handler = addHTMLEventListener(fs, 'change', this._onSelectionChange, this);         
     79        this._handler = Utils.addHTMLEventListener(fs, 'change', this._onSelectionChange, this);         
    8080         
    8181    }, 
  • cowsclient/trunk/cowsclient/public/js/layerDisplayOptions.js

    r5698 r5709  
    106106             
    107107            if (this._handler != null) { 
    108                 removeHTMLEventListener(this._form.getElementsByTagName('fieldset')[0], 'change', this._handler) 
     108                Utils.removeHTMLEventListener(this._form.getElementsByTagName('fieldset')[0], 'change', this._handler) 
    109109                this._handler = null; 
    110110            } 
     
    127127                    for (var i=0;i<this.hideDisplayOptions.length;i++) { 
    128128                         
    129                         if (reMatch(this.hideDisplayOptions[i].endpoint, endpoint)) { 
     129                        if (Utils.reMatch(this.hideDisplayOptions[i].endpoint, endpoint)) { 
    130130                            for (var j=0;j<this.hideDisplayOptions[i].options.length;j++) { 
    131131                                hideOptions.push(this.hideDisplayOptions[i].options[j]); 
     
    161161             
    162162            this._form.appendChild(fs); 
    163             this._handler = addHTMLEventListener(fs, 'change', this._onSelectionChange, this); 
     163            this._handler = Utils.addHTMLEventListener(fs, 'change', this._onSelectionChange, this); 
    164164        }, 
    165165         
     
    175175                var opt = optionsList[i]; 
    176176                 
    177                 if (isValueInList(opt.name, hideOptions)) { 
     177                if (Utils.isValueInList(opt.name, hideOptions)) { 
    178178                    continue; 
    179179                } 
     
    197197             
    198198            var defaultVal =  this._getDefaultValue(opt); 
    199             select = buildSelectBox(opt.name , opt.options, opt.options, defaultVal); 
    200              
    201             var div = buildLabelInputDiv(title, select, 'displayOptionItem') 
     199            select = Utils.buildSelectBox(opt.name , opt.options, opt.options, defaultVal); 
     200             
     201            var div = Utils.buildLabelInputDiv(title, select, 'displayOptionItem') 
    202202            return div 
    203203        }, 
     
    213213             
    214214            input.value = this._getDefaultValue(opt); 
    215             var div = buildLabelInputDiv(title, input, 'displayOptionItem'); 
     215            var div = Utils.buildLabelInputDiv(title, input, 'displayOptionItem'); 
    216216            return div; 
    217217        }, 
     
    232232            } 
    233233                         
    234             var div = buildLabelInputDiv(title, input, 'displayOptionItem'); 
     234            var div = Utils.buildLabelInputDiv(title, input, 'displayOptionItem'); 
    235235            return div; 
    236236        }, 
  • cowsclient/trunk/cowsclient/public/js/layerInformation.js

    r5671 r5709  
    112112        } 
    113113         
    114         this._styleSelect = buildSelectBox('styles', descriptions, values, currentStyle); 
    115          
    116         this._selectHandler = addHTMLEventListener(this._styleSelect, 'change', this._onStyleChange, this); 
    117          
    118         return buildLabelInputDiv('Style', this._styleSelect, 'layerInfoItem'); 
     114        this._styleSelect = Utils.buildSelectBox('styles', descriptions, values, currentStyle); 
     115         
     116        this._selectHandler = Utils.addHTMLEventListener(this._styleSelect, 'change', this._onStyleChange, this); 
     117         
     118        return Utils.buildLabelInputDiv('Style', this._styleSelect, 'layerInfoItem'); 
    119119    }, 
    120120     
     
    123123        // remove the event handler before deleting the element 
    124124        if (this._styleSelect != null && this._selectHandler != null) { 
    125             removeHTMLEventListener(this._styleSelect, 'change', this._selectHandler); 
     125            Utils.removeHTMLEventListener(this._styleSelect, 'change', this._selectHandler); 
    126126        } 
    127127         
    128128        // remove the get figure event handler 
    129129        if (this._getFigureButton != null && this._getFigureHandler != null) { 
    130             removeHTMLEventListener(this._getFigureButton, 'click', this._getFigureHandler); 
     130            Utils.removeHTMLEventListener(this._getFigureButton, 'click', this._getFigureHandler); 
    131131        } 
    132132         
     
    154154        span.innerHTML = value; 
    155155         
    156         return buildLabelInputDiv(name, span, 'layerInfoItem'); 
     156        return Utils.buildLabelInputDiv(name, span, 'layerInfoItem'); 
    157157         
    158158    }, 
     
    188188        } 
    189189         
    190         var inputs = buildSelect(null, 'format', formatDescriptions, formatValues); 
     190        var inputs = Utils.buildSelect(null, 'format', formatDescriptions, formatValues); 
    191191        div.appendChild(inputs); 
    192192         
     
    195195        this._getFigureButton .value = "Get Figure"; 
    196196         
    197         this._getFigureHandler = addHTMLEventListener(this._getFigureButton,  
     197        this._getFigureHandler = Utils.addHTMLEventListener(this._getFigureButton,  
    198198                                     'click', this._onGetFigureClick, this); 
    199199         
     
    219219        for (var p in this.currentOLLayer.params) { 
    220220            if (p.toUpperCase() == 'REQUEST') { 
    221                 this._hiddenInputContainer.appendChild(buildHiddenInputElement('REQUEST', 'GetFigure')); 
     221                this._hiddenInputContainer.appendChild(Utils.buildHiddenInputElement('REQUEST', 'GetFigure')); 
    222222            } 
    223223            else if (p.toUpperCase() == 'FORMAT') { 
     
    225225            } 
    226226            else { 
    227                 this._hiddenInputContainer.appendChild(buildHiddenInputElement(p, layer.params[p])); 
     227                this._hiddenInputContainer.appendChild(Utils.buildHiddenInputElement(p, layer.params[p])); 
    228228            } 
    229229        } 
     
    231231        var bboxString = this._currentSelection.left + "," + this._currentSelection.bottom + "," + this._currentSelection.right+ "," + this._currentSelection.top; 
    232232         
    233         this._hiddenInputContainer.appendChild(buildHiddenInputElement('BBOX', bboxString)); 
    234         this._hiddenInputContainer.appendChild(buildHiddenInputElement('WIDTH', '1200')); 
    235         this._hiddenInputContainer.appendChild(buildHiddenInputElement('HEIGHT', '900')); 
     233        this._hiddenInputContainer.appendChild(Utils.buildHiddenInputElement('BBOX', bboxString)); 
     234        this._hiddenInputContainer.appendChild(Utils.buildHiddenInputElement('WIDTH', '1200')); 
     235        this._hiddenInputContainer.appendChild(Utils.buildHiddenInputElement('HEIGHT', '900')); 
    236236    }, 
    237237    
  • cowsclient/trunk/cowsclient/public/js/layerList.js

    r5626 r5709  
    4747            this.target = new YAHOO.util.DDTarget(dragListId); 
    4848            this.removeLayerBtn = document.getElementById('btn_remove_selected_layer'); 
    49             addHTMLEventListener( this.removeLayerBtn, 'click', this._onRemoveClick, this); 
     49            Utils.addHTMLEventListener( this.removeLayerBtn, 'click', this._onRemoveClick, this); 
    5050        }, 
    5151     
     
    5757                var currentItems = this._getCurrentListItems(); 
    5858                for (var i=0; i<currentItems.length; i++) { 
    59                         addHTMLEventListener( currentItems[i], 'click', this._onItemClick, this); 
     59                        Utils.addHTMLEventListener( currentItems[i], 'click', this._onItemClick, this); 
    6060                } 
    6161        }, 
     
    206206                var itemNumber =  currentItems.length + 1; 
    207207                 
    208                 var onDrag = buildScopedFunction(this._onDragEnd, this); 
     208                var onDrag = Utils.buildScopedFunction(this._onDragEnd, this); 
    209209                 
    210210                new YAHOO.example.DDList(layer.id, onDrag); 
  • cowsclient/trunk/cowsclient/public/js/legendContainer.js

    r5671 r5709  
    55                initialize: function(legendDivId) { 
    66                        this.legendDiv = document.getElementById(legendDivId); 
    7                         this.legendRetriever = new LegendRetriever(); 
     7                        this._retriever = new AjaxRetriever(); 
    88                }, 
    99 
     
    4949                    // add the current openlayers layer parameters 
    5050                    // to the GetLegend url 
    51                     url = addParamsToUrl(url, olLayer.params) 
     51                    url = Utils.addParamsToUrl(url, olLayer.params) 
    5252                                     
    5353                    this.loadNewLegend(url); 
     
    7373             
    7474                    var onSuccessFn = this.setLegend.bindAsEventListener(this) 
    75                 this.legendRetriever.getLegend(url, onSuccessFn)                         
     75                     
     76                    var params = {REQUEST: 'GetLegend', ENDPOINT: url}; 
     77             
     78            this._retriever.getResponse(params, onSuccessFn) 
    7679                }, 
    7780                 
  • cowsclient/trunk/cowsclient/public/js/mapControl.js

    r5690 r5709  
    1111 */ 
    1212 
     13/*global document:false, WMSC:false, Utils:false, OpenLayers:false, 
     14  DDCVisMap:false, SubSelectionMouseToolbar:false, $:false, Ajax:false */ 
     15 
    1316WMSC.VisApp = OpenLayers.Class.create(); 
    1417WMSC.VisApp.prototype =  
     
    2528     * @param showCoast - true - display coastline, otherwise not 
    2629     */ 
    27     initialize: function(div, numZoomLevels, mapWidth, showCoast,  
    28                          baseLayerURL, baseLayerParams, initialBounds )  
     30    initialize: function (div, numZoomLevels, mapWidth, showCoast,  
     31                         baseLayerURL, baseLayerParams, initialBounds)  
    2932    { 
    3033        this.figureCounter = 1; 
     
    3740        // directly. 
    3841        var maxResolution = 360.0 / mapWidth; 
    39         var resolutions = new Array(); 
    40         for (var i=0; i < numZoomLevels; i++)  
     42        var resolutions = []; 
     43        for (var i = 0; i < numZoomLevels; i++)  
    4144        { 
    4245            resolutions.push(maxResolution / Math.pow(1.4, i)); 
     
    5356        this.boxesLayer = new OpenLayers.Layer.Boxes("Sub-selection"); 
    5457 
    55         this.subselControl = new SubSelectionMouseToolbar(new OpenLayers.Pixel(mapWidth-40,10), 
    56                            'vertical', this.boxesLayer); 
     58        this.subselControl = new SubSelectionMouseToolbar( 
     59                     new OpenLayers.Pixel(mapWidth - 40, 10),  
     60                     'vertical',  
     61                     this.boxesLayer); 
    5762         
    5863        this.map.addControl(new OpenLayers.Control.LoadingPanel()); 
     
    6772                'BaseLayer', 
    6873                baseLayerURL, 
    69                 baseLayerParams ); 
     74                baseLayerParams); 
    7075         
    7176//        var lyrBaseClear = new OpenLayers.Layer.Image( 
     
    97102        // retain the correct bounds. 
    98103        this.map.resolution = this.map.getResolutionForZoom(this.map.zoom); 
    99         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); 
     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); 
    100105         
    101106        // Enter selection mode 
     
    104109        this._divId = div; 
    105110         
    106         var link = document.getElementById('debug_link') 
    107         addHTMLEventListener(link, 'click', this._logLocation, this); 
    108          
    109     }, 
    110      
    111     _logLocation: function() { 
    112         WMSC.log("map div location = " + findPos(document.getElementById(this._divId))); 
    113         WMSC.log("dims location= " + findPos(document.getElementById('dims'))); 
    114     }, 
     111    }, 
     112     
     113    _logLocation: function () { 
     114        WMSC.log("map div location = " + Utils.findPos(document.getElementById(this._divId))); 
     115        WMSC.log("dims location= " + Utils.findPos(document.getElementById('dims'))); 
     116    }, 
     117     
    115118     
    116119      /** 
     
    120123      * getSelection retuning an OpenLayers.Bounds object 
    121124      */ 
    122      addBoundsControl: function(control) 
    123      { 
    124          this.boundsControl = control; 
     125    addBoundsControl: function (control) 
     126    { 
     127        this.boundsControl = control; 
    125128        this.boundsControl.events.register('TEXT_SELECTION_CHANGED', this, this.updateSelectionBox); 
    126129        this.boundsControl.events.register('changeWMS', this, this.updateVisLayer); 
     
    129132        this.map.events.register('moveend', this, this.updateBoundsControl); 
    130133        this.map.events.register('zoomend', this, this.updateBoundsBoundsControl); 
    131      },     
    132      
    133     updateBoundsBoundsControl: function(events) { 
    134          WMSC.log("map zoomed -- 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); 
     134    },     
     135     
     136    updateBoundsBoundsControl: function (events) { 
     137        WMSC.log("map zoomed -- 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); 
    135138    }, 
    136139 
     
    145148     
    146149    // Cleaning up is important for IE. 
    147     destroy: function()  
    148     { 
    149         if (this.dimControl) 
     150    destroy: function ()  
     151    { 
     152         
     153        if (this.dimControl) { 
    150154            this.dimControl.destroy(); 
    151  
    152         if (this.layerControl) 
     155        } 
     156 
     157        if (this.layerControl) { 
    153158            this.layerControl.destroy(); 
     159        } 
     160         
    154161        this.subselControl.destroy(); 
    155162    }, 
     
    158165     * Set up coast layer using the specified layer name 
    159166     */ 
    160     _initCoast: function(layerName)  
     167    _initCoast: function (layerName)  
    161168    { 
    162169        // check if coast layer is loaded or if a different coast layer has been specified; reload, if so 
    163         if (!this.coastLayer || this.coastLayer.params.LAYERS != layerName)  
     170        if (!this.coastLayer || this.coastLayer.params.LAYERS !== layerName)  
    164171        { 
    165172            this.coastLayer = new OpenLayers.Layer.WMS("Coastline", 
     
    176183     * NB, the layers are initially removed to ensure they are not duplicated 
    177184     */ 
    178     updateVisLayer: function()  
     185    updateVisLayer: function ()  
    179186    { 
    180187         
    181188        // firstly, remove any existing layers 
    182         j = this.map.getNumLayers(); 
    183         for (var i = 0; i < j; i++) 
     189        var j = this.map.getNumLayers();  
     190        var i = 0; 
     191        for (i = 0; i < j; i++) 
    184192        { 
    185193            this.map.removeLayer(this.map.layers[0]); 
     
    189197        if (!this.visLayer) 
    190198        { 
    191             this.visLayer = new OpenLayers.Layer.WMS("OpenLayers WMS", 
     199            this.visLayer = new OpenLayers.Layer.WMS( 
     200                 "OpenLayers WMS", 
    192201                 "http://labs.metacarta.com/wms/vmap0", 
    193                  {layers: 'basic',format: 'image/png'}); 
     202                 {layers: 'basic', format: 'image/png'} 
     203            ); 
    194204             
    195205            // add extra parameters, if specified by layer control 
    196206            this._mergeDimParams(this.visLayer); 
    197            } 
     207        } 
    198208         
    199209        this.map.addLayer(this.visLayer); 
    200210         
    201211        // retrieve the elements of the layer list and add these to the map 
    202         layerList = document.getElementById("layerlist"); 
    203  
    204         if (layerList != null) { 
     212        var layerList = document.getElementById("layerlist"); 
     213 
     214        if (layerList !== null) { 
    205215            //Changed by domlowe: reversed the order these layers are added to the map. Dragging and dropping the 
    206216            // layer you want to be on top to the bottom of the list was counter intuitive. 
     
    208218            //for (var i = 0; layerList && i < layerList.childNodes.length; i++) 
    209219            //now in revese order: 
    210             for (var i=layerList.childNodes.length-1; layerList && i>=0; i--) 
     220            for (i = layerList.childNodes.length - 1; layerList && i >= 0; i--) 
    211221            { 
    212                 child = layerList.childNodes[i]; 
     222                var child = layerList.childNodes[i]; 
     223                 
    213224                // ignore any hidden list values 
    214                 if (child.className == "hiddenList") 
     225                if (child.className === "hiddenList") { 
    215226                    continue; 
     227                } 
    216228                 
    217                 if (child.nodeName == "LI") 
     229                if (child.nodeName === "LI") 
    218230                { 
    219231                    // extract the required info and load the map 
     
    221233                    // NB, for transparancy to be fully supported, the format must be gif 
    222234                    // - png is only partially supported and jpg not at all 
    223                     endpoint = child.getAttribute("wmcURL"); 
    224                     title = child.getAttribute("title"); 
    225                     layerName = child.getAttribute("layerName"); 
    226  
    227                     mapLayer = new OpenLayers.Layer.WMS( 
     235                    var endpoint = child.getAttribute("wmcURL"); 
     236                    var title = child.getAttribute("title"); 
     237                    var layerName = child.getAttribute("layerName"); 
     238 
     239                    var mapLayer = new OpenLayers.Layer.WMS( 
    228240                                title, 
    229241                                endpoint, 
     
    232244                                  CRS: 'CRS:84', 
    233245                                  layers: layerName, 
    234                                   styles:'', 
     246                                  styles: '', 
    235247                                  transparent: 'true' 
    236248                                 }); 
     249                     
    237250                    // add extra parameters, if specified by layer control 
    238251                    this._mergeDimParams(mapLayer); 
    239                        this.map.addLayer(mapLayer); 
     252                    this.map.addLayer(mapLayer); 
    240253                } 
    241254            } 
     
    243256             
    244257        // add the coast outline, if required 
    245         if (this.showCoast) 
     258        if (this.showCoast) { 
    246259            this._initCoast('coastline_01'); 
     260        } 
    247261 
    248262        // add layer to represent the subselection box on the layer         
     
    258272     * these, if so 
    259273     */ 
    260     _mergeDimParams: function(mapLayer) 
     274    _mergeDimParams: function (mapLayer) 
    261275    { 
    262276        if (this.dimControl && this.dimControl.wmsParams) 
     
    271285     * the coordinate selections to reflect this 
    272286     */ 
    273     resetMapCoords: function()  
     287    resetMapCoords: function ()  
    274288    { 
    275289        WMSC.log("resetMapCoords"); 
     
    284298     * to load and display legend data for this layer 
    285299     */ 
    286     loadLegend: function()  
     300    loadLegend: function ()  
    287301    { 
    288302        var legend = $('legend'); 
    289         if (!legend) 
     303        if (!legend) { 
    290304            return; 
     305        } 
    291306             
    292307        var setLegend = function (xhr)  
    293308        { 
    294309            $('legend').innerHTML = ''; 
    295             var legendHTML =xhr.responseText; 
    296             if (legendHTML) 
     310            var legendHTML = xhr.responseText; 
     311            if (legendHTML) { 
    297312                $('legend').innerHTML = legendHTML; 
     313            } 
    298314        }; 
    299315 
     
    315331        var topLayer = this.map.layers[layerNo - 3]; 
    316332         
    317         if (topLayer.url == null)  
     333        if (topLayer.url === null)  
    318334        { 
    319335            legend.innerHTML = ''; 
     
    322338        { 
    323339            var url = topLayer.getFullRequestString({ 
    324                 REQUEST: 'GetLegend', 
    325                 //FORMAT: 'text/html' 
     340                REQUEST: 'GetLegend'//, FORMAT: 'text/html' 
    326341            }); 
    327342 
    328             var params = {REQUEST: 'GetLegend', 
    329                       ENDPOINT: url}; 
    330              
    331             new Ajax.Request('',  
    332                 {parameters: params, 
    333                 method: "get", 
    334                 onSuccess: setLegend.bindAsEventListener(this), 
    335                 onFailure: failure.bindAsEventListener(this) 
     343            var params = {REQUEST: 'GetLegend', ENDPOINT: url}; 
     344             
     345            var req = new Ajax.Request('', 
     346                { 
     347                    parameters : params, 
     348                    method : "get", 
     349                    onSuccess : setLegend.bindAsEventListener(this), 
     350                    onFailure : failure.bindAsEventListener(this) 
    336351                }); 
    337352        } 
     
    343358     * the dimension selection control to reflect this change 
    344359     */ 
    345     updateBoundsControl: function()  
     360    updateBoundsControl: function ()  
    346361    { 
    347362//        alert("UpdateBoundsControl"); 
    348363        var b = this.subselControl.getActiveBounds(); 
    349          
    350  
    351364 
    352365        WMSC.log("triggering MAP_SELECTION_CHANGED, selection = " + b); 
    353         this.events.triggerEvent('MAP_SELECTION_CHANGED', {selection:b}); 
     366        this.events.triggerEvent('MAP_SELECTION_CHANGED', {selection: b}); 
    354367         
    355368//        // Switch to higerres coasts if needed 
     
    368381     * - taking the values from the input coord control 
    369382     */ 
    370     updateSelectionBox: function(e)  
     383    updateSelectionBox: function (e)  
    371384    { 
    372385        WMSC.log("started update selection box"); 
     
    392405            new_b.bottom = old_b.bottom; 
    393406        } 
     407         
     408        var t; 
     409         
    394410        if (new_b.left > new_b.right)  
    395411        { 
    396             var t = new_b.left;  
     412            t = new_b.left;  
    397413            new_b.left = new_b.right;  
    398414            new_b.right = t; 
     
    400416        if (new_b.bottom > new_b.top)  
    401417        { 
    402             var t = new_b.bottom;  
     418            t = new_b.bottom;  
    403419            new_b.bottom = new_b.top;  
    404420            new_b.top = t; 
     
    410426    }, 
    411427 
    412      
    413  
    414428    drawLayers: function (layers) { 
    415429         
    416          
    417          
     430        var i; 
    418431         
    419432        //remove the old layers 
     
    421434             
    422435            var removeLayers = []; 
    423             for (var i=0; i<this.map.layers.length; i++) { 
    424                 if (this.map.layers[i] != this.baseLayer && 
    425                     this.map.layers[i] != this.boxesLayer) { 
     436            for (i = 0; i < this.map.layers.length; i++) { 
     437                if (this.map.layers[i] !== this.baseLayer && 
     438                    this.map.layers[i] !== this.boxesLayer) { 
    426439                    removeLayers.push(this.map.layers[i]); 
    427440                } 
    428441            } 
    429442             
    430             for (var i=0; i<removeLayers.length; i++) { 
    431                 layer = removeLayers[i]; 
     443            for (i = 0; i < removeLayers.length; i++) { 
     444                var layer = removeLayers[i]; 
    432445                //alert("Removing layer id=" + layer.id + " name=" + layer.name); 
    433446                this.map.removeLayer(layer); 
     
    438451        if (layers.length > 0) { 
    439452             
    440             for (var i=layers.length-1; i>=0; i--) { 
    441                 l = layers[i]; 
     453            for (i = layers.length - 1; i >= 0; i--) { 
     454                var l = layers[i]; 
    442455                 
    443456                this.map.addLayer(l); 
    444                 this.map.setLayerIndex(l,lastLayerIndex); 
     457                this.map.setLayerIndex(l, lastLayerIndex); 
    445458                lastLayerIndex ++; 
    446459                //alert("Added layer name=" + l.name + " index = " + this.map.getLayerIndex(l) ); 
     
    452465        this.map.setLayerIndex(this.boxesLayer, lastLayerIndex); 
    453466         
    454     }, 
    455  
    456  
     467    } 
    457468     
    458469}; 
  • cowsclient/trunk/cowsclient/public/js/splitSelect.js

    r5668 r5709  
    66 * @constructor 
    77 */ 
    8 SplitSelect = function(containerId, name, data, labelText) { 
     8 
     9/*global document:false, WMSC:false, Utils:false*/ 
     10 
     11var SplitSelect = function (containerId, name, data, labelText) { 
    912     
    1013    this._container = document.getElementById(containerId); 
     
    1215    this.data = data; 
    1316     
    14     if (labelText == undefined) { 
     17    if (labelText === undefined) { 
    1518        this.labelText = name; 
    1619    } 
     
    1922    } 
    2023         
    21 } 
     24}; 
    2225 
    2326SplitSelect.prototype = { 
    2427     
    25     build: function() { 
     28    build: function () { 
    2629         
    2730        //if the data is an array just make a single select box 
    28         if (this.data.constructor == Array) { 
     31        if (this.data.constructor === Array) { 
    2932             
    3033            WMSC.log("data =" + this.data); 
    31             this._container.appendChild(buildLabel(this.labelText, { id:this.name + '_label', htmlFor:this.name} )); 
     34            this._container.appendChild(Utils.buildLabel(this.labelText, { id: this.name + '_label', htmlFor: this.name})); 
    3235            this._container.appendChild(document.createTextNode("\n")); 
    33             this._container.appendChild(buildSelect(this.name, this.name, this.data, this.data)); 
     36            this._container.appendChild(Utils.buildSelect(this.name, this.name, this.data, this.data)); 
    3437             
    3538             
     
    4043    }, 
    4144     
    42     _buildSplitSelect: function() { 
     45    _buildSplitSelect: function () { 
    4346 
    44         this._container.appendChild(buildLabel(this.labelText, {id:this.name + '_label'})); 
     47        this._container.appendChild(Utils.buildLabel(this.labelText, {id: this.name + '_label'})); 
    4548        this._container.appendChild(document.createTextNode("\n")); 
    4649         
    4750        var items = this._getItemOrder(); 
    48         for (var i=0;i<items.length;i++) { 
    49             n = items[i]; 
    50             var sel = buildSelect(this.name + "_" + n, this.name + "_" + n, this.data[n], this.data[n]); 
     51        for (var i = 0; i < items.length; i++) { 
     52            var n = items[i]; 
     53            var sel = Utils.buildSelect(this.name + "_" + n, this.name + "_" + n, this.data[n], this.data[n]); 
    5154             
    52             var handler = addHTMLEventListener(sel, 'change', this._buildTime, this); 
     55            var handler = Utils.addHTMLEventListener(sel, 'change', this._buildTime, this); 
    5356             
    5457            this._container.appendChild(sel); 
     
    5861        var value = this._buildTimeString(); 
    5962         
    60         this._container.appendChild(buildHiddenInputElement(this.name, value, this.name)); 
     63        this._container.appendChild(Utils.buildHiddenInputElement(this.name, value, this.name)); 
    6164        this._container.appendChild(document.createTextNode("\n"));             
    6265 
    6366    }, 
    6467     
    65     _getItemOrder: function() { 
     68    _getItemOrder: function () { 
     69        var indicies = []; 
     70        var format = this.data._fmt; 
     71        for (var item in this.data) { 
     72 
     73            if (item === '_fmt') {   
     74                continue;   
     75            } 
     76             
     77            indicies.push([item, format.indexOf(item)]); 
     78        } 
    6679       
    67       var indicies = []; 
    68       var format = this.data._fmt; 
    69       for (item in this.data) { 
    70           if (item == '_fmt') {  continue;  } 
    71           indicies.push([item, format.indexOf(item)]); 
    72       } 
     80        var sortNumber = function (a, b) {  
     81            return a[1] - b[1];  
     82        }; 
     83 
     84        indicies = indicies.sort(sortNumber); 
    7385       
    74       function sortNumber(a,b) { return a[1] - b[1]; } 
    75  
    76       indicies = indicies.sort(sortNumber); 
     86        var items = []; 
     87        for (var i = 0; i < indicies.length; i++) { 
     88            items.push(indicies[i][0]); 
     89        } 
    7790       
    78       var items = []; 
    79       for (var i=0;i<indicies.length;i++) { 
    80           items.push(indicies[i][0]); 
    81       } 
    82        
    83       return items; 
     91        return items; 
    8492    }, 
    8593     
     
    93101        var s = this.data._fmt; 
    94102        var items = this._getItemOrder(); 
    95         for (var i=0;i<items.length;i++) { 
    96             opt = items[i]; 
     103        for (var i = 0; i < items.length; i++) { 
     104            var opt = items[i]; 
    97105           
    98106            var elt = document.getElementById(this.name + "_" + opt); 
     
    101109        } 
    102110        return s; 
    103     }, 
    104 } 
     111    } 
     112}; 
  • cowsclient/trunk/cowsclient/public/js/utils.js

    r5706 r5709  
    1 addHTMLEventListener = function(element, eventName, eventHandler, scope) { 
    2  
    3     var scopedEventHandler = function(e) {eventHandler.apply(scope, [e, this]); } 
     1 
     2var Utils = {}; 
     3 
     4Utils.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    } 
    416 
    517    if(element.addEventListener) { 
     
    1224} 
    1325 
    14 removeHTMLEventListener = function(element, eventName, handler) { 
     26Utils.removeHTMLEventListener = function(element, eventName, handler) { 
    1527 
    1628    if(element.removeEventListener) { 
     
    2133} 
    2234 
    23  
    24  
    25  
    26 buildScopedFunction = function(fn, scope) { 
     35Utils.buildScopedFunction = function(fn, scope) { 
    2736        return function(e) {fn.apply(scope,[e]); } 
    2837} 
    2938 
    3039 
    31 buildSelectBox = function(id, descritptions, values, defaultVal) { 
    32     return buildSelect('select_' + id, 'select_' + id, descritptions, values, defaultVal); 
    33 } 
    34  
    35 buildSelect = function(id, name, descritptions, values, defaultVal) { 
     40Utils.buildSelectBox = function(id, descritptions, values, defaultVal) { 
     41    return Utils.buildSelect('select_' + id, 'select_' + id, descritptions, values, defaultVal); 
     42} 
     43 
     44Utils.buildSelect = function(id, name, descritptions, values, defaultVal) { 
    3645    var select = document.createElement('select'); 
    3746    if (name != null) { 
     
    6473} 
    6574 
    66 buildLabel = function(labelText, atts) { 
     75Utils.buildLabel = function(labelText, atts) { 
    6776    var label = document.createElement("label"); 
    6877    label.innerHTML = labelText; 
     
    7584} 
    7685 
    77 buildLabelInputDiv = function(labelText, inputElement, divClass, labelClass) { 
     86Utils.buildLabelInputDiv = function(labelText, inputElement, divClass, labelClass) { 
    7887    var div = document.createElement("div"); 
    7988    if (divClass != undefined) { 
     
    93102} 
    94103 
    95 addHandlerToFormElements = function(form, eventName, handlerFunction, scope) { 
     104Utils.addHandlerToFormElements = function(form, eventName, handlerFunction, scope) { 
    96105    var handlerLookup = {}; 
    97106     
     
    99108        var element = form.elements[i]; 
    100109 
    101         handlerLookup[element.id] = addHTMLEventListener(element, eventName,  
     110        handlerLookup[element.id] = Utils.addHTMLEventListener(element, eventName,  
    102111                                                         handlerFunction, scope); 
    103112    } 
     
    106115} 
    107116 
    108 removeEventHandlersFromLookup = function(lookup) { 
     117Utils.removeEventHandlersFromLookup = function(lookup) { 
    109118     
    110119    for (id in lookup) { 
     
    121130         
    122131        if (handler != null) { 
    123             removeHTMLEventListener(element, 'change', handler); 
    124         } 
    125     } 
    126  
    127 } 
    128  
    129 removeItems = function(array, item) { 
     132            Utils.removeHTMLEventListener(element, 'change', handler); 
     133        } 
     134    } 
     135 
     136} 
     137 
     138Utils.removeItems = function(array, item) { 
    130139    var i = 0; 
    131140    while (i < array.length) { 
     
    139148} 
    140149 
    141 buildHiddenInputElement = function(name, value, id) { 
     150Utils.buildHiddenInputElement = function(name, value, id) { 
    142151    var input = document.createElement('input'); 
    143152    input.type = "hidden"; 
     
    163172 * @param {function} [changeHandler] on text changed event handler 
    164173 */ 
    165 makeCombobox = function(inputId, toggleId, optionsContainerId, dataList, changeHandler ) { 
     174Utils.makeCombobox = function(inputId, toggleId, optionsContainerId, dataList, changeHandler ) { 
    166175 
    167176    // Instantiate AutoCompletes 
     
    217226 *      be added, so that params[paramName] = paramValue. 
    218227 */ 
    219 addParamsToUrl = function(url, params) { 
     228Utils.addParamsToUrl = function(url, params) { 
    220229     
    221230     
    222231     
    223232    // build a list of uppercase params already on the url 
    224     var urlParams = getParamsFromURL(url); 
     233    var urlParams = Utils.getParamsFromURL(url); 
    225234 
    226235    existingParams = [] 
     
    239248         
    240249        // if the paramer is already on the list then ignore it 
    241         if ( isValueInList(p.toUpperCase(), existingParams) ) { 
     250        if ( Utils.isValueInList(p.toUpperCase(), existingParams) ) { 
    242251            continue; 
    243252        } 
     
    265274 * @returns bool indicating if the value was found 
    266275 */ 
    267 isValueInList = function(value, list) { 
     276Utils.isValueInList = function(value, list) { 
    268277    var included = false; 
    269278     
     
    286295 *      (like a dictionary, obj[paramName] = paramValue) 
    287296 */ 
    288 getParamsFromURL = function(url) { 
     297Utils.getParamsFromURL = function(url) { 
    289298    var params = {}; 
    290299    if (url.indexOf('?') > 0) { 
     
    306315} 
    307316 
    308 findPos = function (obj) { 
     317Utils.findPos = function (obj) { 
    309318    var curleft = 0; 
    310319    var curtop = 0; 
     
    320329} 
    321330 
    322 reMatch = function (expression, txt) { 
     331Utils.reMatch = function (expression, txt) { 
    323332    var re = new RegExp(expression); 
    324333    var result = re.test(txt); 
     
    326335    return result; 
    327336}; 
     337 
     338Utils.alertErrorMessage = function (msg, u, l) { 
     339    txt ="Error: " + msg + "\n"; 
     340    txt+="URL: " + u + "\n"; 
     341    txt+="Line: " + l + "\n\n"; 
     342    alert(txt); 
     343}; 
  • cowsclient/trunk/cowsclient/public/js/wmcRetriever.js

    r5626 r5709  
     1/*global OpenLayers:false, WMSC:false, Ajax:false */ 
    12 
    2 WMCRetriever = OpenLayers.Class.create(); 
    3 WMCRetriever.prototype =  
    4 { 
    5                 contextLookup: {}, 
     3var WMCRetriever = OpenLayers.Class.create(); 
     4 
     5WMCRetriever.prototype = { 
     6        contextLookup: {}, 
     7         
     8    initialize: function (initialEndpoint) { 
    69                 
    7             initialize: function(initialEndpoint){ 
    8                          
    9                         //if the inital endpoint is set then request the  
    10                         // context ready for use. 
    11                         if (initialEndpoint != undefined) { 
    12                                 this.getWMC(initialEndpoint); 
     10                //if the inital endpoint is set then request the  
     11                // context ready for use. 
     12                if (initialEndpoint !== undefined) { 
     13                        this.getWMC(initialEndpoint); 
     14                } 
     15                 
     16    },           
     17     
     18    getWMC: function (endpoint, onSuccessFunction, onFailureFunction) { 
     19         
     20        if (this.isWMCCached(endpoint)) { 
     21                onSuccessFunction(this.contextLookup[endpoint]); 
     22                 
     23        } else { 
     24                 
     25                var onRetrieveWMC = function (xhr) { 
     26                         
     27                        //var wmc = new WMSC.WebMapContext(xhr.responseXML.documentElement); 
     28                        var wmc = new WMSC.Capabilities(xhr.responseXML.documentElement); 
     29                         
     30                        this.addWMCToLookup(endpoint, wmc); 
     31 
     32                        onSuccessFunction(wmc); 
     33                        }; 
     34 
     35                        //var params = {REQUEST: 'GetWebMapContext', ENDPOINT: endpoint}; 
     36                        var params = {REQUEST: 'GetWebMapCapabilities', ENDPOINT: endpoint}; 
     37 
     38                        if (onFailureFunction === undefined) { 
     39                            onFailureFunction = function (resp) {    
     40                                WMSC.log("Failure:" + resp);  
     41                            }; 
    1342                        } 
    1443                         
    15             },           
    16              
    17             getWMC: function(endpoint, onSuccessFunction, onFailureFunction) { 
    18                  
    19                 if (this.isWMCCached(endpoint)) { 
    20                         onSuccessFunction(this.contextLookup[endpoint]); 
    21                          
    22                 } else { 
    23                          
    24                         var onRetrieveWMC = function(xhr) { 
    25                                  
    26                                 //var wmc = new WMSC.WebMapContext(xhr.responseXML.documentElement); 
    27                                 var wmc = new WMSC.Capabilities(xhr.responseXML.documentElement); 
    28                                  
    29                                 this.addWMCToLookup(endpoint, wmc); 
    30  
    31                                 onSuccessFunction(wmc); 
    32                                 }; 
    33          
    34                                 //var params = {REQUEST: 'GetWebMapContext', ENDPOINT: endpoint}; 
    35                                 var params = {REQUEST: 'GetWebMapCapabilities', ENDPOINT: endpoint}; 
    36          
    37                                 if (onFailureFunction == undefined) { 
    38                                     onFailureFunction = function(resp) {   WMSC.log("Failure:" + resp); } 
     44                        // invoke the GetWebMapContext call asynchronously via AJAX 
     45                        var req = new Ajax.Request('',  
     46                                { 
     47                                parameters: params, 
     48                                method: "get", 
     49                                onSuccess: onRetrieveWMC.bindAsEventListener(this), 
     50                                onException : function (resp, e) {    
     51                                    WMSC.log("Exception:" + e);  
     52                                }, 
     53                                onFailure : onFailureFunction 
    3954                                } 
    40                                  
    41                                 // invoke the GetWebMapContext call asynchronously via AJAX 
    42                                 new Ajax.Request('',  
    43                                         {parameters: params, 
    44                                  method: "get", 
    45                                  onSuccess: onRetrieveWMC.bindAsEventListener(this), 
    46                                  onException : function(resp, e) {   WMSC.log("Exception:" + e); }, 
    47                                  onFailure : onFailureFunction, 
    48                                         }); 
    49                 } 
    50             }, 
    51              
    52             addWMCToLookup: function(endpoint, wmc){ 
    53                 this.contextLookup[endpoint] = wmc; 
    54             }, 
    55              
    56             isWMCCached: function(endpoint) { 
    57  
    58                 for (ep in this.contextLookup) { 
    59                         if (ep == endpoint) { 
    60                                 return true; 
    61                         } 
    62                 } 
    63                 return false; 
    64             } 
    65 } 
     55                        ); 
     56        } 
     57    }, 
     58     
     59    addWMCToLookup: function (endpoint, wmc) { 
     60        this.contextLookup[endpoint] = wmc; 
     61    }, 
     62     
     63    isWMCCached: function (endpoint) { 
     64        var ep; 
     65         
     66        for (ep in this.contextLookup) { 
     67                if (ep === endpoint) { 
     68                        return true; 
     69                } 
     70        } 
     71        return false; 
     72    } 
     73}; 
  • cowsclient/trunk/cowsclient/public/js/wmsc.js

    r5626 r5709  
    44 * Define a namespace for the package. 
    55 */ 
    6 WMSC = {}; 
     6 
     7// allowing access to console directly here as any exception raised will be caught 
     8/*global console:false */ 
     9 
     10var WMSC = {}; 
    711 
    812WMSC.DEBUG = true; 
    913 
    10 WMSC.log = function(msg)  
    11 { 
     14WMSC.log = function (msg) { 
    1215     
    13     if (!WMSC.DEBUG) return; 
     16    if (!WMSC.DEBUG) { 
     17        return; 
     18    } 
    1419     
    1520    try  
     
    1823                console.log(msg); 
    1924    } 
    20     catch(err)  
     25    catch (err)  
    2126    {    
    2227                //give up 
     
    2429                //Debug.write(msg); 
    2530    } 
    26 } 
     31}; 
  • cowsclient/trunk/cowsclient/templates/wmsviz.html

    r5698 r5709  
    33      xmlns:xi="http://www.w3.org/2001/XInclude">     
    44<xi:include href="utils.html" /> 
     5 
     6<?python 
     7    def jsonParseIfNotEmpty(var): 
     8        if var is not None and var != "": 
     9            return 'JSON.parse("%s")' % var 
     10        else: 
     11            return 'null'  
     12?> 
     13 
     14 
    515<head> 
    616<link type="text/css" rel="stylesheet" href="$g.server/layout/ddc_style.css"/> 
     
    4757<link rel="stylesheet" type="text/css" href="$g.server/js/yui_2.7.0b/autocomplete/assets/skins/sam/autocomplete.css" /> 
    4858 
    49 <script type="text/javascript" src="$g.server/js/yui_2.7.0b/yahoo-dom-event/yahoo-dom-event.js"></script> 
    5059<script type="text/javascript" src="$g.server/js/yui_2.7.0b/animation/animation.js"></script> 
    5160<script type="text/javascript" src="$g.server/js/yui_2.7.0b/element/element.js"></script> 
     
    101110<script src="$g.server/js/utils.js"></script> 
    102111<script src="$g.server/js/wmcRetriever.js"></script> 
     112<script src="$g.server/js/ajaxRetriever.js"></script> 
    103113 
    104114<script src="$g.server/js/layerDefaultSetter.js"></script> 
     
    106116<!-- END: WMSC library --> 
    107117<script type="text/javascript"> 
     118 
     119YAHOO.util.Event.throwErrors = true; 
    108120 
    109121// Hook into application for debugging.     
     
    113125var layerParameters = null; 
    114126 
    115 var defaultEndpoints = JSON.parse("${c.defaultWMSEndpoints}"); 
    116  
    117 var hideDisplayOptions = JSON.parse("${c.hideDisplayOptions}"); 
    118 var defaultOptions = JSON.parse("${c.defaultOptions}"); 
     127var defaultEndpoints = ${jsonParseIfNotEmpty(c.defaultWMSEndpoints)}; 
     128var hideDisplayOptions = ${jsonParseIfNotEmpty(c.hideDisplayOptions)}; 
     129var defaultOptions = ${jsonParseIfNotEmpty(c.defaultOptions)}; 
    119130 
    120131<?python 
     
    122133?>     
    123134 
    124  
    125 function alertWMC(wmc) { 
    126         //alert("wmc = " + wmc); 
    127 } 
    128  
    129 function init()  
    130 { 
    131  
     135function init() { 
    132136 
    133137        var initialSetupJSON = "${c.initialSetupJSON}"; 
     
    138142        WMSC.log("baseLayerData.url = " + baseLayerData.url); 
    139143        WMSC.log("baseLayerData.params = " + baseLayerData.params); 
    140          
    141          
     144 
    142145    var wmcRetriever = new WMCRetriever(); 
    143146 
     
    156159    var layerControl = new WMSC.VisAppLayers('layerTree', 'layerLeaves',wmcRetriever, 'new_endpoint', 'add_new_endpoint', defaultOptions);   
    157160 
    158  
    159161    figBuilder.addLayerOrderChangedHandlers(layerList.events);     
    160162     
     
    177179    } 
    178180     
    179      
    180      
    181  
    182181    var initialEndpoints = JSON.parse(initialSetupJSON); 
    183182 
     
    190189         
    191190        layerControl.addWebMapContext(endpoint.url); 
    192          
    193191    } 
    194192 
    195     try { 
    196         // build endpoint autocomplete 
    197         makeCombobox("new_endpoint", "endpoint_toggle", "endpoint_options", defaultEndpoints); 
    198     } 
    199     catch( e ) { 
    200         WMSC.log(e); 
    201         throw e; // Allow existing code to handle 
    202     } 
    203      
     193    // build endpoint autocomplete 
     194    Utils.makeCombobox("new_endpoint", "endpoint_toggle", "endpoint_options", defaultEndpoints); 
    204195} 
     196 
    205197 
    206198function cleanup()  
    207199{ 
    208     app.destroy(); 
    209     layerList.destroy(); 
    210     layerParameters.destroy(); 
     200    if ( app !== null) { 
     201        app.destroy(); 
     202    } 
     203     
     204    if (layerList !== null) { 
     205        layerList.destroy(); 
     206    } 
    211207} 
    212208     
     
    386382        </table> 
    387383         
    388          
    389  
    390     <a id='debug_link' href='#'>debug</a> 
    391  
    392  
    393384</div> 
    394385</div> 
Note: See TracChangeset for help on using the changeset viewer.