Ext.apply (Ext.form.VTypes, {
  datetimerange: function (val, field)
  {
    if (field.__hbIsBeingValidated)
    {
      return true;
    }

    field.__hbIsBeingValidated = true;
    var date = field.parseDate (val);

    if (field.startDateField)
    {
      var sd = Ext.getCmp (field.startDateField);
    }
    if (field.endDateField)
    {
      var ed = Ext.getCmp (field.endDateField);
    }
    if (field.startTimeField)
    {
      var st = Ext.getCmp (field.startTimeField);
    }
    if (field.endTimeField)
    {
      var et = Ext.getCmp (field.endTimeField);
    }

    if (    (field instanceof Ext.form.DateField) // end date
         && field.startDateField)
    {
      sd.maxValue = date;
      sd.clearInvalid ();
      sd.validateValue (sd.getRawValue ());

      st.clearInvalid ();

      if (    field.startTimeField && field.endTimeField 
           && (sd.getValue () && (0 == sd.getValue ().getElapsed (date))))
      {
        st.maxValue = et.getValue ();
      }
      else
      {
        st.maxValue = null;
      }

      st.validateValue (st.getRawValue ());
    }
    else if (   (field instanceof Ext.form.DateField) // start date
             && field.endDateField)
    {
      ed.minValue = date;
      ed.clearInvalid ();
      ed.validateValue (ed.getRawValue ());

      et.clearInvalid ();

      if (    field.startTimeField && field.endTimeField
           && (0 == date.getElapsed (ed.getValue ())))
      {
        et.minValue = st.getValue ();
      }
      else
      {
        et.minValue = null;
      }

      et.validateValue (et.getRawValue ());
    }
    else if (   (field instanceof Ext.form.TimeField) // end time
             && field.startDateField && field.endDateField && field.startTimeField)
    {
      st.clearInvalid ();

      if (sd.getValue () && (0 == sd.getValue ().getElapsed (ed.getValue ())))
      {
        st.maxValue = date;
      }
      else
      {
        st.maxValue = null;
      }

      st.validateValue (st.getRawValue ());
    }
    else if (   (field instanceof Ext.form.TimeField) // start time
             && field.startDateField && field.endDateField && field.endTimeField)
    {
      et.clearInvalid ();

      if (sd.getValue () && (0 == sd.getValue ().getElapsed (ed.getValue ())))
      {
        et.minValue = date;
      }
      else
      {
        et.minValue = null;
      }

      et.validateValue (et.getRawValue ());
    }

    field.__hbIsBeingValidated = false;
    return true;
  }
});

var accordion = null;
var mapPanel = null;
var numFeeds = 0;
var loadingTab = null;
var progressBar = null;
var mapSettingsPanel = null;
var cityToolbar = null;
var mapButtons = new Object ();
var veilRadioButton = null;
var rainRadarRadioButton = null;
var enableAutoRefreshFieldSet = null;
var autoRefreshSettings = {
  autoRefreshEnabled: true,
  inputRefreshInterval: 5,
  pageReloadInterval: 60,
  inputRefreshTimeoutRunning: false,
  pageReloadTimeoutRunning: false
}
//var infoSettings = new Object ();
var dictionary = null;
/*
var languageButtons = {}

function getButtonByDOM (DOM)
{
  for (var b in languageButtons)
  {
    if (languageButtons [b].DOM == DOM)
    {
      return languageButtons [b];
    }
  }

  return null;
}
*/

function getLabelOfField (fieldName)
{
  var labels = document.getElementsByTagName ('label');

  for (var l = 0; l < labels.length; ++l)
  {
    var label = labels [l];

    if (fieldName == label.htmlFor)
    {
      return label;
    }
  }

  return null;
}

function loadFeeds ()
{
  if (    (null == sourceFilter) || (false == sourceFilter.isInitialized ())
       || (null == map) || (false == map.isInitialized ())
       || (null == layerMgr) || (false == layerMgr.isInitialized ()))
  {
    setTimeout ('loadFeeds ()', 1000);
    return;
  }

  for (var l in layerMgr.nameToLayer)
  {
    var layer = layerMgr.nameToLayer [l];

    if ("overlay" == layer.type)
    {
      continue;
    }

    ++numFeeds;
    var feedFct = makeFeedFunction (l, layer);
    feedFct ();
    layer.onReload (feedFct, null);
  }
}

var openRSSReport = function (layername, guid, index)
{
    var myReport = layerMgr.getReport (layername, guid);

    if (null == myReport)
    {
      return;
    }

    myReport.openInfoWindow (index);
};

var myPanels = new Object ();

var onImageClick = function (layerName, rowIndex)
{
    if (! layerMgr.nameToLayer [layerName])
    {
      return;  
    }

    if (false == layerMgr.nameToLayer [layerName].visible)
    {
      sourceFilter.activate (layerName);
      setButtonTooltip (myPanels [layerName].myButtonEl.id, dictionary.lookUp ('btnHide'));
      myPanels [layerName].myButtonState = !myPanels [layerName].myButtonState;
      myPanels [layerName].myButtonEl.removeClass ('x-tool-search-over');
      map.redraw (sourceFilter.getActiveLayer ());
    }

    var record = myPanels [layerName].items.items [0].getStore ().getAt (rowIndex);
    var guid = record.get ('msgGUId');
    var refIndex = record.get ('refIndex');
    var myReport = layerMgr.getReport (layerName, guid);

    if (null == myReport)
    {
      return;
    }

    if (false == map.map.getBounds ().contains (myReport.getPrimaryLocation ()))
    {
      map.setView (myReport.getPrimaryLocation (), map.getZoom ());
    }

    setTimeout ('openRSSReport ("' + layerName + '", "' + guid + '", "' + refIndex + '")', 500);
};

function setButtonTooltip (elemId, text)
{
  Ext.QuickTips/*.getQuickTip ()*/.register ({
    target: elemId,
    text: text
  });
}

