Add ability to edit game-specific GFX settings from game properties tab.

Source/Core/DolphinQt/CMakeLists.txt

@@ -52,6 +52,7 @@ add_executable(dolphin-emu
   Config/ConfigControls/ConfigBool.h
   Config/ConfigControls/ConfigChoice.cpp
   Config/ConfigControls/ConfigChoice.h
+	Config/ConfigControls/ConfigControl.h
   Config/ConfigControls/ConfigInteger.cpp
   Config/ConfigControls/ConfigInteger.h
   Config/ConfigControls/ConfigRadio.cpp

Source/Core/DolphinQt/Config/ConfigControls/ConfigBool.cpp

@@ -3,31 +3,28 @@
 
 #include "DolphinQt/Config/ConfigControls/ConfigBool.h"
 
-#include <QEvent>
-#include <QFont>
-#include <QSignalBlocker>
-
-#include "Common/Config/Config.h"
-
-#include "DolphinQt/Settings.h"
-
 ConfigBool::ConfigBool(const QString& label, const Config::Info<bool>& setting, bool reverse)
-    : ToolTipCheckBox(label), m_setting(setting), m_reverse(reverse)
+    : ConfigBool(label, setting, nullptr, reverse)
 {
-  connect(this, &QCheckBox::toggled, this, &ConfigBool::Update);
-  setChecked(Config::Get(m_setting) ^ reverse);
+}
 
-  connect(&Settings::Instance(), &Settings::ConfigChanged, this, [this] {
-    QFont bf = font();
-    bf.setBold(Config::GetActiveLayerForConfig(m_setting) != Config::LayerType::Base);
-    setFont(bf);
+ConfigBool::ConfigBool(const QString& label, const Config::Info<bool>& setting,
+                       Config::Layer* layer, bool reverse)
+    : ConfigControl(label, setting.GetLocation(), layer), m_setting(setting), m_reverse(reverse)
+{
+  setChecked(ReadValue(setting) ^ reverse);
 
-    const QSignalBlocker blocker(this);
-    setChecked(Config::Get(m_setting) ^ m_reverse);
-  });
+  connect(this, &QCheckBox::toggled, this, &ConfigBool::Update);
 }
 
 void ConfigBool::Update()
 {
-  Config::SetBaseOrCurrent(m_setting, static_cast<bool>(isChecked() ^ m_reverse));
+  const bool value = static_cast<bool>(isChecked() ^ m_reverse);
+
+  SaveValue(m_setting, value);
+}
+
+void ConfigBool::OnConfigChanged()
+{
+  setChecked(ReadValue(m_setting) ^ m_reverse);
 }

Source/Core/DolphinQt/Config/ConfigControls/ConfigBool.h

@@ -2,20 +2,25 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
-
+#include "DolphinQt/Config/ConfigControls/ConfigControl.h"
 #include "DolphinQt/Config/ToolTipControls/ToolTipCheckBox.h"
 
 namespace Config
 {
 template <typename T>
 class Info;
-}
+}  // namespace Config
 
