diff --git a/sdrgui/gui/glspectrumgui.cpp b/sdrgui/gui/glspectrumgui.cpp
index db0084ada..35457979c 100644
--- a/sdrgui/gui/glspectrumgui.cpp
+++ b/sdrgui/gui/glspectrumgui.cpp
@@ -1,3 +1,24 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2016-2020 F4EXB                                                 //
+// written by Edouard Griffiths                                                  //
+//                                                                               //
+// OpenGL interface modernization.                                               //
+// See: http://doc.qt.io/qt-5/qopenglshaderprogram.html                          //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+// (at your option) any later version.                                           //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
 #include "gui/glspectrumgui.h"
 #include "dsp/fftwindow.h"
 #include "dsp/spectrumvis.h"
@@ -10,38 +31,25 @@ GLSpectrumGUI::GLSpectrumGUI(QWidget* parent) :
 	ui(new Ui::GLSpectrumGUI),
 	m_spectrumVis(nullptr),
 	m_glSpectrum(nullptr),
-	m_fftSize(1024),
-	m_fftOverlap(0),
-	m_fftWindow(FFTWindow::Hanning),
-	m_refLevel(0),
-	m_powerRange(100),
-	m_decay(1),
-	m_decayDivisor(1),
-	m_histogramStroke(30),
-	m_displayGridIntensity(5),
-	m_displayTraceIntensity(50),
-	m_displayWaterfall(true),
-	m_invertedWaterfall(false),
-	m_displayMaxHold(false),
-	m_displayCurrent(false),
-	m_displayHistogram(false),
-	m_displayGrid(false),
-	m_invert(true),
-	m_averagingMode(AvgModeNone),
-	m_averagingIndex(0),
-	m_averagingMaxScale(5),
-	m_averagingNb(0)
+    m_doApplySettings(true)
 {
 	ui->setupUi(this);
 	on_linscale_toggled(false);
-	ui->refLevel->clear();
-	for(int ref = 0; ref >= -110; ref -= 5)
+
+    ui->refLevel->clear();
+	for(int ref = 0; ref >= -110; ref -= 5) {
 		ui->refLevel->addItem(QString("%1").arg(ref));
+    }
+
 	ui->levelRange->clear();
-	for(int range = 100; range >= 5; range -= 5)
+	for(int range = 100; range >= 5; range -= 5) {
 		ui->levelRange->addItem(QString("%1").arg(range));
+    }
+
 	setAveragingCombo();
 	connect(&m_messageQueue, SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()));
+    displaySettings();
+    applySettings();
 }
 
 GLSpectrumGUI::~GLSpectrumGUI()
@@ -54,410 +62,275 @@ void GLSpectrumGUI::setBuddies(SpectrumVis* spectrumVis, GLSpectrum* glSpectrum)
 	m_spectrumVis = spectrumVis;
 	m_glSpectrum = glSpectrum;
 	m_glSpectrum->setMessageQueueToGUI(&m_messageQueue);