function makeFeedFunction (index, layer)
{
  var reader = new Ext.data.ArrayReader({}, [
       {name: 'msg'},
       {name: 'title'},
       {name: 'msgIndex'},
       {name: 'msgGUId'},
       {name: 'refIndex'},
       {name: 'icon'}]);

  var infoColumnModel = new Ext.grid.ColumnModel ([
        {id:'name', sortable: false, dataIndex: 'name', menuDisabled: true,
         renderer: function (value, metadata, record, rowIndex, colIndex, store)
           {
             return dictionary.lookUp (value + '.caption');
             //return infoSettings [dictionary.activeLanguage] [value] ["caption"];
           }
        },
        {id:'value', sortable: false, dataIndex: 'value', menuDisabled: true,
          renderer: function (value, metadata, record, rowIndex, colIndex, store)
            {
              if (record.get ('name') == 'lastUpdateTime')
              {
                return value.toLocaleTimeString ();
                //return value.toLocaleTimeString () + infoSettings [dictionary.activeLanguage] [record.get ('name')] ["unit"];
              }

              return value + dictionary.lookUp (record.get ('name') + '.unit');
              //return value + infoSettings [dictionary.activeLanguage] [record.get ('name')] ["unit"];
           }
        }
    ]);

  var infoView = new Ext.grid.GridView ({
      forceFit: true
  });

  var infoRecordConstructor = Ext.data.Record.create (
    {name: 'name', type: 'string', sortType: Ext.data.SortTypes.asText, sortDir: 'ASC'},
    {name: 'value', type: 'float'}
  );

  var columnModel = new Ext.grid.ColumnModel ([
        {id:'msg', sortable: false, dataIndex: 'msg', menuDisabled: true,
         renderer: function (value, metadata, record, rowIndex, colIndex, store)
           {
             if (-1 == (new String (layer.name)).indexOf ('vms'))
             {
               return '<table><tr><td style="width:52"><img onclick="onImageClick(\'' + layer.name + '\',' + rowIndex +
                      ');" src="' + record.get ('icon') + '"/></td><td style="white-space:normal;">' +
                      value + '</td></tr></table>';
             }
             else
             {
               return '<table><tr><td style="width:100%"><img onclick="onImageClick(\'' + layer.name + '\',' + rowIndex +
                      ');" src="' + record.get ('icon') + '"/></td><td style="white-space:normal;">' +
                      value + '</td></tr></table>';
             }
           }},
        {id:'title', sortable: false, dataIndex: 'title', menuDisabled: true, hidden: true},
        {id:'msgIndex', sortable: false, dataIndex: 'msgIndex', menuDisabled: true,
         renderer: function (value, metadata, record, rowIndex, colIndex, store)
           {
             if (!record.get)
             {
               return '';
             }

             return '<table width="100%"><tr><td style="font-family:tahoma,arial,helvetica,sans-serif;font-size:11px;font-weight:bold;">' +
                    record.get ('title') + '</td><td style="width:18"><img width="17" height="17" src="' +
                    record.get ('icon') + '"/></td><td style="width:12"></td></tr></table>';
      //       return '<table><tr><td style="width:18"><img width="17" height="17" src="' +
       //             record.get ('icon') + '"/></td><td style="font-family:tahoma,arial,helvetica,sans-serif;font-size:11px;font-weight:bold;">' +
        //            record.get ('title') + '</td></tr></table>';
             //return record.get ('title');
           }},
        {id:'msgGUId', sortable: false, dataIndex: 'msgGUId', menuDisabled: true, hidden: true},
        {id:'refIndex', sortable: false, dataIndex: 'refIndex', menuDisabled: true, hidden: true},
        {id:'icon', sortable: false, dataIndex: 'icon', menuDisabled: true, hidden: true}
    ]);

  var gView = new Ext.grid.GroupingView({
        forceFit:true,
        hideGroupedColumn: true,
        groupTextTpl: '{group}',
        startCollapsed: true});
  // Workaround, damit ein expandiertes Listenelement nicht außerhalb des sichtbaren Bereichs geöffnet wird
  /*gView.oldToggleGroup = gView.toggleGroup;
  gView.toggleGroup = function (group, expanded)
    {
      this.oldToggleGroup (group, expanded);
      group = Ext.getDom(group);
      var gel = Ext.fly(group);
      expanded = expanded !== undefined ? expanded : gel.hasClass('x-grid-group-collapsed');

      if (!expanded)
      {
        for (var n = 0; n < this.mainBody.dom.childNodes.length; ++n)
        {
          if (this.mainBody.dom.childNodes [n] == group)
          {
            this.ensureVisible (n, 0, false);
          }
        }
      }
    };*/

  var myMainPanel = null;
  var myGroupPanel = null;
  var myInfoPanel = null;
  var myFeedFct = null;
  var myLayer = layer;
  var mySource = sourceFilter.getSourceForLayer (myLayer.name);

  var show = function ()
    {
        if (true == myLayer.visible)
        {
          setButtonTooltip (myMainPanel.myButtonEl.id, dictionary.lookUp ('btnShow'));
          myMainPanel.myButtonState = !myMainPanel.myButtonState;
          myMainPanel.myButtonEl.addClass ('x-tool-search-over');
          setTimeout (function () {
            sourceFilter.deactivate (myLayer.name);
            map.redraw (sourceFilter.getActiveLayer ());
          }, 100);
        }
        else
        {
          setButtonTooltip (myMainPanel.myButtonEl.id, dictionary.lookUp ('btnHide'));
          myMainPanel.myButtonState = !myMainPanel.myButtonState;
          myMainPanel.myButtonEl.removeClass ('x-tool-search-over');
          setTimeout (function () {
            sourceFilter.activate (myLayer.name);
            map.redraw (sourceFilter.getActiveLayer ());
          }, 100);
        }
    };

  var refresh = refreshLayer = function ()
    {
        if (myMainPanel.isExpanded)
        {
          myMainPanel.loadMask.show ();
        }
        
        setTimeout (function () {
          myLayer.hide ();
          myLayer.reload ();
          map.redraw (sourceFilter.getActiveLayer ());
        }, 10);
    };

  var onClick = function (grid, rowIndex, e)
    {
        if (false == myLayer.visible)
        {
          sourceFilter.activate (myLayer.name);
          setButtonTooltip (myMainPanel.myButtonEl.id, dictionary.lookUp ('btnHide'));
          myMainPanel.myButtonState = !myMainPanel.myButtonState;
          myMainPanel.myButtonEl.removeClass ('x-tool-search-over');
          map.redraw (sourceFilter.getActiveLayer ());
        }

        var record = grid.getStore ().getAt (rowIndex);
        var guid = record.get ('msgGUId');
        var refIndex = record.get ('refIndex');
        var myReport = myLayer.getReport (guid);

        if (null == myReport)
        {
          return;
        }

        if (false == map.map.getBounds ().contains (myReport.getPrimaryLocation ()))
        {
          map.setView (myReport.getPrimaryLocation (), map.getZoom ());
        }

        setTimeout ('openRSSReport ("' + myLayer.name + '", "' + guid + '", "' + refIndex + '")', 500);
    };

  var onExpand = function ()
  {
    myMainPanel.isExpanded = true;

    setTimeout (function () {
      if (!layerMgr.nameToLayer [myLayer.name].isInitialized ())
      {
        myMainPanel.loadMask.show ();
      }
      else if (!myMainPanel.isLoaded)
      {
        myMainPanel.loadMask.show ();
        myFeedFct ();
      }

      setTimeout (function () {
        layerMgr.nameToLayer [myLayer.name].keepLoaded (true);
      }, 10);
    }, 10);
    return true;
  }

  var onCollapse = function (panel)
  {
    myMainPanel.isExpanded = false;

    if (myMainPanel.loadMask)
    {
      myMainPanel.loadMask.hide ();
    }
    myLayer.keepLoaded (false);
    return true;
  }

  if (mySource && mySource.hasFilter ())
  {
    var from = new Date ();
    from.setMinutes (0, 0, 0);
    var to = new Date ();
    to.setTime (new Date ().getTime () + 86400000);
    to.setMinutes (0, 0, 0);
    sourceFilter.getSourceForLayer (myLayer.name).filter.from = from;
    sourceFilter.getSourceForLayer (myLayer.name).filter.to = to;
    sourceFilter.getSourceForLayer (myLayer.name).filter.ignored =
      (vcnlinfoCookies.get ("timeFilterEnabled_" + myLayer.name) == "false") ? true : false;

    var myTimefilterFieldSet = new Ext.form.FieldSet({
      xtype:'fieldset',
      title: dictionary.lookUp ('enableFilter'),
      checkboxToggle: true,
      autoHeight: true,
      collapsed: true,
      defaultType: 'datefield',
      items: [{
        fieldLabel: dictionary.lookUp ('from'),
        name: 'fromdate' + myLayer.name,
        id: 'fromdate' + myLayer.name,
        format: 'd-m-Y',
        vtype: 'datetimerange',
        value: from,
        endDateField: 'todate' + myLayer.name,
        startTimeField: 'fromtime' + myLayer.name,
        endTimeField: 'totime' + myLayer.name
      }, new Ext.form.TimeField ({
        labelSeparator: '',
        name: 'fromtime' + myLayer.name,
        id: 'fromtime' + myLayer.name,
        format: 'H:i',
        vtype: 'datetimerange',
        value: from,
        startDateField: 'fromdate' + myLayer.name,
        endDateField: 'todate' + myLayer.name,
        endTimeField: 'totime' + myLayer.name,
        increment: 60,
        width: 94
      }),
      {
        fieldLabel: dictionary.lookUp ('to'),
        name: 'todate' + myLayer.name,
        id: 'todate' + myLayer.name,
        format: 'd-m-Y',
        vtype: 'datetimerange',
        value: to,
        startDateField: 'fromdate' + myLayer.name,
        startTimeField: 'fromtime' + myLayer.name,
        endTimeField: 'totime' + myLayer.name
      }, new Ext.form.TimeField ({
        labelSeparator: '',
        name: 'totime' + myLayer.name,
        id: 'totime' + myLayer.name,
        format: 'H:i',
        vtype: 'datetimerange',
        value: to,
        startDateField: 'fromdate' + myLayer.name,
        endDateField: 'todate' + myLayer.name,
        startTimeField: 'fromtime' + myLayer.name,
        increment: 60,
        width: 94
      })]
    });

    var myFilterWindow = new Ext.Window ({
      layout: 'fit',
      title: dictionary.lookUp ('feedSettings') + myLayer.getTitle (),
      height: 220,
      width: 240,
      closable: false,
      constrain: true,
      maximizable: false,
      minimizable: false,
      modal: true,
      resizable: false,
      renderTo: Ext.getBody (),
      items: new Ext.FormPanel ({
        labelWidth: 100,
        border: false,
        items: [myTimefilterFieldSet]
      }),
      buttons: [{
        text: dictionary.lookUp ('btnSave'),
        handler: function () {
          vcnlinfoCookies.set ("timeFilterEnabled_" + myLayer.name,
            myTimefilterFieldSet.collapsed ? "false" : "true");
          sourceFilter.getSourceForLayer (myLayer.name).filter.ignored = myTimefilterFieldSet.collapsed;
          var fromDate = myTimefilterFieldSet.items.items [0].getValue ();
          var fromTime = myTimefilterFieldSet.items.items [1].getValue ();
          var toDate = myTimefilterFieldSet.items.items [2].getValue ();
          var toTime = myTimefilterFieldSet.items.items [3].getValue ();
          sourceFilter.getSourceForLayer (myLayer.name).filter.from = new Date (
            fromDate.getFullYear (),
            fromDate.getMonth (),
            fromDate.getDate (),
            parseInt (fromTime.split (':') [0], 10),
            parseInt (fromTime.split (':') [1], 10), 0, 0);
          sourceFilter.getSourceForLayer (myLayer.name).filter.to = new Date (
            toDate.getFullYear (),
            toDate.getMonth (),
            toDate.getDate (),
            parseInt (toTime.split (':') [0], 10),
            parseInt (toTime.split (':') [1], 10), 0, 0);
          myMainPanel.loadMask.show ();
          myFilterWindow.hide ();
          setTimeout (function () {
            myLayer.setFilter (sourceFilter.getSourceForLayer (myLayer.name).getActiveLayer ());
            map.redraw (sourceFilter.getActiveLayer ());
            myFeedFct ();
          }, 400);
        }
      },{
        text: dictionary.lookUp ('btnCancel'),
        handler: function () {
          myFilterWindow.hide ();
        }
      }]
    });

    myFilterWindow.on ('show',
      function ()
      {
        myFilterWindow.setTitle (dictionary.lookUp ('feedSettings') + myLayer.getTitle ());
        myTimefilterFieldSet.setTitle (dictionary.lookUp ('enableFilter'));
        getLabelOfField ('fromdate' + myLayer.name).innerHTML = dictionary.lookUp ('from');
        getLabelOfField ('todate' + myLayer.name).innerHTML = dictionary.lookUp ('to');
        myFilterWindow.buttons [0].setText (dictionary.lookUp ('btnSave'));
        myFilterWindow.buttons [1].setText (dictionary.lookUp ('btnCancel'));
      });

    var updateTimefilterFieldSet = function () {
      myTimefilterFieldSet.items.items [0].setValue (sourceFilter.getSourceForLayer (myLayer.name).filter.from);
      myTimefilterFieldSet.items.items [1].setValue (sourceFilter.getSourceForLayer (myLayer.name).filter.from);
      myTimefilterFieldSet.items.items [2].setValue (sourceFilter.getSourceForLayer (myLayer.name).filter.to);
      myTimefilterFieldSet.items.items [3].setValue (sourceFilter.getSourceForLayer (myLayer.name).filter.to);

      if ("true" == vcnlinfoCookies.get ("timeFilterEnabled_" + myLayer.name))
      {
        myTimefilterFieldSet.expand (false);
      }
      else
      {
        myTimefilterFieldSet.collapse (false);
      }
    };

    myFilterWindow.addListener ('show',
      function () {
        updateTimefilterFieldSet ();
      },
      updateTimefilterFieldSet,
      {delay: 200}
    );

    for (var i = 0; i < myTimefilterFieldSet.items.items.length; ++i)
    {
      myTimefilterFieldSet.items.items [i].addListener ('change',
        function () {
          for (var j = 0; j < myTimefilterFieldSet.items.items.length; ++j)
          {
            if (!myTimefilterFieldSet.items.items [j].isValid (false))
            {
              myFilterWindow.buttons [0].disable ();
              return;
            }
          }

          myFilterWindow.buttons [0].enable ();
        }
      );
    }
  }
  else if (mySource && mySource.unfoldable)
  {
    var zoom = parseInt (vcnlinfoCookies.get ("unfoldableZoom_" + myLayer.name), 10);

    if (isNaN (zoom))
    {
      zoom = 13;
    }

    if ("true" == vcnlinfoCookies.get ("unfoldableEnabled_" + myLayer.name))
    {
      myLayer.unfoldEnabled (true, zoom);
    }
    else
    {
      myLayer.unfoldEnabled (false, zoom);
    }

    var myFilterFieldSet = new Ext.form.FieldSet ({
      xtype:'fieldset',
      title: dictionary.lookUp ('VMSEnableUnfold'),
      checkboxToggle: true,
      autoHeight: true,
      collapsed: true,
      defaultType: 'numberfield',
      items: [{
        fieldLabel: dictionary.lookUp ('minZoom'),
        id: 'minZoom' + myLayer.name,
        minValue: 0,
        maxValue: 17,
        maxLength: 2
      }]
    });

    var myFilterWindow = new Ext.Window ({
      layout: 'fit',
      title: dictionary.lookUp ('feedSettings') + myLayer.getTitle (),
      height: 220,
      width: 240,
      closable: false,
      constrain: true,
      maximizable: false,
      minimizable: false,
      modal: true,
      resizable: false,
      renderTo: Ext.getBody (),
      items: new Ext.FormPanel ({
        labelWidth: 100,
        border: false,
        items: [myFilterFieldSet]
      }),
      buttons: [{
        text: dictionary.lookUp ('btnSave'),
        handler: function () {
          vcnlinfoCookies.set ("unfoldableEnabled_" + myLayer.name,
            myFilterFieldSet.collapsed ? "false" : "true");
          vcnlinfoCookies.set ("unfoldableZoom_" + myLayer.name,
            myFilterFieldSet.items.items [0].getValue ());
          myLayer.unfoldEnabled (!myFilterFieldSet.collapsed,
            myFilterFieldSet.items.items [0].getValue ());
          myFilterWindow.hide ();
        /*  myLayer.hide ();
          setTimeout (function () {
            map.redraw (sourceFilter.getActiveLayer ());
          }, 400);*/
        }
      },{
        text: dictionary.lookUp ('btnCancel'),
        handler: function () {
          myFilterWindow.hide ();
        }
      }]
    });

    myFilterWindow.on ('show',
      function ()
      {
        myFilterWindow.setTitle (dictionary.lookUp ('feedSettings') + myLayer.getTitle ());
        myFilterFieldSet.setTitle (dictionary.lookUp ('VMSEnableUnfold'));
        getLabelOfField ('minZoom' + myLayer.name).innerHTML = dictionary.lookUp ('minZoom');
        myFilterWindow.buttons [0].setText (dictionary.lookUp ('btnSave'));
        myFilterWindow.buttons [1].setText (dictionary.lookUp ('btnCancel'));
      });

    var updateFilterFieldSet = function () {
      var number = parseInt (vcnlinfoCookies.get ("unfoldableZoom_" + myLayer.name), 10);

      if (isNaN (number))
      {
        number = 13;
      }

      myFilterFieldSet.items.items [0].setValue (number);

      if ("true" == vcnlinfoCookies.get ("unfoldableEnabled_" + myLayer.name))
      {
        myFilterFieldSet.expand (false);
      }
      else
      {
        myFilterFieldSet.collapse (false);
      }
    };

    myFilterWindow.addListener ('show',
      function () {
        updateFilterFieldSet ();
      },
      updateFilterFieldSet,
      {delay: 200}
    );
    
    myFilterFieldSet.items.items [0].addListener ('change',
      function () {
        if (!myFilterFieldSet.items.items [0].isValid (false))
        {
          myFilterWindow.buttons [0].disable ();
          return;
        }

        myFilterWindow.buttons [0].enable ();
      }
    );
  }

  myFeedFct = function ()
  {
    if (myMainPanel && !myMainPanel.isExpanded)
    {
      myMainPanel.isLoaded = false;
      return;
    }

    var reportList = new Array ();

    for (var r = 0; r < myLayer.rssItems.length; ++r)
    {
      var report = myLayer.rssItems [r];

      if (myLayer.filter.filter (report))
      {
        reportList.push ([report.description, report.title, report.itemIndex, report.guid, report.msgIndex, report.iconFilename]);
      }
    }

    if (accordion.items.getCount () == numFeeds)
    {
      accordion.remove (loadingTab, true);
      loadingTab = null;
    }

    if (null == myMainPanel)
    {
      var myTools = new Array ();

      if (myFilterWindow)
      {
        myTools.push ({
          id: 'gear',
          qtip: {text: dictionary.lookUp ('btnFilter')},
          handler: function () {myFilterWindow.show (this);}
        });
      }
      myTools.push ({
        id: 'search',
        qtip: {text: myLayer.visible ? dictionary.lookUp ('btnHide') : dictionary.lookUp ('btnShow')},
        handler: show,
        on: {
          'mouseover' : function () {
            myMainPanel.myButtonState = myLayer.visible;
            myLayer.visible
              ? myMainPanel.myButtonEl.addClass ('x-tool-search-over')
              : myMainPanel.myButtonEl.removeClass ('x-tool-search-over')
          },
          'mouseout'  : function () {
            myMainPanel.myButtonState = !myLayer.visible
            myLayer.visible
              ? myMainPanel.myButtonEl.removeClass ('x-tool-search-over')
              : myMainPanel.myButtonEl.addClass ('x-tool-search-over')
          }
        }
      });
      myTools.push ({
        id: 'refresh',
        qtip: {text: dictionary.lookUp ('btnRefresh')},
        handler: refresh
      });

      myInfoPanel = new Ext.grid.GridPanel ({
        store: new Ext.data.SimpleStore ({
          fields: [
            {name: 'name', type: 'string', sortType: Ext.data.SortTypes.asText, sortDir: 'ASC'},
            {name: 'value', type: 'float'}
          ],
          data: []
        }),
        colModel: infoColumnModel,
        view: infoView,
        region:'north',
        hideHeaders: true
      });

      myGroupPanel = new Ext.grid.GridPanel ({
        store: new Ext.data.GroupingStore ({
            reader: reader,
            sortInfo:{field: 'msgIndex', direction: "ASC"},
            groupField: 'msgIndex'
        }),
        region:'center',
        hideHeaders: true,
        colModel: columnModel,
        view: gView,
        iconCls: 'icon-grid'
      });

      myMainPanel = new Ext.Panel ({
        title: myLayer.getTitle (),
        id: myLayer.name,
        layout: 'border',
        items: [myGroupPanel, myInfoPanel],
        hideCollapseTool: true,
        titleCollapse: true,
        tools: myTools,
        collapsible: true,
        collapsed: true,
        animCollapse: false,
        bodyBorder: false,
	    defaults: {
		    collapsible: false
	    }
      });

      myInfoPanel.getStore ().add (new infoRecordConstructor ({
        name: 'lastUpdateTime',
        value: myLayer.pubDate
      }));

      for (var i in myLayer.getInfo ())
      {
        myInfoPanel.getStore ().add (new infoRecordConstructor ({
          name: i,
          value: myLayer.getInfo () [i]
        }));
      }

      myPanels [myLayer.name] = myMainPanel;
      myMainPanel.layer = myLayer;
      myMainPanel.isLoaded = false;
      myGroupPanel.on ('rowclick', onClick);
      myMainPanel.on ('beforeexpand', onExpand);
      myMainPanel.on ('beforecollapse', onCollapse);

      accordion.insert (0, myMainPanel);
      accordion.doLayout ();
      myMainPanel.loadMask = new Ext.LoadMask (myGroupPanel.id, {msg: 'loading...'});
      myMainPanel.myButtonEl = myMainPanel.getEl ().child ('*[class~="x-tool-search"]');
      myMainPanel.myButtonDom = myMainPanel.getEl ().child ('*[class~="x-tool-search"]', true);
      myMainPanel.myRefreshButtonEl = myMainPanel.getEl ().child ('*[class~="x-tool-refresh"]');

      if (!myLayer.visible)
      {
        myMainPanel.myButtonState = true;
        myMainPanel.myButtonEl.addClass ('x-tool-search-over');
      }

      var myButtonHandler = function (e)
      {
        if ((e.attrChange == e.MODIFICATION) && (e.attrName == "class"))
        {
          var found = (-1 != e.newValue.search (/x-tool-search-over/));

          if (myMainPanel.myButtonState && !found)
          {
            myMainPanel.myButtonEl.addClass ('x-tool-search-over');
          }
          else if (!myMainPanel.myButtonState && found)
          {
            myMainPanel.myButtonEl.removeClass ('x-tool-search-over');
          }
        }
      };

      hbEventHandler.add (myMainPanel.myButtonDom, 'DOMAttrModified', myButtonHandler);
    }
    else
    {
      myGroupPanel.getStore ().loadData (reportList);
      myInfoPanel.getStore ().removeAll ();

      myInfoPanel.getStore ().add (new infoRecordConstructor ({
        name: 'lastUpdateTime',
        value: myLayer.pubDate
      }));

      for (var i in myLayer.getInfo ())
      {
        myInfoPanel.getStore ().add (new infoRecordConstructor ({
          name: i,
          value: myLayer.getInfo () [i]
        }));
      }

      if (myMainPanel.loadMask)
      {
        myMainPanel.loadMask.hide ();
      }

      myMainPanel.isLoaded = true;
    }
  }

  return myFeedFct;
}

