diff --git a/colorprefs.h b/colorprefs.h
new file mode 100644
index 0000000..7db11fc
--- /dev/null
+++ b/colorprefs.h
@@ -0,0 +1,38 @@
+#ifndef COLORPREFS_H
+#define COLORPREFS_H
+
+#include <QColor>
+#include <QString>
+
+struct colorPrefsType{
+    int presetNum = -1;
+    QString *presetName = Q_NULLPTR;
+
+    // Spectrum line plot:
+    QColor gridColor;
+    QColor axisColor;
+    QColor textColor;
+    QColor spectrumLine;
+    QColor spectrumFill;
+    QColor underlayLine;
+    QColor underlayFill;
+    QColor plotBackground;
+    QColor tuningLine;
+
+    // Waterfall:
+    QColor wfBackground;
+    QColor wfGrid;
+    QColor wfAxis;
+    QColor wfText;
+
+    // Meters:
+    QColor meterLevel;
+    QColor meterAverage;
+    QColor meterPeakLevel;
+    QColor meterPeakScale;
+    QColor meterLowerLine;
+    QColor meterLowText;
+};
+
+
+#endif // COLORPREFS_H
diff --git a/meter.cpp b/meter.cpp
index bc606ef..9a24035 100644
--- a/meter.cpp
+++ b/meter.cpp
@@ -48,6 +48,26 @@ meter::meter(QWidget *parent) : QWidget(parent)
 
 }
 
+void meter::setColors(QColor current, QColor peakScale, QColor peakLevel,
+                      QColor average, QColor lowLine,
+                      QColor lowText)
+{
+    currentColor = current;
+
+    peakColor = peakLevel; // color for the peak level indicator
+    highLineColor = peakScale; // color for the red side of the scale
+    highTextColor = peakScale; // color for the red side of the scale's text
+
+    averageColor = average;
+
+    midScaleColor = QColor(Qt::yellow);
+    centerTuningColor = QColor(Qt::green);
+
+    lowLineColor = lowLine;
+    lowTextColor = lowText;
+    this->update();
+}
+
 void meter::clearMeterOnPTTtoggle()
 {
     // When a meter changes type, such as the fixed S -- TxPo meter,
@@ -225,7 +245,7 @@ void meter::paintEvent(QPaintEvent *)
 
 void meter::drawLabel(QPainter *qp)
 {
-    qp->setPen(lowLineColor);
+    qp->setPen(lowTextColor);
     qp->drawText(0,scaleTextYstart, label );
 }
 
@@ -287,9 +307,8 @@ void meter::drawScaleRaw(QPainter *qp)
 
     // Line: X1, Y1 -->to--> X2, Y2
     qp->drawLine(mXstart,scaleLineYstart,peakRedLevel+mXstart,scaleLineYstart);
-    qp->setPen(Qt::red);
+    qp->setPen(highLineColor);
     qp->drawLine(peakRedLevel+mXstart,scaleLineYstart,255+mXstart,scaleLineYstart);
-
 }
 
 void meter::drawScaleVd(QPainter *qp)
@@ -326,7 +345,7 @@ void meter::drawScaleVd(QPainter *qp)
 
     // Line: X1, Y1 -->to--> X2, Y2
     qp->drawLine(mXstart,scaleLineYstart,peakRedLevel+mXstart,scaleLineYstart);
-    qp->setPen(Qt::red);
+    qp->setPen(highLineColor);
     qp->drawLine(peakRedLevel+mXstart,scaleLineYstart,255+mXstart,scaleLineYstart);
 
 }
@@ -337,7 +356,7 @@ void meter::drawScaleCenter(QPainter *qp)
     qp->setPen(lowLineColor);
     qp->drawText(60+mXstart,scaleTextYstart, QString("-"));
 
-    qp->setPen(Qt::green);
+    qp->setPen(centerTuningColor);
     // Attempt to draw the zero at the actual center
     qp->drawText(128-2+mXstart,scaleTextYstart, QString("0"));
 
@@ -348,7 +367,7 @@ void meter::drawScaleCenter(QPainter *qp)
     qp->setPen(lowLineColor);
     qp->drawLine(mXstart,scaleLineYstart,128-32+mXstart,scaleLineYstart);
 
-    qp->setPen(Qt::green);
+    qp->setPen(centerTuningColor);
     qp->drawLine(128-32+mXstart,scaleLineYstart,128+32+mXstart,scaleLineYstart);
 
     qp->setPen(lowLineColor);
@@ -382,7 +401,7 @@ void meter::drawScalePo(QPainter *qp)
     //qDebug() << "meter i: " << i;
     dnPerWatt = (213-143.0f) / 50.0f; // 1.4 dn per watt
     // P=5 here.
-    qp->setPen(Qt::yellow);
+    qp->setPen(midScaleColor);
     int k=0;
     for(i=mXstart+143; i<mXstart+213; i+=(5*dnPerWatt))
     {
@@ -392,7 +411,7 @@ void meter::drawScalePo(QPainter *qp)
     }
 
     // Now we're out past 100:
-    qp->setPen(Qt::red);
+    qp->setPen(highTextColor);
 
     for(i=mXstart+213; i<mXstart+255; i+=(10*dnPerWatt))
     {
@@ -406,7 +425,7 @@ void meter::drawScalePo(QPainter *qp)
 
     // Line: X1, Y1 -->to--> X2, Y2
     qp->drawLine(mXstart,scaleLineYstart,213+mXstart,scaleLineYstart);
-    qp->setPen(Qt::red);
+    qp->setPen(highLineColor);
     qp->drawLine(213+mXstart,scaleLineYstart,255+mXstart,scaleLineYstart);
 
     (void)qp;
@@ -432,7 +451,7 @@ void meter::drawScaleALC(QPainter *qp)
         alc +=20;
     }
 
-    qp->setPen(Qt::red);
+    qp->setPen(highTextColor);
 
     for(; i<mXstart+120; i+=(int)(10*i))
     {
@@ -443,7 +462,7 @@ void meter::drawScaleALC(QPainter *qp)
 
     qp->setPen(lowLineColor);
     qp->drawLine(mXstart,scaleLineYstart,100+mXstart,scaleLineYstart);
-    qp->setPen(Qt::red);
+    qp->setPen(highLineColor);
     qp->drawLine(100+mXstart,scaleLineYstart,255+mXstart,scaleLineYstart);
 
     (void)qp;
@@ -483,7 +502,7 @@ void meter::drawScaleComp(QPainter *qp)
 
     // Line: X1, Y1 -->to--> X2, Y2
     qp->drawLine(mXstart,scaleLineYstart,peakRedLevel+mXstart,scaleLineYstart);
-    qp->setPen(Qt::red);
+    qp->setPen(highLineColor);
     qp->drawLine(peakRedLevel+mXstart,scaleLineYstart,255+mXstart,scaleLineYstart);
 }
 
@@ -495,27 +514,29 @@ void meter::drawScaleSWR(QPainter *qp)
     // 0080=SWR2.0,
     // 0120=SWR3.0
 
+    qp->setPen(lowTextColor);
     qp->drawText(mXstart,scaleTextYstart, QString("1.0"));
     qp->drawText(24+mXstart,scaleTextYstart, QString("1.3"));
     qp->drawText(48+mXstart,scaleTextYstart, QString("1.5"));    
     qp->drawText(80+mXstart,scaleTextYstart, QString("2.0"));
     qp->drawText(100+mXstart,scaleTextYstart, QString("2.5"));
+    qp->setPen(highTextColor);
     qp->drawText(120+mXstart,scaleTextYstart, QString("3.0"));
 
+    qp->setPen(lowLineColor);
     qp->drawLine(  0+mXstart,scaleTextYstart,  0+mXstart, scaleTextYstart+5);
     qp->drawLine( 24+mXstart,scaleTextYstart, 24+mXstart, scaleTextYstart+5);
     qp->drawLine( 48+mXstart,scaleTextYstart, 48+mXstart, scaleTextYstart+5);
     qp->drawLine( 80+mXstart,scaleTextYstart, 80+mXstart, scaleTextYstart+5);
     qp->drawLine(100+mXstart,scaleTextYstart,100+mXstart, scaleTextYstart+5); // does not draw?
+    qp->setPen(highLineColor);
     qp->drawLine(120+mXstart,scaleTextYstart,120+mXstart, scaleTextYstart+5);
 
 
     qp->setPen(lowLineColor);
     qp->drawLine(mXstart,scaleLineYstart,100+mXstart,scaleLineYstart);
-    qp->setPen(Qt::red);
+    qp->setPen(highLineColor);
     qp->drawLine(100+mXstart,scaleLineYstart,255+mXstart,scaleLineYstart);
-
-
 }
 
 void meter::drawScaleId(QPainter *qp)
@@ -553,7 +574,7 @@ void meter::drawScaleId(QPainter *qp)
 
     // Line: X1, Y1 -->to--> X2, Y2
     qp->drawLine(mXstart,scaleLineYstart,peakRedLevel+mXstart,scaleLineYstart);
-    qp->setPen(Qt::red);
+    qp->setPen(highLineColor);
     qp->drawLine(peakRedLevel+mXstart,scaleLineYstart,255+mXstart,scaleLineYstart);
 }
 
@@ -582,7 +603,7 @@ void meter::drawScaleS(QPainter *qp)
     s = 20;
     i+=20;
 
-    qp->setPen(Qt::red);
+    qp->setPen(highTextColor);
 
     for(; i<mXstart+255; i+=40)
     {
@@ -592,9 +613,7 @@ void meter::drawScaleS(QPainter *qp)
     }
 
     qp->setPen(lowLineColor);
-
     qp->drawLine(mXstart,scaleLineYstart,peakRedLevel+mXstart,scaleLineYstart);
-    qp->setPen(Qt::red);
+    qp->setPen(highLineColor);
     qp->drawLine(peakRedLevel+mXstart,scaleLineYstart,255+mXstart,scaleLineYstart);
-
 }
diff --git a/meter.h b/meter.h
index d94657c..b57e362 100644
--- a/meter.h
+++ b/meter.h
@@ -30,6 +30,9 @@ public slots:
     void setMeterShortString(QString);
     QString getMeterShortString();
     meterKind getMeterType();
+    void setColors(QColor current, QColor peakScale, QColor peakLevel,
+                   QColor average, QColor lowLine,
+                   QColor lowText);
 
 
 private:
@@ -84,6 +87,9 @@ private:
     QColor highTextColor;
     QColor highLineColor;
 
+    QColor midScaleColor;
+    QColor centerTuningColor;
+
 };
 
 #endif // METER_H