-	applySettings();
-	applySettingsVis();
+    m_spectrumVis->setMessageQueueToGUI(&m_messageQueue);
 }
 
 void GLSpectrumGUI::resetToDefaults()
 {
-	m_fftSize = 1024;
-	m_fftOverlap = 0;
-	m_fftWindow = FFTWindow::Hanning;
-	m_refLevel = 0;
-	m_powerRange = 100;
-	m_decay = 1;
-	m_decayDivisor = 1;
-	m_histogramStroke = 30;
-	m_displayGridIntensity = 5,
-	m_displayWaterfall = true;
-	m_invertedWaterfall = false;
-	m_displayMaxHold = false;
-	m_displayHistogram = false;
-	m_displayGrid = false;
-	m_invert = true;
-	m_averagingMode = AvgModeNone;
-	m_averagingIndex = 0;
-	m_linear = false;
+    m_settings.resetToDefaults();
+    displaySettings();
 	applySettings();
-	applySettingsVis();
 }
 
 QByteArray GLSpectrumGUI::serialize() const
 {
-	SimpleSerializer s(1);
-
-	s.writeS32(1, m_fftSize);
-	s.writeS32(2, m_fftOverlap);
-	s.writeS32(3, m_fftWindow);
-	s.writeReal(4, m_refLevel);
-	s.writeReal(5, m_powerRange);
-	s.writeBool(6, m_displayWaterfall);
-	s.writeBool(7, m_invertedWaterfall);
-	s.writeBool(8, m_displayMaxHold);
-	s.writeBool(9, m_displayHistogram);
-	s.writeS32(10, m_decay);
-	s.writeBool(11, m_displayGrid);
-	s.writeBool(12, m_invert);
-	s.writeS32(13, m_displayGridIntensity);
-	s.writeS32(14, m_decayDivisor);
-	s.writeS32(15, m_histogramStroke);
-	s.writeBool(16, m_displayCurrent);
-	s.writeS32(17, m_displayTraceIntensity);
-	s.writeReal(18, m_glSpectrum->getWaterfallShare());
-	s.writeS32(19, (int) m_averagingMode);
-	s.writeS32(20, (qint32) getAveragingValue(m_averagingIndex));
-	s.writeBool(21, m_linear);
-
-    return s.final();
+    return m_settings.serialize();
 }
 
 bool GLSpectrumGUI::deserialize(const QByteArray& data)
 {
-	SimpleDeserializer d(data);
-
-	if(!d.isValid()) {
-		resetToDefaults();
-		return false;
-	}
-
-	int tmp;
-
-	if (d.getVersion() == 1)
+    if (m_settings.deserialize(data))
     {
-		d.readS32(1, &m_fftSize, 1024);
-		d.readS32(2, &m_fftOverlap, 0);
-		d.readS32(3, &m_fftWindow, FFTWindow::Hanning);
-		d.readReal(4, &m_refLevel, 0);
-		d.readReal(5, &m_powerRange, 100);
-		d.readBool(6, &m_displayWaterfall, true);
-		d.readBool(7, &m_invertedWaterfall, false);
-		d.readBool(8, &m_displayMaxHold, false);
-		d.readBool(9, &m_displayHistogram, false);
-		d.readS32(10, &m_decay, 1);
-		d.readBool(11, &m_displayGrid, false);
-		d.readBool(12, &m_invert, true);
-		d.readS32(13, &m_displayGridIntensity, 5);
-		d.readS32(14, &m_decayDivisor, 1);
-		d.readS32(15, &m_histogramStroke, 30);
-		d.readBool(16, &m_displayCurrent, false);
-		d.readS32(17, &m_displayTraceIntensity, 50);
-		Real waterfallShare;
-		d.readReal(18, &waterfallShare, 0.66);
-		d.readS32(19, &tmp, 0);
-		m_averagingMode = tmp < 0 ? AvgModeNone : tmp > 3 ? AvgModeMax : (AveragingMode) tmp;
-		d.readS32(20, &tmp, 0);
-		m_averagingIndex = getAveragingIndex(tmp);
-	    m_averagingNb = getAveragingValue(m_averagingIndex);
-	    d.readBool(21, &m_linear, false);
-
-        m_glSpectrum->setWaterfallShare(waterfallShare);
-    	applySettings();
-		applySettingsVis();
-		return true;
-	}
+        displaySettings();
+        applySettings();
+        return true;
+    }
     else
     {
-		resetToDefaults();
-		return false;
-	}
+        resetToDefaults();
+        return false;
+    }
 }
 