function onSwitchLanguage (lang)
{
  if (accordion.layout.activeItem && accordion.layout.activeItem.loadMask)
  {
    accordion.layout.activeItem.loadMask.show ();
  }

  vcnlinfoCookies.set ("language", lang);
  var _lang = lang;

  setTimeout (function () {
    setButtonTooltip (mapPanel.getEl ().child ('*[class~="x-tool-help"]'), dictionary.lookUp ('btnHelp'));
    setButtonTooltip (mapPanel.getEl ().child ('*[class~="x-tool-refresh"]'), dictionary.lookUp ('btnRefresh'));
    switchLanguage (_lang);
    dictionary.setActiveLanguage (_lang);

    for (var l in dictionary.languages)
    {
      var btnName = dictionary.getLangAttr ('name', l);
      var btnTTip = dictionary.lookUp (dictionary.getLangAttr ('btnTTip', l));
      setButtonTooltip (mapButtons [btnName].getEl ().id, btnTTip);
/*
      if (button.lang == lang)
      {
        button.el.removeClass (button.overCls);
      }
      else
      {
        button.el.addClass (button.overCls);
      }*/
    }

    accordion.items.each (function (item, index, length) {
      if (item.layer)
      {
        item.setTitle (item.layer.getTitle ());
        setButtonTooltip (myPanels [item.layer.name].myButtonEl.id,
                          item.layer.visible ? dictionary.lookUp ('btnHide') : dictionary.lookUp ('btnShow'));
        setButtonTooltip (myPanels [item.layer.name].myRefreshButtonEl.id,
                          dictionary.lookUp ('btnRefresh'));
      }
      if (item.loadMask && item.layer.isInitialized ())
      {
        item.loadMask.hide ();
      }
    });
  }, 200);
}

