Migrate hotcue color logic to mixxx::RgbColor

22 files changed, 194 insertions, 148 deletions

diff --git a/src/controllers/colorjsproxy.cpp b/src/controllers/colorjsproxy.cpp
index f7ef331f70..24aa43797e 100644
--- a/src/controllers/colorjsproxy.cpp
+++ b/src/controllers/colorjsproxy.cpp
@@ -1,5 +1,7 @@
 #include "controllers/colorjsproxy.h"
+
 #include "preferences/hotcuecolorpalettesettings.h"
+#include "util/color/rgbcolor.h"
 
 ColorJSProxy::ColorJSProxy(QScriptEngine* pScriptEngine,
         HotcueColorPaletteSettings colorPaletteSettings)
@@ -16,25 +18,24 @@ Q_INVOKABLE QScriptValue ColorJSProxy::hotcueColorPalette() {
 }
 
 QScriptValue ColorJSProxy::colorFromHexCode(uint colorCode) {
-    QColor color = QColor::fromRgba(colorCode);
+    QRgb rgb = QRgb(colorCode);
     QScriptValue jsColor = m_pScriptEngine->newObject();
-    jsColor.setProperty("red", color.red());
-    jsColor.setProperty("green", color.green());
-    jsColor.setProperty("blue", color.blue());
-    jsColor.setProperty("alpha", color.alpha());
+    jsColor.setProperty("red", qRed(rgb));
+    jsColor.setProperty("green", qGreen(rgb));
+    jsColor.setProperty("blue", qBlue(rgb));
+    jsColor.setProperty("alpha", qAlpha(rgb));
     return jsColor;
 }
 
 QScriptValue ColorJSProxy::makeHotcueColorPalette(QScriptEngine* pScriptEngine,
         HotcueColorPaletteSettings colorPaletteSettings) {
     // TODO: make sure we get notified when the palette changes
-    QList<QColor> colorList =
-            colorPaletteSettings.getHotcueColorPalette().m_colorList;
+    QList<mixxx::RgbColor> colorList = colorPaletteSettings.getHotcueColorPalette().m_colorList;
     int numColors = colorList.length();
     QScriptValue jsColorList = pScriptEngine->newArray(numColors);
     for (int i = 0; i < numColors; ++i) {
-        QColor color = colorList.at(i);
-        jsColorList.setProperty(i, colorFromHexCode(color.rgba()));
+        mixxx::RgbColor color = colorList.at(i);
+        jsColorList.setProperty(i, colorFromHexCode(color));
     }
     return jsColorList;
 }