-void GLSpectrumGUI::applySettings()
+void GLSpectrumGUI::displaySettings()
 {
-	ui->refLevel->setCurrentIndex(-m_refLevel / 5);
-	ui->levelRange->setCurrentIndex((100 - m_powerRange) / 5);
-	ui->decay->setSliderPosition(m_decay);
-	ui->decayDivisor->setSliderPosition(m_decayDivisor);
-	ui->stroke->setSliderPosition(m_histogramStroke);
-	ui->waterfall->setChecked(m_displayWaterfall);
-	ui->maxHold->setChecked(m_displayMaxHold);
-	ui->current->setChecked(m_displayCurrent);
-	ui->histogram->setChecked(m_displayHistogram);
-	ui->invert->setChecked(m_invert);
-	ui->grid->setChecked(m_displayGrid);
-	ui->gridIntensity->setSliderPosition(m_displayGridIntensity);
+    blockApplySettings(true);
+	ui->refLevel->setCurrentIndex(-m_settings.m_refLevel / 5);
+	ui->levelRange->setCurrentIndex((100 - m_settings.m_powerRange) / 5);
+	ui->decay->setSliderPosition(m_settings.m_decay);
+	ui->decayDivisor->setSliderPosition(m_settings.m_decayDivisor);
+	ui->stroke->setSliderPosition(m_settings.m_histogramStroke);
+	ui->waterfall->setChecked(m_settings.m_displayWaterfall);
+	ui->maxHold->setChecked(m_settings.m_displayMaxHold);
+	ui->current->setChecked(m_settings.m_displayCurrent);
+	ui->histogram->setChecked(m_settings.m_displayHistogram);
+	ui->invert->setChecked(m_settings.m_invert);
+	ui->grid->setChecked(m_settings.m_displayGrid);
+	ui->gridIntensity->setSliderPosition(m_settings.m_displayGridIntensity);
 
-	ui->decay->setToolTip(QString("Decay: %1").arg(m_decay));
-	ui->decayDivisor->setToolTip(QString("Decay divisor: %1").arg(m_decayDivisor));
-	ui->stroke->setToolTip(QString("Stroke: %1").arg(m_histogramStroke));
-	ui->gridIntensity->setToolTip(QString("Grid intensity: %1").arg(m_displayGridIntensity));
-	ui->traceIntensity->setToolTip(QString("Trace intensity: %1").arg(m_displayTraceIntensity));
+	ui->decay->setToolTip(QString("Decay: %1").arg(m_settings.m_decay));
+	ui->decayDivisor->setToolTip(QString("Decay divisor: %1").arg(m_settings.m_decayDivisor));
+	ui->stroke->setToolTip(QString("Stroke: %1").arg(m_settings.m_histogramStroke));
+	ui->gridIntensity->setToolTip(QString("Grid intensity: %1").arg(m_settings.m_displayGridIntensity));
+	ui->traceIntensity->setToolTip(QString("Trace intensity: %1").arg(m_settings.m_displayTraceIntensity));
 
-	m_glSpectrum->setDisplayWaterfall(m_displayWaterfall);
-	m_glSpectrum->setInvertedWaterfall(m_invertedWaterfall);
-	m_glSpectrum->setDisplayMaxHold(m_displayMaxHold);
-	m_glSpectrum->setDisplayCurrent(m_displayCurrent);
-	m_glSpectrum->setDisplayHistogram(m_displayHistogram);
-	m_glSpectrum->setDecay(m_decay);
-	m_glSpectrum->setDecayDivisor(m_decayDivisor);
-	m_glSpectrum->setHistoStroke(m_histogramStroke);
-	m_glSpectrum->setInvertedWaterfall(m_invert);
-	m_glSpectrum->setDisplayGrid(m_displayGrid);
-	m_glSpectrum->setDisplayGridIntensity(m_displayGridIntensity);
-
-	setAveragingToolitp();
-}
-
-void GLSpectrumGUI::applySettingsVis()
-{
 	ui->fftWindow->blockSignals(true);
 	ui->averaging->blockSignals(true);
 	ui->averagingMode->blockSignals(true);
 	ui->linscale->blockSignals(true);
 
-	ui->fftWindow->setCurrentIndex(m_fftWindow);
+	ui->fftWindow->setCurrentIndex(m_settings.m_fftWindow);
 
 	for (int i = 0; i < 6; i++)
 	{
-		if (m_fftSize == (1 << (i + 7)))
+		if (m_settings.m_fftSize == (1 << (i + 7)))
 		{
 			ui->fftSize->setCurrentIndex(i);
 			break;
 		}
 	}
 
-	ui->averaging->setCurrentIndex(m_averagingIndex);
-    m_averagingNb = getAveragingValue(m_averagingIndex);
-	ui->averagingMode->setCurrentIndex((int) m_averagingMode);
-	ui->linscale->setChecked(m_linear);
-
-	if (m_glSpectrum) {
-		m_glSpectrum->setLinear(m_linear);
-	}
-
-	if (m_spectrumVis)
-	{
-	    m_spectrumVis->configure(
-            m_fftSize,
-            m_refLevel,
-            m_powerRange,
-            m_fftOverlap,
-            m_averagingNb,
-            (SpectrumVis::AvgMode) m_averagingMode,
-            (FFTWindow::Function) m_fftWindow,
-            m_linear
-		);
-	}
+	ui->averaging->setCurrentIndex(m_settings.m_averagingIndex);
+	ui->averagingMode->setCurrentIndex((int) m_settings.m_averagingMode);
+	ui->linscale->setChecked(m_settings.m_linear);
+	setAveragingToolitp();
 
 	ui->fftWindow->blockSignals(false);
 	ui->averaging->blockSignals(false);
 	ui->averagingMode->blockSignals(false);
 	ui->linscale->blockSignals(false);
+    blockApplySettings(false);
+}
+
+void GLSpectrumGUI::blockApplySettings(bool block)
+{
+    m_doApplySettings = !block;
+}
+
+void GLSpectrumGUI::applySettings()
+{
+    if (!m_doApplySettings) {
+        return;
+    }
+
+    if (m_glSpectrum)
+    {
+        m_glSpectrum->setDisplayWaterfall(m_settings.m_displayWaterfall);
+        m_glSpectrum->setInvertedWaterfall(m_settings.m_invertedWaterfall);
+        m_glSpectrum->setDisplayMaxHold(m_settings.m_displayMaxHold);
+        m_glSpectrum->setDisplayCurrent(m_settings.m_displayCurrent);
+        m_glSpectrum->setDisplayHistogram(m_settings.m_displayHistogram);
+        m_glSpectrum->setDecay(m_settings.m_decay);
+        m_glSpectrum->setDecayDivisor(m_settings.m_decayDivisor);
+        m_glSpectrum->setHistoStroke(m_settings.m_histogramStroke);
+        m_glSpectrum->setInvertedWaterfall(m_settings.m_invert);
+        m_glSpectrum->setDisplayGrid(m_settings.m_displayGrid);
+        m_glSpectrum->setDisplayGridIntensity(m_settings.m_displayGridIntensity);
+        m_glSpectrum->setDisplayTraceIntensity(m_settings.m_displayTraceIntensity);
+
+        if ((m_settings.m_averagingMode == GLSpectrumSettings::AvgModeFixed) || (m_settings.m_averagingMode == GLSpectrumSettings::AvgModeMax)) {
+            m_glSpectrum->setTimingRate(getAveragingValue(m_settings.m_averagingIndex) == 0 ? 1 : getAveragingValue(m_settings.m_averagingIndex));
+        } else {
+            m_glSpectrum->setTimingRate(1);
+        }
+
+        Real refLevel = m_settings.m_linear ? pow(10.0, m_settings.m_refLevel/10.0) : m_settings.m_refLevel;
+        Real powerRange = m_settings.m_linear ? pow(10.0, m_settings.m_refLevel/10.0) :  m_settings.m_powerRange;
+        qDebug("GLSpectrumGUI::applySettings: refLevel: %e powerRange: %e", refLevel, powerRange);
+        m_glSpectrum->setReferenceLevel(refLevel);
+        m_glSpectrum->setPowerRange(powerRange);
+        m_glSpectrum->setLinear(m_settings.m_linear);
+    }
+
+    if (m_spectrumVis)
+    {
+	    m_spectrumVis->configure(
+            m_settings.m_fftSize,
+            m_settings.m_refLevel,
+            m_settings.m_powerRange,
+            m_settings.m_fftOverlap,
+            getAveragingValue(m_settings.m_averagingIndex),
+            (SpectrumVis::AvgMode) m_settings.m_averagingMode,
+            (FFTWindow::Function) m_settings.m_fftWindow,
+            m_settings.m_linear
+		);
+    }
 }
 
 void GLSpectrumGUI::on_fftWindow_currentIndexChanged(int index)
 {
 	qDebug("GLSpectrumGUI::on_fftWindow_currentIndexChanged: %d", index);
-	m_fftWindow = index;
-	applySettingsVis();
+	m_settings.m_fftWindow = (FFTWindow::Function) index;
+	applySettings();
 }
 
 void GLSpectrumGUI::on_fftSize_currentIndexChanged(int index)
 {
 	qDebug("GLSpectrumGUI::on_fftSize_currentIndexChanged: %d", index);
-	m_fftSize = 1 << (7 + index);
-	applySettingsVis();
+	m_settings.m_fftSize = 1 << (7 + index);
+	applySettings();
 	setAveragingToolitp();
 }
 
 void GLSpectrumGUI::on_averagingMode_currentIndexChanged(int index)
 {
 	qDebug("GLSpectrumGUI::on_averagingMode_currentIndexChanged: %d", index);
-    m_averagingMode = index < 0 ? AvgModeNone : index > 3 ? AvgModeMax : (AveragingMode) index;
+    m_settings.m_averagingMode = index < 0 ?
+        GLSpectrumSettings::AvgModeNone :
+        index > 3 ?
+            GLSpectrumSettings::AvgModeMax :
+            (GLSpectrumSettings::AveragingMode) index;
 
-    if (m_averagingMode == AvgModeMoving)
+    if (m_settings.m_averagingMode == GLSpectrumSettings::AvgModeMoving)
     {
-        m_averagingMaxScale = 2;
+        m_settings.m_averagingMaxScale = 2;
         setAveragingCombo();
-        m_averagingNb = m_averagingNb > 1000 ? 1000 : m_averagingNb;
     }
     else
     {
-        m_averagingMaxScale = 5;
+        m_settings.m_averagingMaxScale = 5;
         setAveragingCombo();
     }
 
-	applySettingsVis();
-
-    if (m_glSpectrum)
-    {
-        if ((m_averagingMode == AvgModeFixed) || (m_averagingMode == AvgModeMax)) {
-            m_glSpectrum->setTimingRate(m_averagingNb == 0 ? 1 : m_averagingNb);
-        } else {
-            m_glSpectrum->setTimingRate(1);
-        }
-    }
+	applySettings();
 }
 
 void GLSpectrumGUI::on_averaging_currentIndexChanged(int index)
 {
 	qDebug("GLSpectrumGUI::on_averaging_currentIndexChanged: %d", index);
-    m_averagingIndex = index;
-
-	applySettingsVis();
-
-    if (m_glSpectrum)
-    {
-        if ((m_averagingMode == AvgModeFixed) || (m_averagingMode == AvgModeMax)) {
-            m_glSpectrum->setTimingRate(m_averagingNb == 0 ? 1 : m_averagingNb);
-        } else {
-            m_glSpectrum->setTimingRate(1);
-        }
-    }
-
+    m_settings.m_averagingIndex = index;
+	applySettings();
     setAveragingToolitp();
 }
 
 void GLSpectrumGUI::on_linscale_toggled(bool checked)
 {
 	qDebug("GLSpectrumGUI::on_averaging_currentIndexChanged: %s", checked ? "lin" : "log");
-    m_linear = checked;
-
-	applySettingsVis();
-
-    if (m_glSpectrum)
-    {
-        Real refLevel = m_linear ? pow(10.0, m_refLevel/10.0) : m_refLevel;
-        Real powerRange = m_linear ? pow(10.0, m_refLevel/10.0) :  m_powerRange;
-        qDebug("GLSpectrumGUI::on_linscale_toggled: refLevel: %e powerRange: %e", refLevel, powerRange);
-        m_glSpectrum->setReferenceLevel(refLevel);
-        m_glSpectrum->setPowerRange(powerRange);
-        m_glSpectrum->setLinear(m_linear);
-    }
+    m_settings.m_linear = checked;
+	applySettings();
 }
 
 void GLSpectrumGUI::on_refLevel_currentIndexChanged(int index)
 {
-	m_refLevel = 0 - index * 5;
-
-	if (m_glSpectrum)
-	{
-	    Real refLevel = m_linear ? pow(10.0, m_refLevel/10.0) : m_refLevel;
-        Real powerRange = m_linear ? pow(10.0, m_refLevel/10.0) :  m_powerRange;
-	    qDebug("GLSpectrumGUI::on_refLevel_currentIndexChanged: refLevel: %e ", refLevel);
-	    m_glSpectrum->setReferenceLevel(refLevel);
-        m_glSpectrum->setPowerRange(powerRange);
-	}
-
-    applySettingsVis();
+	m_settings.m_refLevel = 0 - index * 5;
+    applySettings();
 }
 
 void GLSpectrumGUI::on_levelRange_currentIndexChanged(int index)
 {
-	m_powerRange = 100 - index * 5;
-
-	if (m_glSpectrum)
-	{
-        Real refLevel = m_linear ? pow(10.0, m_refLevel/10.0) : m_refLevel;
-	    Real powerRange = m_linear ? pow(10.0, m_refLevel/10.0) :  m_powerRange;
-	    qDebug("GLSpectrumGUI::on_levelRange_currentIndexChanged: powerRange: %e", powerRange);
-        m_glSpectrum->setReferenceLevel(refLevel);
-	    m_glSpectrum->setPowerRange(powerRange);
-	}
-
-    applySettingsVis();
+	m_settings.m_powerRange = 100 - index * 5;
+    applySettings();
 }
 
 void GLSpectrumGUI::on_decay_valueChanged(int index)
 {
-	m_decay = index;
-	ui->decay->setToolTip(QString("Decay: %1").arg(m_decay));
-
-	if (m_glSpectrum) {
-	    m_glSpectrum->setDecay(m_decay);
-	}
+	m_settings.m_decay = index;
+	ui->decay->setToolTip(QString("Decay: %1").arg(m_settings.m_decay));
+    applySettings();
 }
 
 void GLSpectrumGUI::on_decayDivisor_valueChanged(int index)
 {
-	m_decayDivisor = index;
-	//ui->decayDivisor->setToolTip(QString("Decay divisor: %1").arg(m_decayDivisor));
-	if(m_glSpectrum != 0) {
-		applySettings();
-	}
+	m_settings.m_decayDivisor = index;
+	ui->decayDivisor->setToolTip(QString("Decay divisor: %1").arg(m_settings.m_decayDivisor));
+    applySettings();
 }
 
 void GLSpectrumGUI::on_stroke_valueChanged(int index)
 {
-	m_histogramStroke = index;
-	//ui->stroke->setToolTip(QString("Stroke: %1").arg(m_histogramStroke));
-	if (m_glSpectrum) {
-		applySettings();
-	}
+	m_settings.m_histogramStroke = index;
+	ui->stroke->setToolTip(QString("Stroke: %1").arg(m_settings.m_histogramStroke));
+    applySettings();
 }
 
 void GLSpectrumGUI::on_waterfall_toggled(bool checked)
 {
-	m_displayWaterfall = checked;
-
-	if (m_glSpectrum) {
-	    m_glSpectrum->setDisplayWaterfall(m_displayWaterfall);
-	}
+	m_settings.m_displayWaterfall = checked;
+    applySettings();
 }
 
 void GLSpectrumGUI::on_histogram_toggled(bool checked)
 {
-	m_displayHistogram = checked;
-
-	if (m_glSpectrum) {
-	    m_glSpectrum->setDisplayHistogram(m_displayHistogram);
-	}
+	m_settings.m_displayHistogram = checked;
+    applySettings();
 }
 
 void GLSpectrumGUI::on_maxHold_toggled(bool checked)
 {
-	m_displayMaxHold = checked;
-
-	if (m_glSpectrum) {
-	    m_glSpectrum->setDisplayMaxHold(m_displayMaxHold);
-	}
+	m_settings.m_displayMaxHold = checked;
+    applySettings();
 }
 
 void GLSpectrumGUI::on_current_toggled(bool checked)
 {
-	m_displayCurrent = checked;
-
-	if (m_glSpectrum) {
-	    m_glSpectrum->setDisplayCurrent(m_displayCurrent);
-	}
+	m_settings.m_displayCurrent = checked;
+    applySettings();
 }
 
 void GLSpectrumGUI::on_invert_toggled(bool checked)
 {
-	m_invert = checked;
-
-	if (m_glSpectrum) {
-	    m_glSpectrum->setInvertedWaterfall(m_invert);
-	}
+	m_settings.m_invert = checked;
+    applySettings();
 }
 
 void GLSpectrumGUI::on_grid_toggled(bool checked)
 {
-	m_displayGrid = checked;
-
-	if (m_glSpectrum) {
-	    m_glSpectrum->setDisplayGrid(m_displayGrid);
-	}
+	m_settings.m_displayGrid = checked;
+    applySettings();
 }
 
 void GLSpectrumGUI::on_gridIntensity_valueChanged(int index)
 {
-	m_displayGridIntensity = index;
-	ui->gridIntensity->setToolTip(QString("Grid intensity: %1").arg(m_displayGridIntensity));
-
-	if (m_glSpectrum) {
-	    m_glSpectrum->setDisplayGridIntensity(m_displayGridIntensity);
-	}
+	m_settings.m_displayGridIntensity = index;
+	ui->gridIntensity->setToolTip(QString("Grid intensity: %1").arg(m_settings.m_displayGridIntensity));
+    applySettings();
 }
 
 void GLSpectrumGUI::on_traceIntensity_valueChanged(int index)
 {
-	m_displayTraceIntensity = index;
-	ui->traceIntensity->setToolTip(QString("Trace intensity: %1").arg(m_displayTraceIntensity));
-
-	if (m_glSpectrum) {
-	    m_glSpectrum->setDisplayTraceIntensity(m_displayTraceIntensity);
-	}
+	m_settings.m_displayTraceIntensity = index;
+	ui->traceIntensity->setToolTip(QString("Trace intensity: %1").arg(m_settings.m_displayTraceIntensity));
+    applySettings();
 }
 
 void GLSpectrumGUI::on_clearSpectrum_clicked(bool checked)