Ext.onReady (function ()
{
  settings = new hbSettings ('settings.xml');
  Ext.state.Manager.setProvider (new Ext.state.CookieProvider ());
  Ext.getBody ().addClass ('x-gray');
  Ext.QuickTips.init ();

  cityToolbar = new Ext.Toolbar ();

  mapPanel = new Ext.Panel ({
    title: 'VCNLinfo Map',
    layout:'fit',
    region:'center',
    html: '<div id="map"></div>',
    header: false,
    tbar: cityToolbar
  });

  var onMapPanelResize = function (p, width, height)
  {
    Ext.get ('map').setWidth (p.getInnerWidth ());
    Ext.get ('map').setHeight (p.getInnerHeight ());
    hbScreenOverlay.prototype.map_top = Ext.get ('map').getTop ();
    hbScreenOverlay.prototype.map_bottom = Ext.get ('map').getBottom ();
    hbScreenOverlay.prototype.map_left = Ext.get ('map').getLeft ();
    hbScreenOverlay.prototype.map_right = Ext.get ('map').getRight ();
  }

  mapPanel.on ('bodyresize', onMapPanelResize);

  progressBar = new Ext.ProgressBar ({text: '0 feeds loaded...'});

  loadingTab = new Ext.Panel ({title:'Loading Feeds...',
                  items: [progressBar],
                  border:false  });
  var accordionItems = [loadingTab];

  accordion = new Ext.Panel({
    title: 'RSS Reader',
    width: 384,
    split:true,
    layout:'accordion',
    region:'west',
    collapsible: true,
    defaults: {
        bodyStyle: 'padding:15px'
    },
    layoutConfig: {
        animate: true,
        activeOnTop: true
    },
    items: accordionItems
  });

  var viewport = new Ext.Viewport ({
    cls: 'et2-background',
    layout:'border',
    items: [mapPanel, accordion]
  });

  deferredRSSMapInit ();
});