diff --git a/src/engine/controls/cuecontrol.cpp b/src/engine/controls/cuecontrol.cpp
index 8a3cf18261..ae38a9900c 100644
--- a/src/engine/controls/cuecontrol.cpp
+++ b/src/engine/controls/cuecontrol.cpp
@@ -318,7 +318,7 @@ void CueControl::detachCue(HotcueControl* pControl) {
     disconnect(pCue.get(), 0, this, 0);
     pControl->resetCue();
     // Reset the color CO to -1
-    pControl->setColor(QColor());
+    pControl->setColor(std::nullopt);
 }
 
 void CueControl::trackLoaded(TrackPointer pNewTrack) {
@@ -1694,8 +1694,11 @@ void CueControl::hotcueFocusColorPrev(double v) {
         return;
     }
 
-    QColor color = pControl->getColor();
-    DEBUG_ASSERT(color.isValid());
+    mixxx::RgbColor::optional_t controlColor = pControl->getColor();
+    if (!controlColor) {
+        return;
+    }
+    mixxx::RgbColor color = controlColor.value();
 
     HotcueColorPaletteSettings m_colorPaletteSettings(m_pConfig);
     ColorPalette colorPalette = m_colorPaletteSettings.getHotcueColorPalette();
@@ -1725,8 +1728,11 @@ void CueControl::hotcueFocusColorNext(double v) {
         return;
     }
 
-    QColor color = pControl->getColor();
-    DEBUG_ASSERT(color.isValid());
+    mixxx::RgbColor::optional_t controlColor = pControl->getColor();
+    if (!controlColor) {
+        return;
+    }
+    mixxx::RgbColor color = controlColor.value();
 
     HotcueColorPaletteSettings colorPaletteSettings(m_pConfig);
     ColorPalette colorPalette = colorPaletteSettings.getHotcueColorPalette();
@@ -1857,7 +1863,7 @@ void HotcueControl::slotHotcuePositionChanged(double newPosition) {
 }
 
 void HotcueControl::slotHotcueColorChanged(double newColor) {
-    m_pCue->setColor(QColor::fromRgba(newColor));
+    m_pCue->setColor(mixxx::RgbColor(newColor));
     emit(hotcueColorChanged(this, newColor));
 }
 
@@ -1872,16 +1878,20 @@ void HotcueControl::setCue(CuePointer pCue) {
     // because we have a null check for valid data else where in the code
     m_pCue = pCue;
 }
-QColor HotcueControl::getColor() const {
-    return QColor::fromRgba(m_hotcueColor->get());
+mixxx::RgbColor::optional_t HotcueControl::getColor() const {
+    double value = m_hotcueColor->get();
+    if (value < 0) {
+        return std::nullopt;
+    }
+    return mixxx::RgbColor(value);
 }
 
-void HotcueControl::setColor(const QColor& newColor) {
-    if (newColor.isValid()) {
-        m_hotcueColor->set(newColor.rgba());
-    } else {
-        m_hotcueColor->set(-1);
+void HotcueControl::setColor(const mixxx::RgbColor::optional_t& newColor) {
+    if (newColor) {
+        m_hotcueColor->set(newColor.value());
+        return;
     }
+    m_hotcueColor->set(-1);
 }
 void HotcueControl::resetCue() {
     // clear pCue first because we have a null check for valid data else where
diff --git a/src/engine/controls/cuecontrol.h b/src/engine/controls/cuecontrol.h
index 414191fdf0..ef4432d8b5 100644
--- a/src/engine/controls/cuecontrol.h
+++ b/src/engine/controls/cuecontrol.h
@@ -51,8 +51,8 @@ class HotcueControl : public QObject {
     void setCue(CuePointer pCue);
     void resetCue();
     void setPosition(double position);
-    void setColor(const QColor& newColor);
-    QColor getColor() const;
+    void setColor(const mixxx::RgbColor::optional_t& newColor);
+    mixxx::RgbColor::optional_t getColor() const;
 
     // Used for caching the preview state of this hotcue control.
     inline bool isPreviewing() {
diff --git a/src/library/dao/cuedao.cpp b/src/library/dao/cuedao.cpp
index e43859645e..0781c5752d 100644
--- a/src/library/dao/cuedao.cpp
+++ b/src/library/dao/cuedao.cpp
@@ -1,15 +1,17 @@
 // cuedao.cpp
 // Created 10/26/2009 by RJ Ryan (rryan@mit.edu)
 
+#include "library/dao/cuedao.h"
+
+#include <QVariant>
 #include <QtDebug>
 #include <QtSql>
-#include <QVariant>
 
-#include "library/dao/cuedao.h"
+#include "library/queryutil.h"
 #include "track/cue.h"
 #include "track/track.h"
-#include "library/queryutil.h"
 #include "util/assert.h"
+#include "util/color/rgbcolor.h"
 #include "util/performancetimer.h"
 
 int CueDAO::cueCount() {
@@ -52,7 +54,7 @@ CuePointer CueDAO::cueFromRow(const QSqlQuery& query) const {
     int hotcue = record.value(record.indexOf("hotcue")).toInt();
     QString label = record.value(record.indexOf("label")).toString();
     uint colorValue = record.value(record.indexOf("color")).toUInt();
-    QColor color = QColor::fromRgba(colorValue);
+    mixxx::RgbColor color = mixxx::RgbColor(colorValue);
     CuePointer pCue(new Cue(id,
             trackId,
             (Cue::Type)type,
@@ -152,7 +154,7 @@ bool CueDAO::saveCue(Cue* cue) {
         query.bindValue(":length", cue->getLength());
         query.bindValue(":hotcue", cue->getHotCue());
         query.bindValue(":label", cue->getLabel());
-        query.bindValue(":color", cue->getColor().rgba());
+        query.bindValue(":color", static_cast<quint32>(cue->getColor()));
 
         if (query.exec()) {
             int id = query.lastInsertId().toInt();
@@ -180,7 +182,7 @@ bool CueDAO::saveCue(Cue* cue) {
         query.bindValue(":length", cue->getLength());
         query.bindValue(":hotcue", cue->getHotCue());
         query.bindValue(":label", cue->getLabel());
-        query.bindValue(":color", cue->getColor().rgba());
+        query.bindValue(":color", static_cast<quint32>(cue->getColor()));
 
         if (query.exec()) {
             cue->setDirty(false);
diff --git a/src/preferences/configobject.cpp b/src/preferences/configobject.cpp
index 22900ac4e4..a05030b039 100644
--- a/src/preferences/configobject.cpp
+++ b/src/preferences/configobject.cpp
@@ -1,14 +1,15 @@
 #include "preferences/configobject.h"
 
-#include <QIODevice>
-#include <QTextStream>
 #include <QApplication>
 #include <QDir>
+#include <QIODevice>
+#include <QTextStream>
 #include <QtDebug>
 
-#include "widget/wwidget.h"
 #include "util/cmdlineargs.h"
+#include "util/color/rgbcolor.h"
 #include "util/xml.h"
+#include "widget/wwidget.h"
 
 // TODO(rryan): Move to a utility file.
 namespace {
@@ -285,8 +286,19 @@ void ConfigObject<ConfigValue>::setValue(
 template<>
 template<>
 void ConfigObject<ConfigValue>::setValue(
-        const ConfigKey& key, const QColor& value) {
-    set(key, ConfigValue(value.name(QColor::NameFormat::HexArgb)));
+        const ConfigKey& key, const mixxx::RgbColor::optional_t& value) {
+    if (!value) {
+        set(key, ConfigValue(""));
+        return;
+    }
+    set(key, ConfigValue(mixxx::toQColor(value.value()).name(QColor::NameFormat::HexArgb)));
+}
+
+template<>
+template<>
+void ConfigObject<ConfigValue>::setValue(
+        const ConfigKey& key, const mixxx::RgbColor& value) {
+    set(key, ConfigValue(mixxx::toQColor(value).name(QColor::NameFormat::HexArgb)));
 }
 
 template <> template <>
@@ -327,20 +339,41 @@ double ConfigObject<ConfigValue>::getValue(
 
 template<>
 template<>
-QColor ConfigObject<ConfigValue>::getValue(
-        const ConfigKey& key, const QColor& default_value) const {
+mixxx::RgbColor::optional_t ConfigObject<ConfigValue>::getValue(
+        const ConfigKey& key, const mixxx::RgbColor::optional_t& default_value) const {
     const ConfigValue value = get(key);
     if (value.isNull()) {
         return default_value;
     }
-    auto color = QColor(value.value);
-    return color.isValid() ? color : default_value;
+    QColor parsedColor(value.value);
+    if (!parsedColor.isValid()) {
+        return default_value;
+    }
+    auto color = mixxx::RgbColor::optional_t(parsedColor.rgb());
+    return color ? color : default_value;
+}
+
+template<>
+template<>
+mixxx::RgbColor::optional_t ConfigObject<ConfigValue>::getValue(const ConfigKey& key) const {
+    return getValue(key, mixxx::RgbColor::optional_t(std::nullopt));
+}
+
+template<>
+template<>
+mixxx::RgbColor ConfigObject<ConfigValue>::getValue(
+        const ConfigKey& key, const mixxx::RgbColor& default_value) const {
+    const mixxx::RgbColor::optional_t value = getValue(key, mixxx::RgbColor::optional_t(std::nullopt));
+    if (!value) {
+        return default_value;
+    }
+    return *value;
 }
 
 template<>
 template<>
-QColor ConfigObject<ConfigValue>::getValue(const ConfigKey& key) const {
-    return getValue(key, QColor());
+mixxx::RgbColor ConfigObject<ConfigValue>::getValue(const ConfigKey& key) const {
+    return getValue(key, mixxx::RgbColor(0));
 }
 
 // For string literal default
diff --git a/src/preferences/hotcuecolorpalettesettings.cpp b/src/preferences/hotcuecolorpalettesettings.cpp
index 4faf0f9308..76903b054e 100644
--- a/src/preferences/hotcuecolorpalettesettings.cpp
+++ b/src/preferences/hotcuecolorpalettesettings.cpp
@@ -3,12 +3,10 @@
 const QString HotcueColorPaletteSettings::sGroup = "[HotcueColorPalette]";
 
 ColorPalette HotcueColorPaletteSettings::getHotcueColorPalette() const {
-    QList<QColor> colorList;
+    QList<mixxx::RgbColor> colorList;
     for (const ConfigKey& key : m_pConfig->getKeysWithGroup(sGroup)) {
-        QColor color = m_pConfig->getValue<QColor>(key);
-        if (color.isValid()) {
-            colorList.append(color);
-        }
+        mixxx::RgbColor color = mixxx::RgbColor(m_pConfig->getValue<mixxx::RgbColor>(key, mixxx::RgbColor(0)));
+        colorList.append(color);
     }
 
     // If no palette is defined in the settings, we use the default one.
@@ -24,8 +22,8 @@ void HotcueColorPaletteSettings::setHotcueColorPalette(
     removePalette();
 
     for (int index = 0; index < colorPalette.m_colorList.count(); ++index) {
-        QColor color = colorPalette.m_colorList[index];
-        m_pConfig->setValue<QColor>(keyForIndex(index), color);
+        mixxx::RgbColor color = colorPalette.m_colorList[index];
+        m_pConfig->setValue<mixxx::RgbColor>(keyForIndex(index), color);
     }
 }
 
diff --git a/src/test/colorconfig_test.cpp b/src/test/colorconfig_test.cpp
index 477bab40a5..81a5e36fdb 100644
--- a/src/test/colorconfig_test.cpp
+++ b/src/test/colorconfig_test.cpp
@@ -1,45 +1,35 @@
 #include <gtest/gtest.h>
-#include <QColor>
 
+#include "preferences/hotcuecolorpalettesettings.h"
 #include "test/mixxxtest.h"
-
-#include <preferences/hotcuecolorpalettesettings.h>
-#include <util/color/colorpalette.h>
+#include "util/color/colorpalette.h"
+#include "util/color/rgbcolor.h"
 
 class ColorConfigTest : public MixxxTest {};
 
-TEST_F(ColorConfigTest, SavingColorWithoutAlpha) {
-    ConfigKey key("[Color]", "color");
-    QColor originalColor("#FF9900");
-    config()->setValue(key, originalColor);
-    saveAndReloadConfig();
-    QColor colorFromConfig = config()->getValue(key);
-    ASSERT_EQ(originalColor, colorFromConfig);
-}
-
-TEST_F(ColorConfigTest, SavingColorWithAlpha) {
+TEST_F(ColorConfigTest, SavingColor) {
     ConfigKey key("[Color]", "color");
-    QColor originalColor("#66FF9900");
+    mixxx::RgbColor originalColor(0xFF9900);
     config()->setValue(key, originalColor);
     saveAndReloadConfig();
-    QColor colorFromConfig = config()->getValue(key);
+    mixxx::RgbColor colorFromConfig = config()->getValue(key, mixxx::RgbColor(0));
     ASSERT_EQ(originalColor, colorFromConfig);
 }
 
 TEST_F(ColorConfigTest, GetDefaultColorWhenNoStoredColor) {
     ConfigKey key("[Color]", "color");
-    QColor defaultColor("#66FF9900");
-    QColor colorFromConfig = config()->getValue(key, defaultColor);
+    mixxx::RgbColor defaultColor(0x66FF99);
+    mixxx::RgbColor colorFromConfig = config()->getValue(key, defaultColor);
     ASSERT_EQ(defaultColor, colorFromConfig);
 }
 
 TEST_F(ColorConfigTest, SaveColorPalette) {
     HotcueColorPaletteSettings colorPaletteSettings(config());
-    ColorPalette originalColorPalette(QList<QColor>{
-            QColor("#66FF9900"),
-            QColor("#FF9900"),
-            QColor("#00000000"),
-            QColor("#FFFFFF"),
+    ColorPalette originalColorPalette(QList<mixxx::RgbColor>{
+            mixxx::RgbColor(0x66FF99),
+            mixxx::RgbColor(0xFF9900),
+            mixxx::RgbColor(0x000000),
+            mixxx::RgbColor(0xFFFFFF),
     });
     ConfigKey key("[ColorPalette]", "colorPalette");
     colorPaletteSettings.setHotcueColorPalette(originalColorPalette);
@@ -51,15 +41,15 @@ TEST_F(ColorConfigTest, SaveColorPalette) {
 
 TEST_F(ColorConfigTest, ReplaceColorPalette) {
     HotcueColorPaletteSettings colorPaletteSettings(config());
-    ColorPalette colorPalette1(QList<QColor>{
-            QColor("#66FF9900"),
-            QColor("#FF9900"),
-            QColor("#00000000"),
-            QColor("#FFFFFF"),
+    ColorPalette colorPalette1(QList<mixxx::RgbColor>{
+            mixxx::RgbColor(0x66FF99),
+            mixxx::RgbColor(0xFF9900),
+            mixxx::RgbColor(0x000000),
+            mixxx::RgbColor(0xFFFFFF),
     });
-    ColorPalette colorPalette2(QList<QColor>{
-            QColor("#0000FF"),
-            QColor("#FF0000"),
+    ColorPalette colorPalette2(QList<mixxx::RgbColor>{
+            mixxx::RgbColor(0x0000FF),
+            mixxx::RgbColor(0xFF0000),
     });
     ConfigKey key("[ColorPalette]", "colorPalette");
     colorPaletteSettings.setHotcueColorPalette(colorPalette1);
@@ -75,5 +65,5 @@ TEST_F(ColorConfigTest, DefaultColorPalette) {
     HotcueColorPaletteSettings colorPaletteSettings(config());
     ColorPalette colorPaletteFromConfig =
             colorPaletteSettings.getHotcueColorPalette();
-    ASSERT_EQ(ColorPalette::mixxxHotcuesPalette, colorPaletteFromConfig);
+    ASSERT_EQ(ColorPalette::mixxxPalette, colorPaletteFromConfig);
 }
diff --git a/src/test/controllerengine_test.cpp b/src/test/controllerengine_test.cpp
index ea6a9ad011..18976c5f34 100644
--- a/src/test/controllerengine_test.cpp
+++ b/src/test/controllerengine_test.cpp
@@ -620,23 +620,23 @@ TEST_F(ControllerEngineTest, connectionExecutesWithCorrectThisObject) {
 }
 
 TEST_F(ControllerEngineTest, colorProxyTestMixxxPalette) {
-    QList<QColor> allColors = ColorPalette::mixxxPalette.m_colorList;
+    QList<mixxx::RgbColor> allColors = ColorPalette::mixxxPalette.m_colorList;
     for (int i = 0; i < allColors.length(); ++i) {
-        QColor color = allColors[i];
-        qDebug() << "Testing color " << color.name();
-        QString colorCode = QString::number(color.rgba());
+        mixxx::RgbColor color = allColors[i];
+        qDebug() << "Testing color " << mixxx::RgbColor::toQString(color);
+        QString colorCode = QString::number(color);
         QScriptValue jsColor = pScriptEngine->evaluate(
                 "color.colorFromHexCode(" + colorCode + ")");
-        EXPECT_EQ(jsColor.property("red").toInt32(), color.red());
-        EXPECT_EQ(jsColor.property("green").toInt32(), color.green());
-        EXPECT_EQ(jsColor.property("blue").toInt32(), color.blue());
-        EXPECT_EQ(jsColor.property("alpha").toInt32(), color.alpha());
+        EXPECT_EQ(jsColor.property("red").toInt32(), qRed(color));
+        EXPECT_EQ(jsColor.property("green").toInt32(), qGreen(color));
+        EXPECT_EQ(jsColor.property("blue").toInt32(), qBlue(color));
+        EXPECT_EQ(jsColor.property("alpha").toInt32(), qAlpha(color));
 
         QScriptValue jsColor2 = pScriptEngine->evaluate(
                 "color.hotcueColorPalette()[" + QString::number(i) + "]");
-        EXPECT_EQ(jsColor2.property("red").toInt32(), color.red());
-        EXPECT_EQ(jsColor2.property("green").toInt32(), color.green());
-        EXPECT_EQ(jsColor2.property("blue").toInt32(), color.blue());
-        EXPECT_EQ(jsColor2.property("alpha").toInt32(), color.alpha());
+        EXPECT_EQ(jsColor2.property("red").toInt32(), qRed(color));
+        EXPECT_EQ(jsColor2.property("green").toInt32(), qGreen(color));
+        EXPECT_EQ(jsColor2.property("blue").toInt32(), qBlue(color));
+        EXPECT_EQ(jsColor2.property("alpha").toInt32(), qAlpha(color));
     }
 }
diff --git a/src/track/cue.cpp b/src/track/cue.cpp
index 99ec0f7427..286d2269aa 100644
--- a/src/track/cue.cpp
+++ b/src/track/cue.cpp
@@ -10,6 +10,7 @@
 
 namespace {
     const QString kDefaultLabel = ""; // empty string, not null
+    const mixxx::RgbColor kDefaultCueColor = mixxx::RgbColor(0xFFF2F2FF); // white
 }
 
 //static
@@ -28,7 +29,7 @@ Cue::Cue(TrackId trackId)
           m_sampleEndPosition(Cue::kNoPosition),
           m_iHotCue(-1),
           m_label(kDefaultLabel),
-          m_color(QColor()) {
+          m_color(kDefaultCueColor) {
     DEBUG_ASSERT(!m_label.isNull());
 }
 
@@ -39,7 +40,7 @@ Cue::Cue(int id,
         double length,
         int hotCue,
         QString label,
-        QColor color)
+        mixxx::RgbColor color)
         : m_bDirty(false),
           m_iId(id),
           m_trackId(trackId),
@@ -159,12 +160,12 @@ void Cue::setLabel(const QString label) {
     emit updated();
 }
 
-QColor Cue::getColor() const {
+mixxx::RgbColor Cue::getColor() const {
     QMutexLocker lock(&m_mutex);
     return m_color;
 }
 
-void Cue::setColor(const QColor& color) {
+void Cue::setColor(const mixxx::RgbColor& color) {
     QMutexLocker lock(&m_mutex);
     m_color = color;
     m_bDirty = true;
diff --git a/src/track/cue.h b/src/track/cue.h
index 9b6d133766..cf86b4393d 100644
--- a/src/track/cue.h
+++ b/src/track/cue.h
@@ -1,11 +1,12 @@
 #ifndef MIXXX_CUE_H
 #define MIXXX_CUE_H
 
-#include <QObject>
-#include <QMutex>
 #include <QColor>
+#include <QMutex>
+#include <QObject>
 
 #include "track/trackid.h"
+#include "util/color/rgbcolor.h"
 #include "util/memory.h"
 
 class CuePosition;
@@ -53,8 +54,8 @@ class Cue : public QObject {
     QString getLabel() const;
     void setLabel(QString label);
 
-    QColor getColor() const;
-    void setColor(const QColor& color);
+    mixxx::RgbColor getColor() const;
+    void setColor(const mixxx::RgbColor& color);
 
     double getEndPosition() const;
 
@@ -70,7 +71,7 @@ class Cue : public QObject {
             double length,
             int hotCue,
             QString label,
-            QColor color);
+            mixxx::RgbColor color);
     void setDirty(bool dirty);
     void setId(int id);
     void setTrackId(TrackId trackId);
@@ -85,7 +86,7 @@ class Cue : public QObject {
     double m_sampleEndPosition;
     int m_iHotCue;
     QString m_label;
-    QColor m_color;
+    mixxx::RgbColor m_color;
 
     friend class Track;
     friend class CueDAO;
diff --git a/src/util/color/colorpalette.cpp b/src/util/color/colorpalette.cpp
index 3f16c8f676..9b3a3f725f 100644
--- a/src/util/color/colorpalette.cpp
+++ b/src/util/color/colorpalette.cpp
@@ -1,11 +1,12 @@
 #include "colorpalette.h"
 
 const ColorPalette ColorPalette::mixxxPalette =
-        ColorPalette(QList<QColor>{QColor("#c50a08"),
-                QColor("#32be44"),
-                QColor("#0044ff"),
-                QColor("#f8d200"),
-                QColor("#42d4f4"),
-                QColor("#af00cc"),
-                QColor("#fca6d7"),
-                QColor("#f2f2ff")});
+        ColorPalette(QList<mixxx::RgbColor>{
+                mixxx::RgbColor(0xC50A08),
+                mixxx::RgbColor(0x32BE44),
+                mixxx::RgbColor(0x0044FF),
+                mixxx::RgbColor(0xF8D200),
+                mixxx::RgbColor(0x42D4F4),
+                mixxx::RgbColor(0xAF00CC),
+                mixxx::RgbColor(0xFCA6D7),
+                mixxx::RgbColor(0xF2F2FF)});
diff --git a/src/util/color/colorpalette.h b/src/util/color/colorpalette.h
index 5bd2eb836d..26375fe76f 100644
--- a/src/util/color/colorpalette.h
+++ b/src/util/color/colorpalette.h
@@ -1,15 +1,16 @@
 #pragma once
 
-#include <QColor>
 #include <QList>
 
+#include "util/color/rgbcolor.h"
+
 class ColorPalette {
   public:
-    ColorPalette(QList<QColor> colorList)
+    ColorPalette(QList<mixxx::RgbColor> colorList)
             : m_colorList(colorList) {
     }
 
-    QColor at(int i) const {
+    mixxx::RgbColor at(int i) const {
         return m_colorList.at(i);
     }
 
@@ -17,21 +18,21 @@ class ColorPalette {
         return m_colorList.size();
     }
 
-    int indexOf(QColor color) const {
+    int indexOf(mixxx::RgbColor color) const {
         return m_colorList.indexOf(color);
     }
 
-    QList<QColor>::const_iterator begin() const {
+    QList<mixxx::RgbColor>::const_iterator begin() const {
         return m_colorList.begin();
     }
 
-    QList<QColor>::const_iterator end() const {
+    QList<mixxx::RgbColor>::const_iterator end() const {
         return m_colorList.end();
     }
 
     static const ColorPalette mixxxPalette;
 
-    QList<QColor> m_colorList;
+    QList<mixxx::RgbColor> m_colorList;
 };
 
 inline bool operator==(
diff --git a/src/waveform/renderers/waveformrendermark.cpp b/src/waveform/renderers/waveformrendermark.cpp
index 26a840e897..61aa4f1b1f 100644
--- a/src/waveform/renderers/waveformrendermark.cpp
+++ b/src/waveform/renderers/waveformrendermark.cpp
@@ -123,7 +123,7 @@ void WaveformRenderMark::slotCuesUpdated() {
         }
 
         QString newLabel = pCue->getLabel();
-        QColor newColor = pCue->getColor();
+        QColor newColor = mixxx::RgbColor::toQColor(pCue->getColor());
         if (pMark->m_text.isNull() || newLabel != pMark->m_text ||
                 !pMark->fillColor().isValid() || newColor != pMark->fillColor()) {
             pMark->m_text = newLabel;
diff --git a/src/widget/wcolorpicker.cpp b/src/widget/wcolorpicker.cpp
index 717ea97a27..f74a121569 100644
--- a/src/widget/wcolorpicker.cpp
+++ b/src/widget/wcolorpicker.cpp
@@ -36,7 +36,7 @@ WColorPicker::WColorPicker(ColorOption colorOption, QWidget* parent)
     int column = 0;
 
     if (m_colorOption == ColorOption::AllowNoColor) {
-        addColorButton(QColor(), pLayout, row, column);
+        addColorButton(std::nullopt, pLayout, row, column);
         column++;
     }
 
@@ -50,17 +50,17 @@ WColorPicker::WColorPicker(ColorOption colorOption, QWidget* parent)
     }
 }
 
-void WColorPicker::addColorButton(const QColor& color, QGridLayout* pLayout, int row, int column) {
+void WColorPicker::addColorButton(const mixxx::RgbColor::optional_t& color, QGridLayout* pLayout, int row, int column) {
     setLayout(pLayout);
     parented_ptr<QPushButton> pColorButton = make_parented<QPushButton>("", this);
     if (m_pStyle) {
         pColorButton->setStyle(m_pStyle);
     }
 
-    if (color.isValid()) {
+    if (color) {
         // Set the background color of the button. This can't be overridden in skin stylesheets.
         pColorButton->setStyleSheet(
-                QString("QPushButton { background-color: %1; }").arg(color.name()));
+                QString("QPushButton { background-color: %1; }").arg(mixxx::RgbColor::toQString(color)));
     } else {
         pColorButton->setProperty("noColor", true);
     }
@@ -85,10 +85,13 @@ void WColorPicker::addColorButton(const QColor& color, QGridLayout* pLayout, int
 void WColorPicker::resetSelectedColor() {
     // Unset currently selected color
     int i;
-    if (m_colorOption == ColorOption::AllowNoColor && !m_selectedColor.isValid()) {
+    if (!m_selectedColor) {
+        if (m_colorOption != ColorOption::AllowNoColor) {
+            return;
+        }
         i = 0;
     } else {
-        i = m_palette.indexOf(m_selectedColor);
+        i = m_palette.indexOf(m_selectedColor.value());
         if (i == -1) {
             return;
         }
@@ -109,16 +112,19 @@ void WColorPicker::resetSelectedColor() {
     pButton->style()->polish(pButton);
 }
 
-void WColorPicker::setSelectedColor(const QColor& color) {
+void WColorPicker::setSelectedColor(const mixxx::RgbColor::optional_t& color) {
     resetSelectedColor();
 
     m_selectedColor = color;
 
     int i;
-    if (m_colorOption == ColorOption::AllowNoColor && !color.isValid()) {
+    if (!color) {
+        if (m_colorOption != ColorOption::AllowNoColor) {
+            return;
+        }
         i = 0;
     } else {
-        i = m_palette.indexOf(color);
+        i = m_palette.indexOf(color.value());
         if (i == -1) {
             return;
         }
@@ -153,11 +159,10 @@ void WColorPicker::useColorSet(const ColorPalette& palette) {
         // Set the background color of the button. This can't be overridden in skin stylesheets.
         m_colorButtons.at(j)->setStyleSheet(
                 QString("QPushButton { background-color: %1; }")
-                .arg(palette.at(i).name()));
+                        .arg(mixxx::RgbColor::toQString(palette.at(i))));
     }
 }
 
-
-void WColorPicker::slotColorPicked(const QColor& color) {
+void WColorPicker::slotColorPicked(const mixxx::RgbColor::optional_t& color) {
     setSelectedColor(color);
 }
diff --git a/src/widget/wcolorpicker.h b/src/widget/wcolorpicker.h
index cb3d45e6b3..2a97b2e0cf 100644
--- a/src/widget/wcolorpicker.h
+++ b/src/widget/wcolorpicker.h
@@ -20,19 +20,19 @@ class WColorPicker : public QWidget {
     explicit WColorPicker(ColorOption colorOption, QWidget* parent = nullptr);
 
     void resetSelectedColor();
-    void setSelectedColor(const QColor& color);
+    void setSelectedColor(const mixxx::RgbColor::optional_t& color);
     void useColorSet(const ColorPalette& palette);
 
   signals:
-    void colorPicked(QColor color);
+    void colorPicked(mixxx::RgbColor::optional_t color);
 
   private slots:
-    void slotColorPicked(const QColor& color);
+    void slotColorPicked(const mixxx::RgbColor::optional_t& color);
 
   private:
-    void addColorButton(const QColor& color, QGridLayout* pLayout, int row, int column);
+    void addColorButton(const mixxx::RgbColor::optional_t& color, QGridLayout* pLayout, int row, int column);
     ColorOption m_colorOption;
-    QColor m_selectedColor;
+    mixxx::RgbColor::optional_t m_selectedColor;
     ColorPalette m_palette;
     QList<QPushButton*> m_colorButtons;
     QStyle* m_pStyle;
diff --git a/src/widget/wcolorpickeraction.cpp b/src/widget/wcolorpickeraction.cpp
index 5270a75a4b..6c2afc6579 100644
--- a/src/widget/wcolorpickeraction.cpp
+++ b/src/widget/wcolorpickeraction.cpp
@@ -17,6 +17,6 @@ void WColorPickerAction::resetSelectedColor() {
     m_pColorPicker->resetSelectedColor();
 }
 
-void WColorPickerAction::setSelectedColor(QColor color) {
+void WColorPickerAction::setSelectedColor(mixxx::RgbColor::optional_t color) {
     m_pColorPicker->setSelectedColor(color);
 }
diff --git a/src/widget/wcolorpickeraction.h b/src/widget/wcolorpickeraction.h
index 9c9ced435b..e565f33004 100644
--- a/src/widget/wcolorpickeraction.h
+++ b/src/widget/wcolorpickeraction.h
@@ -15,10 +15,10 @@ class WColorPickerAction : public QWidgetAction {
             QWidget* parent = nullptr);
 
     void resetSelectedColor();
-    void setSelectedColor(QColor color = QColor());
+    void setSelectedColor(mixxx::RgbColor::optional_t color);
 
   signals:
-    void colorPicked(QColor color);
+    void colorPicked(mixxx::RgbColor::optional_t color);
 
   private:
     parented_ptr<WColorPicker> m_pColorPicker;
diff --git a/src/widget/wcuemenupopup.cpp b/src/widget/wcuemenupopup.cpp
index 97a2cff3ea..9e22308fdb 100644
--- a/src/widget/wcuemenupopup.cpp
+++ b/src/widget/wcuemenupopup.cpp
@@ -97,7 +97,7 @@ void WCueMenuPopup::setTrackAndCue(TrackPointer pTrack, CuePointer pCue) {
         m_pCueNumber->setText(QString(""));
         m_pCuePosition->setText(QString(""));
         m_pEditLabel->setText(QString(""));
-        m_pColorPicker->setSelectedColor(QColor());
+        m_pColorPicker->setSelectedColor(std::nullopt);
     }
 }
 
@@ -108,11 +108,14 @@ void WCueMenuPopup::slotEditLabel() {