@@ -478,7 +351,7 @@ int GLSpectrumGUI::getAveragingIndex(int averagingValue) const
     int v = averagingValue;
     int j = 0;
 
-    for (int i = 0; i <= m_averagingMaxScale; i++)
+    for (int i = 0; i <= m_settings.m_averagingMaxScale; i++)
     {
         if (v < 20)
         {
@@ -498,7 +371,7 @@ int GLSpectrumGUI::getAveragingIndex(int averagingValue) const
         v /= 10;
     }
 
-    return 3*m_averagingMaxScale + 3;
+    return 3*m_settings.m_averagingMaxScale + 3;
 }
 
 int GLSpectrumGUI::getAveragingValue(int averagingIndex) const
@@ -508,7 +381,7 @@ int GLSpectrumGUI::getAveragingValue(int averagingIndex) const
     }
 
     int v = averagingIndex - 1;
-    int m = pow(10.0, v/3 > m_averagingMaxScale ? m_averagingMaxScale : v/3);
+    int m = pow(10.0, v/3 > m_settings.m_averagingMaxScale ? m_settings.m_averagingMaxScale : v/3);
     int x = 1;
 
     if (v % 3 == 0) {
@@ -529,7 +402,7 @@ void GLSpectrumGUI::setAveragingCombo()
     ui->averaging->clear();
     ui->averaging->addItem(QString("1"));
 
-    for (int i = 0; i <= m_averagingMaxScale; i++)
+    for (int i = 0; i <= m_settings.m_averagingMaxScale; i++)
     {
         QString s;
         int m = pow(10.0, i);
@@ -587,7 +460,9 @@ void GLSpectrumGUI::setAveragingToolitp()
     if (m_glSpectrum)
     {
         QString s;
-        float averagingTime = (m_fftSize * (m_averagingNb == 0 ? 1 : m_averagingNb)) / (float) m_glSpectrum->getSampleRate();
+        float averagingTime = (m_settings.m_fftSize * (getAveragingValue(m_settings.m_averagingIndex) == 0 ?
+            1 :
+            getAveragingValue(m_settings.m_averagingIndex))) / (float) m_glSpectrum->getSampleRate();
         setNumberStr(averagingTime, 2, s);
         ui->averaging->setToolTip(QString("Number of averaging samples (avg time: %1s)").arg(s));
     }
diff --git a/sdrgui/gui/glspectrumgui.h b/sdrgui/gui/glspectrumgui.h
index f529f9921..3f66a6f15 100644
--- a/sdrgui/gui/glspectrumgui.h
+++ b/sdrgui/gui/glspectrumgui.h
@@ -1,8 +1,31 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2016-2020 F4EXB                                                 //
+// written by Edouard Griffiths                                                  //
+//                                                                               //
+// OpenGL interface modernization.                                               //
+// See: http://doc.qt.io/qt-5/qopenglshaderprogram.html                          //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+// (at your option) any later version.                                           //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
 #ifndef INCLUDE_GLSPECTRUMGUI_H
 #define INCLUDE_GLSPECTRUMGUI_H
 
 #include <QWidget>
+
 #include "dsp/dsptypes.h"
+#include "dsp/glspectrumsettings.h"
 #include "export.h"
 #include "settings/serializable.h"
 #include "util/messagequeue.h"
@@ -42,32 +65,12 @@ private:
 	SpectrumVis* m_spectrumVis;
 	GLSpectrum* m_glSpectrum;
 	MessageQueue m_messageQueue;
+    GLSpectrumSettings m_settings;
+    bool m_doApplySettings;
 
-	qint32 m_fftSize;
-	qint32 m_fftOverlap;
-	qint32 m_fftWindow;
-	Real m_refLevel;
-	Real m_powerRange;
-	int m_decay;
-	int m_decayDivisor;
-	int m_histogramStroke;
-	int m_displayGridIntensity;
-	int m_displayTraceIntensity;
-	bool m_displayWaterfall;
-	bool m_invertedWaterfall;
-	bool m_displayMaxHold;
-	bool m_displayCurrent;
-	bool m_displayHistogram;
-	bool m_displayGrid;
-	bool m_invert;
-	AveragingMode m_averagingMode;
-	int m_averagingIndex;
-	int m_averagingMaxScale; //!< Max power of 10 multiplier to 2,5,10 base ex: 2 -> 2,5,10,20,50,100,200,500,1000
-	unsigned int m_averagingNb;
-	bool m_linear; //!< linear else logarithmic scale
-
+    void blockApplySettings(bool block);
 	void applySettings();
-	void applySettingsVis();
+    void displaySettings();
 	int getAveragingIndex(int averaging) const;
 	int getAveragingValue(int averagingIndex) const;
 	void setAveragingCombo();