preferences/colorpaletteeditor: Add support for hotcue color indices

CMakeLists.txt

@@ -501,6 +501,7 @@ add_library(mixxx-lib STATIC EXCLUDE_FROM_ALL
   src/preferences/dlgpreferencepage.cpp
   src/preferences/effectsettingsmodel.cpp
   src/preferences/colorpaletteeditor.cpp
+  src/preferences/colorpaletteeditormodel.cpp
   src/preferences/colorpaletteeditortableview.cpp
   src/preferences/colorpalettesettings.cpp
   src/preferences/replaygainsettings.cpp

build/depends.py

@@ -792,6 +792,7 @@ def sources(self, build):
                    "src/preferences/broadcastprofile.cpp",
                    "src/preferences/upgrade.cpp",
                    "src/preferences/colorpaletteeditor.cpp",
+                   "src/preferences/colorpaletteeditormodel.cpp",
                    "src/preferences/colorpaletteeditortableview.cpp",
                    "src/preferences/colorpalettesettings.cpp",
                    "src/preferences/dlgpreferencepage.cpp",

src/preferences/colorpaletteeditor.cpp

@@ -55,12 +55,12 @@ ColorPaletteEditor::ColorPaletteEditor(QWidget* parent)
                         foreach (const ColorPalette& palette, mixxx::PredefinedColorPalettes::kPalettes) {
                             if (text == palette.getName()) {
                                 bPaletteFound = true;
-                                m_pTableView->setColors(palette.getColorList());
+                                m_pTableView->setColorPalette(palette);
                                 break;
                             }
                         }
                         if (!bPaletteFound) {
-                            m_pTableView->setColors(colorPaletteSettings.getColorPalette(text, mixxx::PredefinedColorPalettes::kDefaultHotcueColorPalette).getColorList());
+                            m_pTableView->setColorPalette(colorPaletteSettings.getColorPalette(text, mixxx::PredefinedColorPalettes::kDefaultHotcueColorPalette));
                         }
                     }
                 } else {
@@ -84,7 +84,7 @@ ColorPaletteEditor::ColorPaletteEditor(QWidget* parent)
             [this] {
                 QString paletteName = m_pPaletteNameComboBox->currentText();
                 ColorPaletteSettings colorPaletteSettings(m_pConfig);
-                colorPaletteSettings.setColorPalette(paletteName, ColorPalette(paletteName, m_pTableView->getColors()));
+                colorPaletteSettings.setColorPalette(paletteName, m_pTableView->getColorPalette(paletteName));
                 m_pTableView->setDirty(false);
                 reset();
                 m_pPaletteNameComboBox->setCurrentText(paletteName);

src/preferences/colorpaletteeditormodel.cpp

@@ -0,0 +1,112 @@
+#include "preferences/colorpaletteeditormodel.h"
+
+namespace {
+
+QIcon toQIcon(const QColor& color) {
+    QPixmap pixmap(50, 50);
+    pixmap.fill(color);
+    return QIcon(pixmap);
+}
+
+} // namespace
+
+bool ColorPaletteEditorModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) {
+    // Always move the entire row, and don't allow column "shifting"
+    Q_UNUSED(column);
+    return QStandardItemModel::dropMimeData(data, action, row, 0, parent);
+}
+
+bool ColorPaletteEditorModel::setData(const QModelIndex& modelIndex, const QVariant& value, int role) {
+    if (modelIndex.isValid() && modelIndex.column() == 1) {
+        bool ok;
+        int hotcueIndex = value.toInt(&ok);
+
+        // Make sure that the value is valid
+        if (!ok || hotcueIndex <= 0 || hotcueIndex > rowCount()) {
+            return QStandardItemModel::setData(modelIndex, QVariant(), role);
+        }
+
+        // Make sure there is no other row with the same hotcue index
+        for (int i = 0; i < rowCount(); i++) {
+            QModelIndex otherModelIndex = index(i, 1);
+            QVariant otherValue = data(otherModelIndex);
+            int otherHotcueIndex = otherValue.toInt(&ok);
+            if (ok && otherHotcueIndex == hotcueIndex) {
+                QStandardItemModel::setData(otherModelIndex, QVariant(), role);
+            }
+        }
+    }
+
+    return QStandardItemModel::setData(modelIndex, value, role);
+}
+
+void ColorPaletteEditorModel::setColor(int row, const QColor& color) {
+    QStandardItem* pItem = item(row, 0);
+    if (pItem) {
+        pItem->setIcon(toQIcon(color));
+        pItem->setText(color.name());
+    }
+}
+
+void ColorPaletteEditorModel::setHotcueIndex(int row, int hotcueIndex) {
+    QStandardItem* pItem = item(row, 1);
+    if (pItem) {
+        pItem->setText(QString::number(hotcueIndex));
+    }
+}
+
+void ColorPaletteEditorModel::appendRow(const QColor& color, int hotcueIndex) {
+    QStandardItem* pColorItem = new QStandardItem(toQIcon(color), color.name());
+    pColorItem->setEditable(false);
+    pColorItem->setDropEnabled(false);
+
+    QString hotcueIndexStr;
+    if (hotcueIndex >= 0) {
+        hotcueIndexStr = QString::number(hotcueIndex + 1);
+    }
+
+    QStandardItem* pHotcueIndexItem = new QStandardItem(hotcueIndexStr);
+    pHotcueIndexItem->setEditable(true);
+    pHotcueIndexItem->setDropEnabled(false);
+
+    QStandardItemModel::appendRow(QList<QStandardItem*>{pColorItem, pHotcueIndexItem});
+}
+
+void ColorPaletteEditorModel::setColorPalette(const ColorPalette& palette) {
+    // Remove all rows
+    removeRows(0, rowCount());
+
+    // Make a map of hotcue indices
+    QMap<int, int> hotcueColorIndicesMap;
+    QList<unsigned int> hotcueColorIndices = palette.getHotcueIndices();
+    for (int i = 0; i < hotcueColorIndices.size(); i++) {
+        int colorIndex = hotcueColorIndices.at(i);
+        hotcueColorIndicesMap.insert(colorIndex, i);
+    }
+
+    for (int i = 0; i < palette.size(); i++) {
+        QColor color = mixxx::RgbColor::toQColor(palette.at(i));
+        int colorIndex = hotcueColorIndicesMap.value(i, kNoHotcueIndex);
+        appendRow(color, colorIndex);
+    }
+}
+
+ColorPalette ColorPaletteEditorModel::getColorPalette(const QString& name) const {
+    QList<mixxx::RgbColor> colors;
+    QMap<int, unsigned int> hotcueColorIndices;
+    for (int i = 0; i < rowCount(); i++) {
+        QStandardItem* pColorItem = item(i, 0);
+        QStandardItem* pHotcueIndexItem = item(i, 1);
+        mixxx::RgbColor::optional_t color = mixxx::RgbColor::fromQString(pColorItem->text());
+        if (color) {
+            colors << *color;
+
+            bool ok;
+            int hotcueIndex = pHotcueIndexItem->text().toInt(&ok);
+            if (ok) {
+                hotcueColorIndices.insert(hotcueIndex - 1, colors.size() - 1);
+            }
+        }
+    }
+    return ColorPalette(name, colors, hotcueColorIndices.values());
+}

src/preferences/colorpaletteeditormodel.h

@@ -0,0 +1,27 @@
+#pragma once
+#include <QStandardItemModel>
+
+#include "util/color/colorpalette.h"
+
+class ColorPaletteEditorModel : public QStandardItemModel {
+    Q_OBJECT
+  public:
+    static constexpr int kNoHotcueIndex = -1;
+
+    ColorPaletteEditorModel(int rows, int columns, QObject* parent = nullptr)
+            : QStandardItemModel(rows, columns, parent) {
+    }
+    ColorPaletteEditorModel(QObject* parent = nullptr)
+            : QStandardItemModel(parent) {
+    }
+
+    bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) override;
+    bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole);
+
+    void setColor(int row, const QColor& color);
+    void setHotcueIndex(int row, int hotcueIndex);
+    void appendRow(const QColor& color, int hotcueIndex = kNoHotcueIndex);
+
+    void setColorPalette(const ColorPalette& palette);
+    ColorPalette getColorPalette(const QString& name) const;
+};