-class ConfigBool : public ToolTipCheckBox
+class ConfigBool final : public ConfigControl<ToolTipCheckBox>
 {
   Q_OBJECT
 public:
   ConfigBool(const QString& label, const Config::Info<bool>& setting, bool reverse = false);
+  ConfigBool(const QString& label, const Config::Info<bool>& setting, Config::Layer* layer,
+             bool reverse = false);
+
+protected:
+  void OnConfigChanged() override;
 
 private:
   void Update();

Source/Core/DolphinQt/Config/ConfigControls/ConfigChoice.cpp

@@ -2,88 +2,71 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "DolphinQt/Config/ConfigControls/ConfigChoice.h"
-
 #include <QSignalBlocker>
 
-#include "Common/Config/Config.h"
-
-#include "DolphinQt/Settings.h"
-
-ConfigChoice::ConfigChoice(const QStringList& options, const Config::Info<int>& setting)
-    : m_setting(setting)
+ConfigChoice::ConfigChoice(const QStringList& options, const Config::Info<int>& setting,
+                           Config::Layer* layer)
+    : ConfigControl(setting.GetLocation(), layer), m_setting(setting)
 {
   addItems(options);
-  connect(this, &QComboBox::currentIndexChanged, this, &ConfigChoice::Update);
-  setCurrentIndex(Config::Get(m_setting));
-
-  connect(&Settings::Instance(), &Settings::ConfigChanged, this, [this] {
-    QFont bf = font();
-    bf.setBold(Config::GetActiveLayerForConfig(m_setting) != Config::LayerType::Base);
-    setFont(bf);
+  setCurrentIndex(ReadValue(setting));
 
-    const QSignalBlocker blocker(this);
-    setCurrentIndex(Config::Get(m_setting));
-  });
+  connect(this, &QComboBox::currentIndexChanged, this, &ConfigChoice::Update);
 }
 
 void ConfigChoice::Update(int choice)
 {
-  Config::SetBaseOrCurrent(m_setting, choice);
+  SaveValue(m_setting, choice);
+}
+
+void ConfigChoice::OnConfigChanged()
+{
+  setCurrentIndex(ReadValue(m_setting));
 }
 
 ConfigStringChoice::ConfigStringChoice(const std::vector<std::string>& options,
-                                       const Config::Info<std::string>& setting)
-    : m_setting(setting), m_text_is_data(true)
+                                       const Config::Info<std::string>& setting,
+                                       Config::Layer* layer)
+    : ConfigControl(setting.GetLocation(), layer), m_setting(setting), m_text_is_data(true)
 {
   for (const auto& op : options)
     addItem(QString::fromStdString(op));
 
-  Connect();
   Load();
+  connect(this, &QComboBox::currentIndexChanged, this, &ConfigStringChoice::Update);
 }
 
 ConfigStringChoice::ConfigStringChoice(const std::vector<std::pair<QString, QString>>& options,
-                                       const Config::Info<std::string>& setting)
-    : m_setting(setting), m_text_is_data(false)
+                                       const Config::Info<std::string>& setting,
+                                       Config::Layer* layer)
+    : ConfigControl(setting.GetLocation(), layer), m_setting(setting), m_text_is_data(false)
 {
   for (const auto& [option_text, option_data] : options)
     addItem(option_text, option_data);
 
-  Connect();
-  Load();
-}
-
-void ConfigStringChoice::Connect()
-{
-  const auto on_config_changed = [this]() {
-    QFont bf = font();
-    bf.setBold(Config::GetActiveLayerForConfig(m_setting) != Config::LayerType::Base);
-    setFont(bf);
-
-    Load();
-  };
-
-  connect(&Settings::Instance(), &Settings::ConfigChanged, this, on_config_changed);
   connect(this, &QComboBox::currentIndexChanged, this, &ConfigStringChoice::Update);
+  Load();
 }
 
 void ConfigStringChoice::Update(int index)
 {
   if (m_text_is_data)
-  {
-    Config::SetBaseOrCurrent(m_setting, itemText(index).toStdString());
-  }
+    SaveValue(m_setting, itemText(index).toStdString());
   else
-  {
-    Config::SetBaseOrCurrent(m_setting, itemData(index).toString().toStdString());
-  }
+    SaveValue(m_setting, itemData(index).toString().toStdString());
 }
 
 void ConfigStringChoice::Load()
 {
-  const QString setting_value = QString::fromStdString(Config::Get(m_setting));
-
+  const QString setting_value = QString::fromStdString(ReadValue(m_setting));
   const int index = m_text_is_data ? findText(setting_value) : findData(setting_value);
-  const QSignalBlocker blocker(this);
+
+  // This can be called publicly.
+  const QSignalBlocker block(this);
   setCurrentIndex(index);
 }
+
+void ConfigStringChoice::OnConfigChanged()
+{
+  Load();
+}

Source/Core/DolphinQt/Config/ConfigControls/ConfigChoice.h

@@ -7,35 +7,47 @@
 #include <utility>
 #include <vector>
 
+#include "DolphinQt/Config/ConfigControls/ConfigControl.h"
 #include "DolphinQt/Config/ToolTipControls/ToolTipComboBox.h"
 
-#include "Common/Config/Config.h"
+namespace Config
+{
+template <typename T>
+class Info;
+}  // namespace Config
 