diff --git a/qledlabel.cpp b/qledlabel.cpp
index 640b1c4..d85ca8a 100644
--- a/qledlabel.cpp
+++ b/qledlabel.cpp
@@ -6,12 +6,14 @@ static const QString greenSS = QString("color: white;border-radius: %1;backgroun
 static const QString redSS = QString("color: white;border-radius: %1;background-color: qlineargradient(spread:pad, x1:0.145, y1:0.16, x2:0.92, y2:0.988636, stop:0 rgba(255, 12, 12, 255), stop:0.869347 rgba(103, 0, 0, 255));").arg(SIZE / 2);
 static const QString orangeSS = QString("color: white;border-radius: %1;background-color: qlineargradient(spread:pad, x1:0.232, y1:0.272, x2:0.98, y2:0.959773, stop:0 rgba(255, 113, 4, 255), stop:1 rgba(91, 41, 7, 255))").arg(SIZE / 2);
 static const QString blueSS = QString("color: white;border-radius: %1;background-color: qlineargradient(spread:pad, x1:0.04, y1:0.0565909, x2:0.799, y2:0.795, stop:0 rgba(203, 220, 255, 255), stop:0.41206 rgba(0, 115, 255, 255), stop:1 rgba(0, 49, 109, 255));").arg(SIZE / 2);
+static const QString blankSS = QString("color: white;border-radius: %1;background-color: qlineargradient(spread:pad, x1:0.04, y1:0.0565909, x2:0.799, y2:0.795, stop:0 rgba(203, 220, 255, 0), stop:0.41206 rgba(0, 115, 255, 0), stop:1 rgba(0, 49, 109, 0));").arg(SIZE / 2);
 
 QLedLabel::QLedLabel(QWidget* parent) :
     QLabel(parent)
 {
     //Set to ok by default
     setState(StateOkBlue);
+    baseColor = QColor(0, 115, 255, 255);
     setFixedSize(SIZE, SIZE);
 }
 
@@ -29,6 +31,11 @@ void QLedLabel::setState(State state)
         setStyleSheet(redSS);
         break;
     case StateOkBlue:
+        setStyleSheet(blueSS);
+        break;
+    case StateBlank:
+        setStyleSheet(blankSS);
+        break;
     default:
         setStyleSheet(blueSS);
         break;
@@ -38,4 +45,62 @@ void QLedLabel::setState(State state)
 void QLedLabel::setState(bool state)
 {
     setState(state ? StateOk : StateError);
-}
\ No newline at end of file
+}
+
+void QLedLabel::setColor(QColor customColor, bool applyGradient=true)
+{
+    QColor top,middle,bottom;
+    this->baseColor = customColor;
+
+    if(applyGradient)
+    {
+        top = customColor.lighter(200);
+        middle = customColor;
+        bottom = customColor.darker(200);
+    } else {
+        top = customColor;
+        middle = customColor;
+        bottom = customColor;
+    }
+
+    // Stop 0 is the upper corner color, white-ish
+    // Stop 0.4 is the middle color
+    // Stop 1 is the bottom-right corner, darker.
+
+    QString colorSS = QString("color: white;\
+            border-radius: %1;background-color: \
+            qlineargradient(spread:pad, x1:0.04, \
+            y1:0.0565909, x2:0.799, y2:0.795, \
+            stop:0 \
+            rgba(%2, %3, %4, %5), \
+            stop:0.41206 \
+            rgba(%6, %7, %8, %9), \
+            stop:1 \
+            rgba(%10, %11, %12, %13));").arg(SIZE / 2)
+            .arg(top.red()).arg(top.green()).arg(top.blue()).arg(top.alpha())
+            .arg(middle.red()).arg(middle.green()).arg(middle.blue()).arg(middle.alpha())
+            .arg(bottom.red()).arg(bottom.green()).arg(bottom.blue()).arg(bottom.alpha());
+
+    setStyleSheet(colorSS);
+}
+
+void QLedLabel::setColor(QString colorString, bool applyGradient=true)
+{
+    QColor c = QColor(colorString);
+    setColor(c, applyGradient);
+}
+
+void QLedLabel::setColor(QColor c)
+{
+    this->setColor(c, true);
+}
+
+void QLedLabel::setColor(QString s)
+{
+    this->setColor(s, true);
+}
+
+QColor QLedLabel::getColor()
+{
+    return baseColor;
+}
diff --git a/qledlabel.h b/qledlabel.h
index b5dc706..d4117c9 100644
--- a/qledlabel.h
+++ b/qledlabel.h
@@ -13,7 +13,8 @@ public:
         StateOk,
         StateOkBlue,
         StateWarning,
-        StateError
+        StateError,
+        StateBlank
     };
 
 
@@ -22,6 +23,14 @@ signals:
 public slots:
     void setState(State state);
     void setState(bool state);
+    void setColor(QColor customColor, bool applyGradient);
+    void setColor(QString colorString, bool applyGradient);
+    void setColor(QColor c);
+    void setColor(QString s);
+    QColor getColor();
+
+private:
+    QColor baseColor;
 };
 
 #endif // QLEDLABEL_H
diff --git a/wfmain.cpp b/wfmain.cpp
index c55d6cc..a39b0f3 100644
--- a/wfmain.cpp
+++ b/wfmain.cpp
@@ -53,15 +53,18 @@ wfmain::wfmain(const QString serialPortCL, const QString hostCL, const QString s
     setupKeyShortcuts();
 
     setupMainUI();
+    prepareSettingsWindow();
 
     setSerialDevicesUI();
 
-    setDefaultColors();
     setDefPrefs();
 
     getSettingsFilePath(settingsFile);
 
     setupPlots();
+    setDefaultColorPresets();
+    setDefaultColors();
+
     loadSettings(); // Look for saved preferences
 
     setAudioDevicesUI();
@@ -71,6 +74,8 @@ wfmain::wfmain(const QString serialPortCL, const QString hostCL, const QString s
     qDebug(logSystem()) << "Running setUIToPrefs()";
     setUIToPrefs();
 
+    loadColorPresetToUIandPlots(0);
+
     qDebug(logSystem()) << "Running setInititalTiming()";
     setInitialTiming();
 
@@ -877,8 +882,22 @@ void wfmain::setupMainUI()
             [=](const unsigned char &newValue) { issueCmdUniquePriority(cmdSetTPBFOuter, newValue);}
     );
 
+}
 
+void wfmain::prepareSettingsWindow()
+{
+    settingsTabisAttached = true;
 
+    settingsWidgetWindow = new QWidget;
+    settingsWidgetLayout = new QGridLayout;
+    settingsWidgetTab = new QTabWidget;
+
+    settingsWidgetWindow->setLayout(settingsWidgetLayout);
+    settingsWidgetLayout->addWidget(settingsWidgetTab);
+    settingsWidgetWindow->setWindowFlag(Qt::WindowCloseButtonHint, false);
+    //settingsWidgetWindow->setWindowFlag(Qt::WindowMinimizeButtonHint, false);
+    //settingsWidgetWindow->setWindowFlag(Qt::WindowMaximizeButtonHint, false);
+    // TODO: Capture an event when the window closes and handle accordingly.
 }
 
 void wfmain::updateSizes(int tabIndex)
@@ -966,12 +985,6 @@ void wfmain::setInitialTiming()
     delayedCommand->setSingleShot(false);
     connect(delayedCommand, SIGNAL(timeout()), this, SLOT(sendRadioCommandLoop()));
 
-    // TODO: Remove this:
-//    periodicPollingTimer = new QTimer(this);
-//    periodicPollingTimer->setInterval(10);
-//    periodicPollingTimer->setSingleShot(false);
-    //connect(periodicPollingTimer, SIGNAL(timeout()), this, SLOT(sendRadioCommandLoop()));
-
     pttTimer = new QTimer(this);
     pttTimer->setInterval(180*1000); // 3 minute max transmit time in ms
     pttTimer->setSingleShot(true);
@@ -1040,16 +1053,9 @@ void wfmain::setUIToPrefs()
     ui->fullScreenChk->setChecked(prefs.useFullScreen);
     on_fullScreenChk_clicked(prefs.useFullScreen);
 
-    ui->useDarkThemeChk->setChecked(prefs.useDarkMode);
-    on_useDarkThemeChk_clicked(prefs.useDarkMode);
-
     ui->useSystemThemeChk->setChecked(prefs.useSystemTheme);
     on_useSystemThemeChk_clicked(prefs.useSystemTheme);
 