function deferredRSSMapInit ()
{
  if (false == settings.isInitialized ())
  {
    setTimeout (deferredRSSMapInit (), 100);
    return;
  }

  dictionary = settings.dictionary;
  dictionary.initialize ();

  var lastLanguage = vcnlinfoCookies.get ("language");

  if (lastLanguage)
  {
    dictionary.setActiveLanguage (lastLanguage);
  }

  var mapSettingsItems = [];

  if ((null != settings.get ("enableOverlayMenu")) && ("true" == settings.get ("enableOverlayMenu")))
  {
    veilRadioButton = new Ext.form.Radio ({
      boxLabel: 'Show Veil',
      name: 'overlay',
      checked: false,
      labelSeparator: ''
    });

    rainRadarRadioButton = new Ext.form.Radio ({
      boxLabel: 'Show Rain Radar',
      name: 'overlay',
      checked: false,
      labelSeparator: ''
    });

    mapSettingsItems.push ({
      title:'Overlays',
      layout:'form',
      defaultType: 'radio',
      items: [veilRadioButton,rainRadarRadioButton]
    });
  }

  if ((null != settings.get ("enableAutoRefresh")) && ("true" == settings.get ("enableAutoRefresh")))
  {
    enableAutoRefreshFieldSet = new Ext.form.FieldSet ({
      xtype:'fieldset',
      title: 'Enable Auto Refresh',
      checkboxToggle: true,
      checkboxName: 'autoRefreshEnabled-ChkBx',
      autoHeight: true,
      collapsed: true,
      defaultType: 'numberfield',
      items: [{
        fieldLabel: 'Input Refresh Interval (in minutes)',
        name: 'input',
        width: 50
      },{
        fieldLabel: 'Page Reload Interval (in minutes)',
        name: 'page',
        width: 50
      }]
    });
    
    mapSettingsItems.push ({
      title:'Automatic Refresh',
      layout:'form',
      labelWidth: 200,
      items: [enableAutoRefreshFieldSet]
    });
  }

  if (mapSettingsItems.length > 0)
  {
    mapSettingsPanel = new Ext.Window ({
      layout: 'fit',
      title: 'Map Settings',
      height: 250,
      width: 320,
      closable: false,
      constrain: true,
      maximizable: false,
      minimizable: false,
      modal: true,
      resizable: false,
      renderTo: Ext.getBody (),
      items: new Ext.FormPanel ({
        labelWidth: 1,
        border:false,
        items: new Ext.TabPanel ({
          activeTab: 0,
          defaults:{autoHeight:true, bodyStyle:'padding:10px'}, 
          items: mapSettingsItems
        })
      }),
      buttons: [{
          text: 'Save',
          handler: function () {
            var veil = veilRadioButton.getValue ();

            if (true == veil)
            {
              sourceFilter.activate ("veil");
            }
            else
            {
              sourceFilter.activate ("rain radar");
            }

            vcnlinfoCookies.set ("autoRefreshEnabled", enableAutoRefreshFieldSet.collapsed ? "false" : "true");
            vcnlinfoCookies.set ("InputRefreshInterval", enableAutoRefreshFieldSet.items.items [0].getValue ());
            vcnlinfoCookies.set ("PageReloadInterval", enableAutoRefreshFieldSet.items.items [1].getValue ());

            mapSettingsPanel.hide ();
            map.redraw (sourceFilter.getActiveLayer ());
            _initAutoRefresh ();
          }
        },
        {
          text: 'Cancel',
          handler: function () {
            mapSettingsPanel.hide ();
          }
        }
      ]
    });

    var updateAutoRefreshFieldSet = function () {
      if (autoRefreshSettings.autoRefreshEnabled)
      {
        enableAutoRefreshFieldSet.expand (false);
      }
      else
      {
        enableAutoRefreshFieldSet.collapse (false);
      }
    };

    enableAutoRefreshFieldSet.addListener ('render',
      function () {
        updateAutoRefreshFieldSet ();
        mapSettingsPanel.addListener ('show', updateAutoRefreshFieldSet);
      },
      enableAutoRefreshFieldSet,
      {delay: 200}
    );
  }

  var toolbarText = cityToolbar.addText (settings.get ("title") + " Map");

  for (var l in dictionary.languages)
  {
    var btnName = dictionary.getLangAttr ('name', l);
    var btnTTip = dictionary.lookUp (dictionary.getLangAttr ('btnTTip', l));
    var cls = dictionary.getLangAttr ('cls', l);
    mapButtons [btnName] = cityToolbar.addButton ({
      cls: cls,
      tooltip: {text: btnTTip},
      handler: function () {
        setTimeout ("onSwitchLanguage ('" + this + "')", 200);
      },
      scope: l
    });
  }

  if (null != settings.get ("shortcut"))
  {
    var shortcutStore = new Ext.data.SimpleStore ({
      fields: [
        {name: 'name', type: 'string', sortType: Ext.data.SortTypes.asText, sortDir: 'ASC'},
        {name: 'lat', type: 'float'},
        {name: 'lng', type: 'float'},
        {name: 'zoom', type: 'int'}
      ],
      data: []
    });

    var cityCombo = new Ext.form.ComboBox ({
      store: shortcutStore,
      displayField: 'name',
      typeAhead: true,
      mode: 'local',
      triggerAction: 'all',
      emptyText: 'Select a city...',
      selectOnFocus: true,
      width: 135
    });

    cityCombo.addListener ('select',
      function (combo, record, index) {
        map.map.setCenter (new GLatLng (record.get ("lat"), record.get ("lng")) , record.get ("zoom"));
      }
    );

    cityToolbar.addField (cityCombo);
    cityCombo.getEl ().parent ().applyStyles ('margin-left:auto;margin-right:auto;');
    cityCombo.getEl ().parent ().parent ().applyStyles ('width:100%;');
  }
  else
  {
    toolbarText.getEl ().parentNode.style.width = '100%';
  }

  if (null != mapSettingsPanel)
  {
    mapButtons ['settings'] = cityToolbar.addButton ({
      cls: 'et2-gear-button',
      tooltip: {text: dictionary.lookUp ('btnMapSettings')},
      handler: function () {
        veilRadioButton.setValue (sourceFilter.getSourceForLayer ("veil").getActiveLayer ().layername == "veil" ? true : false);
        rainRadarRadioButton.setValue (sourceFilter.getSourceForLayer ("veil").getActiveLayer ().layername == "veil" ? false : true);
        enableAutoRefreshFieldSet.items.items [0].setValue (autoRefreshSettings.inputRefreshInterval);
        enableAutoRefreshFieldSet.items.items [1].setValue (autoRefreshSettings.pageReloadInterval);
        mapSettingsPanel.show (mapButtons ['settings']);
      }
    });
  }
  mapButtons ['refresh'] = cityToolbar.addButton ({
    cls: 'et2-refresh-button',
    tooltip: {text: dictionary.lookUp ('btnRefreshAll')},
    handler: function () {
      var reloadLayer = function (layerName) {
        myPanels [layerName].layer.hide ();
        myPanels [layerName].layer.reload ();
      };

      for (var p in myPanels)
      {
        if (myPanels [p].isExpanded)
        {
          myPanels [p].loadMask.show ();
        }

        setTimeout ('myPanels ["' + p + '"].layer.hide ();myPanels ["' + p + '"].layer.reload ();', 10);
      }

      setTimeout (function () {
        map.redraw (sourceFilter.getActiveLayer ());
      }, 100);
    }
  });
  mapButtons ['help'] = cityToolbar.addButton ({
    cls: 'et2-help-button',
    tooltip: {text: dictionary.lookUp ('btnHelp')},
    handler: function () {
      setTimeout (function () {
        window.open (dictionary.lookUp ('linkHelp'),
          dictionary.lookUp ('captionHelp'),
          'width=800, height=600, resizable=yes, scrollbars=yes');
      }, 100);
    }
  });

  Ext.get ('map').setWidth (mapPanel.getInnerWidth ());
  Ext.get ('map').setHeight (mapPanel.getInnerHeight () - cityToolbar.getBox ().height + 5);
  hbScreenOverlay.prototype.map_top = Ext.get ('map').getTop ();
  hbScreenOverlay.prototype.map_bottom = Ext.get ('map').getBottom ();
  hbScreenOverlay.prototype.map_left = Ext.get ('map').getLeft ();
  hbScreenOverlay.prototype.map_right = Ext.get ('map').getRight ();

  load ();
/*
  for (var b in languageButtons)
  {
    var button = languageButtons [b];
    button.el = mapPanel.getEl ().child ('*[class~="' + button.cls + '"]');
    button.DOM = mapPanel.getEl ().child ('*[class~="' + button.cls + '"]', true);

    if (button.lang == language)
    {
      button.el.removeClass (button.overCls);
    }
    else
    {
      button.el.addClass (button.overCls);
    }

    var myButtonHandler = function (e)
    {
      if ((e.attrChange == e.MODIFICATION) && (e.attrName == "class"))
      {
        var match = e.newValue.match (/x-tool-[\S]*-over/);
        var b = getButtonByDOM (e.target);

        if (b)
        {
          if (null != match)
          {
            if ((b.lang == language) || (b.mouseOverState))
            {
              b.el.removeClass (match [0]);
            }
          }
          else if ((b.lang != language) && (!b.mouseOverState))
          {*/
  //          match = e.newValue.match (/x-tool-[\S]*/);
/*
            if (null != match)
            {
              b.el.addClass (match [0] + '-over');
            }
          }
        }
      }
    };

    hbEventHandler.add (button.DOM, 'DOMAttrModified', myButtonHandler);
  }
*/
 /* if (language == "german")
  {
    onSwitchLanguage (language);
  }*/

  if (null != settings.get ("shortcut"))
  {
    var shortcuts = settings.get ("shortcut");
    var scRecordConstructor = Ext.data.Record.create (
      {name: 'name', type: 'string', sortType: Ext.data.SortTypes.asText, sortDir: 'ASC'},
      {name: 'lat', type: 'float'},
      {name: 'lng', type: 'float'},
      {name: 'zoom', type: 'int'}
    );

    for (var s = 0; s < shortcuts.length; ++s)
    {
      shortcutStore.add (new scRecordConstructor ({
        name: shortcuts [s] ["name"],
        lat: parseFloat (shortcuts [s] ["lat"]),
        lng: parseFloat (shortcuts [s] ["lng"]),
        zoom: parseInt (shortcuts [s] ["zoom"], 10)
      }));
    }
  }
/*
  for (var l in dictionary.languages)
  {
    infoSettings [l] = new Object ();
    infoSettings [l] ["lastUpdateTime"] = new Object ();
    infoSettings [l] ["lastUpdateTime"] ["caption"] = dictionary.lookUp ('captionLastUpdate', l);
    infoSettings [l] ["lastUpdateTime"] ["unit"] = '';
  }

  var showInfo = settings.get ("showInfo");

  if (null != showInfo)
  {
    for (var si = 0; si < showInfo.length; ++si)
    {
      var name = showInfo [si] ["elementName"];

      for (var el = 0; el < showInfo [si] ["element"].length; ++el)
      {
        var element = showInfo [si] ["element"] [el];

        if (! infoSettings [element ["language"]])
        {
          infoSettings [element ["language"]] = new Object ();
        }

        infoSettings [element ["language"]] [name] = new Object ();
        infoSettings [element ["language"]] [name] ["caption"] = element ["caption"];
        infoSettings [element ["language"]] [name] ["unit"] = element ["unit"];
      }
    }
  }
*/
  loadFeeds ();
  setTimeout (function () {
    map.redraw (sourceFilter.getActiveLayer ());
  }, 100);
  _initAutoRefresh ();
  
  var userInformation = dictionary.lookUp ('userInfo');

  var userInformationWindow = new Ext.Window ({
      layout: 'fit',
      title: 'Information',
      height: 108,
      width: 240,
      closable: true,
      constrain: true,
      maximizable: false,
      minimizable: false,
      modal: true,
      resizable: false,
      renderTo: Ext.getBody (),
      html: '<div class="x-panel-body">' + userInformation + '</div>',
      buttons: [{
          text: 'OK',
          handler: function () {
            userInformationWindow.close ();
          }
        }
      ]
    });

    userInformationWindow.show ();
}