-class ConfigChoice : public ToolTipComboBox
+class ConfigChoice : public ConfigControl<ToolTipComboBox>
 {
   Q_OBJECT
 public:
-  ConfigChoice(const QStringList& options, const Config::Info<int>& setting);
+  ConfigChoice(const QStringList& options, const Config::Info<int>& setting,
+               Config::Layer* layer = nullptr);
+
+protected:
+  void OnConfigChanged() override;
 
 private:
   void Update(int choice);
 
   Config::Info<int> m_setting;
+  Config::Layer* m_layer = nullptr;
 };
 
-class ConfigStringChoice : public ToolTipComboBox
+class ConfigStringChoice : public ConfigControl<ToolTipComboBox>
 {
   Q_OBJECT
 public:
   ConfigStringChoice(const std::vector<std::string>& options,
-                     const Config::Info<std::string>& setting);
+                     const Config::Info<std::string>& setting, Config::Layer* layer = nullptr);
   ConfigStringChoice(const std::vector<std::pair<QString, QString>>& options,
-                     const Config::Info<std::string>& setting);
+                     const Config::Info<std::string>& setting, Config::Layer* layer = nullptr);
+  void Load();
+
+protected:
+  void OnConfigChanged() override;
 
 private:
-  void Connect();
   void Update(int index);
-  void Load();
 
   Config::Info<std::string> m_setting;
   bool m_text_is_data = false;

Source/Core/DolphinQt/Config/ConfigControls/ConfigControl.h

@@ -0,0 +1,104 @@
+// Copyright 2024 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <QFont>
+#include <QMouseEvent>
+#include <QSignalBlocker>
+
+#include "DolphinQt/Settings.h"
+
+namespace Config
+{
+template <typename T>
+class Info;
+class Layer;
+struct Location;
+}  // namespace Config
+
+template <class Derived>
+class ConfigControl : public Derived
+{
+public:
+  ConfigControl(const Config::Location& location, Config::Layer* layer)
+      : m_location(location), m_layer(layer)
+  {
+    ConnectConfig();
+  }
+  ConfigControl(const QString& label, const Config::Location& location, Config::Layer* layer)
+      : Derived(label), m_location(location), m_layer(layer)
+  {
+    ConnectConfig();
+  }
+  ConfigControl(const Qt::Orientation& orient, const Config::Location& location,
+                Config::Layer* layer)
+      : Derived(orient), m_location(location), m_layer(layer)
+  {
+    ConnectConfig();
+  }
+
+  const Config::Location GetLocation() const { return m_location; }
+
+protected:
+  void ConnectConfig()
+  {
+    Derived::connect(&Settings::Instance(), &Settings::ConfigChanged, this, [this] {
+      QFont bf = Derived::font();
+      bf.setBold(IsConfigLocal());
+      Derived::setFont(bf);
+
+      const QSignalBlocker blocker(this);
+      OnConfigChanged();
+    });
+  }
+
+  template <typename T>
+  void SaveValue(const Config::Info<T>& setting, const T& value)
+  {
+    if (m_layer != nullptr)
+    {
+      m_layer->Set(m_location, value);
+      Config::OnConfigChanged();
+      return;
+    }
+
+    Config::SetBaseOrCurrent(setting, value);
+  }
+
+  template <typename T>
+  const T ReadValue(const Config::Info<T>& setting) const
+  {
+    if (m_layer != nullptr)
+      return m_layer->Get(setting);
+
+    return Config::Get(setting);
+  }
+
+  virtual void OnConfigChanged(){};
+
+private:
+  bool IsConfigLocal() const
+  {
+    if (m_layer != nullptr)
+      return m_layer->Exists(m_location);
+    else
+      return Config::GetActiveLayerForConfig(m_location) != Config::LayerType::Base;
+  }
+
+  void mousePressEvent(QMouseEvent* event) override
+  {
+    if (m_layer != nullptr && event->button() == Qt::RightButton)
+    {
+      m_layer->DeleteKey(m_location);
+      Config::OnConfigChanged();
+    }
+    else
+    {
+      Derived::mousePressEvent(event);
+    }
+  }
+
+  const Config::Location m_location;
+  Config::Layer* m_layer;
+};