-    ui->drawPeakChk->setChecked(prefs.drawPeaks);
-    on_drawPeakChk_clicked(prefs.drawPeaks);
-    drawPeaks = prefs.drawPeaks;
-
     underlayMode = prefs.underlayMode;
     switch(underlayMode)
     {
@@ -1080,13 +1086,21 @@ void wfmain::setUIToPrefs()
 
     ui->wfLengthSlider->setValue(prefs.wflength);
     prepareWf(prefs.wflength);
-
+    preparePlasma();
     ui->topLevelSlider->setValue(prefs.plotCeiling);
     ui->botLevelSlider->setValue(prefs.plotFloor);
 
     plot->yAxis->setRange(QCPRange(prefs.plotFloor, prefs.plotCeiling));
     colorMap->setDataRange(QCPRange(prefs.plotFloor, prefs.plotCeiling));
 
+    colorPrefsType p;
+    for(int pn=0; pn < numColorPresetsTotal; pn++)
+    {
+        p = colorPreset[pn];
+        if(p.presetName != Q_NULLPTR)
+            ui->colorPresetCombo->setItemText(pn, *p.presetName);
+    }
+
     ui->wfthemeCombo->setCurrentIndex(ui->wfthemeCombo->findData(prefs.wftheme));
     colorMap->setGradient(static_cast<QCPColorGradient::GradientPreset>(prefs.wftheme));
 
@@ -1275,9 +1289,9 @@ void wfmain::setupKeyShortcuts()
 void wfmain::setDefPrefs()
 {
     defPrefs.useFullScreen = false;
-    defPrefs.useDarkMode = true;
     defPrefs.useSystemTheme = false;
     defPrefs.drawPeaks = true;
+    defPrefs.currentColorPresetNumber = 0;
     defPrefs.underlayMode = underlayNone;
     defPrefs.underlayBufferSize = 64;
     defPrefs.wfAntiAlias = false;
@@ -1322,7 +1336,6 @@ void wfmain::loadSettings()
     // UI: (full screen, dark theme, draw peaks, colors, etc)
     settings->beginGroup("Interface");
     prefs.useFullScreen = settings->value("UseFullScreen", defPrefs.useFullScreen).toBool();
-    prefs.useDarkMode = settings->value("UseDarkMode", defPrefs.useDarkMode).toBool();
     prefs.useSystemTheme = settings->value("UseSystemTheme", defPrefs.useSystemTheme).toBool();
     prefs.wftheme = settings->value("WFTheme", defPrefs.wftheme).toInt();
     prefs.plotFloor = settings->value("plotFloor", defPrefs.plotFloor).toInt();
@@ -1348,37 +1361,53 @@ void wfmain::loadSettings()
     prefs.meter2Type = static_cast<meterKind>(settings->value("Meter2Type", defPrefs.meter2Type).toInt());
     settings->endGroup();
 
-    // Load color schemes:
-    // Per this bug: https://forum.qt.io/topic/24725/solved-qvariant-will-drop-alpha-value-when-save-qcolor/5
-    // the alpha channel is dropped when converting raw qvariant of QColor. Therefore, we are storing as unsigned int and converting back.
+    // Load in the color presets. The default values are already loaded.
 
-    settings->beginGroup("DarkColors");
-    prefs.colorScheme.Dark_PlotBackground = QColor::fromRgba(settings->value("Dark_PlotBackground", defaultColors.Dark_PlotBackground.rgba()).toUInt());
-    prefs.colorScheme.Dark_PlotAxisPen = QColor::fromRgba(settings->value("Dark_PlotAxisPen", defaultColors.Dark_PlotAxisPen.rgba()).toUInt());
+    settings->beginGroup("ColorPresets");
+    settings->value("currentColorPresetNumber", prefs.currentColorPresetNumber).toInt();
+    if(prefs.currentColorPresetNumber > numColorPresetsTotal-1)
+        prefs.currentColorPresetNumber = 0;
 
-    prefs.colorScheme.Dark_PlotLegendTextColor = QColor::fromRgba(settings->value("Dark_PlotLegendTextColor", defaultColors.Dark_PlotLegendTextColor.rgba()).toUInt());
-    prefs.colorScheme.Dark_PlotLegendBorderPen = QColor::fromRgba(settings->value("Dark_PlotLegendBorderPen", defaultColors.Dark_PlotLegendBorderPen.rgba()).toUInt());
-    prefs.colorScheme.Dark_PlotLegendBrush = QColor::fromRgba(settings->value("Dark_PlotLegendBrush", defaultColors.Dark_PlotLegendBrush.rgba()).toUInt());
-
-    prefs.colorScheme.Dark_PlotTickLabel = QColor::fromRgba(settings->value("Dark_PlotTickLabel", defaultColors.Dark_PlotTickLabel.rgba()).toUInt());
-    prefs.colorScheme.Dark_PlotBasePen = QColor::fromRgba(settings->value("Dark_PlotBasePen", defaultColors.Dark_PlotBasePen.rgba()).toUInt());
-    prefs.colorScheme.Dark_PlotTickPen = QColor::fromRgba(settings->value("Dark_PlotTickPen", defaultColors.Dark_PlotTickPen.rgba()).toUInt());
-
-    prefs.colorScheme.Dark_PeakPlotLine = QColor::fromRgba(settings->value("Dark_PeakPlotLine", defaultColors.Dark_PeakPlotLine.rgba()).toUInt());
-    prefs.colorScheme.Dark_TuningLine = QColor::fromRgba(settings->value("Dark_TuningLine", defaultColors.Dark_TuningLine.rgba()).toUInt());
-    settings->endGroup();
-
-    settings->beginGroup("LightColors");
-    prefs.colorScheme.Light_PlotBackground = QColor::fromRgba(settings->value("Light_PlotBackground", defaultColors.Light_PlotBackground.rgba()).toUInt());
-    prefs.colorScheme.Light_PlotAxisPen = QColor::fromRgba(settings->value("Light_PlotAxisPen", defaultColors.Light_PlotAxisPen.rgba()).toUInt());
-    prefs.colorScheme.Light_PlotLegendTextColor = QColor::fromRgba(settings->value("Light_PlotLegendTextColo", defaultColors.Light_PlotLegendTextColor.rgba()).toUInt());
-    prefs.colorScheme.Light_PlotLegendBorderPen = QColor::fromRgba(settings->value("Light_PlotLegendBorderPen", defaultColors.Light_PlotLegendBorderPen.rgba()).toUInt());
-    prefs.colorScheme.Light_PlotLegendBrush = QColor::fromRgba(settings->value("Light_PlotLegendBrush", defaultColors.Light_PlotLegendBrush.rgba()).toUInt());
-    prefs.colorScheme.Light_PlotTickLabel = QColor::fromRgba(settings->value("Light_PlotTickLabel", defaultColors.Light_PlotTickLabel.rgba()).toUInt());
-    prefs.colorScheme.Light_PlotBasePen = QColor::fromRgba(settings->value("Light_PlotBasePen", defaultColors.Light_PlotBasePen.rgba()).toUInt());
-    prefs.colorScheme.Light_PlotTickPen = QColor::fromRgba(settings->value("Light_PlotTickPen", defaultColors.Light_PlotTickPen.rgba()).toUInt());
-    prefs.colorScheme.Light_PeakPlotLine = QColor::fromRgba(settings->value("Light_PeakPlotLine", defaultColors.Light_PeakPlotLine.rgba()).toUInt());
-    prefs.colorScheme.Light_TuningLine = QColor::fromRgba(settings->value("Light_TuningLine", defaultColors.Light_TuningLine.rgba()).toUInt());
+    int numPresetsInFile = settings->beginReadArray("ColorPreset");
+    // We will use the number of presets that the working copy of wfview
+    // supports, as we must never exceed the available number.
+    if(numPresetsInFile > 0)
+    {
+        colorPrefsType *p;
+        QString tempName;
+        for(int pn=0; pn < numColorPresetsTotal; pn++)
+        {
+            settings->setArrayIndex(pn);
+            p = &(colorPreset[pn]);
+            p->presetNum = settings->value("presetNum", p->presetNum).toInt();
+            tempName = settings->value("presetName", *p->presetName).toString();
+            if((!tempName.isEmpty()) && tempName.length() < 33)
+            {
+                    p->presetName->clear();
+                    p->presetName->append(tempName);
+            }
+            p->gridColor.setNamedColor(settings->value("gridColor", p->gridColor.name(QColor::HexArgb)).toString());
+            p->axisColor.setNamedColor(settings->value("axisColor", p->axisColor.name(QColor::HexArgb)).toString());
+            p->textColor.setNamedColor(settings->value("textColor", p->textColor.name(QColor::HexArgb)).toString());
+            p->spectrumLine.setNamedColor(settings->value("spectrumLine", p->spectrumLine.name(QColor::HexArgb)).toString());
+            p->spectrumFill.setNamedColor(settings->value("spectrumFill", p->spectrumFill.name(QColor::HexArgb)).toString());
+            p->underlayLine.setNamedColor(settings->value("underlayLine", p->underlayLine.name(QColor::HexArgb)).toString());
+            p->underlayFill.setNamedColor(settings->value("underlayFill", p->underlayFill.name(QColor::HexArgb)).toString());
+            p->plotBackground.setNamedColor(settings->value("plotBackground", p->plotBackground.name(QColor::HexArgb)).toString());
+            p->tuningLine.setNamedColor(settings->value("tuningLine", p->tuningLine.name(QColor::HexArgb)).toString());
+            p->wfBackground.setNamedColor(settings->value("wfBackground", p->wfBackground.name(QColor::HexArgb)).toString());
+            p->wfGrid.setNamedColor(settings->value("wfGrid", p->wfGrid.name(QColor::HexArgb)).toString());
+            p->wfAxis.setNamedColor(settings->value("wfAxis", p->wfAxis.name(QColor::HexArgb)).toString());
+            p->wfText.setNamedColor(settings->value("wfText", p->wfText.name(QColor::HexArgb)).toString());
+            p->meterLevel.setNamedColor(settings->value("meterLevel", p->meterLevel.name(QColor::HexArgb)).toString());
+            p->meterAverage.setNamedColor(settings->value("meterAverage", p->meterAverage.name(QColor::HexArgb)).toString());
+            p->meterPeakLevel.setNamedColor(settings->value("meterPeakLevel", p->meterPeakLevel.name(QColor::HexArgb)).toString());
+            p->meterPeakScale.setNamedColor(settings->value("meterPeakScale", p->meterPeakScale.name(QColor::HexArgb)).toString());
+            p->meterLowerLine.setNamedColor(settings->value("meterLowerLine", p->meterLowerLine.name(QColor::HexArgb)).toString());
+            p->meterLowText.setNamedColor(settings->value("meterLowText", p->meterLowText.name(QColor::HexArgb)).toString());
+        }
+    }
+    settings->endArray();
     settings->endGroup();
 
     // Radio and Comms: C-IV addr, port to use
@@ -1839,7 +1868,6 @@ void wfmain::saveSettings()
     settings->beginGroup("Interface");
     settings->setValue("UseFullScreen", prefs.useFullScreen);
     settings->setValue("UseSystemTheme", prefs.useSystemTheme);
-    settings->setValue("UseDarkMode", prefs.useDarkMode);
     settings->setValue("DrawPeaks", prefs.drawPeaks);
     settings->setValue("underlayMode", prefs.underlayMode);
     settings->setValue("underlayBufferSize", prefs.underlayBufferSize);
@@ -1921,50 +1949,38 @@ void wfmain::saveSettings()
     settings->endArray();
     settings->endGroup();
 
-    // Note: X and Y get the same colors. See setPlotTheme() function
-
-    settings->beginGroup("DarkColors");
-    settings->setValue("Dark_PlotBackground", prefs.colorScheme.Dark_PlotBackground.rgba());
-    settings->setValue("Dark_PlotAxisPen", prefs.colorScheme.Dark_PlotAxisPen.rgba());
-    settings->setValue("Dark_PlotLegendTextColor", prefs.colorScheme.Dark_PlotLegendTextColor.rgba());
-    settings->setValue("Dark_PlotLegendBorderPen", prefs.colorScheme.Dark_PlotLegendBorderPen.rgba());
-    settings->setValue("Dark_PlotLegendBrush", prefs.colorScheme.Dark_PlotLegendBrush.rgba());
-    settings->setValue("Dark_PlotTickLabel", prefs.colorScheme.Dark_PlotTickLabel.rgba());
-    settings->setValue("Dark_PlotBasePen", prefs.colorScheme.Dark_PlotBasePen.rgba());
-    settings->setValue("Dark_PlotTickPen", prefs.colorScheme.Dark_PlotTickPen.rgba());
-    settings->setValue("Dark_PeakPlotLine", prefs.colorScheme.Dark_PeakPlotLine.rgba());
-    settings->setValue("Dark_TuningLine", prefs.colorScheme.Dark_TuningLine.rgba());
-    settings->endGroup();
-
-    settings->beginGroup("LightColors");
-    settings->setValue("Light_PlotBackground", prefs.colorScheme.Light_PlotBackground.rgba());
-    settings->setValue("Light_PlotAxisPen", prefs.colorScheme.Light_PlotAxisPen.rgba());
-    settings->setValue("Light_PlotLegendTextColor", prefs.colorScheme.Light_PlotLegendTextColor.rgba());
-    settings->setValue("Light_PlotLegendBorderPen", prefs.colorScheme.Light_PlotLegendBorderPen.rgba());
-    settings->setValue("Light_PlotLegendBrush", prefs.colorScheme.Light_PlotLegendBrush.rgba());
-    settings->setValue("Light_PlotTickLabel", prefs.colorScheme.Light_PlotTickLabel.rgba());
-    settings->setValue("Light_PlotBasePen", prefs.colorScheme.Light_PlotBasePen.rgba());
-    settings->setValue("Light_PlotTickPen", prefs.colorScheme.Light_PlotTickPen.rgba());
-    settings->setValue("Light_PeakPlotLine", prefs.colorScheme.Light_PeakPlotLine.rgba());
-    settings->setValue("Light_TuningLine", prefs.colorScheme.Light_TuningLine.rgba());
-
-    settings->endGroup();
-
-    // This is a reference to see how the preference file is encoded.
-    settings->beginGroup("StandardColors");
-
-    settings->setValue("white", QColor(Qt::white).rgba());
-    settings->setValue("black", QColor(Qt::black).rgba());
-
-    settings->setValue("red_opaque", QColor(Qt::red).rgba());
-    settings->setValue("red_translucent", QColor(255,0,0,128).rgba());
-    settings->setValue("green_opaque", QColor(Qt::green).rgba());
-    settings->setValue("green_translucent", QColor(0,255,0,128).rgba());
-    settings->setValue("blue_opaque", QColor(Qt::blue).rgba());
-    settings->setValue("blue_translucent", QColor(0,0,255,128).rgba());
-    settings->setValue("cyan", QColor(Qt::cyan).rgba());
-    settings->setValue("magenta", QColor(Qt::magenta).rgba());
-    settings->setValue("yellow", QColor(Qt::yellow).rgba());
+    // Color presets:
+    settings->beginGroup("ColorPresets");
+    settings->setValue("currentColorPresetNumber", prefs.currentColorPresetNumber);
+    settings->beginWriteArray("ColorPreset", numColorPresetsTotal);
+    colorPrefsType *p;
+    for(int pn=0; pn < numColorPresetsTotal; pn++)
+    {
+        p = &(colorPreset[pn]);
+        settings->setArrayIndex(pn);
+        settings->setValue("presetNum", p->presetNum);
+        settings->setValue("presetName", *(p->presetName));
+        settings->setValue("gridColor", p->gridColor.name(QColor::HexArgb));
+        settings->setValue("axisColor", p->axisColor.name(QColor::HexArgb));
+        settings->setValue("textColor", p->textColor.name(QColor::HexArgb));
+        settings->setValue("spectrumLine", p->spectrumLine.name(QColor::HexArgb));
+        settings->setValue("spectrumFill", p->spectrumFill.name(QColor::HexArgb));
+        settings->setValue("underlayLine", p->underlayLine.name(QColor::HexArgb));
+        settings->setValue("underlayFill", p->underlayFill.name(QColor::HexArgb));
+        settings->setValue("plotBackground", p->plotBackground.name(QColor::HexArgb));
+        settings->setValue("tuningLine", p->tuningLine.name(QColor::HexArgb));
+        settings->setValue("wfBackground", p->wfBackground.name(QColor::HexArgb));
+        settings->setValue("wfGrid", p->wfGrid.name(QColor::HexArgb));
+        settings->setValue("wfAxis", p->wfAxis.name(QColor::HexArgb));
+        settings->setValue("wfText", p->wfText.name(QColor::HexArgb));
+        settings->setValue("meterLevel", p->meterLevel.name(QColor::HexArgb));
+        settings->setValue("meterAverage", p->meterAverage.name(QColor::HexArgb));
+        settings->setValue("meterPeakScale", p->meterPeakScale.name(QColor::HexArgb));
+        settings->setValue("meterPeakLevel", p->meterPeakLevel.name(QColor::HexArgb));
+        settings->setValue("meterLowerLine", p->meterLowerLine.name(QColor::HexArgb));
+        settings->setValue("meterLowText", p->meterLowText.name(QColor::HexArgb));
+    }
+    settings->endArray();
     settings->endGroup();
 
     settings->beginGroup("Server");
@@ -2080,17 +2096,6 @@ void wfmain::prepareWf(unsigned int wfLength)
         QByteArray empty((int)spectWidth, '\x01');
         spectrumPeaks = QByteArray( (int)spectWidth, '\x01' );
 
-        if(spectrumPlasmaSize == 0)
-            spectrumPlasmaSize = 128;
-
-        //spectrumPlasma.resize(spectrumPlasmaSize);
-        for(unsigned int p=0; p < spectrumPlasmaSize; p++)
-        {
-            spectrumPlasma.append(empty);
-        }
-
-        //wfimage.resize(wfLengthMax);
-
         if((unsigned int)wfimage.size() < wfLengthMax)
         {
             unsigned int i=0;
@@ -2110,7 +2115,7 @@ void wfmain::prepareWf(unsigned int wfLength)
 
         colorMap->data()->setValueRange(QCPRange(0, wfLength-1));
         colorMap->data()->setKeyRange(QCPRange(0, spectWidth-1));
-        colorMap->setDataRange(QCPRange(0, rigCaps.spectAmpMax));
+        colorMap->setDataRange(QCPRange(prefs.plotFloor, prefs.plotCeiling));
         colorMap->setGradient(static_cast<QCPColorGradient::GradientPreset>(ui->wfthemeCombo->currentData().toInt()));
 
         if(colorMapData == Q_NULLPTR)
@@ -2562,14 +2567,6 @@ void wfmain::showStatusBarText(QString text)
     ui->statusBar->showMessage(text, 5000);
 }
 
-void wfmain::on_useDarkThemeChk_clicked(bool checked)
-{
-    //setAppTheme(checked);
-    setPlotTheme(wf, checked);
-    setPlotTheme(plot, checked);
-    prefs.useDarkMode = checked;
-}
-
 void wfmain::on_useSystemThemeChk_clicked(bool checked)
 {
     setAppTheme(!checked);
@@ -2603,77 +2600,61 @@ void wfmain::setAppTheme(bool isCustom)
 
 void wfmain::setDefaultColors()
 {
-    defaultColors.Dark_PlotBackground = QColor(0,0,0,255);
-    defaultColors.Dark_PlotAxisPen = QColor(75,75,75,255);
-    defaultColors.Dark_PlotLegendTextColor = QColor(255,255,255,255);
-    defaultColors.Dark_PlotLegendBorderPen = QColor(255,255,255,255);
-    defaultColors.Dark_PlotLegendBrush = QColor(0,0,0,200);
-    defaultColors.Dark_PlotTickLabel = QColor(Qt::white);
-    defaultColors.Dark_PlotBasePen = QColor(Qt::white);
-    defaultColors.Dark_PlotTickPen = QColor(Qt::white);
-    defaultColors.Dark_PeakPlotLine = QColor(Qt::yellow);
-    defaultColors.Dark_TuningLine = QColor(Qt::cyan);
+    // These are some intended built-in color schemes.
+    // They can be user-modified and may be restored simply
+    // by removing the relevent color preset preference file entries.
 
-    defaultColors.Light_PlotBackground = QColor(255,255,255,255);
-    defaultColors.Light_PlotAxisPen = QColor(200,200,200,255);
-    defaultColors.Light_PlotLegendTextColor = QColor(0,0,0,255);
-    defaultColors.Light_PlotLegendBorderPen = QColor(0,0,0,255);
-    defaultColors.Light_PlotLegendBrush = QColor(255,255,255,200);
-    defaultColors.Light_PlotTickLabel = QColor(Qt::black);
-    defaultColors.Light_PlotBasePen = QColor(Qt::black);
-    defaultColors.Light_PlotTickPen = QColor(Qt::black);
-    defaultColors.Light_PeakPlotLine = QColor(Qt::blue);
-    defaultColors.Light_TuningLine = QColor(Qt::blue);
-}
+    colorPrefsType *pDark = &colorPreset[0];
+    colorPrefsType *pLight = &colorPreset[1];
 
-void wfmain::setPlotTheme(QCustomPlot *plot, bool isDark)
-{
-    if(isDark)
-    {
-        plot->setBackground(prefs.colorScheme.Dark_PlotBackground);
-        //plot->setBackground(QColor(0,0,0,255));
+    // Dark:
+    pDark->presetName->clear();
+    pDark->presetName->append("Dark");
+    pDark->plotBackground = QColor(0,0,0,255);
+    pDark->axisColor = QColor(Qt::white);
+    pDark->textColor = QColor(255,255,255,255);
+    pDark->gridColor = QColor("transparent");
+    pDark->spectrumFill = QColor("transparent");
+    pDark->spectrumLine = QColor(Qt::yellow);
+    //pDark->underlayLine = QColor(20+200/4.0*1,70*(1.6-1/4.0), 150, 150).lighter(200);
+    pDark->underlayLine = QColor("#9633ff55");
+    pDark->underlayFill = QColor(20+200/4.0*1,70*(1.6-1/4.0), 150, 150);
+    pDark->tuningLine = QColor("#ff55ffff");
 
-        plot->xAxis->grid()->setPen(prefs.colorScheme.Dark_PlotAxisPen);
-        plot->yAxis->grid()->setPen(prefs.colorScheme.Dark_PlotAxisPen);
+    pDark->meterLevel = QColor("#148CD2").darker();
+    pDark->meterAverage = QColor("#3FB7CD");
+    pDark->meterPeakScale = QColor(Qt::red);
+    pDark->meterPeakLevel = QColor("#3CA0DB").lighter();
+    pDark->meterLowerLine = QColor("#eff0f1");
+    pDark->meterLowText = QColor("#eff0f1");
 
-        plot->legend->setTextColor(prefs.colorScheme.Dark_PlotLegendTextColor);
-        plot->legend->setBorderPen(prefs.colorScheme.Dark_PlotLegendBorderPen);
-        plot->legend->setBrush(prefs.colorScheme.Dark_PlotLegendBrush);
+    pDark->wfBackground = QColor(Qt::black);
+    pDark->wfAxis = QColor(Qt::white);
+    pDark->wfGrid = QColor("transparent");
+    pDark->wfText = QColor(Qt::white);
 
-        plot->xAxis->setTickLabelColor(prefs.colorScheme.Dark_PlotTickLabel);
-        plot->xAxis->setLabelColor(prefs.colorScheme.Dark_PlotTickLabel);
-        plot->yAxis->setTickLabelColor(prefs.colorScheme.Dark_PlotTickLabel);
-        plot->yAxis->setLabelColor(prefs.colorScheme.Dark_PlotTickLabel);
+    // Bright:
+    pLight->presetName->clear();
+    pLight->presetName->append("Bright");
+    pLight->plotBackground = QColor(Qt::white);
+    pLight->axisColor = QColor(200,200,200,255);
+    pLight->gridColor = QColor("transparent");
+    pLight->textColor = QColor(Qt::black);
+    pLight->spectrumFill = QColor("transparent");
+    pLight->spectrumLine = QColor(Qt::black);
+    pLight->underlayLine = QColor(Qt::blue);
+    pLight->tuningLine = QColor(Qt::darkBlue);
 
-        plot->xAxis->setBasePen(prefs.colorScheme.Dark_PlotBasePen);
-        plot->xAxis->setTickPen(prefs.colorScheme.Dark_PlotTickPen);
-        plot->yAxis->setBasePen(prefs.colorScheme.Dark_PlotBasePen);
-        plot->yAxis->setTickPen(prefs.colorScheme.Dark_PlotTickPen);
-        plot->graph(0)->setPen(prefs.colorScheme.Dark_PeakPlotLine);
-        freqIndicatorLine->setPen(prefs.colorScheme.Dark_TuningLine);
-    } else {
-        //color = ui->groupBox->palette().color(QPalette::Button);
+    pLight->meterAverage = QColor("#3FB7CD");
+    pLight->meterPeakLevel = QColor("#3CA0DB");
+    pLight->meterPeakScale = QColor(Qt::darkRed);
+    pLight->meterLowerLine = QColor(Qt::black);
+    pLight->meterLowText = QColor(Qt::black);
 
-        plot->setBackground(prefs.colorScheme.Light_PlotBackground);
-        plot->xAxis->grid()->setPen(prefs.colorScheme.Light_PlotAxisPen);
-        plot->yAxis->grid()->setPen(prefs.colorScheme.Light_PlotAxisPen);
-
-        plot->legend->setTextColor(prefs.colorScheme.Light_PlotLegendTextColor);
-        plot->legend->setBorderPen(prefs.colorScheme.Light_PlotLegendBorderPen);
-        plot->legend->setBrush(prefs.colorScheme.Light_PlotLegendBrush);
-
-        plot->xAxis->setTickLabelColor(prefs.colorScheme.Light_PlotTickLabel);
-        plot->xAxis->setLabelColor(prefs.colorScheme.Light_PlotTickLabel);
-        plot->yAxis->setTickLabelColor(prefs.colorScheme.Light_PlotTickLabel);
-        plot->yAxis->setLabelColor(prefs.colorScheme.Light_PlotTickLabel);
-
-        plot->xAxis->setBasePen(prefs.colorScheme.Light_PlotBasePen);
-        plot->xAxis->setTickPen(prefs.colorScheme.Light_PlotTickPen);
-        plot->yAxis->setBasePen(prefs.colorScheme.Light_PlotBasePen);
-        plot->yAxis->setTickPen(prefs.colorScheme.Light_PlotTickLabel);
-        plot->graph(0)->setPen(prefs.colorScheme.Light_PeakPlotLine);
-        freqIndicatorLine->setPen(prefs.colorScheme.Light_TuningLine);
-    }
+    pLight->wfBackground = QColor(Qt::white);
+    pLight->wfAxis = QColor(200,200,200,255);
+    pLight->wfGrid = QColor("transparent");
+    pLight->wfText = QColor(Qt::black);
 }
 
 void wfmain::doCmd(commandtype cmddata)
@@ -2800,10 +2781,8 @@ void wfmain::doCmd(commandtype cmddata)
             doCmd(cmd);
             break;
     }
-
 }
 
-
 void wfmain::doCmd(cmds cmd)
 {
     // Use this function to take action upon a command.
@@ -3567,6 +3546,7 @@ void wfmain::receiveSpectrumData(QByteArray spectrum, double startFreq, double e
 
     QVector <double> x(spectWidth), y(spectWidth), y2(spectWidth);
 
+    // TODO: Keep x around unless the frequency range changes. Should save a little time.
     for(int i=0; i < spectWidth; i++)
     {
         x[i] = (i * (endFreq-startFreq)/spectWidth) + startFreq;
@@ -3591,31 +3571,48 @@ void wfmain::receiveSpectrumData(QByteArray spectrum, double startFreq, double e
     //spectrumPlasma.resize(spectrumPlasmaSize);
     plasmaMutex.unlock();
 
-    // HACK DO NOT CHECK IN:
-    drawPeaks = false;
-    drawPlasma = true;
 
     if(!spectrumDrawLock)
     {
         if((plotFloor != oldPlotFloor) || (plotCeiling != oldPlotCeiling))
             updateRange = true;
 
-        //ui->qcp->addGraph();
+#if QCUSTOMPLOT_VERSION >= 0x020000
+
         plot->graph(0)->setData(x,y, true);
         if((freq.MHzDouble < endFreq) && (freq.MHzDouble > startFreq))
         {
             freqIndicatorLine->start->setCoords(freq.MHzDouble,0);
             freqIndicatorLine->end->setCoords(freq.MHzDouble,rigCaps.spectAmpMax);
         }
+
         if(underlayMode == underlayPeakHold)
         {
             plot->graph(1)->setData(x,y2, true); // peaks
         } else if (underlayMode != underlayNone) {
             computePlasma();
-            plot->graph(1)->setData(x,spectrumPlasmaLine);
+            plot->graph(1)->setData(x,spectrumPlasmaLine, true);
         } else {
             plot->graph(1)->setData(x,y2, true); // peaks, but probably cleared out
         }
+#else
+        plot->graph(0)->setData(x,y);
+        if((freq.MHzDouble < endFreq) && (freq.MHzDouble > startFreq))
+        {
+            freqIndicatorLine->start->setCoords(freq.MHzDouble,0);
+            freqIndicatorLine->end->setCoords(freq.MHzDouble,rigCaps.spectAmpMax);
+        }
+
+        if(underlayMode == underlayPeakHold)
+        {
+            plot->graph(1)->setData(x,y2); // peaks
+        } else if (underlayMode != underlayNone) {
+            computePlasma();
+            plot->graph(1)->setData(x,spectrumPlasmaLine);
+        } else {
+            plot->graph(1)->setData(x,y2); // peaks, but probably cleared out
+        }
+#endif
 
         if(updateRange)
             plot->yAxis->setRange(prefs.plotFloor, prefs.plotCeiling);
@@ -3650,6 +3647,28 @@ void wfmain::receiveSpectrumData(QByteArray spectrum, double startFreq, double e
     }
 }
 
+void wfmain::preparePlasma()
+{
+    if(plasmaPrepared)
+        return;
+    QByteArray empty((int)spectWidth, '\x01');
+
+    if(spectrumPlasmaSize == 0)
+        spectrumPlasmaSize = 128;
+
+    plasmaMutex.lock();
+    spectrumPlasma.clear();
+
+    for(unsigned int p=0; p < spectrumPlasmaSize; p++)
+    {
+        spectrumPlasma.append(empty);
+    }
+
+    spectrumPlasma.squeeze();
+    plasmaMutex.unlock();
+    plasmaPrepared = true;
+}
+
 void wfmain::computePlasma()
 {
     plasmaMutex.lock();
@@ -3662,7 +3681,7 @@ void wfmain::computePlasma()
         {
             for(int pos=0; pos < specPlasmaSize; pos++)
             {
-                spectrumPlasmaLine[col] += spectrumPlasma[pos][col];
+                spectrumPlasmaLine[col] += (unsigned char)spectrumPlasma[pos][col];
             }
             spectrumPlasmaLine[col] = spectrumPlasmaLine[col] / specPlasmaSize;
         }
@@ -3672,13 +3691,12 @@ void wfmain::computePlasma()
         {
             for(int pos=0; pos < specPlasmaSize; pos++)
             {
-                if((double)(spectrumPlasma[pos][col]) > spectrumPlasmaLine[col])
-                    spectrumPlasmaLine[col] = spectrumPlasma[pos][col];
+                if((double)((unsigned char)spectrumPlasma[pos][col]) > spectrumPlasmaLine[col])
+                    spectrumPlasmaLine[col] = (unsigned char)spectrumPlasma[pos][col];
             }
         }
     }
     plasmaMutex.unlock();
-
 }
 
 void wfmain::receiveSpectrumMode(spectrumMode spectMode)
@@ -3877,26 +3895,6 @@ void wfmain::on_clearPeakBtn_clicked()
     return;
 }
 
-void wfmain::on_drawPeakChk_clicked(bool checked)
-{
-    if(checked)
-    {
-        on_clearPeakBtn_clicked(); // clear
-        drawPeaks = true;
-
-    } else {
-        drawPeaks = false;
-
-#if QCUSTOMPLOT_VERSION >= 0x020000
-        plot->graph(1)->data()->clear();
-#else
-        plot->graph(1)->clearData();
-#endif
-
-    }
-    prefs.drawPeaks = checked;
-}
-
 void wfmain::on_fullScreenChk_clicked(bool checked)
 {
     if(checked)
@@ -6165,7 +6163,6 @@ void wfmain::on_underlayPeakHold_toggled(bool checked)
         prefs.underlayMode = underlayMode;
         on_clearPeakBtn_clicked();
     }
-
 }
 
 void wfmain::on_underlayPeakBuffer_toggled(bool checked)
@@ -6215,3 +6212,609 @@ void wfmain::on_debugBtn_clicked()
 //    adjustSize();
 
 }
+
+// ----------   color helper functions:   ---------- //
+
+void wfmain::setColorElement(QColor color,
+                             QLedLabel *led,
+                             QLabel *label,
+                             QLineEdit *lineText)
+{
+    if(led != Q_NULLPTR)
+    {
+        led->setColor(color, true);
+    }
+    if(label != Q_NULLPTR)
+    {
+        label->setText(color.name(QColor::HexArgb));
+    }
+    if(lineText != Q_NULLPTR)
+    {
+        lineText->setText(color.name(QColor::HexArgb));
+    }
+}
+
+void wfmain::setColorElement(QColor color, QLedLabel *led, QLabel *label)
+{
+    setColorElement(color, led, label, Q_NULLPTR);
+}
+
+void wfmain::setColorElement(QColor color, QLedLabel *led, QLineEdit *lineText)
+{
+    setColorElement(color, led, Q_NULLPTR, lineText);
+}
+
+QColor wfmain::getColorFromPicker(QColor initialColor)
+{
+    QColorDialog::ColorDialogOptions options;
+    options.setFlag(QColorDialog::ShowAlphaChannel, true);
+    options.setFlag(QColorDialog::DontUseNativeDialog, true);
+    QColor selColor = QColorDialog::getColor(initialColor, this, "Select Color", options);
+    if(selColor.isValid())
+        return selColor;
+    else
+        return initialColor;
+}
+
+void wfmain::getSetColor(QLedLabel *led, QLabel *label)
+{
+    QColor selColor = getColorFromPicker(led->getColor());
+    setColorElement(selColor, led, label);
+}
+
+void wfmain::getSetColor(QLedLabel *led, QLineEdit *line)
+{
+    QColor selColor = getColorFromPicker(led->getColor());
+    setColorElement(selColor, led, line);
+}
+
+QString wfmain::setColorFromString(QString colorstr, QLedLabel *led)
+{
+    if(led==Q_NULLPTR)
+        return "ERROR";
+
+    if(!colorstr.startsWith("#"))
+    {
+        colorstr.prepend("#");
+    }
+    if(colorstr.length() != 9)
+    {
+        // TODO: Tell user about AA RR GG BB
+        return led->getColor().name(QColor::HexArgb);
+    }
+    led->setColor(colorstr, true);
+    return led->getColor().name(QColor::HexArgb);
+}
+
+void wfmain::useCurrentColorPreset()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    useColorPreset(&colorPreset[pos]);
+}
+
+void wfmain::useColorPreset(colorPrefsType *cp)
+{
+    // Apply the given preset to the UI elements
+    // prototyped from setPlotTheme()
+    if(cp == Q_NULLPTR)
+        return;
+
+    //qInfo(logSystem()) << "Setting plots to color preset number " << cp->presetNum << ", with name " << *(cp->presetName);
+
+    plot->setBackground(cp->plotBackground);
+
+    plot->xAxis->grid()->setPen(cp->gridColor);
+    plot->yAxis->grid()->setPen(cp->gridColor);
+
+    plot->legend->setTextColor(cp->textColor);
+    plot->legend->setBorderPen(cp->gridColor);
+    plot->legend->setBrush(cp->gridColor);
+
+    plot->xAxis->setTickLabelColor(cp->textColor);
+    plot->xAxis->setLabelColor(cp->gridColor);
+    plot->yAxis->setTickLabelColor(cp->textColor);
+    plot->yAxis->setLabelColor(cp->gridColor);
+
+    plot->xAxis->setBasePen(cp->axisColor);
+    plot->xAxis->setTickPen(cp->axisColor);
+    plot->yAxis->setBasePen(cp->axisColor);
+    plot->yAxis->setTickPen(cp->axisColor);
+
+    freqIndicatorLine->setPen(QPen(cp->tuningLine));
+
+    plot->graph(0)->setPen(QPen(cp->spectrumLine));
+    plot->graph(0)->setBrush(QBrush(cp->spectrumFill));
+
+    plot->graph(1)->setPen(QPen(cp->underlayLine));
+    plot->graph(1)->setBrush(QBrush(cp->underlayFill));
+
+    wf->yAxis->setBasePen(cp->wfAxis);
+    wf->yAxis->setTickPen(cp->wfAxis);
+    wf->xAxis->setBasePen(cp->wfAxis);
+    wf->xAxis->setTickPen(cp->wfAxis);
+
+    wf->xAxis->setLabelColor(cp->wfGrid);
+    wf->yAxis->setLabelColor(cp->wfGrid);
+
+    wf->xAxis->setTickLabelColor(cp->wfText);
+    wf->yAxis->setTickLabelColor(cp->wfText);
+
+    wf->setBackground(cp->wfBackground);
+
+    ui->meterSPoWidget->setColors(cp->meterLevel, cp->meterPeakScale, cp->meterPeakLevel, cp->meterAverage, cp->meterLowerLine, cp->meterLowText);
+    ui->meter2Widget->setColors(cp->meterLevel, cp->meterPeakScale, cp->meterPeakLevel, cp->meterAverage, cp->meterLowerLine, cp->meterLowText);
+}
+
+void wfmain::setColorButtonOperations(QColor *colorStore,
+                            QLineEdit *e, QLedLabel *d)
+{
+    // Call this function with a pointer into the colorPreset color you
+    // wish to edit.
+
+    if(colorStore==Q_NULLPTR)
+    {
+        qInfo(logSystem()) << "ERROR, invalid pointer to color received.";
+        return;
+    }
+    getSetColor(d, e);
+    QColor t = d->getColor();
+    colorStore->setNamedColor(t.name(QColor::HexArgb));
+    useCurrentColorPreset();
+}
+
+void wfmain::setColorLineEditOperations(QColor *colorStore,
+                                QLineEdit *e, QLedLabel *d)
+{
+    // Call this function with a pointer into the colorPreset color you
+    // wish to edit.
+    if(colorStore==Q_NULLPTR)
+    {
+        qInfo(logSystem()) << "ERROR, invalid pointer to color received.";
+        return;
+    }
+
+    QString colorStrValidated = setColorFromString(e->text(), d);
+    e->setText(colorStrValidated);
+    colorStore->setNamedColor(colorStrValidated);
+    useCurrentColorPreset();
+}
+
+void wfmain::on_colorPopOutBtn_clicked()
+{
+
+    if(settingsTabisAttached)
+    {
+        settingsTab = ui->tabWidget->currentWidget();
+        ui->tabWidget->removeTab(ui->tabWidget->indexOf(settingsTab));
+        settingsWidgetTab->addTab(settingsTab, "Settings");
+        settingsWidgetWindow->show();
+        ui->colorPopOutBtn->setText("Re-attach");
+        ui->tabWidget->setCurrentIndex(0);
+        settingsTabisAttached = false;
+    } else {
+        settingsTab = settingsWidgetTab->currentWidget();
+
+        settingsWidgetTab->removeTab(settingsWidgetTab->indexOf(settingsTab));
+        ui->tabWidget->addTab(settingsTab, "Settings");
+        settingsWidgetWindow->close();
+
+        ui->colorPopOutBtn->setText("Pop-Out");
+        ui->tabWidget->setCurrentIndex(3);
+        settingsTabisAttached = true;
+    }
+}
+
+void wfmain::setDefaultColorPresets()
+{
+    // Default wfview colors in each preset
+    // gets overridden after preferences are loaded
+    for(int pn=0; pn < numColorPresetsTotal; pn++)
+    {
+        //qInfo(logSystem()) << "Setting default color preset " << pn;
+        colorPrefsType *p = &colorPreset[pn];
+
+        p->presetNum = pn;
+        if(p->presetName == Q_NULLPTR)
+        {
+            p->presetName = new QString(  QString("Preset %1").arg(pn) );
+        }
+
+        // Colors are "#AARRGGBB" (AA=0xff is opaque)
+        // or as (r, g, b, a)
+        // Since the UI shows ##AARRGGBB, we should use
+        // that format in the code when convenient.
+
+        p->gridColor = QColor(0,0,0,255);
+        p->axisColor = QColor(Qt::white);
+        p->textColor = QColor(Qt::white);
+        p->spectrumLine = QColor(Qt::yellow);
+        p->spectrumFill = QColor("transparent");
+        p->underlayLine = QColor(20+200/4.0*1,70*(1.6-1/4.0), 150, 150).lighter(200);
+        p->underlayFill = QColor(20+200/4.0*1,70*(1.6-1/4.0), 150, 150);
+        p->plotBackground = QColor(Qt::black);
+        p->tuningLine = QColor(Qt::blue);
+
+        p->meterLevel = QColor("#148CD2").darker();
+        p->meterAverage = QColor("#3FB7CD");
+        p->meterPeakLevel = QColor("#3CA0DB").lighter();
+        p->meterPeakScale = QColor(Qt::red);
+        p->meterLowerLine = QColor("#eff0f1");
+        p->meterLowText = QColor("#eff0f1");
+
+        p->wfBackground = QColor(Qt::black);
+        p->wfAxis = QColor(Qt::white);
+        p->wfGrid = QColor(Qt::white);
+        p->wfText = QColor(Qt::white);
+
+        //qInfo(logSystem()) << "default color preset [" << pn << "] set to pn.presetNum index [" << p->presetNum << "]" << ", with name " << *(p->presetName);
+        ui->colorPresetCombo->setItemText(pn, *(p->presetName));
+    }
+}
+
+void wfmain::setEditAndLedFromColor(QColor c, QLineEdit *e, QLedLabel *d)
+{
+    bool blockSignals = true;
+    if(e != Q_NULLPTR)
+    {
+        e->blockSignals(blockSignals);
+        e->setText(c.name(QColor::HexArgb));
+        e->blockSignals(false);
+    }
+    if(d != Q_NULLPTR)
+    {
+        d->setColor(c);
+    }
+}
+
+void wfmain::loadColorPresetToUIandPlots(int presetNumber)
+{
+    if(presetNumber >= numColorPresetsTotal)
+    {
+        qDebug(logSystem()) << "WARNING: asked for preset number [" << presetNumber << "], which is out of range.";
+        return;
+    }
+
+    colorPrefsType p = colorPreset[presetNumber];
+    //qInfo(logSystem()) << "color preset number [" << presetNumber << "] requested for UI load, which has internal index of [" << p.presetNum << "]";
+    setEditAndLedFromColor(p.gridColor, ui->colorEditGrid, ui->colorSwatchGrid);
+    setEditAndLedFromColor(p.axisColor, ui->colorEditAxis, ui->colorSwatchAxis);
+    setEditAndLedFromColor(p.textColor, ui->colorEditText, ui->colorSwatchText);
+    setEditAndLedFromColor(p.spectrumLine, ui->colorEditSpecLine, ui->colorSwatchSpecLine);
+    setEditAndLedFromColor(p.spectrumFill, ui->colorEditSpecFill, ui->colorSwatchSpecFill);
+    setEditAndLedFromColor(p.underlayLine, ui->colorEditUnderlayLine, ui->colorSwatchUnderlayLine);
+    setEditAndLedFromColor(p.underlayFill, ui->colorEditUnderlayFill, ui->colorSwatchUnderlayFill);
+    setEditAndLedFromColor(p.plotBackground, ui->colorEditPlotBackground, ui->colorSwatchPlotBackground);
+    setEditAndLedFromColor(p.tuningLine, ui->colorEditTuningLine, ui->colorSwatchTuningLine);
+
+    setEditAndLedFromColor(p.meterLevel, ui->colorEditMeterLevel, ui->colorSwatchMeterLevel);
+    setEditAndLedFromColor(p.meterAverage, ui->colorEditMeterAvg, ui->colorSwatchMeterAverage);
+    setEditAndLedFromColor(p.meterPeakLevel, ui->colorEditMeterPeakLevel, ui->colorSwatchMeterPeakLevel);
+    setEditAndLedFromColor(p.meterPeakScale, ui->colorEditMeterPeakScale, ui->colorSwatchMeterPeakScale);
+    setEditAndLedFromColor(p.meterLowerLine, ui->colorEditMeterScale, ui->colorSwatchMeterScale);
+    setEditAndLedFromColor(p.meterLowText, ui->colorEditMeterText, ui->colorSwatchMeterText);
+
+    setEditAndLedFromColor(p.wfBackground, ui->colorEditWfBackground, ui->colorSwatchWfBackground);
+    setEditAndLedFromColor(p.wfGrid, ui->colorEditWfGrid, ui->colorSwatchWfGrid);
+    setEditAndLedFromColor(p.wfAxis, ui->colorEditWfAxis, ui->colorSwatchWfAxis);
+    setEditAndLedFromColor(p.wfText, ui->colorEditWfText, ui->colorSwatchWfText);
+
+    useColorPreset(&p);
+}
+
+void wfmain::on_colorRenamePresetBtn_clicked()
+{
+    int p = ui->colorPresetCombo->currentIndex();
+    QString newName;
+    QMessageBox msgBox;
+
+    bool ok = false;
+    newName = QInputDialog::getText(this, tr("QInputDialog::getText()"),
+                                    tr("Preset Name (32 characters max):"), QLineEdit::Normal,
+                                    ui->colorPresetCombo->currentText(), &ok);
+    if(!ok)
+        return;
+
+    if(ok && (newName.length() < 33) && !newName.isEmpty())
+    {
+        colorPreset[p].presetName->clear();
+        colorPreset[p].presetName->append(newName);
+        ui->colorPresetCombo->setItemText(p, *(colorPreset[p].presetName));
+    } else {
+        if(newName.isEmpty() || (newName.length() > 32))
+        {
+            msgBox.setText("Error, name must be at least one character and not exceed 32 characters.");
+            msgBox.exec();
+        }
+    }
+}
+
+void wfmain::on_colorPresetCombo_currentIndexChanged(int index)
+{
+    prefs.currentColorPresetNumber = index;
+    loadColorPresetToUIandPlots(index);
+}
+
+// ---------- end color helper functions ---------- //
+
+// ----------       Color UI slots        ----------//
+
+// Grid:
+void wfmain::on_colorSetBtnGrid_clicked()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].gridColor);
+    setColorButtonOperations(c, ui->colorEditGrid, ui->colorSwatchGrid);
+}
+void wfmain::on_colorEditGrid_editingFinished()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].gridColor);
+    setColorLineEditOperations(c, ui->colorEditGrid, ui->colorSwatchGrid);
+}
+
+// Axis:
+void wfmain::on_colorSetBtnAxis_clicked()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].axisColor);
+    setColorButtonOperations(c, ui->colorEditAxis, ui->colorSwatchAxis);
+}
+void wfmain::on_colorEditAxis_editingFinished()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].axisColor);
+    setColorLineEditOperations(c, ui->colorEditAxis, ui->colorSwatchAxis);
+}
+
+// Text:
+void wfmain::on_colorSetBtnText_clicked()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].textColor);
+    setColorButtonOperations(c, ui->colorEditText, ui->colorSwatchText);
+}
+void wfmain::on_colorEditText_editingFinished()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].textColor);
+    setColorLineEditOperations(c, ui->colorEditText, ui->colorSwatchText);
+}
+
+// SpecLine:
+void wfmain::on_colorEditSpecLine_editingFinished()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].spectrumLine);
+    setColorLineEditOperations(c, ui->colorEditSpecLine, ui->colorSwatchSpecLine);
+}
+void wfmain::on_colorSetBtnSpecLine_clicked()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].spectrumLine);
+    setColorButtonOperations(c, ui->colorEditSpecLine, ui->colorSwatchSpecLine);
+}
+
+// SpecFill:
+void wfmain::on_colorSetBtnSpecFill_clicked()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].spectrumFill);
+    setColorButtonOperations(c, ui->colorEditSpecFill, ui->colorSwatchSpecFill);
+}
+void wfmain::on_colorEditSpecFill_editingFinished()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].spectrumFill);
+    setColorLineEditOperations(c, ui->colorEditSpecFill, ui->colorSwatchSpecFill);
+}
+
+// PlotBackground:
+void wfmain::on_colorEditPlotBackground_editingFinished()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].plotBackground);
+    setColorLineEditOperations(c, ui->colorEditPlotBackground, ui->colorSwatchPlotBackground);
+}
+void wfmain::on_colorSetBtnPlotBackground_clicked()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].plotBackground);
+    setColorButtonOperations(c, ui->colorEditPlotBackground, ui->colorSwatchPlotBackground);
+}
+
+// Underlay Line:
+void wfmain::on_colorSetBtnUnderlayLine_clicked()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].underlayLine);
+    setColorButtonOperations(c, ui->colorEditUnderlayLine, ui->colorSwatchUnderlayLine);
+}
+
+void wfmain::on_colorEditUnderlayLine_editingFinished()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].underlayLine);
+    setColorLineEditOperations(c, ui->colorEditUnderlayLine, ui->colorSwatchUnderlayLine);
+}
+
+// Underlay Fill:
+void wfmain::on_colorSetBtnUnderlayFill_clicked()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].underlayFill);
+    setColorButtonOperations(c, ui->colorEditUnderlayFill, ui->colorSwatchUnderlayFill);
+}
+void wfmain::on_colorEditUnderlayFill_editingFinished()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].underlayFill);
+    setColorLineEditOperations(c, ui->colorEditUnderlayFill, ui->colorSwatchUnderlayFill);
+}
+
+// WF Background:
+void wfmain::on_colorSetBtnwfBackground_clicked()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].wfBackground);
+    setColorButtonOperations(c, ui->colorEditWfBackground, ui->colorSwatchWfBackground);
+}
+void wfmain::on_colorEditWfBackground_editingFinished()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].wfBackground);
+    setColorLineEditOperations(c, ui->colorEditWfBackground, ui->colorSwatchWfBackground);
+}
+
+// WF Grid:
+void wfmain::on_colorSetBtnWfGrid_clicked()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].wfGrid);
+    setColorButtonOperations(c, ui->colorEditWfGrid, ui->colorSwatchWfGrid);
+}
+void wfmain::on_colorEditWfGrid_editingFinished()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].wfGrid);
+    setColorLineEditOperations(c, ui->colorEditWfGrid, ui->colorSwatchWfGrid);
+}
+
+// WF Axis:
+void wfmain::on_colorSetBtnWfAxis_clicked()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].wfAxis);
+    setColorButtonOperations(c, ui->colorEditWfAxis, ui->colorSwatchWfAxis);
+}
+void wfmain::on_colorEditWfAxis_editingFinished()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].wfAxis);
+    setColorLineEditOperations(c, ui->colorEditWfAxis, ui->colorSwatchWfAxis);
+}
+
+// WF Text:
+void wfmain::on_colorSetBtnWfText_clicked()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].wfText);
+    setColorButtonOperations(c, ui->colorEditWfText, ui->colorSwatchWfText);
+}
+void wfmain::on_colorEditWfText_editingFinished()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].wfText);
+    setColorLineEditOperations(c, ui->colorEditWfText, ui->colorSwatchWfText);
+}
+
+// Tuning Line:
+void wfmain::on_colorSetBtnTuningLine_clicked()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].tuningLine);
+    setColorButtonOperations(c, ui->colorEditTuningLine, ui->colorSwatchTuningLine);
+}
+void wfmain::on_colorEditTuningLine_editingFinished()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].tuningLine);
+    setColorLineEditOperations(c, ui->colorEditTuningLine, ui->colorSwatchTuningLine);
+}
+
+// Meter Level:
+void wfmain::on_colorSetBtnMeterLevel_clicked()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].meterLevel);
+    setColorButtonOperations(c, ui->colorEditMeterLevel, ui->colorSwatchMeterLevel);
+}
+void wfmain::on_colorEditMeterLevel_editingFinished()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].meterLevel);
+    setColorLineEditOperations(c, ui->colorEditMeterLevel, ui->colorSwatchMeterLevel);
+}
+
+// Meter Average:
+void wfmain::on_colorSetBtnMeterAvg_clicked()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].meterAverage);
+    setColorButtonOperations(c, ui->colorEditMeterAvg, ui->colorSwatchMeterAverage);
+}
+void wfmain::on_colorEditMeterAvg_editingFinished()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].meterAverage);
+    setColorLineEditOperations(c, ui->colorEditMeterAvg, ui->colorSwatchMeterAverage);
+}
+
+// Meter Peak Level:
+void wfmain::on_colorSetBtnMeterPeakLevel_clicked()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].meterPeakLevel);
+    setColorButtonOperations(c, ui->colorEditMeterPeakLevel, ui->colorSwatchMeterPeakLevel);
+}
+void wfmain::on_colorEditMeterPeakLevel_editingFinished()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].meterPeakLevel);
+    setColorLineEditOperations(c, ui->colorEditMeterPeakLevel, ui->colorSwatchMeterPeakLevel);
+}
+
+// Meter Peak Scale:
+void wfmain::on_colorSetBtnMeterPeakScale_clicked()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].meterPeakScale);
+    setColorButtonOperations(c, ui->colorEditMeterPeakScale, ui->colorSwatchMeterPeakScale);
+}
+void wfmain::on_colorEditMeterPeakScale_editingFinished()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].meterPeakScale);
+    setColorLineEditOperations(c, ui->colorEditMeterPeakScale, ui->colorSwatchMeterPeakScale);
+}
+
+// Meter Scale (line):
+void wfmain::on_colorSetBtnMeterScale_clicked()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].meterLowerLine);
+    setColorButtonOperations(c, ui->colorEditMeterScale, ui->colorSwatchMeterScale);
+}
+void wfmain::on_colorEditMeterScale_editingFinished()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].meterLowerLine);
+    setColorLineEditOperations(c, ui->colorEditMeterScale, ui->colorSwatchMeterScale);
+}
+
+// Meter Text:
+void wfmain::on_colorSetBtnMeterText_clicked()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].meterLowText);
+    setColorButtonOperations(c, ui->colorEditMeterText, ui->colorSwatchMeterText);
+}
+void wfmain::on_colorEditMeterText_editingFinished()
+{
+    int pos = ui->colorPresetCombo->currentIndex();
+    QColor *c = &(colorPreset[pos].meterLowText);
+    setColorLineEditOperations(c, ui->colorEditMeterText, ui->colorSwatchMeterText);
+}
+
+// ----------   End color UI slots        ----------//
+
+
+void wfmain::on_colorRevertPresetBtn_clicked()
+{
+    // revert to default colors:
+    // TODO: Add arguments to setDefaultColors()
+    //int pn = ui->colorPresetCombo->currentIndex();
+    //setDefaultColors();
+}
+
+
+
diff --git a/wfmain.h b/wfmain.h
index 55fc8d2..d35c811 100644
--- a/wfmain.h
+++ b/wfmain.h
@@ -16,6 +16,8 @@
 #include <QMetaType>
 #include <QMutex>
 #include <QMutexLocker>
