moved color stuff to ColorTable, now shows sample text and icons

1 files changed, 278 insertions, 0 deletions

diff --git a/src/colortable.cpp b/src/colortable.cpp
new file mode 100644
index 00000000..7546abe5
--- /dev/null
+++ b/src/colortable.cpp
@@ -0,0 +1,278 @@
+#include "colortable.h"
+#include "modflagicondelegate.h"
+#include "settings.h"
+
+class ColorItem;
+ColorItem* colorItemForRow(QTableWidget* table, int row);
+
+void paintBackground(
+  QTableWidget* table, QPainter* p, const QStyleOptionViewItem& option,
+  const QModelIndex& index);
+
+
+class ColoredBackgroundDelegate : public QStyledItemDelegate
+{
+public:
+  ColoredBackgroundDelegate(QTableWidget* table)
+    : m_table(table)
+  {
+  }
+
+  void paint(
+    QPainter* p, const QStyleOptionViewItem& option,
+    const QModelIndex& index) const override
+  {
+    paintBackground(m_table, p, option, index);
+
+    QStyleOptionViewItem itemOption(option);
+    initStyleOption(&itemOption, index);
+    itemOption.state = QStyle::State_Enabled;
+
+    QStyledItemDelegate::paint(p, itemOption, index);
+  }
+
+private:
+  QTableWidget* m_table;
+};
+
+
+class FakeModFlagIconDelegate : public ModFlagIconDelegate
+{
+public:
+  explicit FakeModFlagIconDelegate(QTableWidget* table)
+    : m_table(table)
+  {
+  }
+
+  void paint(
+    QPainter *painter, const QStyleOptionViewItem &option,
+    const QModelIndex &index) const override
+  {
+    paintBackground(m_table, painter, option, index);
+    ModFlagIconDelegate::paintIcons(painter, option, index, getIcons(index));
+  }
+
+protected:
+  QList<QString> getIcons(const QModelIndex &index) const override
+  {
+    const auto flags = {
+      ModInfo::FLAG_CONFLICT_MIXED,
+      ModInfo::FLAG_ARCHIVE_LOOSE_CONFLICT_OVERWRITE,
+      ModInfo::FLAG_ARCHIVE_LOOSE_CONFLICT_OVERWRITTEN,
+      ModInfo::FLAG_ARCHIVE_CONFLICT_MIXED,
+      ModInfo::FLAG_BACKUP,
+      ModInfo::FLAG_NOTENDORSED,
+      ModInfo::FLAG_NOTES,
+      ModInfo::FLAG_ALTERNATE_GAME
+    };
+
+    return getIconsForFlags(flags, false);
+  }
+
+  size_t getNumIcons(const QModelIndex &index) const override
+  {
+    return getIcons(index).size();
+  }
+
+private:
+  QTableWidget* m_table;
+};
+
+
+class ColorItem : public QTableWidgetItem
+{
+public:
+  ColorItem(
+    QString caption, QColor defaultColor,
+    std::function<QColor ()> get,
+    std::function<void (const QColor&)> commit) :
+      m_caption(std::move(caption)), m_default(defaultColor),
+      m_get(get), m_commit(commit)
+  {
+    setText(m_caption);
+    set(get());
+  }
+
+  const QString& caption() const
+  {
+    return m_caption;
+  }
+
+  QColor get() const
+  {
+    return m_temp;
+  }
+
+  bool set(const QColor& c)
+  {
+    if (m_temp != c) {
+      m_temp = c;
+      return true;
+    }
+
+    return false;
+  }
+
+  void commit()
+  {
+    m_commit(m_temp);
+  }
+
+  bool reset()
+  {
+    return set(m_default);
+  }
+
+private:
+  const QString m_caption;
+  const QColor m_default;
+  std::function<QColor ()> m_get;
+  std::function<void (const QColor&)> m_commit;
+  QColor m_temp;
+};
+
+
+ColorItem* colorItemForRow(QTableWidget* table, int row)
+{
+  return dynamic_cast<ColorItem*>(table->item(row, 0));
+}
+
+template <class F>
+void forEachColorItem(QTableWidget* table, F&& f)
+{
+  const auto rowCount = table->rowCount();
+
+  for (int i=0; i<rowCount; ++i) {
+    if (auto* ci=colorItemForRow(table, i)) {
+      f(ci);
+    }
+  }
+}
+
+void paintBackground(
+  QTableWidget* table, QPainter* p, const QStyleOptionViewItem& option,
+  const QModelIndex& index)
+{
+  if (auto* ci=colorItemForRow(table, index.row())) {
+    p->save();
+    p->fillRect(option.rect, ci->get());
+    p->restore();
+  }
+}
+
+
+ColorTable::ColorTable(QWidget* parent)
+  : QTableWidget(parent), m_settings(nullptr)
+{
+  setColumnCount(3);
+  setHorizontalHeaderLabels({"", "", ""});
+
+  setItemDelegateForColumn(1, new ColoredBackgroundDelegate(this));
+  setItemDelegateForColumn(2, new FakeModFlagIconDelegate(this));
+
+  connect(
+    this, &QTableWidget::cellActivated,
+    [&]{ onColorActivated(); });
+}
+
+void ColorTable::load(Settings& s)
+{
+  m_settings = &s;
+
+  addColor(
+    QObject::tr("Is overwritten (loose files)"),
+    QColor(0, 255, 0, 64),
+    [this]{ return m_settings->colors().modlistOverwrittenLoose(); },
+    [this](auto&& v){ m_settings->colors().setModlistOverwrittenLoose(v); });
+
+  addColor(
+    QObject::tr("Is overwriting (loose files)"),
+    QColor(255, 0, 0, 64),
+    [this]{ return m_settings->colors().modlistOverwritingLoose(); },
+    [this](auto&& v){ m_settings->colors().setModlistOverwritingLoose(v); });
+
+  addColor(
+    QObject::tr("Is overwritten (archives)"),
+    QColor(0, 255, 255, 64),
+    [this]{ return m_settings->colors().modlistOverwrittenArchive(); },
+    [this](auto&& v){ m_settings->colors().setModlistOverwrittenArchive(v); });
+
+  addColor(
+    QObject::tr("Is overwriting (archives)"),
+    QColor(255, 0, 255, 64),
+    [this]{ return m_settings->colors().modlistOverwritingArchive(); },
+    [this](auto&& v){ m_settings->colors().setModlistOverwritingArchive(v); });
+
+  addColor(
+    QObject::tr("Mod contains selected plugin"),
+    QColor(0, 0, 255, 64),
+    [this]{ return m_settings->colors().modlistContainsPlugin(); },
+    [this](auto&& v){ m_settings->colors().setModlistContainsPlugin(v); });
+
+  addColor(
+    QObject::tr("Plugin is contained in selected mod"),
+    QColor(0, 0, 255, 64),
+    [this]{ return m_settings->colors().pluginListContained(); },
+    [this](auto&& v){ m_settings->colors().setPluginListContained(v); });
+}
+
+void ColorTable::resetColors()
+{
+  bool changed = false;
+
+  forEachColorItem(this, [&](auto* item) {
+    if (item->reset()) {
+      changed = true;
+    }
+  });
+
+  if (changed) {
+    update();
+  }
+}
+
+void ColorTable::commitColors()
+{
+  forEachColorItem(this, [](auto* item) {
+    item->commit();
+  });
+}
+
+void ColorTable::addColor(
+  const QString& text, const QColor& defaultColor,
+  std::function<QColor ()> get,
+  std::function<void (const QColor&)> commit)
+{
+  const auto r = rowCount();
+  setRowCount(r + 1);
+
+  auto* item = new ColorItem(text, defaultColor, get, commit);
+
+  setItem(r, 0, item);
+  setItem(r, 1, new QTableWidgetItem("Text"));
+  setItem(r, 2, new QTableWidgetItem);
+
+  resizeColumnsToContents();
+}
+
+void ColorTable::onColorActivated()
+{
+  const auto rows = selectionModel()->selectedRows();
+  if (rows.isEmpty()) {
+    return;
+  }
+
+  const auto row = rows[0].row();
+  auto* ci = colorItemForRow(this, row);
+  if (!ci) {
+    return;
+  }
+
+  const QColor result = QColorDialog::getColor(
+    ci->get(), topLevelWidget(), ci->caption(), QColorDialog::ShowAlphaChannel);
+
+  if (result.isValid()) {
+    ci->set(result);
+    update(model()->index(row, 1));
+  }
+}