mapFeedback = function (guid, index)
{
  var splitted = guid.split (':');
  var layer = splitted [0];
  var report = layerMgr.getReport (layer, guid);

  if (null == report)
  {
    return;
  }

  if (undefined == index)
  {
    index = 0;
  }

  if (!myPanels [layer].isLoaded)
  {
    myPanels [layer].expand ();
    setTimeout ("mapFeedback ('" + guid + "'," + index + ")", 1000);
    return;
  }

  var found = myPanels [layer].items.items [0].getStore ().findBy (
    function (record, id)
    {
      if (record.get ('msgGUId') != guid)
      {
        return false;
      }
      if (record.get ('refIndex') != index)
      {
        return false;
      }

      return true;
    });

  if (-1 != found)
  {
    myPanels [layer].expand ();
    var view = myPanels [layer].items.items [0].getView ();
    var record = myPanels [layer].items.items [0].getStore ().getAt (found);
    var groupId = view.getGroupId ('<table width="100%"><tr><td style="font-family:tahoma,arial,helvetica,sans-serif;font-size:11px;font-weight:bold;">' +
                    record.get ('title') + '</td><td style="width:18"><img width="17" height="17" src="' +
                    record.get ('icon') + '"/></td><td style="width:12"></td></tr></table>');
    view.toggleGroup (Ext.util.Format.htmlDecode (groupId), true);
    view.focusRow (found);
    myPanels [layer].items.items [0].getSelectionModel ().selectRow (found);
  }
}