+#include <QColorDialog>
+#include <QColor>
 
 #include "logcategories.h"
 #include "commhandler.h"
@@ -35,6 +37,7 @@
 #include "rigctld.h"
 #include "aboutbox.h"
 #include "selectradio.h"
+#include "colorprefs.h"
 
 #include <qcustomplot.h>
 #include <qserialportinfo.h>
@@ -49,6 +52,7 @@
 #include "rtaudio/RtAudio.h"
 #endif
 
+#define numColorPresetsTotal (5)
 
 namespace Ui {
 class wfmain;
@@ -297,8 +301,6 @@ private slots:
 
     void on_clearPeakBtn_clicked();
 
-    void on_drawPeakChk_clicked(bool checked);
-
     void on_fullScreenChk_clicked(bool checked);
 
     void on_goFreqBtn_clicked();
@@ -327,14 +329,8 @@ private slots:
 
     void on_scopeEdgeCombo_currentIndexChanged(int index);
 
-    // void on_modeSelectCombo_currentIndexChanged(int index);
-
-    void on_useDarkThemeChk_clicked(bool checked);
-
     void on_modeSelectCombo_activated(int index);
 
-    // void on_freqDial_actionTriggered(int action);
-
     void on_freqDial_valueChanged(int value);
 
     void on_band6mbtn_clicked();
@@ -383,7 +379,6 @@ private slots:
 
     void on_saveSettingsBtn_clicked();
 
-
     void on_debugBtn_clicked();
 
     void on_pttEnableChk_clicked(bool checked);
@@ -426,7 +421,6 @@ private slots:
 
     void on_dataModeBtn_toggled(bool checked);
 
-
     void on_transmitBtn_clicked();
 
     void on_adjRefBtn_clicked();
@@ -555,6 +549,90 @@ private slots:
 
     void on_underlayAverageBuffer_toggled(bool checked);
 
+    void on_colorSetBtnGrid_clicked();
+
+    void on_colorSetBtnPlotBackground_clicked();
+
+    void on_colorSetBtnText_clicked();
+
+    void on_colorSetBtnSpecLine_clicked();
+
+    void on_colorSetBtnSpecFill_clicked();
+
+    void on_colorEditPlotBackground_editingFinished();
+
+    void on_colorPopOutBtn_clicked();
+
+    void on_colorPresetCombo_currentIndexChanged(int index);
+
+    void on_colorEditSpecLine_editingFinished();
+
+    void on_colorEditGrid_editingFinished();
+
+    void on_colorEditText_editingFinished();
+
+    void on_colorEditSpecFill_editingFinished();
+
+    void on_colorSetBtnAxis_clicked();
+
+    void on_colorEditAxis_editingFinished();
+
+    void on_colorSetBtnUnderlayLine_clicked();
+
+    void on_colorEditUnderlayLine_editingFinished();
+
+    void on_colorSetBtnUnderlayFill_clicked();
+
+    void on_colorEditUnderlayFill_editingFinished();
+
+    void on_colorSetBtnwfBackground_clicked();
+
+    void on_colorEditWfBackground_editingFinished();
+
+    void on_colorSetBtnWfGrid_clicked();
+
+    void on_colorEditWfGrid_editingFinished();
+
+    void on_colorSetBtnWfAxis_clicked();
+
+    void on_colorEditWfAxis_editingFinished();
+
+    void on_colorSetBtnWfText_clicked();
+
+    void on_colorEditWfText_editingFinished();
+
+    void on_colorSetBtnTuningLine_clicked();
+
+    void on_colorEditTuningLine_editingFinished();
+
+    void on_colorSetBtnMeterLevel_clicked();
+
+    void on_colorEditMeterLevel_editingFinished();
+
+    void on_colorSetBtnMeterAvg_clicked();
+
+    void on_colorEditMeterAvg_editingFinished();
+
+    void on_colorSetBtnMeterScale_clicked();
+
+    void on_colorEditMeterScale_editingFinished();
+
+    void on_colorSetBtnMeterText_clicked();
+
+    void on_colorEditMeterText_editingFinished();
+
+    void on_colorRenamePresetBtn_clicked();
+
+    void on_colorRevertPresetBtn_clicked();
+
+    void on_colorSetBtnMeterPeakLevel_clicked();
+
+    void on_colorEditMeterPeakLevel_editingFinished();
+
+    void on_colorSetBtnMeterPeakScale_clicked();
+
+    void on_colorEditMeterPeakScale_editingFinished();
+
 private:
     Ui::wfmain *ui;
     void closeEvent(QCloseEvent *event);
@@ -568,11 +646,11 @@ private:
     QCustomPlot *plot; // line plot
     QCustomPlot *wf; // waterfall image
     QCPItemLine * freqIndicatorLine;
-    //commHandler *comm;
     void setAppTheme(bool isCustom);
-    void setPlotTheme(QCustomPlot *plot, bool isDark);
     void prepareWf();
     void prepareWf(unsigned int wfLength);
+    void preparePlasma();
+    bool plasmaPrepared = false;
     void computePlasma();
     void showHideSpectrum(bool show);
     void getInitialRigState();
@@ -672,7 +750,6 @@ private:
     QVector <QByteArray> spectrumPlasma;
     unsigned int spectrumPlasmaSize = 64;
     underlay_t underlayMode = underlayNone;
-    bool drawPlasma = true;
     QMutex plasmaMutex;
     void resizePlasmaBuffer(int newSize);
 
@@ -687,7 +764,6 @@ private:
     unsigned int wfLengthMax;
 
     bool onFullscreen;
-    bool drawPeaks;
     bool freqTextSelected;
     void checkFreqSel();
 
@@ -760,34 +836,11 @@ private:
     datekind datesetpoint;
 
     freqMemory mem;
-    struct colors {
-        QColor Dark_PlotBackground;
-        QColor Dark_PlotAxisPen;
-        QColor Dark_PlotLegendTextColor;
-        QColor Dark_PlotLegendBorderPen;
-        QColor Dark_PlotLegendBrush;
-        QColor Dark_PlotTickLabel;
-        QColor Dark_PlotBasePen;
-        QColor Dark_PlotTickPen;
-        QColor Dark_PeakPlotLine;
-        QColor Dark_TuningLine;
 
-        QColor Light_PlotBackground;
-        QColor Light_PlotAxisPen;
-        QColor Light_PlotLegendTextColor;
-        QColor Light_PlotLegendBorderPen;
-        QColor Light_PlotLegendBrush;
-        QColor Light_PlotTickLabel;
-        QColor Light_PlotBasePen;
-        QColor Light_PlotTickPen;
-        QColor Light_PeakPlotLine;
-        QColor Light_TuningLine;
-
-    } colorScheme;
+    colorPrefsType colorPreset[numColorPresetsTotal];
 
     struct preferences {
         bool useFullScreen;
-        bool useDarkMode;
         bool useSystemTheme;
         bool drawPeaks;
         underlay_t underlayMode = underlayNone;
@@ -805,7 +858,7 @@ private:
         bool enableLAN;
         bool enableRigCtlD;
         quint16 rigCtlPort;
-        colors colorScheme;
+        int currentColorPresetNumber = 0;
         QString virtualSerialPort;
         unsigned char localAFgain;
         unsigned int wflength;
@@ -828,13 +881,33 @@ private:
     audioSetup rxSetup;
     audioSetup txSetup;
 
-
-    colors defaultColors;
-
     void setDefaultColors(); // populate with default values
     void useColors(); // set the plot up
     void setDefPrefs(); // populate default values to default prefs
     void setTuningSteps();
+    void setColorElement(QColor color, QLedLabel *led, QLabel *label);
+    void setColorElement(QColor color, QLedLabel *led, QLineEdit *lineText);
+    void setColorElement(QColor color, QLedLabel *led, QLabel *label, QLineEdit *lineText);
+    QColor getColorFromPicker(QColor initialColor);
+    void getSetColor(QLedLabel *led, QLabel *label);
+    void getSetColor(QLedLabel *led, QLineEdit *line);
+    QString setColorFromString(QString aarrggbb, QLedLabel *led);
+    void setDefaultColorPresets();
+    void loadColorPresetToUIandPlots(int presetNumber);
+    void useColorPreset(colorPrefsType *cp);
+    void useCurrentColorPreset();
+    void setEditAndLedFromColor(QColor c, QLineEdit *e, QLedLabel *d);
+    void setColorButtonOperations(QColor *colorStore, QLineEdit *e, QLedLabel *d);
+    void setColorLineEditOperations(QColor *colorStore, QLineEdit *e, QLedLabel *d);
+
+    void detachSettingsTab();
+    void reattachSettingsTab();
+    void prepareSettingsWindow();
+    QWidget *settingsWidgetWindow;
+    QWidget *settingsTab;
+    QGridLayout *settingsWidgetLayout;
+    QTabWidget *settingsWidgetTab;
+    bool settingsTabisAttached = true;
 
     quint64 roundFrequency(quint64 frequency, unsigned int tsHz);
     quint64 roundFrequencyWithStep(quint64 oldFreq, int steps,\
diff --git a/wfmain.ui b/wfmain.ui
index 2e0d107..3e78a4e 100644
--- a/wfmain.ui
+++ b/wfmain.ui
@@ -6,7 +6,7 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>1002</width>
+    <width>1032</width>
     <height>569</height>
    </rect>
   </property>
@@ -2820,13 +2820,6 @@
              <layout class="QVBoxLayout" name="verticalLayout_24">
               <item>
                <layout class="QHBoxLayout" name="horizontalLayout_21">
-                <item>
-                 <widget class="QCheckBox" name="drawPeakChk">
-                  <property name="text">
-                   <string>Draw Peaks</string>
-                  </property>
-                 </widget>
-                </item>
                 <item>
                  <widget class="QCheckBox" name="tuningFloorZerosChk">
                   <property name="text">
@@ -2854,13 +2847,6 @@
               </item>
               <item>
                <layout class="QHBoxLayout" name="horizontalLayout_22">
-                <item>
-                 <widget class="QCheckBox" name="useDarkThemeChk">
-                  <property name="text">
-                   <string>Waterfall Dark Theme</string>
-                  </property>
-                 </widget>
-                </item>
                 <item>
                  <widget class="QCheckBox" name="wfInterpolateChk">
                   <property name="text">
@@ -2872,16 +2858,16 @@
                  </widget>
                 </item>
                 <item>
-                 <widget class="QCheckBox" name="useSystemThemeChk">
+                 <widget class="QCheckBox" name="wfAntiAliasChk">
                   <property name="text">
-                   <string>Use System Theme</string>
+                   <string>Anti-Alias Waterfall</string>
                   </property>
                  </widget>
                 </item>
                 <item>
-                 <widget class="QCheckBox" name="wfAntiAliasChk">
+                 <widget class="QCheckBox" name="useSystemThemeChk">
                   <property name="text">
-                   <string>Anti-Alias Waterfall</string>
+                   <string>Use System Theme</string>
                   </property>
                  </widget>
                 </item>
@@ -2974,7 +2960,7 @@
                 <item>
                  <widget class="QLabel" name="label_42">
                   <property name="text">
-                   <string>Uneerlay Buffer Size:</string>
+                   <string>Underlay Buffer Size:</string>
                   </property>
                  </widget>
                 </item>
@@ -3088,6 +3074,566 @@
                 </item>
                </layout>
               </item>
+              <item>
+               <widget class="QGroupBox" name="groupBox_9">
+                <property name="baseSize">
+                 <size>
+                  <width>0</width>
+                  <height>0</height>
+                 </size>
+                </property>
+                <property name="title">
+                 <string>User-defined Color Editor</string>
+                </property>
+                <layout class="QGridLayout" name="gridLayout_4">
+                 <item row="0" column="0">
+                  <widget class="QScrollArea" name="scrollArea">
+                   <property name="widgetResizable">
+                    <bool>true</bool>
+                   </property>
+                   <widget class="QWidget" name="scrollAreaWidgetContents">
+                    <property name="geometry">
+                     <rect>
+                      <x>0</x>
+                      <y>-409</y>
+                      <width>767</width>
+                      <height>612</height>
+                     </rect>
+                    </property>
+                    <layout class="QGridLayout" name="gridLayout_2">
+                     <item row="20" column="1">
+                      <widget class="QLineEdit" name="colorEditMeterText">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <property name="text">
+                        <string>#AARRGGBB</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="4" column="0">
+                      <widget class="QPushButton" name="colorSetBtnText">
+                       <property name="text">
+                        <string>Text</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="1" column="1">
+                      <widget class="QComboBox" name="colorPresetCombo">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <item>
+                        <property name="text">
+                         <string>1</string>
+                        </property>
+                       </item>
+                       <item>
+                        <property name="text">
+                         <string>2</string>
+                        </property>
+                       </item>
+                       <item>
+                        <property name="text">
+                         <string>3</string>
+                        </property>
+                       </item>
+                       <item>
+                        <property name="text">
+                         <string>4</string>
+                        </property>
+                       </item>
+                       <item>
+                        <property name="text">
+                         <string>5</string>
+                        </property>
+                       </item>
+                      </widget>
+                     </item>
+                     <item row="1" column="6">
+                      <widget class="QPushButton" name="colorRenamePresetBtn">
+                       <property name="text">
+                        <string>Rename Preset</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="15" column="0">
+                      <widget class="QPushButton" name="colorSetBtnMeterLevel">
+                       <property name="text">
+                        <string>Meter Level</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="8" column="1">
+                      <widget class="QLineEdit" name="colorEditUnderlayLine">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <property name="text">
+                        <string>#AARRGGBB</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="10" column="1">
+                      <widget class="QLineEdit" name="colorEditWfBackground">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <property name="text">
+                        <string>#AARRGGBB</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="13" column="2">
+                      <widget class="QLedLabel" name="colorSwatchWfText" native="true"/>
+                     </item>
+                     <item row="8" column="0">
+                      <widget class="QPushButton" name="colorSetBtnUnderlayLine">
+                       <property name="text">
+                        <string>Underlay Line</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="1" column="5">
+                      <widget class="QPushButton" name="colorRevertPresetBtn">
+                       <property name="text">
+                        <string>Revert</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="5" column="2">
+                      <widget class="QLedLabel" name="colorSwatchPlotBackground" native="true"/>
+                     </item>
+                     <item row="3" column="2">
+                      <widget class="QLedLabel" name="colorSwatchAxis" native="true"/>
+                     </item>
+                     <item row="17" column="0">
+                      <widget class="QPushButton" name="colorSetBtnMeterPeakLevel">
+                       <property name="text">
+                        <string>Meter Peak Level</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="12" column="1">
+                      <widget class="QLineEdit" name="colorEditWfAxis">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <property name="text">
+                        <string>#AARRGGBB</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="4" column="2">
+                      <widget class="QLedLabel" name="colorSwatchText" native="true"/>
+                     </item>
+                     <item row="8" column="2">
+                      <widget class="QLedLabel" name="colorSwatchUnderlayLine" native="true"/>
+                     </item>
+                     <item row="3" column="1">
+                      <widget class="QLineEdit" name="colorEditAxis">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <property name="text">
+                        <string>#AARRGGBB</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="2" column="1">
+                      <widget class="QLineEdit" name="colorEditGrid">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <property name="text">
+                        <string>#AARRGGBB</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="16" column="0">
+                      <widget class="QPushButton" name="colorSetBtnMeterAvg">
+                       <property name="text">
+                        <string>Meter Average</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="19" column="1">
+                      <widget class="QLineEdit" name="colorEditMeterScale">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <property name="text">
+                        <string>#AARRGGBB</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="12" column="0">
+                      <widget class="QPushButton" name="colorSetBtnWfAxis">
+                       <property name="text">
+                        <string>Waterfall Axis</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="3" column="0">
+                      <widget class="QPushButton" name="colorSetBtnAxis">
+                       <property name="text">
+                        <string>Axis</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="9" column="0">
+                      <widget class="QPushButton" name="colorSetBtnUnderlayFill">
+                       <property name="text">
+                        <string>Underlay Fill</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="19" column="0">
+                      <widget class="QPushButton" name="colorSetBtnMeterScale">
+                       <property name="text">
+                        <string>Meter Scale</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="14" column="1">
+                      <widget class="QLineEdit" name="colorEditTuningLine">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <property name="text">
+                        <string>#AARRGGBB</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="1" column="2">
+                      <widget class="QWidget" name="colorDummyLed" native="true"/>
+                     </item>
+                     <item row="20" column="0">
+                      <widget class="QPushButton" name="colorSetBtnMeterText">
+                       <property name="text">
+                        <string>Meter Text</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="6" column="2">
+                      <widget class="QLedLabel" name="colorSwatchSpecLine" native="true"/>
+                     </item>
+                     <item row="6" column="0">
+                      <widget class="QPushButton" name="colorSetBtnSpecLine">
+                       <property name="text">
+                        <string>Spectrum Line</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="9" column="1">
+                      <widget class="QLineEdit" name="colorEditUnderlayFill">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <property name="text">
+                        <string>#AARRGGBB</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="15" column="2">
+                      <widget class="QLedLabel" name="colorSwatchMeterLevel" native="true"/>
+                     </item>
+                     <item row="16" column="1">
+                      <widget class="QLineEdit" name="colorEditMeterAvg">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <property name="text">
+                        <string>#AARRGGBB</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="1" column="8">
+                      <spacer name="colorHorizSpacerTopLine">
+                       <property name="orientation">
+                        <enum>Qt::Horizontal</enum>
+                       </property>
+                       <property name="sizeHint" stdset="0">
+                        <size>
+                         <width>40</width>
+                         <height>20</height>
+                        </size>
+                       </property>
+                      </spacer>
+                     </item>
+                     <item row="15" column="1">
+                      <widget class="QLineEdit" name="colorEditMeterLevel">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <property name="text">
+                        <string>#AARRGGBB</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="11" column="0">
+                      <widget class="QPushButton" name="colorSetBtnWfGrid">
+                       <property name="text">
+                        <string>Waterfall Grid</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="17" column="2">
+                      <widget class="QLedLabel" name="colorSwatchMeterPeakLevel" native="true"/>
+                     </item>
+                     <item row="10" column="0">
+                      <widget class="QPushButton" name="colorSetBtnwfBackground">
+                       <property name="text">
+                        <string>Waterfall Back</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="7" column="2">
+                      <widget class="QLedLabel" name="colorSwatchSpecFill" native="true"/>
+                     </item>
+                     <item row="14" column="2">
+                      <widget class="QLedLabel" name="colorSwatchTuningLine" native="true"/>
+                     </item>
+                     <item row="4" column="1">
+                      <widget class="QLineEdit" name="colorEditText">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <property name="text">
+                        <string>#AARRGGBB</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="11" column="1">
+                      <widget class="QLineEdit" name="colorEditWfGrid">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <property name="text">
+                        <string>#AARRGGBB</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="10" column="2">
+                      <widget class="QLedLabel" name="colorSwatchWfBackground" native="true"/>
+                     </item>
+                     <item row="13" column="0">
+                      <widget class="QPushButton" name="colorSetBtnWfText">
+                       <property name="text">
+                        <string>Waterfall Text</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="13" column="1">
+                      <widget class="QLineEdit" name="colorEditWfText">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <property name="text">
+                        <string>#AARRGGBB</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="1" column="4">
+                      <widget class="QPushButton" name="colorSavePresetBtn">
+                       <property name="text">
+                        <string>Save Presets</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="11" column="2">
+                      <widget class="QLedLabel" name="colorSwatchWfGrid" native="true"/>
+                     </item>
+                     <item row="16" column="2">
+                      <widget class="QLedLabel" name="colorSwatchMeterAverage" native="true"/>
+                     </item>
+                     <item row="19" column="2">
+                      <widget class="QLedLabel" name="colorSwatchMeterScale" native="true"/>
+                     </item>
+                     <item row="1" column="0">
+                      <widget class="QLabel" name="colorPresetLabel">
+                       <property name="text">
+                        <string>Preset:</string>
+                       </property>
+                       <property name="alignment">
+                        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="6" column="1">
+                      <widget class="QLineEdit" name="colorEditSpecLine">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <property name="text">
+                        <string>#AARRGGBB</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="2" column="0">
+                      <widget class="QPushButton" name="colorSetBtnGrid">
+                       <property name="text">
+                        <string>Grid</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="9" column="2">
+                      <widget class="QLedLabel" name="colorSwatchUnderlayFill" native="true"/>
+                     </item>
+                     <item row="5" column="0">
+                      <widget class="QPushButton" name="colorSetBtnPlotBackground">
+                       <property name="text">
+                        <string>Plot Background</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="2" column="2">
+                      <widget class="QLedLabel" name="colorSwatchGrid" native="true"/>
+                     </item>
+                     <item row="17" column="1">
+                      <widget class="QLineEdit" name="colorEditMeterPeakLevel">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <property name="text">
+                        <string>#AARRGGBB</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="5" column="1">
+                      <widget class="QLineEdit" name="colorEditPlotBackground">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <property name="text">
+                        <string>#AARRGGBB</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="20" column="2">
+                      <widget class="QLedLabel" name="colorSwatchMeterText" native="true"/>
+                     </item>
+                     <item row="12" column="2">
+                      <widget class="QLedLabel" name="colorSwatchWfAxis" native="true"/>
+                     </item>
+                     <item row="14" column="0">
+                      <widget class="QPushButton" name="colorSetBtnTuningLine">
+                       <property name="text">
+                        <string>Tuning Line</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="7" column="0">
+                      <widget class="QPushButton" name="colorSetBtnSpecFill">
+                       <property name="text">
+                        <string>Spectrum Fill</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="7" column="1">
+                      <widget class="QLineEdit" name="colorEditSpecFill">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <property name="text">
+                        <string>#AARRGGBB</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="1" column="7">
+                      <widget class="QPushButton" name="colorPopOutBtn">
+                       <property name="text">
+                        <string>Pop-Out</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="18" column="0">
+                      <widget class="QPushButton" name="colorSetBtnMeterPeakScale">
+                       <property name="text">
+                        <string>Meter High Scale</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="18" column="1">
+                      <widget class="QLineEdit" name="colorEditMeterPeakScale">
+                       <property name="maximumSize">
+                        <size>
+                         <width>90</width>
+                         <height>16777215</height>
+                        </size>
+                       </property>
+                       <property name="text">
+                        <string>#AARRGGBB</string>
+                       </property>
+                      </widget>
+                     </item>
+                     <item row="18" column="2">
+                      <widget class="QLedLabel" name="colorSwatchMeterPeakScale" native="true"/>
+                     </item>
+                    </layout>
+                   </widget>
+                  </widget>
+                 </item>
+                </layout>
+               </widget>
+              </item>
               <item>
                <spacer name="verticalSpacer_2">
                 <property name="orientation">
@@ -3096,7 +3642,7 @@
                 <property name="sizeHint" stdset="0">
                  <size>
                   <width>20</width>
-                  <height>40</height>
+                  <height>20</height>
                  </size>
                 </property>
                </spacer>
@@ -4006,7 +4552,7 @@
     <rect>
      <x>0</x>
      <y>0</y>
-     <width>1002</width>
+     <width>1032</width>
      <height>21</height>
     </rect>
    </property>
@@ -4024,6 +4570,12 @@
    <header>meter.h</header>
    <container>1</container>
   </customwidget>
+  <customwidget>
+   <class>QLedLabel</class>
+   <extends>QWidget</extends>
+   <header>qledlabel.h</header>
+   <container>1</container>
+  </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
diff --git a/wfview.pro b/wfview.pro
index 4ba46d7..d9443fb 100644
--- a/wfview.pro
+++ b/wfview.pro
@@ -176,6 +176,7 @@ SOURCES += main.cpp\
     aboutbox.cpp 
 
 HEADERS  += wfmain.h \
+    colorprefs.h \
     commhandler.h \
     rigcommander.h \
     freqmemory.h \