src/preferences/colorpaletteeditortableview.cpp

@@ -6,13 +6,7 @@
 
 namespace {
 const QColor kDefaultPaletteColor(0, 0, 0);
-
-QIcon toQIcon(const QColor& color) {
-    QPixmap pixmap(50, 50);
-    pixmap.fill(color);
-    return QIcon(pixmap);
 }
-} // namespace
 
 ColorPaletteEditorTableView::ColorPaletteEditorTableView(QWidget* parent)
         : QTableView(parent),
@@ -24,9 +18,12 @@ ColorPaletteEditorTableView::ColorPaletteEditorTableView(QWidget* parent)
     setDragDropMode(QAbstractItemView::InternalMove);
     setDragDropOverwriteMode(false);
     setContextMenuPolicy(Qt::CustomContextMenu);
-    horizontalHeader()->setVisible(false);
+
     // Set our custom model - this prevents row "shifting"
     setModel(m_model);
+    m_model->setColumnCount(2);
+    m_model->setHeaderData(0, Qt::Horizontal, tr("Color"), Qt::DisplayRole);
+    m_model->setHeaderData(1, Qt::Horizontal, tr("Assign to Hotcue"), Qt::DisplayRole);
 
     connect(m_model,
             &ColorPaletteEditorModel::rowsMoved,
@@ -46,14 +43,13 @@ ColorPaletteEditorTableView::ColorPaletteEditorTableView(QWidget* parent)
     connect(this,
             &ColorPaletteEditorTableView::doubleClicked,
             [this](const QModelIndex& index) {
-                QStandardItem* item = m_model->itemFromIndex(index);
-                if (!item) {
-                    return;
+                if (index.isValid() && index.column() == 0) {
+                    QColor color = QColorDialog::getColor();
+                    if (color.isValid()) {
+                        m_model->setColor(index.row(), color);
+                        setDirty(true);
+                    }
                 }
-                QColor color = QColorDialog::getColor();
-                item->setIcon(toQIcon(color));
-                item->setText(color.name());
-                setDirty(true);
             });
     connect(this, &ColorPaletteEditorTableView::customContextMenuRequested, [this](const QPoint& pos) {
         QMenu menu(this);
@@ -62,11 +58,7 @@ ColorPaletteEditorTableView::ColorPaletteEditorTableView(QWidget* parent)
         QAction* pRemoveAction = menu.addAction("Remove");
         QAction* pAction = menu.exec(viewport()->mapToGlobal(pos));
         if (pAction == pAddAction) {
-            QStandardItem* item = new QStandardItem(
-                    toQIcon(kDefaultPaletteColor), kDefaultPaletteColor.name());
-            item->setEditable(false);
-            item->setDropEnabled(false);
-            m_model->appendRow(item);
+            m_model->appendRow(kDefaultPaletteColor);
         } else if (pAction == pRemoveAction) {
             QModelIndexList selection = selectionModel()->selectedRows();
 
@@ -80,30 +72,11 @@ ColorPaletteEditorTableView::ColorPaletteEditorTableView(QWidget* parent)
         }
     });
 }
-
-void ColorPaletteEditorTableView::setColors(const QList<mixxx::RgbColor>& colors) {
-    m_model->clear();
-    foreach (const mixxx::RgbColor rgbColor, colors) {
-        QColor color = mixxx::RgbColor::toQColor(rgbColor);
-        QIcon icon = toQIcon(color);
-        QString colorName = color.name();
-
-        QStandardItem* item = new QStandardItem(icon, colorName);
-        item->setEditable(false);
-        item->setDropEnabled(false);
-        m_model->appendRow(item);
-    }
+void ColorPaletteEditorTableView::setColorPalette(const ColorPalette& palette) {
+    m_model->setColorPalette(palette);
     setDirty(false);
 }
 
-QList<mixxx::RgbColor> ColorPaletteEditorTableView::getColors() const {
-    QList<mixxx::RgbColor> colors;
-    for (int i = 0; i < m_model->rowCount(); i++) {
-        QStandardItem* item = m_model->item(i, 0);
-        mixxx::RgbColor::optional_t color = mixxx::RgbColor::fromQString(item->text());
-        if (color) {
-            colors << *color;
-        }
-    }
-    return colors;
+ColorPalette ColorPaletteEditorTableView::getColorPalette(const QString& name) const {
+    return m_model->getColorPalette(name);
 }

src/preferences/colorpaletteeditortableview.h

@@ -1,25 +1,8 @@
 #pragma once
-#include <QStandardItemModel>
 #include <QTableView>
 
-#include "util/color/rgbcolor.h"
-
-class ColorPaletteEditorModel : public QStandardItemModel {
-    Q_OBJECT
-  public:
-    ColorPaletteEditorModel(int rows, int columns, QObject* parent = nullptr)
-            : QStandardItemModel(rows, columns, parent) {
-    }
-    ColorPaletteEditorModel(QObject* parent = nullptr)
-            : QStandardItemModel(parent) {
-    }
-
-    bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) override {
-        // Always move the entire row, and don't allow column "shifting"
-        Q_UNUSED(column);
-        return QStandardItemModel::dropMimeData(data, action, row, 0, parent);
-    }
-};
+#include "preferences/colorpaletteeditormodel.h"
+#include "util/color/colorpalette.h"
 
 class ColorPaletteEditorTableView : public QTableView {
     Q_OBJECT
@@ -42,8 +25,8 @@ class ColorPaletteEditorTableView : public QTableView {
         return m_bDirty;
     }
 
-    QList<mixxx::RgbColor> getColors() const;
-    void setColors(const QList<mixxx::RgbColor>& colors);
+    ColorPalette getColorPalette(const QString& name) const;
+    void setColorPalette(const ColorPalette& palette);
 
   signals:
     void dirtyChanged(bool bDirty);