function _initAutoRefresh ()
{
  if ("" != vcnlinfoCookies.get ("autoRefreshEnabled"))
  {
    autoRefreshSettings.autoRefreshEnabled = ("true" == vcnlinfoCookies.get ("autoRefreshEnabled"));
  }
  if ("" != vcnlinfoCookies.get ("InputRefreshInterval"))
  {
    autoRefreshSettings.inputRefreshInterval = parseInt (vcnlinfoCookies.get ("InputRefreshInterval"), 10);
  }
  if ("" != vcnlinfoCookies.get ("PageReloadInterval"))
  {
    autoRefreshSettings.pageReloadInterval = parseInt (vcnlinfoCookies.get ("PageReloadInterval"), 10);
  }

  if (autoRefreshSettings.autoRefreshEnabled)
  {
    if (!autoRefreshSettings.inputRefreshTimeoutRunning && (autoRefreshSettings.inputRefreshInterval > 0))
    {
      autoRefreshSettings.inputRefreshTimeoutRunning = true;
      setTimeout ('_autoRefresh ()',
                  60000 * autoRefreshSettings.inputRefreshInterval);
    }
    else
    {
      autoRefreshSettings.inputRefreshTimeoutRunning = false;
    }

    if (!autoRefreshSettings.pageReloadTimeoutRunning && (autoRefreshSettings.pageReloadInterval > 0))
    {
      autoRefreshSettings.pageReloadTimeoutRunning = true;
      setTimeout ('_autoPageReload ()',
                  60000 * autoRefreshSettings.pageReloadInterval);
    }
    else
    {
      autoRefreshSettings.pageReloadTimeoutRunning = false;
    }
  }
  else
  {
    autoRefreshSettings.inputRefreshTimeoutRunning = false;
    autoRefreshSettings.pageReloadTimeoutRunning = false;
  }
}

function _autoRefresh ()
{
  if (autoRefreshSettings.autoRefreshEnabled)
  {
    for (var p in myPanels)
    {
      if (myPanels [p].isExpanded)
      {
        myPanels [p].loadMask.show ();
      }

      setTimeout ('myPanels ["' + p + '"].layer.hide ();myPanels ["' + p + '"].layer.reload ();', 10);
    }

    setTimeout (function () {
      map.redraw (sourceFilter.getActiveLayer ());
    }, 100);

    if (autoRefreshSettings.inputRefreshInterval > 0)
    {
      autoRefreshSettings.inputRefreshTimeoutRunning = true;
      setTimeout ('_autoRefresh ()',
                  60000 * autoRefreshSettings.inputRefreshInterval);
    }
    else
    {
      autoRefreshSettings.inputRefreshTimeoutRunning = false;
    }
  }
  else
  {
    autoRefreshSettings.inputRefreshTimeoutRunning = false;
  }
}

function _autoPageReload ()
{
  if (autoRefreshSettings.autoRefreshEnabled)
  {
    window.location = window.location;

    if (autoRefreshSettings.pageReloadInterval > 0)
    {
      autoRefreshSettings.pageReloadTimeoutRunning = true;
      setTimeout ('_autoPageReload ()',
                  60000 * autoRefreshSettings.pageReloadInterval);
    }
    else
    {
      autoRefreshSettings.pageReloadTimeoutRunning = false;
    }
  }
  else
  {
    autoRefreshSettings.pageReloadTimeoutRunning = false;
  }
}