* GUI Video-Settings changes:

  - Removed recent ghanges about separate per-game Video Settings
  - Added "One Window 3-State Support" (very close to full implementation)

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@7391 8ced0084-cf51-0410-be5f-012b33b47a6e

11 files changed, 925 insertions, 548 deletions

diff --git a/Source/Core/Common/Src/VideoBackendBase.cpp b/Source/Core/Common/Src/VideoBackendBase.cpp
index 1c77ec7c9b..1fbe0f4a41 100644
--- a/Source/Core/Common/Src/VideoBackendBase.cpp
+++ b/Source/Core/Common/Src/VideoBackendBase.cpp
@@ -16,7 +16,6 @@
 // http://code.google.com/p/dolphin-emu/
 
 #include "VideoBackendBase.h"
-#include "../../VideoCommon/Src/VideoConfig.h"
 
 // TODO: ugly
 #ifdef _WIN32
@@ -74,13 +73,3 @@ void VideoBackend::ActivateBackend(const std::string& name)
 		if (name == (*it)->GetName())
 			g_video_backend = *it;
 }
-
-void VideoBackend::LoadConfig()
-{
-	g_Config.Load(((File::GetUserPath(D_CONFIG_IDX) + ini_name) + ".ini").c_str());
-}
-
-void VideoBackend::SaveConfig()
-{
-	g_Config.Save(((File::GetUserPath(D_CONFIG_IDX) + ini_name) + ".ini").c_str());
-}
diff --git a/Source/Core/Common/Src/VideoBackendBase.h b/Source/Core/Common/Src/VideoBackendBase.h
index 4e2690911f..667a3d3a32 100644
--- a/Source/Core/Common/Src/VideoBackendBase.h
+++ b/Source/Core/Common/Src/VideoBackendBase.h
@@ -83,10 +83,6 @@ struct SCPFifoStruct
 class VideoBackend
 {
 public:
-	const char* const ini_name;
-
-	VideoBackend(const char* _ini_name) : ini_name(_ini_name) {}
-
 	virtual ~VideoBackend() {}
 
 	virtual void EmuStateChange(EMUSTATE_CHANGE) = 0;
@@ -131,9 +127,6 @@ public:
 	virtual writeFn16 Video_PEWrite16() = 0;
 	virtual writeFn32 Video_PEWrite32() = 0;
 
-	void LoadConfig();
-	void SaveConfig();
-
 	static void PopulateList();
 	static void ClearList();
 	static void ActivateBackend(const std::string& name);
@@ -145,9 +138,6 @@ extern VideoBackend* g_video_backend;
 // inherited by dx9/dx11/ogl backends
 class VideoBackendHardware : public VideoBackend
 {
-protected:
-	VideoBackendHardware(const char* _ini_name) : VideoBackend(_ini_name) {}
-
 	void DoState(PointerWrap &p);
 	void RunLoop(bool enable);
 
diff --git a/Source/Core/DolphinWX/Src/ConfigMain.cpp b/Source/Core/DolphinWX/Src/ConfigMain.cpp
index f2c32ad847..73605f7783 100644
--- a/Source/Core/DolphinWX/Src/ConfigMain.cpp
+++ b/Source/Core/DolphinWX/Src/ConfigMain.cpp
@@ -1377,11 +1377,7 @@ void CConfigMain::OnSelectionChanged(wxCommandEvent& ev)
 void CConfigMain::OnConfig(wxCommandEvent&)
 {
 	if (g_video_backend)
-	{
-		g_video_backend->LoadConfig();
 		g_video_backend->ShowConfig(this);
-		g_video_backend->SaveConfig();
-	}
 }
 
 // Search for avaliable resolutions
diff --git a/Source/Core/DolphinWX/Src/FrameTools.cpp b/Source/Core/DolphinWX/Src/FrameTools.cpp
index 86436244c4..0ed693da50 100644
--- a/Source/Core/DolphinWX/Src/FrameTools.cpp
+++ b/Source/Core/DolphinWX/Src/FrameTools.cpp
@@ -1161,11 +1161,7 @@ void CFrame::OnConfigMain(wxCommandEvent& WXUNUSED (event))
 void CFrame::OnConfigGFX(wxCommandEvent& WXUNUSED (event))
 {
 	if (g_video_backend)
-	{
-		g_video_backend->LoadConfig();
 		g_video_backend->ShowConfig(this);
-		g_video_backend->SaveConfig();
-	}
 }
 
 void CFrame::OnConfigDSP(wxCommandEvent& WXUNUSED (event))
diff --git a/Source/Core/DolphinWX/Src/GameListCtrl.cpp b/Source/Core/DolphinWX/Src/GameListCtrl.cpp
index 513c1ed679..6d4a8d15d3 100644
--- a/Source/Core/DolphinWX/Src/GameListCtrl.cpp
+++ b/Source/Core/DolphinWX/Src/GameListCtrl.cpp
@@ -29,7 +29,6 @@
 #include "Blob.h"
 #include "Core.h"
 #include "ISOProperties.h"
-#include "VideoConfigDiag.h"
 #include "IniFile.h"
 #include "FileUtil.h"
 #include "CDUtils.h"
@@ -125,7 +124,6 @@ BEGIN_EVENT_TABLE(CGameListCtrl, wxListCtrl)
 	EVT_LIST_COL_BEGIN_DRAG(LIST_CTRL, CGameListCtrl::OnColBeginDrag)
 	EVT_LIST_COL_CLICK(LIST_CTRL, CGameListCtrl::OnColumnClick)
 	EVT_MENU(IDM_PROPERTIES, CGameListCtrl::OnProperties)
-	EVT_MENU(IDM_GAMEVIDEOCONFIG, CGameListCtrl::OnGameVideoConfig)
 	EVT_MENU(IDM_GAMEWIKI, CGameListCtrl::OnWiki)
 	EVT_MENU(IDM_OPENCONTAININGFOLDER, CGameListCtrl::OnOpenContainingFolder)
 	EVT_MENU(IDM_OPENSAVEFOLDER, CGameListCtrl::OnOpenSaveFolder)
@@ -1001,7 +999,6 @@ void CGameListCtrl::OnRightClick(wxMouseEvent& event)
 		{
 			wxMenu* popupMenu = new wxMenu;
 			popupMenu->Append(IDM_PROPERTIES, _("&Properties"));
-			popupMenu->Append(IDM_GAMEVIDEOCONFIG, _("&Graphics Configuration"));
 			popupMenu->Append(IDM_GAMEWIKI, _("&Wiki"));
 			popupMenu->AppendSeparator();
 
@@ -1170,31 +1167,6 @@ void CGameListCtrl::OnProperties(wxCommandEvent& WXUNUSED (event))
 		Update();
 }
 
-void CGameListCtrl::OnGameVideoConfig(wxCommandEvent&)
-{
-	const GameListItem* const iso = GetSelectedISO();
-	if (!iso)
-		return;
-
-	VideoConfig const vc = g_Config;
-
-	g_Config.SetAllUndetermined();
-
-	// ugly
-	DiscIO::IVolume* const open_iso = DiscIO::CreateVolumeFromFilename(iso->GetFileName());
-	std::string const unique_id = open_iso->GetUniqueID();
-	std::string const ini_path = File::GetUserPath(D_GAMECONFIG_IDX) + unique_id + ".ini";
-	g_Config.GameIniLoad(ini_path.c_str());
-	delete open_iso;
-
-	VideoConfigDiag vcd(this, unique_id, true);
-	vcd.ShowModal();
-
-	g_Config.GameIniSave(ini_path.c_str());
-
-	g_Config = vc;
-}
-
 void CGameListCtrl::OnWiki(wxCommandEvent& WXUNUSED (event))
 {
 	const GameListItem *iso = GetSelectedISO();
diff --git a/Source/Core/DolphinWX/Src/GameListCtrl.h b/Source/Core/DolphinWX/Src/GameListCtrl.h
index 65c399b818..8a9a993140 100644
--- a/Source/Core/DolphinWX/Src/GameListCtrl.h
+++ b/Source/Core/DolphinWX/Src/GameListCtrl.h
@@ -98,7 +98,6 @@ private:
 	void OnKeyPress(wxListEvent& event);
 	void OnSize(wxSizeEvent& event);
 	void OnProperties(wxCommandEvent& event);
-	void OnGameVideoConfig(wxCommandEvent&);
 	void OnWiki(wxCommandEvent& event);
 	void OnOpenContainingFolder(wxCommandEvent& event);
 	void OnOpenSaveFolder(wxCommandEvent& event);
diff --git a/Source/Core/DolphinWX/Src/Globals.h b/Source/Core/DolphinWX/Src/Globals.h
index e32bbf0ec1..72d8d81701 100644
--- a/Source/Core/DolphinWX/Src/Globals.h
+++ b/Source/Core/DolphinWX/Src/Globals.h
@@ -92,7 +92,6 @@ enum
 	IDM_RESTART,
 	IDM_CHANGEDISC,
 	IDM_PROPERTIES,
-	IDM_GAMEVIDEOCONFIG,
 	IDM_GAMEWIKI,
 	IDM_LOAD_WII_MENU,
 	IDM_CONNECT_WIIMOTE1,
diff --git a/Source/Core/DolphinWX/Src/VideoConfigDiag.cpp b/Source/Core/DolphinWX/Src/VideoConfigDiag.cpp
index 623f802029..379bd8c084 100644
--- a/Source/Core/DolphinWX/Src/VideoConfigDiag.cpp
+++ b/Source/Core/DolphinWX/Src/VideoConfigDiag.cpp
@@ -1,4 +1,3 @@
-
 #include "VideoConfigDiag.h"
 
 #include "FileUtil.h"
@@ -14,58 +13,97 @@
 #include "Core.h"
 #include "Host.h"
 
+extern CFrame* main_frame;
+
 #define _connect_macro_(b, f, c, s)	(b)->Connect(wxID_ANY, (c), wxCommandEventHandler( f ), (wxObject*)0, (wxEvtHandler*)s)
 
-// hackity hack
-static bool g_use_intermediate_state = false;
+// template instantiation
+template class BoolSettingCB<wxCheckBox>;
+template class BoolSettingRB<wxRadioButton>;
 
-SettingCheckBox::SettingCheckBox(wxWindow* parent, const wxString& label,
-	const wxString& tooltip, bool &setting, long style)
-	: wxCheckBox(parent, -1, label, wxDefaultPosition, wxDefaultSize,
-		style | (g_use_intermediate_state ? (wxCHK_3STATE | wxCHK_ALLOW_3RD_STATE_FOR_USER) : 0))
+template <>
+SettingCheckBox::BoolSettingCB(wxWindow* parent, const wxString& label, const wxString& tooltip, bool &setting, bool &def_setting, bool &state, bool reverse, long style)
+	: wxCheckBox(parent, -1, label, wxDefaultPosition, wxDefaultSize, style)
 	, m_setting(setting)
+	, d_setting(def_setting)
+	, m_state(&state)
+	, m_reverse(reverse)
 {
 	SetToolTip(tooltip);
+	SetValue(m_setting ^ m_reverse);
+	_connect_macro_(this, SettingCheckBox::UpdateValue, wxEVT_COMMAND_CHECKBOX_CLICKED, this);
+}
 
-	if (VideoConfig::IsUndetermined(m_setting))
-		Set3StateValue(wxCHK_UNDETERMINED);
-	else
-		SetValue(m_setting);
-
+// without 3sate support
+template <>
+SettingCheckBox::BoolSettingCB(wxWindow* parent, const wxString& label, const wxString& tooltip, bool &setting, bool reverse, long style)
+	: wxCheckBox(parent, -1, label, wxDefaultPosition, wxDefaultSize, style)
+	, m_setting(setting)
+	, d_setting(setting)
+	, m_state(0)
+	, m_reverse(reverse)
+{
+	SetToolTip(tooltip);
+	SetValue(m_setting ^ m_reverse);
 	_connect_macro_(this, SettingCheckBox::UpdateValue, wxEVT_COMMAND_CHECKBOX_CLICKED, this);
 }
 
-SettingRadioButton::SettingRadioButton(wxWindow* parent, const wxString& label,
-	const wxString& tooltip, bool &setting, bool reverse, long style)
+template <>
+SettingRadioButton::BoolSettingRB(wxWindow* parent, const wxString& label, const wxString& tooltip, bool &setting, bool reverse, long style)
 	: wxRadioButton(parent, -1, label, wxDefaultPosition, wxDefaultSize, style)
 	, m_setting(setting)
 	, m_reverse(reverse)
 {
 	SetToolTip(tooltip);
-
-	if (!VideoConfig::IsUndetermined(m_setting) && m_setting != m_reverse)
-		SetValue(true);
-
+	SetValue(m_setting ^ m_reverse);
 	_connect_macro_(this, SettingRadioButton::UpdateValue, wxEVT_COMMAND_RADIOBUTTON_SELECTED, this);
 }
 
-SettingChoice::SettingChoice(wxWindow* parent, int &setting, const wxString& tooltip,
-	int num, const wxString choices[], long style)
+SettingChoice::SettingChoice(wxWindow* parent, int &setting, const wxString& tooltip, int num, const wxString choices[], long style)
 	: wxChoice(parent, -1, wxDefaultPosition, wxDefaultSize, num, choices)
 	, m_setting(setting)
+	, d_setting(setting)
+	, m_index(setting)
+	, m_state(0)
 {
 	SetToolTip(tooltip);
-
-	if (g_use_intermediate_state)
-		Insert(wxTRANSLATE("< Default >"), 0);
-	Select(m_setting + g_use_intermediate_state);
-
+	Select(m_setting);
 	_connect_macro_(this, SettingChoice::UpdateValue, wxEVT_COMMAND_CHOICE_SELECTED, this);
 }
 
 void SettingChoice::UpdateValue(wxCommandEvent& ev)
 {
-	m_setting = ev.GetInt() - g_use_intermediate_state;
+	m_setting = ev.GetInt();
+	ev.Skip();
+}
+
+// variant
+SettingChoice::SettingChoice(wxWindow* parent, int &setting, int &def_setting, bool &state, int &cur_index, const wxString& tooltip, int num, const wxString choices[], long style)
+	: wxChoice(parent, -1, wxDefaultPosition, wxDefaultSize, num, choices)
+	, m_setting(setting)
+	, d_setting(def_setting)
+	, m_index(cur_index)
+	, m_state(&state)
+{
+	SetToolTip(tooltip);
+	Select(m_setting);
+	_connect_macro_(this, SettingChoice::UpdateValue_variant, wxEVT_COMMAND_CHOICE_SELECTED, this);
+}
+
+void SettingChoice::UpdateValue_variant(wxCommandEvent& ev)
+{
+	m_setting = ev.GetInt();
+	if (m_state) *m_state = true;
+	if (m_index != 0)
+	{
+		if (m_setting == 0)
+		{
+			m_setting = d_setting;
+			if (m_state) *m_state = false;
+		}
+		else
+			m_setting -= 1;
+	}
 	ev.Skip();
 }
 
@@ -76,6 +114,17 @@ void VideoConfigDiag::Event_ClickClose(wxCommandEvent&)
 
 void VideoConfigDiag::Event_Close(wxCloseEvent& ev)
 {
+	if (cur_profile == 0)
+	{
+		cur_vconfig.Save((File::GetUserPath(D_CONFIG_IDX) + ininame + ".ini").c_str());
+	}
+	else
+	{
+		const GameListItem* item = GameListCtrl->GetISO(GameListCtrl->GetItemData(cur_profile - 1));
+		cur_vconfig.GameIniSave((File::GetUserPath(D_CONFIG_IDX) + ininame + ".ini").c_str(), 
+				(File::GetUserPath(D_GAMECONFIG_IDX) + item->GetUniqueID() + ".ini").c_str());
+	}
+
 	EndModal(wxID_OK);
 
 	TextureCache::InvalidateDefer(); // For settings like hi-res textures/texture format/etc.
@@ -132,18 +181,57 @@ wxString hotkeys_tooltip = wxT("");
 wxString ppshader_tooltip = wxT("");
 wxString cache_efb_copies_tooltip = wxTRANSLATE("When using EFB to RAM we very often need to decode RAM data to a VRAM texture, which is a very time-consuming task.\nWith this option enabled, we'll skip decoding a texture if it didn't change.\nThis results in a nice speedup, but possibly causes glitches.\nIf you have any problems with this option enabled you should either try increasing the safety of the texture cache or disable this option.\n(NOTE: The safer the texture cache is adjusted the lower the speedup will be; accurate texture cache set to \"safe\" might actually be slower!)");
 
-VideoConfigDiag::VideoConfigDiag(wxWindow* parent, const std::string &title, bool is_game_config)
-	: wxDialog(parent, -1, wxString::Format(_("Dolphin %s Graphics Configuration"),
-		wxGetTranslation(wxString::From8BitData(title.c_str()))),
+wxString def_profile = _("< as Default Profile >");
+
+VideoConfigDiag::VideoConfigDiag(wxWindow* parent, const std::string &title, const std::string& _ininame)
+	: wxDialog(parent, -1,
+		wxString::Format(_("Dolphin %s Graphics Configuration"),
+			wxGetTranslation(wxString::From8BitData(title.c_str()))),
 		wxDefaultPosition, wxDefaultSize)
-	//, choice_adapter(NULL)
-	//, choice_ppshader(NULL)
-	, vconfig(g_Config)
+	, choice_adapter(NULL)
+	, choice_ppshader(NULL)
+	, ininame(_ininame)
+	, GameListCtrl(main_frame->GetGameListCtrl())
 {
-	g_use_intermediate_state = is_game_config;
+	
+	#define SET_PARAMS(member) cur_vconfig.member, def_vconfig.member, cur_vconfig.UI_State.member
+	
+	// TODO: Make this less hacky
+	cur_vconfig = g_Config; // take over backend_info
+
+	// If a game from the game list is running, show the game specific config; show the default config otherwise
+	long cb_style = wxCHK_3STATE;
+	cur_profile = 0;
+	if (Core::IsRunning())
+	{
+		// Search which ISO has been started
+		for (long index = GameListCtrl->GetNextItem(-1); index != -1; index = GameListCtrl->GetNextItem(index))
+		{
+			const GameListItem* item = GameListCtrl->GetISO(GameListCtrl->GetItemData(index));
+			if (!item) continue;
+			if (item->GetUniqueID() == SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID)
+			{
+				cur_profile = index + 1;
+				break;
+			}
+		}
+	}
+	
+	prev_profile = cur_profile;
+
+	// Load default profile settings
+	def_vconfig.Load((File::GetUserPath(D_CONFIG_IDX) + ininame + ".ini").c_str());
+	
+	// Load current profile settings
+	std::string game_ini;
+	if (cur_profile != 0)
+	{
+		const GameListItem* item = GameListCtrl->GetISO(GameListCtrl->GetItemData(cur_profile - 1));
+		game_ini = File::GetUserPath(D_GAMECONFIG_IDX) + item->GetUniqueID() + ".ini";
+		cb_style = wxCHK_3STATE|wxCHK_ALLOW_3RD_STATE_FOR_USER;
+	}
 
-	// Load settings
-	//vconfig.Load((File::GetUserPath(D_CONFIG_IDX) + ininame + ".ini").c_str());
+	cur_vconfig.Load((File::GetUserPath(D_CONFIG_IDX) + ininame + ".ini").c_str(), (cur_profile != 0), game_ini.c_str());
 
 	wxNotebook* const notebook = new wxNotebook(this, -1, wxDefaultPosition, wxDefaultSize);
 
@@ -157,20 +245,36 @@ VideoConfigDiag::VideoConfigDiag(wxWindow* parent, const std::string &title, boo
 	{
 	wxFlexGridSizer* const szr_basic = new wxFlexGridSizer(2, 5, 5);
 
+	// game specific config
+	szr_basic->Add(new wxStaticText(page_general, -1, _("Configuration profile:")), 1, wxALIGN_CENTER_VERTICAL, 5);
+	profile_cb = new SettingChoice(page_general, cur_profile, wxGetTranslation(profile_tooltip));
+	szr_basic->Add(profile_cb, 1, 0, 0);
+
+	profile_cb->AppendString(_("(Default)"));
+	for (long index = GameListCtrl->GetNextItem(-1); index != -1; index = GameListCtrl->GetNextItem(index))
+	{
+		const GameListItem* item = GameListCtrl->GetISO(GameListCtrl->GetItemData(index));
+		if (!item) continue;
+		profile_cb->AppendString(wxString(item->GetName(0).c_str(), wxConvUTF8));
+	}
+
+	profile_cb->Select(cur_profile);
+	_connect_macro_(profile_cb, VideoConfigDiag::Event_OnProfileChange, wxEVT_COMMAND_CHOICE_SELECTED, this);
+
 	// adapter // for D3D only
-	if (vconfig.backend_info.Adapters.size())
+	if (cur_vconfig.backend_info.Adapters.size())
 	{
 	szr_basic->Add(new wxStaticText(page_general, -1, _("Adapter:")), 1, wxALIGN_CENTER_VERTICAL, 5);
-	SettingChoice * const choice_adapter =
-		new SettingChoice(page_general, vconfig.iAdapter, wxGetTranslation(adapter_tooltip));
+	choice_adapter = new SettingChoice(page_general, SET_PARAMS(iAdapter), cur_profile, wxGetTranslation(adapter_tooltip));
 
 	std::vector<std::string>::const_iterator
-		it = vconfig.backend_info.Adapters.begin(),
-		itend = vconfig.backend_info.Adapters.end();
+		it = cur_vconfig.backend_info.Adapters.begin(),
+		itend = cur_vconfig.backend_info.Adapters.end();
 	for (; it != itend; ++it)
 		choice_adapter->AppendString(wxString::FromAscii(it->c_str()));
 
-	choice_adapter->Select(vconfig.iAdapter);
+	if (cur_profile != 0)
+		choice_adapter->Insert(def_profile, 0);
 
 	szr_basic->Add(choice_adapter, 1, 0, 0);
 	}
@@ -181,19 +285,21 @@ VideoConfigDiag::VideoConfigDiag(wxWindow* parent, const std::string &title, boo
 		_("Force 16:9"), _("Force 4:3"), _("Stretch to Window") };
 
 	szr_basic->Add(new wxStaticText(page_general, -1, _("Aspect Ratio:")), 1, wxALIGN_CENTER_VERTICAL, 0);
-	SettingChoice * const choice_aspect = new SettingChoice(page_general,
-		vconfig.iAspectRatio, wxGetTranslation(ar_tooltip), sizeof(ar_choices)/sizeof(*ar_choices), ar_choices);
+	choice_aspect = new SettingChoice(page_general,
+		SET_PARAMS(iAspectRatio), cur_profile, wxGetTranslation(ar_tooltip), sizeof(ar_choices)/sizeof(*ar_choices), ar_choices);
+
+	if (cur_profile != 0)
+		choice_aspect->Insert(def_profile, 0);
+
 	szr_basic->Add(choice_aspect, 1, 0, 0);
 	}
 
 	// widescreen hack
 	{
 	szr_basic->AddStretchSpacer(1);
-	szr_basic->Add(new SettingCheckBox(page_general, _("Widescreen Hack"),
-		wxGetTranslation(ws_hack_tooltip), vconfig.bWidescreenHack), 1, 0, 0);
+	szr_basic->Add(widescreen_hack = new SettingCheckBox(page_general, _("Widescreen Hack"), wxGetTranslation(ws_hack_tooltip), SET_PARAMS(bWidescreenHack), false, cb_style), 1, 0, 0);
 	szr_basic->AddStretchSpacer(1);
-	szr_basic->Add(new SettingCheckBox(page_general, _("V-Sync"),
-		wxGetTranslation(vsync_tooltip), vconfig.bVSync), 1, 0, 0);
+	szr_basic->Add(vsync = new SettingCheckBox(page_general, _("V-Sync"), wxGetTranslation(vsync_tooltip), SET_PARAMS(bVSync), false, cb_style), 1, 0, 0);
 	}
 
 	// enhancements
@@ -201,37 +307,33 @@ VideoConfigDiag::VideoConfigDiag(wxWindow* parent, const std::string &title, boo
 
 	szr_enh->Add(new wxStaticText(page_general, -1, _("Anisotropic Filtering:")), 1, wxALIGN_CENTER_VERTICAL, 0);
 	const wxString af_choices[] = {wxT("1x"), wxT("2x"), wxT("4x"), wxT("8x"), wxT("16x")};
-	szr_enh->Add(new SettingChoice(page_general, vconfig.iMaxAnisotropy,
-		wxGetTranslation(af_tooltip), 5, af_choices));
+	szr_enh->Add(anisotropic_filtering = new SettingChoice(page_general, SET_PARAMS(iMaxAnisotropy), cur_profile, wxGetTranslation(af_tooltip), 5, af_choices));
+	
+	if (cur_profile != 0)
+		anisotropic_filtering->Insert(def_profile, 0);
+	
+	text_aamode = new wxStaticText(page_general, -1, _("Anti-Aliasing:"));
+	szr_enh->Add(text_aamode, 1, wxALIGN_CENTER_VERTICAL, 0);
+	choice_aamode = new SettingChoice(page_general, SET_PARAMS(iMultisampleMode), cur_profile, wxGetTranslation(aa_tooltip));
 
-	if (!vconfig.backend_info.AAModes.empty())
-	{
-		szr_enh->Add(new wxStaticText(page_general, -1, _("Anti-Aliasing:")), 1, wxALIGN_CENTER_VERTICAL, 0);
-		SettingChoice * const choice_aamode = new SettingChoice(page_general, vconfig.iMultisampleMode, wxGetTranslation(aa_tooltip));
+	std::vector<std::string>::const_iterator
+		it = cur_vconfig.backend_info.AAModes.begin(),
+		itend = cur_vconfig.backend_info.AAModes.end();
+	for (; it != itend; ++it)
+		choice_aamode->AppendString(wxGetTranslation(wxString::FromAscii(it->c_str())));
 
-		std::vector<std::string>::const_iterator
-			it = vconfig.backend_info.AAModes.begin(),
-			itend = vconfig.backend_info.AAModes.end();
-		for (; it != itend; ++it)
-			choice_aamode->AppendString(wxGetTranslation(wxString::FromAscii(it->c_str())));
+	if (cur_profile != 0)
+		choice_aamode->Insert(def_profile, 0);
 
-		choice_aamode->Select(vconfig.iMultisampleMode);
-		szr_enh->Add(choice_aamode);
-	}
+	szr_enh->Add(choice_aamode);
 
-	szr_enh->Add(new SettingCheckBox(page_general, _("Load Native Mipmaps"),
-		wxGetTranslation(native_mips_tooltip), vconfig.bUseNativeMips));
-	szr_enh->Add(new SettingCheckBox(page_general, _("EFB Scaled Copy"),
-		wxGetTranslation(scaled_efb_copy_tooltip), vconfig.bCopyEFBScaled));	
-	szr_enh->Add(new SettingCheckBox(page_general, _("Pixel Lighting"),
-		wxGetTranslation(pixel_lighting_tooltip), vconfig.bEnablePixelLighting));
-	szr_enh->Add(new SettingCheckBox(page_general, _("Pixel Depth"),
-		wxGetTranslation(pixel_depth_tooltip), vconfig.bEnablePerPixelDepth));
-	szr_enh->Add(new SettingCheckBox(page_general, _("Force Bi/Trilinear Filtering"),
-		wxGetTranslation(force_filtering_tooltip), vconfig.bForceFiltering));
+	szr_enh->Add(native_mips = new SettingCheckBox(page_general, _("Load Native Mipmaps"), wxGetTranslation(native_mips_tooltip), SET_PARAMS(bUseNativeMips), false, cb_style));
+	szr_enh->Add(efb_scaled_copy = new SettingCheckBox(page_general, _("EFB Scaled Copy"), wxGetTranslation(scaled_efb_copy_tooltip), SET_PARAMS(bCopyEFBScaled), false, cb_style));	
+	szr_enh->Add(pixel_lighting = new SettingCheckBox(page_general, _("Pixel Lighting"), wxGetTranslation(pixel_lighting_tooltip), SET_PARAMS(bEnablePixelLighting), false, cb_style));
+	szr_enh->Add(pixel_depth =  new SettingCheckBox(page_general, _("Pixel Depth"), wxGetTranslation(pixel_depth_tooltip), SET_PARAMS(bEnablePerPixelDepth), false, cb_style));
+	szr_enh->Add(force_filtering = new SettingCheckBox(page_general, _("Force Bi/Trilinear Filtering"), wxGetTranslation(force_filtering_tooltip), SET_PARAMS(bForceFiltering), false, cb_style));
 	
-	SettingCheckBox * const _3d_vision = new SettingCheckBox(page_general, _("3D Vision (Requires Fullscreen)"), wxGetTranslation(_3d_vision_tooltip), vconfig.b3DVision);
-	_3d_vision->Show(vconfig.backend_info.bSupports3DVision);
+	_3d_vision = new SettingCheckBox(page_general, _("3D Vision (Requires Fullscreen)"), wxGetTranslation(_3d_vision_tooltip), SET_PARAMS(b3DVision), false, cb_style);
 	szr_enh->Add(_3d_vision);
 
 	// - EFB
@@ -240,24 +342,23 @@ VideoConfigDiag::VideoConfigDiag(wxWindow* parent, const std::string &title, boo
 	const wxString efbscale_choices[] = { _("Fractional"), _("Integral [recommended]"),
 		wxT("1x"), wxT("2x"), wxT("3x"), wxT("0.75x"), wxT("0.5x"), wxT("0.375x") };
 
-	SettingChoice * const choice_efbscale = new SettingChoice(page_general,
-			vconfig.iEFBScale, wxGetTranslation(internal_res_tooltip), sizeof(efbscale_choices)/sizeof(*efbscale_choices), efbscale_choices);
+	choice_efbscale = new SettingChoice(page_general,
+			SET_PARAMS(iEFBScale), cur_profile, wxGetTranslation(internal_res_tooltip), sizeof(efbscale_choices)/sizeof(*efbscale_choices), efbscale_choices);
+
+	if (cur_profile != 0)
+		choice_efbscale->Insert(def_profile, 0);
 
 	efb_scale_szr->Add(new wxStaticText(page_general, -1, _("Scale:")), 0, wxALIGN_CENTER_VERTICAL, 5);
-	//efb_scale_szr->AddStretchSpacer(1);
-	efb_scale_szr->Add(choice_efbscale, 0, wxBOTTOM | wxLEFT, 5);
+	efb_scale_szr->Add(choice_efbscale, 1,  wxLEFT, 5);
 
-	SettingCheckBox * const emulate_efb_format_changes = new SettingCheckBox(page_general, _("Emulate Format Changes"),
-		wxGetTranslation(efb_emulate_format_changes_tooltip), vconfig.bEFBEmulateFormatChanges);
+	emulate_efb_format_changes = new SettingCheckBox(page_general, _("Emulate format changes"), wxGetTranslation(efb_emulate_format_changes_tooltip), SET_PARAMS(bEFBEmulateFormatChanges), false, cb_style);
 
 	// EFB copy
-	SettingCheckBox * const efbcopy_enable = new SettingCheckBox(page_general, _("Enable"), wxGetTranslation(efb_copy_tooltip), vconfig.bEFBCopyEnable);
-	SettingRadioButton * const efbcopy_texture = new SettingRadioButton(page_general, _("Texture"), wxGetTranslation(efb_copy_texture_tooltip), vconfig.bCopyEFBToTexture, false, wxRB_GROUP);
-	SettingRadioButton * const efbcopy_ram = new SettingRadioButton(page_general, _("RAM"), wxGetTranslation(efb_copy_ram_tooltip), vconfig.bCopyEFBToTexture, true);
-	SettingCheckBox * const cache_efb_copies = new SettingCheckBox(page_general, _("Enable Cache"), wxGetTranslation(cache_efb_copies_tooltip), vconfig.bEFBCopyCacheEnable);
-	
+	efbcopy_enable = new SettingCheckBox(page_general, _("Enable"), wxGetTranslation(efb_copy_tooltip), SET_PARAMS(bEFBCopyEnable), false, cb_style);
+	efbcopy_texture = new SettingRadioButton(page_general, _("Texture"), wxGetTranslation(efb_copy_texture_tooltip), cur_vconfig.bCopyEFBToTexture, false, wxRB_GROUP);
+	efbcopy_ram = new SettingRadioButton(page_general, _("RAM"), wxGetTranslation(efb_copy_ram_tooltip), cur_vconfig.bCopyEFBToTexture, true);
+	cache_efb_copies = new SettingCheckBox(page_general, _("Enable cache"), wxGetTranslation(cache_efb_copies_tooltip), SET_PARAMS(bEFBCopyCacheEnable), false, cb_style);
 	wxStaticBoxSizer* const group_efbcopy = new wxStaticBoxSizer(wxHORIZONTAL, page_general, _("Copy"));
-	
 	group_efbcopy->Add(efbcopy_enable, 0, wxLEFT | wxRIGHT | wxBOTTOM, 5);
 	group_efbcopy->AddStretchSpacer(1);
 	group_efbcopy->Add(efbcopy_texture, 0, wxRIGHT, 5);
@@ -266,18 +367,18 @@ VideoConfigDiag::VideoConfigDiag(wxWindow* parent, const std::string &title, boo
 
 
 	// - safe texture cache
-	SettingCheckBox * const stc_enable = new SettingCheckBox(page_general, _("Enable"), wxGetTranslation(stc_tooltip), vconfig.bSafeTextureCache);
+	stc_enable = new SettingCheckBox(page_general, _("Enable"), wxGetTranslation(stc_tooltip), SET_PARAMS(bSafeTextureCache), false, cb_style);
 
-	wxRadioButton * const stc_safe = new wxRadioButton(page_general, -1, _("Safe"),
+	stc_safe = new wxRadioButton(page_general, -1, _("Safe"),
 		wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
 	stc_safe->SetToolTip(wxGetTranslation(stc_speed_tooltip));
 	_connect_macro_(stc_safe, VideoConfigDiag::Event_StcSafe, wxEVT_COMMAND_RADIOBUTTON_SELECTED, this);
 
-	wxRadioButton * const stc_normal = new wxRadioButton(page_general, -1, _("Normal"));
+	stc_normal = new wxRadioButton(page_general, -1, _("Normal"));
 	stc_normal->SetToolTip(wxGetTranslation(stc_speed_tooltip));
 	_connect_macro_(stc_normal, VideoConfigDiag::Event_StcNormal, wxEVT_COMMAND_RADIOBUTTON_SELECTED, this);
 
-	wxRadioButton * const stc_fast = new wxRadioButton(page_general, -1, _("Fast"));
+	stc_fast = new wxRadioButton(page_general, -1, _("Fast"));
 	stc_fast->SetToolTip(wxGetTranslation(stc_speed_tooltip));
 	_connect_macro_(stc_fast, VideoConfigDiag::Event_StcFast, wxEVT_COMMAND_RADIOBUTTON_SELECTED, this);
 
@@ -292,8 +393,7 @@ VideoConfigDiag::VideoConfigDiag(wxWindow* parent, const std::string &title, boo
 	wxStaticBoxSizer* const group_efb = new wxStaticBoxSizer(wxVERTICAL, page_general, _("EFB"));
 	szr_general->Add(group_efb, 0, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 5);
 	group_efb->Add(efb_scale_szr, 0, wxBOTTOM | wxLEFT, 5);
-	group_efb->Add(new SettingCheckBox(page_general, _("Enable CPU Access"),
-		wxGetTranslation(efb_access_tooltip), vconfig.bEFBAccessEnable), 0, wxBOTTOM | wxLEFT, 5);
+	group_efb->Add(efbaccess_enable = new SettingCheckBox(page_general, _("Enable CPU Access"), wxGetTranslation(efb_access_tooltip), SET_PARAMS(bEFBAccessEnable), false, cb_style), 0, wxBOTTOM | wxLEFT, 5);
 	group_efb->Add(emulate_efb_format_changes, 0, wxBOTTOM | wxLEFT, 5);
 	group_efb->Add(group_efbcopy, 0, wxEXPAND | wxBOTTOM, 5);
 
@@ -315,20 +415,23 @@ VideoConfigDiag::VideoConfigDiag(wxWindow* parent, const std::string &title, boo
 	notebook->AddPage(page_advanced, _("Advanced"));
 	wxBoxSizer* const szr_advanced = new wxBoxSizer(wxVERTICAL);
 
+	// configuration profiles
+	{
+	wxStaticBoxSizer* const group_profile = new wxStaticBoxSizer(wxHORIZONTAL, page_advanced, _("Configuration profile"));
+	profile_text = new wxStaticText(page_advanced, -1, profile_cb->GetStringSelection());
+	szr_advanced->Add(group_profile, 0, wxEXPAND | wxALL, 5);
+	group_profile->Add(profile_text, 1, wxEXPAND | wxALL, 5);
+	}
+
 	// - rendering
 	{
 	wxGridSizer* const szr_rendering = new wxGridSizer(2, 5, 5);
 
-	szr_rendering->Add(new SettingCheckBox(page_advanced, _("Enable Wireframe"),
-		wxGetTranslation(wireframe_tooltip), vconfig.bWireFrame));
-	szr_rendering->Add(new SettingCheckBox(page_advanced, _("Disable Lighting"),
-		wxGetTranslation(disable_lighting_tooltip), vconfig.bDisableLighting));
-	szr_rendering->Add(new SettingCheckBox(page_advanced, _("Disable Textures"),
-		wxGetTranslation(disable_textures_tooltip), vconfig.bDisableTexturing));
-	szr_rendering->Add(new SettingCheckBox(page_advanced, _("Disable Fog"),
-		wxGetTranslation(disable_fog_tooltip), vconfig.bDisableFog));
-	szr_rendering->Add(new SettingCheckBox(page_advanced, _("Disable Dest. Alpha Pass"),
-		wxGetTranslation(disable_alphapass_tooltip), vconfig.bDstAlphaPass));
+	szr_rendering->Add(wireframe = new SettingCheckBox(page_advanced, _("Enable Wireframe"), wxGetTranslation(wireframe_tooltip), SET_PARAMS(bWireFrame), false, cb_style));
+	szr_rendering->Add(disable_lighting = new SettingCheckBox(page_advanced, _("Disable Lighting"), wxGetTranslation(disable_lighting_tooltip), SET_PARAMS(bDisableLighting), false, cb_style));
+	szr_rendering->Add(disable_textures = new SettingCheckBox(page_advanced, _("Disable Textures"), wxGetTranslation(disable_textures_tooltip), SET_PARAMS(bDisableTexturing), false, cb_style));
+	szr_rendering->Add(disable_fog = new SettingCheckBox(page_advanced, _("Disable Fog"), wxGetTranslation(disable_fog_tooltip), SET_PARAMS(bDisableFog), false, cb_style));
+	szr_rendering->Add(disable_dst_alpha = new SettingCheckBox(page_advanced, _("Disable Dest. Alpha Pass"), wxGetTranslation(disable_alphapass_tooltip), SET_PARAMS(bDstAlphaPass), false, cb_style));
 
 	wxStaticBoxSizer* const group_rendering = new wxStaticBoxSizer(wxVERTICAL, page_advanced, _("Rendering"));
 	szr_advanced->Add(group_rendering, 0, wxEXPAND | wxALL, 5);
@@ -339,20 +442,13 @@ VideoConfigDiag::VideoConfigDiag(wxWindow* parent, const std::string &title, boo
 	{
 	wxGridSizer* const szr_info = new wxGridSizer(2, 5, 5);
 
-	szr_info->Add(new SettingCheckBox(page_advanced, _("Show FPS"),
-		wxGetTranslation(show_fps_tooltip), vconfig.bShowFPS));
-	szr_info->Add(new SettingCheckBox(page_advanced, _("Various Statistics"),
-		wxGetTranslation(show_stats_tooltip), vconfig.bOverlayStats));
-	szr_info->Add(new SettingCheckBox(page_advanced, _("Projection Stats"),
-		wxGetTranslation(proj_stats_tooltip), vconfig.bOverlayProjStats));
-	szr_info->Add(new SettingCheckBox(page_advanced, _("Texture Format"),
-		wxGetTranslation(texfmt_tooltip), vconfig.bTexFmtOverlayEnable));
-	szr_info->Add(new SettingCheckBox(page_advanced, _("EFB Copy Regions"),
-		wxGetTranslation(efb_copy_regions_tooltip), vconfig.bShowEFBCopyRegions));
-	szr_info->Add(new SettingCheckBox(page_advanced, _("Show Shader Errors"),
-		wxT(""), vconfig.bShowShaderErrors));
-	szr_info->Add(new SettingCheckBox(page_advanced, _("Show Input Display"),
-		wxGetTranslation(show_input_display_tooltip), vconfig.bShowInputDisplay));
+	szr_info->Add(show_fps = new SettingCheckBox(page_advanced, _("Show FPS"), wxGetTranslation(show_fps_tooltip), SET_PARAMS(bShowFPS), false, cb_style));
+	szr_info->Add(overlay_stats = new SettingCheckBox(page_advanced, _("Various Statistics"), wxGetTranslation(show_stats_tooltip), SET_PARAMS(bOverlayStats), false, cb_style));
+	szr_info->Add(overlay_proj_stats = new SettingCheckBox(page_advanced, _("Projection Stats"), wxGetTranslation(proj_stats_tooltip), SET_PARAMS(bOverlayProjStats), false, cb_style));
+	szr_info->Add(texfmt_overlay = new SettingCheckBox(page_advanced, _("Texture Format"), wxGetTranslation(texfmt_tooltip), SET_PARAMS(bTexFmtOverlayEnable), false, cb_style));
+	szr_info->Add(efb_copy_regions = new SettingCheckBox(page_advanced, _("EFB Copy Regions"), wxGetTranslation(efb_copy_regions_tooltip), SET_PARAMS(bShowEFBCopyRegions), false, cb_style));
+	szr_info->Add(show_shader_errors = new SettingCheckBox(page_advanced, _("Show Shader Errors"), wxT(""), SET_PARAMS(bShowShaderErrors), false, cb_style));
+	szr_info->Add(show_input_display = new SettingCheckBox(page_advanced, _("Show Input Display"), wxGetTranslation(show_input_display_tooltip), SET_PARAMS(bShowInputDisplay), false, cb_style));
 
 	wxStaticBoxSizer* const group_info = new wxStaticBoxSizer(wxVERTICAL, page_advanced, _("Information"));
 	szr_advanced->Add(group_info, 0, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 5);
@@ -361,9 +457,9 @@ VideoConfigDiag::VideoConfigDiag(wxWindow* parent, const std::string &title, boo
 	
 	// - XFB
 	{
-	SettingCheckBox * const enable_xfb = new SettingCheckBox(page_advanced, _("Enable"), wxGetTranslation(xfb_tooltip), vconfig.bUseXFB);
-	SettingRadioButton * const virtual_xfb = new SettingRadioButton(page_advanced, _("Virtual"), wxGetTranslation(xfb_tooltip), vconfig.bUseRealXFB, true, wxRB_GROUP);
-	SettingRadioButton * const real_xfb = new SettingRadioButton(page_advanced, _("Real"), wxGetTranslation(xfb_tooltip), vconfig.bUseRealXFB);
+	enable_xfb = new SettingCheckBox(page_advanced, _("Enable"), wxGetTranslation(xfb_tooltip), SET_PARAMS(bUseXFB), false, cb_style);
+	virtual_xfb = new SettingRadioButton(page_advanced, _("Virtual"), wxGetTranslation(xfb_tooltip), cur_vconfig.bUseRealXFB, true, wxRB_GROUP);
+	real_xfb = new SettingRadioButton(page_advanced, _("Real"), wxGetTranslation(xfb_tooltip), cur_vconfig.bUseRealXFB);
 
 	wxStaticBoxSizer* const group_xfb = new wxStaticBoxSizer(wxHORIZONTAL, page_advanced, _("XFB"));
 	szr_advanced->Add(group_xfb, 0, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 5);
@@ -371,24 +467,21 @@ VideoConfigDiag::VideoConfigDiag(wxWindow* parent, const std::string &title, boo
 	group_xfb->AddStretchSpacer(1);
 	group_xfb->Add(virtual_xfb, 0, wxRIGHT, 5);
 	group_xfb->Add(real_xfb, 0, wxRIGHT, 5);
+
+
 	}	// xfb
 
 	// - utility
 	{
 	wxGridSizer* const szr_utility = new wxGridSizer(2, 5, 5);
 
-	szr_utility->Add(new SettingCheckBox(page_advanced, _("Dump Textures"),
-		wxGetTranslation(dump_textures_tooltip), vconfig.bDumpTextures));
-	szr_utility->Add(new SettingCheckBox(page_advanced, _("Load Hi-Res Textures"),
-		wxGetTranslation(load_hires_textures_tooltip), vconfig.bHiresTextures));
-	szr_utility->Add(new SettingCheckBox(page_advanced, _("Dump EFB Target"),
-		dump_efb_tooltip, vconfig.bDumpEFBTarget));
-	szr_utility->Add(new SettingCheckBox(page_advanced, _("Dump Frames"),
-		dump_frames_tooltip, vconfig.bDumpFrames));
-	szr_utility->Add(new SettingCheckBox(page_advanced, _("Free Look"),
-		free_look_tooltip, vconfig.bFreeLook));
+	szr_utility->Add(dump_textures = new SettingCheckBox(page_advanced, _("Dump Textures"), wxGetTranslation(dump_textures_tooltip), SET_PARAMS(bDumpTextures), false, cb_style));
+	szr_utility->Add(hires_textures = new SettingCheckBox(page_advanced, _("Load Hi-Res Textures"), wxGetTranslation(load_hires_textures_tooltip), SET_PARAMS(bHiresTextures), false, cb_style));
+	szr_utility->Add(dump_efb = new SettingCheckBox(page_advanced, _("Dump EFB Target"), dump_efb_tooltip, SET_PARAMS(bDumpEFBTarget), false, cb_style));
+	szr_utility->Add(dump_frames = new SettingCheckBox(page_advanced, _("Dump Frames"), dump_frames_tooltip, SET_PARAMS(bDumpFrames), false, cb_style));
+	szr_utility->Add(free_look = new SettingCheckBox(page_advanced, _("Free Look"), free_look_tooltip, SET_PARAMS(bFreeLook), false, cb_style));
 #if !defined WIN32 && defined HAVE_LIBAV
-	szr_utility->Add(new SettingCheckBox(page_advanced, _("Dump Frames With FFV1"), use_ffv1_tooltip, vconfig.bUseFFV1));
+	szr_utility->Add(frame_dumps_via_ffv1 = new SettingCheckBox(page_advanced, _("Frame dumps use FFV1"), use_ffv1_tooltip, SET_PARAMS(bUseFFV1), false, cb_style));
 #endif
 
 	wxStaticBoxSizer* const group_utility = new wxStaticBoxSizer(wxVERTICAL, page_advanced, _("Utility"));
@@ -400,37 +493,30 @@ VideoConfigDiag::VideoConfigDiag(wxWindow* parent, const std::string &title, boo
 	{
 	wxGridSizer* const szr_misc = new wxGridSizer(2);
 
-	szr_misc->Add(new SettingCheckBox(page_advanced, _("Crop"),
-		crop_tooltip, vconfig.bCrop), 0, wxBOTTOM, 5);
-	szr_misc->Add(new SettingCheckBox(page_advanced, _("Enable OpenCL"),
-		opencl_tooltip, vconfig.bEnableOpenCL), 0, wxLEFT|wxBOTTOM, 5);
-	szr_misc->Add(new SettingCheckBox(page_advanced, _("Enable Display List Caching"),
-		dlc_tooltip, vconfig.bDlistCachingEnable), 0, wxBOTTOM, 5);
-	szr_misc->Add(new SettingCheckBox(page_advanced, _("Enable Hotkeys"),
-		hotkeys_tooltip, vconfig.bOSDHotKey), 0, wxLEFT|wxBOTTOM, 5);
-	szr_misc->Add(new SettingCheckBox(page_advanced, _("OpenMP Texture Decoder"),
-		omp_tooltip, vconfig.bOMPDecoder), 0, wxBOTTOM, 5);
-	szr_misc->AddSpacer(0);
+	szr_misc->Add(crop = new SettingCheckBox(page_advanced, _("Crop"), crop_tooltip, SET_PARAMS(bCrop), false, cb_style), 0, wxBOTTOM, 5);
+	szr_misc->Add(opencl = new SettingCheckBox(page_advanced, _("Enable OpenCL"), opencl_tooltip, SET_PARAMS(bEnableOpenCL), false, cb_style), 0, wxLEFT|wxBOTTOM, 5);
+	szr_misc->Add(dlcache = new SettingCheckBox(page_advanced, _("Enable Display List Caching"), dlc_tooltip, SET_PARAMS(bDlistCachingEnable), false, cb_style), 0, wxBOTTOM, 5);
+	szr_misc->Add(hotkeys = new SettingCheckBox(page_advanced, _("Enable Hotkeys"), hotkeys_tooltip, SET_PARAMS(bOSDHotKey), false, cb_style), 0, wxLEFT|wxBOTTOM, 5);
+	szr_misc->Add(ompdecoder = new SettingCheckBox(page_advanced, _("OpenMP Texture Decoder"), omp_tooltip, SET_PARAMS(bOMPDecoder), false, cb_style), 0, wxBOTTOM, 5);
+	szr_misc->AddStretchSpacer(1);
 
 	// postproc shader
-	if (vconfig.backend_info.PPShaders.size())
+	if (cur_vconfig.backend_info.PPShaders.size())
 	{
 		szr_misc->Add(new wxStaticText(page_advanced, -1, _("Post-Processing Shader:")), 1, wxALIGN_CENTER_VERTICAL, 0);
 
-		wxChoice * const choice_ppshader = new wxChoice(page_advanced, -1, wxDefaultPosition);
+		choice_ppshader = new wxChoice(page_advanced, -1, wxDefaultPosition);
 		choice_ppshader->SetToolTip(wxGetTranslation(ppshader_tooltip));
 		choice_ppshader->AppendString(_("(off)"));
 
 		std::vector<std::string>::const_iterator
-			it = vconfig.backend_info.PPShaders.begin(),
-			itend = vconfig.backend_info.PPShaders.end();
+			it = cur_vconfig.backend_info.PPShaders.begin(),
+			itend = cur_vconfig.backend_info.PPShaders.end();
 		for (; it != itend; ++it)
 			choice_ppshader->AppendString(wxString::FromAscii(it->c_str()));
 
-		if (vconfig.sPostProcessingShader.empty())
-			choice_ppshader->Select(0);
-		else
-			choice_ppshader->SetStringSelection(wxString::FromAscii(vconfig.sPostProcessingShader.c_str()));
+		if (cur_profile != 0)
+			choice_ppshader->Insert(def_profile, 0);
 
 		_connect_macro_(choice_ppshader, VideoConfigDiag::Event_PPShader, wxEVT_COMMAND_CHOICE_SELECTED, this);
 
@@ -457,10 +543,305 @@ VideoConfigDiag::VideoConfigDiag(wxWindow* parent, const std::string &title, boo
 	SetSizerAndFit(szr_main);
 	Center();
 	SetFocus();
+
+	SetUIValuesFromConfig();
+	Connect(wxID_ANY, wxEVT_UPDATE_UI, wxUpdateUIEventHandler(VideoConfigDiag::OnUpdateUI), NULL, this);
+	UpdateWindowUI();
+}
+
+void VideoConfigDiag::ChangeStyle()
+{
+	// here where we change opportune UI Controls only if we come from, or we go to, default profile
+	if (prev_profile != cur_profile && !(prev_profile && cur_profile))
+	{
+		long cb_style = (cur_profile == 0) ? wxCHK_3STATE : wxCHK_3STATE|wxCHK_ALLOW_3RD_STATE_FOR_USER;
+		
+		if (cur_vconfig.backend_info.Adapters.size())
+		{
+			if (cur_profile == 0) choice_adapter->Delete(0);
+			else choice_adapter->Insert(def_profile, 0);
+
+			choice_adapter->GetParent()->Layout(); // redraws all elements inside the parent container
+		}
+		if (cur_profile == 0) choice_aspect->Delete(0);
+		else choice_aspect->Insert(def_profile, 0);
+		choice_aspect->GetParent()->Layout();
+
+		widescreen_hack->SetWindowStyle(cb_style);
+		vsync->SetWindowStyle(cb_style);
+
+		if (cur_profile == 0) anisotropic_filtering->Delete(0);
+		else anisotropic_filtering->Insert(def_profile, 0);
+		anisotropic_filtering->GetParent()->Layout();
+
+		if (cur_profile == 0) choice_aamode->Delete(0);
+		else choice_aamode->Insert(def_profile, 0);
+		choice_aamode->GetParent()->Layout();
+
+		native_mips->SetWindowStyle(cb_style);
+		efb_scaled_copy->SetWindowStyle(cb_style);	
+		pixel_lighting->SetWindowStyle(cb_style);
+		pixel_depth->SetWindowStyle(cb_style);
+		force_filtering->SetWindowStyle(cb_style);
+		_3d_vision->SetWindowStyle(cb_style);
+
+		if (cur_profile == 0) choice_efbscale->Delete(0);
+		else choice_efbscale->Insert(def_profile, 0);
+		choice_efbscale->GetParent()->Layout();
+
+		efbaccess_enable->SetWindowStyle(cb_style);
+		emulate_efb_format_changes->SetWindowStyle(cb_style);
+		efbcopy_enable->SetWindowStyle(cb_style);
+		cache_efb_copies->SetWindowStyle(cb_style);
+		stc_enable->SetWindowStyle(cb_style);
+		wireframe->SetWindowStyle(cb_style);
+		disable_lighting->SetWindowStyle(cb_style);
+		disable_textures->SetWindowStyle(cb_style);
+		disable_fog->SetWindowStyle(cb_style);
+		disable_dst_alpha->SetWindowStyle(cb_style);
+		show_fps->SetWindowStyle(cb_style);
+		overlay_stats->SetWindowStyle(cb_style);
+		overlay_proj_stats->SetWindowStyle(cb_style);
+		texfmt_overlay->SetWindowStyle(cb_style);
+		efb_copy_regions->SetWindowStyle(cb_style);
+		show_shader_errors->SetWindowStyle(cb_style);
+		show_input_display->SetWindowStyle(cb_style);
+		enable_xfb->SetWindowStyle(cb_style);
+		dump_textures->SetWindowStyle(cb_style);
+		hires_textures->SetWindowStyle(cb_style);
+		dump_efb->SetWindowStyle(cb_style);
+		dump_frames->SetWindowStyle(cb_style);
+		free_look->SetWindowStyle(cb_style);
+
+	#if !defined WIN32 && defined HAVE_LIBAV
+		frame_dumps_via_ffv1->SetWindowStyle(cb_style);
+	#endif
+
+		hotkeys->SetWindowStyle(cb_style);
+		dlcache->SetWindowStyle(cb_style);
+		ompdecoder->SetWindowStyle(cb_style);
+		opencl->SetWindowStyle(cb_style);
+		crop->SetWindowStyle(cb_style);
+
+		if (cur_vconfig.backend_info.PPShaders.size())
+		{
+			if (cur_profile == 0)
+				choice_ppshader->Delete(0);
+			else
+				choice_ppshader->Insert(def_profile, 0);
+
+			choice_ppshader->GetParent()->Layout();
+		}
+
+		Fit(); // wraps sizes of the outer layout...
+		Center(); // ...and lastly re-center the main window
+	}
+}
+
+void VideoConfigDiag::Event_OnProfileChange(wxCommandEvent& ev)
+{
+	// Save settings of current profile
+	if (cur_profile == 0)
+	{
+		def_vconfig = cur_vconfig; // copy default profile changes
+		cur_vconfig.Save((File::GetUserPath(D_CONFIG_IDX) + ininame + ".ini").c_str());
+	}
+	else
+	{
+		const GameListItem* item = GameListCtrl->GetISO(GameListCtrl->GetItemData(cur_profile - 1));
+		cur_vconfig.GameIniSave((File::GetUserPath(D_CONFIG_IDX) + ininame + ".ini").c_str(), 
+				(std::string(File::GetUserPath(D_GAMECONFIG_IDX)) + item->GetUniqueID() + ".ini").c_str());
+	}
+
+	// Enable new profile
+	cur_profile = ev.GetInt();
+
+	// Reset settings and, if necessary, load game-specific settings
+	std::string game_ini;
+	if (cur_profile != 0)
+	{
+		const GameListItem* item = GameListCtrl->GetISO(GameListCtrl->GetItemData(cur_profile - 1));
+		game_ini = File::GetUserPath(D_GAMECONFIG_IDX) + item->GetUniqueID() + ".ini";
+	}
+
+	cur_vconfig.Load((File::GetUserPath(D_CONFIG_IDX) + ininame + ".ini").c_str(), (cur_profile != 0), game_ini.c_str());
+
+	ChangeStyle();
+	prev_profile = cur_profile;
+
+	// Update our UI elements with the new config
+	SetUIValuesFromConfig();
+	UpdateWindowUI();
+	profile_text->SetLabel(profile_cb->GetStringSelection());
+
+	ev.Skip();
+}
+
+void VideoConfigDiag::OnUpdateUI(wxUpdateUIEvent& ev)
+{
+	bool enable_group;
+
+	// Anti-aliasing
+	choice_aamode->Enable(cur_vconfig.backend_info.AAModes.size() > 1);
+	text_aamode->Enable(cur_vconfig.backend_info.AAModes.size() > 1);
+
+	// pixel lighting
+	pixel_lighting->Enable(cur_vconfig.backend_info.bSupportsPixelLighting);
+
+	// 3D vision
+	_3d_vision->Show(cur_vconfig.backend_info.bSupports3DVision);
+
+	// EFB copy
+	enable_group = cur_vconfig.bEFBCopyEnable && (efbcopy_enable->Get3StateValue() != wxCHK_UNDETERMINED);
+	efbcopy_texture->Enable(enable_group);
+	efbcopy_ram->Enable(enable_group);
+	cache_efb_copies->Enable(cur_vconfig.bEFBCopyEnable && !cur_vconfig.bCopyEFBToTexture);
+
+	// EFB format change emulation
+	emulate_efb_format_changes->Enable(cur_vconfig.backend_info.bSupportsFormatReinterpretation);
+
+	// ATC
+	enable_group = cur_vconfig.bSafeTextureCache && (stc_enable->Get3StateValue() != wxCHK_UNDETERMINED);
+	stc_safe->Enable(enable_group);
+	stc_normal->Enable(enable_group);
+	stc_fast->Enable(enable_group);
+
+	// XFB
+	enable_group = cur_vconfig.bUseXFB && (enable_xfb->Get3StateValue() != wxCHK_UNDETERMINED);
+	virtual_xfb->Enable(enable_group);
+	real_xfb->Enable(enable_group);
+
+	// here where we check Radio Button Groups if main CheckBox has 3rd state activated
+	// NOTE: this code block just before g_Config is updated
+	if (cur_profile != 0)
+	{
+		if (ev.GetId() == efbcopy_enable->GetId())
+		{
+			if (efbcopy_enable->Get3StateValue() == wxCHK_UNDETERMINED)
+			{
+				cur_vconfig.bCopyEFBToTexture = def_vconfig.bCopyEFBToTexture;
+				efbcopy_texture->SetValue(cur_vconfig.bCopyEFBToTexture);
+				efbcopy_ram->SetValue(!cur_vconfig.bCopyEFBToTexture);
+			}
+		}
+		if (ev.GetId() == stc_enable->GetId())
+		{
+			if (stc_enable->Get3StateValue() == wxCHK_UNDETERMINED)
+			{
+				cur_vconfig.iSafeTextureCache_ColorSamples = def_vconfig.iSafeTextureCache_ColorSamples;
+				stc_safe->SetValue(0 == cur_vconfig.iSafeTextureCache_ColorSamples);
+				stc_normal->SetValue(512 == cur_vconfig.iSafeTextureCache_ColorSamples);
+				stc_fast->SetValue(128 == cur_vconfig.iSafeTextureCache_ColorSamples);
+			}
+		}
+		if (ev.GetId() == enable_xfb->GetId()) //XFB
+		{
+			if (enable_xfb->Get3StateValue() == wxCHK_UNDETERMINED)
+			{
+				cur_vconfig.bUseRealXFB = def_vconfig.bUseRealXFB;
+				virtual_xfb->SetValue(!cur_vconfig.bUseRealXFB);
+				real_xfb->SetValue(cur_vconfig.bUseRealXFB);
+			}
+		}
+	}
+	
+	// If emulation hasn't started, yet, always update g_Config.
+	// Otherwise only update it if we're editing the currently running game's profile
+	if (!Core::IsRunning())
+	{
+		g_Config = cur_vconfig;
+	}
+	else if (cur_profile != 0)
+	{
+		// TODO: Modifying the default profile should update g_Config as well
+		if (GameListCtrl->GetISO(GameListCtrl->GetItemData(cur_profile - 1))->GetUniqueID() ==
+					SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID)
+			g_Config = cur_vconfig;
+	}
+
+	ev.Skip();
 }
 
 void VideoConfigDiag::SetUIValuesFromConfig()
 {
-	//for (auto i = m_settings.begin(), e = m_settings.end(); i != e; ++i)
-	//	(*i)->UpdateUI();
+	
+	int inc = (cur_profile != 0) ? 1 : 0;
+	
+	#define SET_CHOICE(control, member) {\
+		void *p = control;\
+		switch (sizeof(cur_vconfig.member)) {\
+		case sizeof(bool): if (cur_vconfig.UI_State.member) ((wxCheckBox*)p)->Set3StateValue((wxCheckBoxState)cur_vconfig.member);\
+			else ((wxCheckBox*)p)->Set3StateValue(wxCHK_UNDETERMINED); break;\
+		case sizeof(int): if (cur_vconfig.UI_State.member) ((wxChoice*)p)->SetSelection(cur_vconfig.member + inc);\
+			else ((wxChoice*)p)->SetSelection(0); break; } }
+
+	if (choice_adapter) SET_CHOICE(choice_adapter, iAdapter);
+	cur_vconfig.VerifyValidity();
+	SET_CHOICE(choice_aspect, iAspectRatio);
+	SET_CHOICE(widescreen_hack, bWidescreenHack);
+	SET_CHOICE(vsync, bVSync);
+
+	SET_CHOICE(anisotropic_filtering, iMaxAnisotropy);
+	SET_CHOICE(choice_aamode, iMultisampleMode);
+
+	SET_CHOICE(native_mips, bUseNativeMips);
+	SET_CHOICE(efb_scaled_copy,bCopyEFBScaled);
+	SET_CHOICE(pixel_lighting, bEnablePixelLighting);
+	SET_CHOICE(pixel_depth, bEnablePerPixelDepth);
+	SET_CHOICE(force_filtering, bForceFiltering);
+	SET_CHOICE(_3d_vision, b3DVision);
+
+	SET_CHOICE(choice_efbscale, iEFBScale);
+	SET_CHOICE(efbaccess_enable, bEFBAccessEnable);
+	SET_CHOICE(emulate_efb_format_changes, bEFBEmulateFormatChanges);
+
+	SET_CHOICE(efbcopy_enable, bEFBCopyEnable);
+	efbcopy_texture->SetValue(cur_vconfig.bCopyEFBToTexture);
+	efbcopy_ram->SetValue(!cur_vconfig.bCopyEFBToTexture);
+	SET_CHOICE(cache_efb_copies, bEFBCopyCacheEnable);
+
+	SET_CHOICE(stc_enable, bSafeTextureCache);
+	stc_safe->SetValue(0 == cur_vconfig.iSafeTextureCache_ColorSamples);
+	stc_normal->SetValue(512 == cur_vconfig.iSafeTextureCache_ColorSamples);
+	stc_fast->SetValue(128 == cur_vconfig.iSafeTextureCache_ColorSamples);
+
+	SET_CHOICE(wireframe, bWireFrame);
+	SET_CHOICE(disable_lighting, bDisableLighting);
+	SET_CHOICE(disable_textures, bDisableTexturing);
+	SET_CHOICE(disable_fog, bDisableFog);
+	SET_CHOICE(disable_dst_alpha, bDstAlphaPass);
+
+	SET_CHOICE(show_fps, bShowFPS);
+	SET_CHOICE(overlay_stats, bOverlayStats);
+	SET_CHOICE(overlay_proj_stats, bOverlayProjStats);
+	SET_CHOICE(texfmt_overlay, bTexFmtOverlayEnable);
+	SET_CHOICE(efb_copy_regions, bShowEFBCopyRegions);
+	SET_CHOICE(show_shader_errors, bShowShaderErrors);
+	SET_CHOICE(show_input_display, bShowInputDisplay);
+
+	SET_CHOICE(enable_xfb, bUseXFB);
+	virtual_xfb->SetValue(!cur_vconfig.bUseRealXFB);
+	real_xfb->SetValue(cur_vconfig.bUseRealXFB);
+
+	SET_CHOICE(dump_textures, bDumpTextures);
+	SET_CHOICE(hires_textures, bHiresTextures);
+	SET_CHOICE(dump_efb, bDumpEFBTarget);
+	SET_CHOICE(dump_frames, bDumpFrames);
+	SET_CHOICE(free_look, bFreeLook);
+#if !defined WIN32 && defined HAVE_LIBAV
+	SET_CHOICE(frame_dumps_via_ffv1, bUseFFV1);
+#endif
+
+	SET_CHOICE(crop, bCrop);
+	SET_CHOICE(opencl, bEnableOpenCL);
+	SET_CHOICE(dlcache, bDlistCachingEnable);
+	SET_CHOICE(dlcache, bDlistCachingEnable);
+	SET_CHOICE(ompdecoder, bOMPDecoder);
+	SET_CHOICE(hotkeys, bOSDHotKey);
+
+	if (choice_ppshader)
+	{
+		if (cur_vconfig.sPostProcessingShader.empty()) choice_ppshader->Select(0);
+		else choice_ppshader->SetStringSelection(wxString::FromAscii(cur_vconfig.sPostProcessingShader.c_str()));
+	}
 }
diff --git a/Source/Core/DolphinWX/Src/VideoConfigDiag.h b/Source/Core/DolphinWX/Src/VideoConfigDiag.h
index 4d2f858a75..238e1b82b6 100644
--- a/Source/Core/DolphinWX/Src/VideoConfigDiag.h
+++ b/Source/Core/DolphinWX/Src/VideoConfigDiag.h
@@ -17,29 +17,36 @@
 #include <wx/panel.h>
 #include <wx/spinctrl.h>
 
-class SettingCheckBox : public wxCheckBox
+template <typename U>
+class BoolSettingCB : public wxCheckBox
 {
 public:
-	SettingCheckBox(wxWindow* parent, const wxString& label, const wxString& tooltip,
-		bool &setting, long style = 0);
+	BoolSettingCB(wxWindow* parent, const wxString& label, const wxString& tooltip, bool &setting, bool reverse = false, long style = 0);
+	
+	// overload constructor
+	BoolSettingCB(wxWindow* parent, const wxString& label, const wxString& tooltip, bool &setting, bool &def_setting, bool &state, bool reverse = false, long style = 0);
 
 	void UpdateValue(wxCommandEvent& ev)
 	{
-		int const val = Get3StateValue();
-		*reinterpret_cast<u8*>(&m_setting) = (u8)val;
+		if (m_state) *m_state = (ev.GetInt() != wxCHK_UNDETERMINED);
+		m_setting = (ev.GetInt() == wxCHK_UNDETERMINED) ? d_setting : ((ev.GetInt() != 0) & true); // discriminate CheckBox 3State
+		m_setting = m_setting ^ m_reverse;
 		ev.Skip();
 	}
 
 private:
 	bool &m_setting;
+	bool &d_setting;
+	bool *m_state;
+	const bool m_reverse;
 };
 
-class SettingRadioButton : public wxRadioButton
+template <typename W>
+class BoolSettingRB : public wxRadioButton
 {
 public:
-	SettingRadioButton(wxWindow* parent, const wxString& label, const wxString& tooltip,
-		bool &setting, bool reverse = false, long style = 0);
-
+	BoolSettingRB(wxWindow* parent, const wxString& label, const wxString& tooltip, bool &setting, bool reverse = false, long style = 0);
+	
 	void UpdateValue(wxCommandEvent& ev)
 	{
 		m_setting = (ev.GetInt() != 0) ^ m_reverse;
@@ -51,6 +58,9 @@ private:
 	const bool m_reverse;
 };
 
+typedef BoolSettingCB<wxCheckBox> SettingCheckBox;
+typedef BoolSettingRB<wxRadioButton> SettingRadioButton;
+
 template <typename T>
 class IntegerSetting : public wxSpinCtrl
 {
@@ -62,7 +72,6 @@ public:
 		m_setting = ev.GetInt();
 		ev.Skip();
 	}
-
 private:
 	T& m_setting;
 };
@@ -74,10 +83,17 @@ class SettingChoice : public wxChoice
 public:
 	SettingChoice(wxWindow* parent, int &setting, const wxString& tooltip, int num = 0, const wxString choices[] = NULL, long style = 0);
 	
-	void UpdateValue(wxCommandEvent& ev);
+	// overload constructor
+	SettingChoice(wxWindow* parent, int &setting, int &def_setting, bool &state, int &cur_index, const wxString& tooltip, int num = 0, const wxString choices[] = NULL, long style = 0);
+
 
+	void UpdateValue(wxCommandEvent& ev);
+	void UpdateValue_variant(wxCommandEvent& ev);
 private:
 	int &m_setting;
+	int &d_setting;
+	int &m_index;
+	bool *m_state;
 };
 
 class CGameListCtrl;
@@ -85,33 +101,120 @@ class CGameListCtrl;
 class VideoConfigDiag : public wxDialog
 {
 public:
-	VideoConfigDiag(wxWindow* parent, const std::string &title, bool is_game_config = false);
+	VideoConfigDiag(wxWindow* parent, const std::string &title, const std::string& ininame);
 
-private:
+protected:
 	void Event_Backend(wxCommandEvent &ev) { ev.Skip(); } // TODO: Query list of supported AA modes
 	void Event_Adapter(wxCommandEvent &ev) { ev.Skip(); } // TODO
 
-	void Event_StcSafe(wxCommandEvent &ev) { vconfig.iSafeTextureCache_ColorSamples = 0; ev.Skip(); }
-	void Event_StcNormal(wxCommandEvent &ev) { vconfig.iSafeTextureCache_ColorSamples = 512; ev.Skip(); }
-	void Event_StcFast(wxCommandEvent &ev) { vconfig.iSafeTextureCache_ColorSamples = 128; ev.Skip(); }
+	void Event_StcSafe(wxCommandEvent &ev) { cur_vconfig.iSafeTextureCache_ColorSamples = 0; ev.Skip(); }
+	void Event_StcNormal(wxCommandEvent &ev) { cur_vconfig.iSafeTextureCache_ColorSamples = 512; ev.Skip(); }
+	void Event_StcFast(wxCommandEvent &ev) { cur_vconfig.iSafeTextureCache_ColorSamples = 128; ev.Skip(); }
 
 	void Event_PPShader(wxCommandEvent &ev)
 	{
 		const int sel = ev.GetInt();
 		if (sel)
-			vconfig.sPostProcessingShader = ev.GetString().mb_str();
+			cur_vconfig.sPostProcessingShader = ev.GetString().mb_str();
 		else
-			vconfig.sPostProcessingShader.clear();
+			cur_vconfig.sPostProcessingShader.clear();
 		ev.Skip();
 	}
 
 	void Event_ClickClose(wxCommandEvent&);
 	void Event_Close(wxCloseEvent&);
 
+	void Event_OnProfileChange(wxCommandEvent& ev);
+
+	// Enables/disables UI elements depending on current config - if appropriate also updates g_Config
+	void OnUpdateUI(wxUpdateUIEvent& ev);
+
 	// Refresh UI values from current config (used when reloading config)
 	void SetUIValuesFromConfig();
 
-	VideoConfig& vconfig;
+	// Redraw the aspect about some UI controls when a profile is selected
+	void ChangeStyle();
+
+	// Don't mess with keeping two comboboxes in sync, use only one CB instead..
+	SettingChoice* profile_cb; // "General" tab
+	wxStaticText* profile_text; // "Advanced" tab
+
+	wxChoice* choice_adapter;
+	wxChoice* choice_aspect;
+	SettingCheckBox* widescreen_hack;
+	SettingCheckBox* vsync;
+
+	SettingChoice* anisotropic_filtering;
+	wxStaticText* text_aamode;
+	SettingChoice* choice_aamode;
+
+	SettingCheckBox* native_mips;
+	SettingCheckBox* efb_scaled_copy;
+	SettingCheckBox* pixel_lighting;
+	SettingCheckBox* pixel_depth;
+	SettingCheckBox* force_filtering;
+	SettingCheckBox* _3d_vision;
+
+	wxChoice* choice_efbscale;
+	SettingCheckBox* efbaccess_enable;
+	SettingCheckBox* emulate_efb_format_changes;
+
+	SettingCheckBox* efbcopy_enable;
+	SettingRadioButton* efbcopy_texture;
+	SettingRadioButton* efbcopy_ram;
+	SettingCheckBox* cache_efb_copies;
+
+	SettingCheckBox* stc_enable;
+	wxRadioButton* stc_safe;
+	wxRadioButton* stc_normal;
+	wxRadioButton* stc_fast;
+
+	SettingCheckBox* wireframe;
+	SettingCheckBox* disable_lighting;
+	SettingCheckBox* disable_textures;
+	SettingCheckBox* disable_fog;
+	SettingCheckBox* disable_dst_alpha;
+
+	SettingCheckBox* show_fps;
+	SettingCheckBox* overlay_stats;
+	SettingCheckBox* overlay_proj_stats;
+	SettingCheckBox* texfmt_overlay;
+	SettingCheckBox* efb_copy_regions;
+	SettingCheckBox* show_shader_errors;
+	SettingCheckBox* show_input_display;
+
+	SettingCheckBox* enable_xfb;
+	SettingRadioButton* virtual_xfb;
+	SettingRadioButton* real_xfb;
+
+	SettingCheckBox* dump_textures;
+	SettingCheckBox* hires_textures;
+	SettingCheckBox* dump_efb;
+	SettingCheckBox* dump_frames;
+	SettingCheckBox* free_look;
+	SettingCheckBox* frame_dumps_via_ffv1;
+
+	SettingCheckBox* crop;
+	SettingCheckBox* opencl;
+	SettingCheckBox* dlcache;
+	SettingCheckBox* hotkeys;
+	SettingCheckBox* ompdecoder;
+	wxChoice* choice_ppshader;
+
+	// TODO: Add options for
+	//cur_vconfig.bTexFmtOverlayCenter
+	//cur_vconfig.bAnaglyphStereo
+	//cur_vconfig.iAnaglyphStereoSeparation
+	//cur_vconfig.iAnaglyphFocalAngle
+	//cur_vconfig.bShowEFBCopyRegions
+	//cur_vconfig.iCompileDLsLevel
+
+	VideoConfig cur_vconfig;
+	VideoConfig def_vconfig;
+	std::string ininame;
+	int cur_profile;
+	int prev_profile;
+	const CGameListCtrl *GameListCtrl;
 };
 
 #endif
diff --git a/Source/Core/VideoCommon/Src/VideoConfig.cpp b/Source/Core/VideoCommon/Src/VideoConfig.cpp
index 9e75a59fa9..d88e20a836 100644
--- a/Source/Core/VideoCommon/Src/VideoConfig.cpp
+++ b/Source/Core/VideoCommon/Src/VideoConfig.cpp
@@ -45,83 +45,88 @@ VideoConfig::VideoConfig()
 	backend_info.bSupports3DVision = false;
 }
 
-void VideoConfig::Load(const char *ini_file)
+void VideoConfig::Load(const char *main_ini_file, bool filecheck_passed, const char *game_ini_file)
 {
 	std::string temp;
 	IniFile iniFile;
-	iniFile.Load(ini_file);
-	
-	iniFile.Get("Hardware", "VSync", &bVSync, 0); // Hardware
-	iniFile.Get("Settings", "wideScreenHack", &bWidescreenHack, false);
-	iniFile.Get("Settings", "AspectRatio", &iAspectRatio, (int)ASPECT_AUTO);
-	iniFile.Get("Settings", "Crop", &bCrop, false);
-	iniFile.Get("Settings", "UseXFB", &bUseXFB, 0);
-	iniFile.Get("Settings", "UseRealXFB", &bUseRealXFB, 0);
-	iniFile.Get("Settings", "UseNativeMips", &bUseNativeMips, true);
+	iniFile.Load(main_ini_file);
+
+	#define SET_STATE(evaluate, member) evaluate; UI_State.member = true;
+
+	SET_STATE(iniFile.Get("Hardware", "VSync", &bVSync, false), bVSync); // Hardware
+	SET_STATE(iniFile.Get("Settings", "wideScreenHack", &bWidescreenHack, false), bWidescreenHack);
+	SET_STATE(iniFile.Get("Settings", "AspectRatio", &iAspectRatio, (int)ASPECT_AUTO), iAspectRatio);
+	SET_STATE(iniFile.Get("Settings", "Crop", &bCrop, false), bCrop);
+	SET_STATE(iniFile.Get("Settings", "UseXFB", &bUseXFB, false), bUseXFB);
+	iniFile.Get("Settings", "UseRealXFB", &bUseRealXFB, false);
+	SET_STATE(iniFile.Get("Settings", "UseNativeMips", &bUseNativeMips, true), bUseNativeMips);
 	
-	iniFile.Get("Settings", "SafeTextureCache", &bSafeTextureCache, false); // Settings
+	SET_STATE(iniFile.Get("Settings", "SafeTextureCache", &bSafeTextureCache, false), bSafeTextureCache); // Settings
 	//Safe texture cache params
 	iniFile.Get("Settings", "SafeTextureCacheColorSamples", &iSafeTextureCache_ColorSamples,512);
 
-	iniFile.Get("Settings", "ShowFPS", &bShowFPS, false); // Settings
-	iniFile.Get("Settings", "ShowInputDisplay", &bShowInputDisplay, false);
-	iniFile.Get("Settings", "OverlayStats", &bOverlayStats, false);
-	iniFile.Get("Settings", "OverlayProjStats", &bOverlayProjStats, false);
-	iniFile.Get("Settings", "ShowEFBCopyRegions", &bShowEFBCopyRegions, false);
-	iniFile.Get("Settings", "DLOptimize", &iCompileDLsLevel, 0);
-	iniFile.Get("Settings", "DumpTextures", &bDumpTextures, 0);
-	iniFile.Get("Settings", "HiresTextures", &bHiresTextures, 0);
-	iniFile.Get("Settings", "DumpEFBTarget", &bDumpEFBTarget, 0);
-	iniFile.Get("Settings", "DumpFrames", &bDumpFrames, 0);
-	iniFile.Get("Settings", "FreeLook", &bFreeLook, 0);
-	iniFile.Get("Settings", "UseFFV1", &bUseFFV1, 0);
-	iniFile.Get("Settings", "AnaglyphStereo", &bAnaglyphStereo, false);
-	iniFile.Get("Settings", "AnaglyphStereoSeparation", &iAnaglyphStereoSeparation, 200);
-	iniFile.Get("Settings", "AnaglyphFocalAngle", &iAnaglyphFocalAngle, 0);
-	iniFile.Get("Settings", "EnablePixelLighting", &bEnablePixelLighting, 0);
-	iniFile.Get("Settings", "EnablePerPixelDepth", &bEnablePerPixelDepth, 0);
-	
-	iniFile.Get("Settings", "ShowShaderErrors", &bShowShaderErrors, 0);
-	iniFile.Get("Settings", "MSAA", &iMultisampleMode, 0);
-	iniFile.Get("Settings", "EFBScale", &iEFBScale, 1); // integral
-	
-	iniFile.Get("Settings", "DstAlphaPass", &bDstAlphaPass, false);
-	
-	iniFile.Get("Settings", "TexFmtOverlayEnable", &bTexFmtOverlayEnable, 0);
-	iniFile.Get("Settings", "TexFmtOverlayCenter", &bTexFmtOverlayCenter, 0);
-	iniFile.Get("Settings", "WireFrame", &bWireFrame, 0);
-	iniFile.Get("Settings", "DisableLighting", &bDisableLighting, 0);
-	iniFile.Get("Settings", "DisableTexturing", &bDisableTexturing, 0);
-	iniFile.Get("Settings", "DisableFog", &bDisableFog, 0);
-	
-	iniFile.Get("Settings", "EnableOpenCL", &bEnableOpenCL, false);
+	SET_STATE(iniFile.Get("Settings", "ShowFPS", &bShowFPS, false), bShowFPS); // Settings
+	SET_STATE(iniFile.Get("Settings", "ShowInputDisplay", &bShowInputDisplay, false), bShowInputDisplay);
+	SET_STATE(iniFile.Get("Settings", "OverlayStats", &bOverlayStats, false), bOverlayStats);
+	SET_STATE(iniFile.Get("Settings", "OverlayProjStats", &bOverlayProjStats, false), bOverlayProjStats);
+	SET_STATE(iniFile.Get("Settings", "ShowEFBCopyRegions", &bShowEFBCopyRegions, false), bShowEFBCopyRegions);
+	SET_STATE(iniFile.Get("Settings", "DLOptimize", &iCompileDLsLevel, 0), iCompileDLsLevel);
+	SET_STATE(iniFile.Get("Settings", "DumpTextures", &bDumpTextures, false), bDumpTextures);
+	SET_STATE(iniFile.Get("Settings", "HiresTextures", &bHiresTextures, false), bHiresTextures);
+	SET_STATE(iniFile.Get("Settings", "DumpEFBTarget", &bDumpEFBTarget, false), bDumpEFBTarget) ;
+	SET_STATE(iniFile.Get("Settings", "DumpFrames", &bDumpFrames, false), bDumpFrames);
+	SET_STATE(iniFile.Get("Settings", "FreeLook", &bFreeLook, false), bFreeLook);
+	SET_STATE(iniFile.Get("Settings", "UseFFV1", &bUseFFV1, false), bUseFFV1);
+	SET_STATE(iniFile.Get("Settings", "AnaglyphStereo", &bAnaglyphStereo, false), bAnaglyphStereo);
+	SET_STATE(iniFile.Get("Settings", "AnaglyphStereoSeparation", &iAnaglyphStereoSeparation, 200), iAnaglyphStereoSeparation);
+	SET_STATE(iniFile.Get("Settings", "AnaglyphFocalAngle", &iAnaglyphFocalAngle, 0), iAnaglyphFocalAngle);
+	SET_STATE(iniFile.Get("Settings", "EnablePixelLigting", &bEnablePixelLighting, false), bEnablePixelLighting);
+	SET_STATE(iniFile.Get("Settings", "EnablePerPixelDepth", &bEnablePerPixelDepth, false), bEnablePerPixelDepth);
+	
+	SET_STATE(iniFile.Get("Settings", "ShowShaderErrors", &bShowShaderErrors, false), bShowShaderErrors);
+	SET_STATE(iniFile.Get("Settings", "MSAA", &iMultisampleMode, 0), iMultisampleMode);
+	SET_STATE(iniFile.Get("Settings", "EFBScale", &iEFBScale, 1), iEFBScale); // integral
+	
+	SET_STATE(iniFile.Get("Settings", "DstAlphaPass", &bDstAlphaPass, false), bDstAlphaPass);
+	
+	SET_STATE(iniFile.Get("Settings", "TexFmtOverlayEnable", &bTexFmtOverlayEnable, false), bTexFmtOverlayEnable);
+	SET_STATE(iniFile.Get("Settings", "TexFmtOverlayCenter", &bTexFmtOverlayCenter, false), bTexFmtOverlayCenter);
+	SET_STATE(iniFile.Get("Settings", "WireFrame", &bWireFrame, false), bWireFrame);
+	SET_STATE(iniFile.Get("Settings", "DisableLighting", &bDisableLighting, false), bDisableLighting);
+	SET_STATE(iniFile.Get("Settings", "DisableTexturing", &bDisableTexturing, false), bDisableTexturing);
+	SET_STATE(iniFile.Get("Settings", "DisableFog", &bDisableFog, false), bDisableFog);
+	
+	SET_STATE(iniFile.Get("Settings", "EnableOpenCL", &bEnableOpenCL, false), bEnableOpenCL);
 #ifdef _OPENMP
-	iniFile.Get("Settings", "OMPDecoder", &bOMPDecoder, false);
+	SET_STATE(iniFile.Get("Settings", "OMPDecoder", &bOMPDecoder, false), bOMPDecoder);
 #endif
 
-	iniFile.Get("Enhancements", "ForceFiltering", &bForceFiltering, 0);
-	iniFile.Get("Enhancements", "MaxAnisotropy", &iMaxAnisotropy, 0);  // NOTE - this is x in (1 << x)
+	SET_STATE(iniFile.Get("Enhancements", "ForceFiltering", &bForceFiltering, false), bForceFiltering);
+	SET_STATE(iniFile.Get("Enhancements", "MaxAnisotropy", &iMaxAnisotropy, 0), iMaxAnisotropy);  // NOTE - this is x in (1 << x)
 	iniFile.Get("Enhancements", "PostProcessingShader", &sPostProcessingShader, "");
-	iniFile.Get("Enhancements", "Enable3dVision", &b3DVision, false);
+	SET_STATE(iniFile.Get("Enhancements", "Enable3dVision", &b3DVision, false), b3DVision);
 	
-	iniFile.Get("Hacks", "EFBAccessEnable", &bEFBAccessEnable, true);
-	iniFile.Get("Hacks", "DlistCachingEnable", &bDlistCachingEnable,false);
-	iniFile.Get("Hacks", "EFBCopyEnable", &bEFBCopyEnable, true);
-	iniFile.Get("Hacks", "EFBCopyDisableHotKey", &bOSDHotKey, 0);
+	SET_STATE(iniFile.Get("Hacks", "EFBAccessEnable", &bEFBAccessEnable, true), bEFBAccessEnable);
+	SET_STATE(iniFile.Get("Hacks", "DlistCachingEnable", &bDlistCachingEnable,false), bDlistCachingEnable);
+	SET_STATE(iniFile.Get("Hacks", "EFBCopyEnable", &bEFBCopyEnable, true), bEFBCopyEnable);
+	SET_STATE(iniFile.Get("Hacks", "EFBCopyDisableHotKey", &bOSDHotKey, false), bOSDHotKey);
 	iniFile.Get("Hacks", "EFBToTextureEnable", &bCopyEFBToTexture, false);
-	iniFile.Get("Hacks", "EFBScaledCopy", &bCopyEFBScaled, true);
-	iniFile.Get("Hacks", "EFBCopyCacheEnable", &bEFBCopyCacheEnable, false);
-	iniFile.Get("Hacks", "EFBEmulateFormatChanges", &bEFBEmulateFormatChanges, true);
+	SET_STATE(iniFile.Get("Hacks", "EFBScaledCopy", &bCopyEFBScaled, true), bCopyEFBScaled);
+	SET_STATE(iniFile.Get("Hacks", "EFBCopyCacheEnable", &bEFBCopyCacheEnable, false), bEFBCopyCacheEnable);
+	SET_STATE(iniFile.Get("Hacks", "EFBEmulateFormatChanges", &bEFBEmulateFormatChanges, true), bEFBEmulateFormatChanges);
 
 	iniFile.Get("Hardware", "Adapter", &iAdapter, 0);
 	if (iAdapter == -1)
 		iAdapter = 0;
+	SET_STATE(true, iAdapter);
 	
 	// Load common settings
 	iniFile.Load(File::GetUserPath(F_DOLPHINCONFIG_IDX));
 	bool bTmp;
 	iniFile.Get("Interface", "UsePanicHandlers", &bTmp, true);
 	SetEnableAlert(bTmp);
+	if (filecheck_passed)
+		GameIniLoad(game_ini_file);
 }
 
 void VideoConfig::GameIniLoad(const char *ini_file)
@@ -129,94 +134,91 @@ void VideoConfig::GameIniLoad(const char *ini_file)
 	IniFile iniFile;
 	iniFile.Load(ini_file);
 
-	iniFile.GetIfExists("Video_Hardware", "VSync", &bVSync);
-	iniFile.GetIfExists("Video_Settings", "wideScreenHack", &bWidescreenHack);
-	iniFile.GetIfExists("Video_Settings", "AspectRatio", &iAspectRatio);
-	iniFile.GetIfExists("Video_Settings", "Crop", &bCrop);
-	iniFile.GetIfExists("Video_Settings", "UseXFB", &bUseXFB);
-	iniFile.GetIfExists("Video_Settings", "UseRealXFB", &bUseRealXFB);
-	iniFile.GetIfExists("Video_Settings", "UseNativeMips", &bUseNativeMips);
+	#define SET_UISTATE(check, member) UI_State.member = (check) ? true : false
 
-	iniFile.GetIfExists("Video_Settings", "SafeTextureCache", &bSafeTextureCache);
+	SET_UISTATE(iniFile.GetIfExists("Video_Hardware", "VSync", &bVSync), bVSync);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "wideScreenHack", &bWidescreenHack), bWidescreenHack);
+	
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "AspectRatio", &iAspectRatio), iAspectRatio);
+	
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "Crop", &bCrop), bCrop);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "UseXFB", &bUseXFB), bUseXFB);
+	
+	iniFile.GetIfExists("Video_Settings", "UseRealXFB", &bUseRealXFB);
+	
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "UseNativeMips", &bUseNativeMips), bUseNativeMips);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "SafeTextureCache", &bSafeTextureCache), bSafeTextureCache);
+	
 	iniFile.GetIfExists("Video_Settings", "SafeTextureCacheColorSamples", &iSafeTextureCache_ColorSamples);
 
-	iniFile.GetIfExists("Video_Settings", "ShowFPS", &bShowFPS);
-	iniFile.GetIfExists("Video_Settings", "ShowInputDisplay", &bShowInputDisplay);
-	iniFile.GetIfExists("Video_Settings", "OverlayStats", &bOverlayStats);
-	iniFile.GetIfExists("Video_Settings", "OverlayProjStats", &bOverlayProjStats);
-	iniFile.GetIfExists("Video_Settings", "ShowEFBCopyRegions", &bShowEFBCopyRegions);
-	iniFile.GetIfExists("Video_Settings", "DLOptimize", &iCompileDLsLevel);
-	iniFile.GetIfExists("Video_Settings", "DumpTextures", &bDumpTextures);
-	iniFile.GetIfExists("Video_Settings", "HiresTextures", &bHiresTextures);
-	iniFile.GetIfExists("Video_Settings", "DumpEFBTarget", &bDumpEFBTarget);
-	iniFile.GetIfExists("Video_Settings", "DumpFrames", &bDumpFrames);
-	iniFile.GetIfExists("Video_Settings", "FreeLook", &bFreeLook);
-	iniFile.GetIfExists("Video_Settings", "UseFFV1", &bUseFFV1);
-	iniFile.GetIfExists("Video_Settings", "AnaglyphStereo", &bAnaglyphStereo);
-	iniFile.GetIfExists("Video_Settings", "AnaglyphStereoSeparation", &iAnaglyphStereoSeparation);
-	iniFile.GetIfExists("Video_Settings", "AnaglyphFocalAngle", &iAnaglyphFocalAngle);
-	iniFile.GetIfExists("Video_Settings", "EnablePixelLighting", &bEnablePixelLighting);
-	iniFile.GetIfExists("Video_Settings", "EnablePerPixelDepth", &bEnablePerPixelDepth);
-
-	iniFile.GetIfExists("Video_Settings", "ShowShaderErrors", &bShowShaderErrors);
-	iniFile.GetIfExists("Video_Settings", "MSAA", &iMultisampleMode);
-	iniFile.GetIfExists("Video_Settings", "EFBScale", &iEFBScale); // integral
-
-	iniFile.GetIfExists("Video_Settings", "DstAlphaPass", &bDstAlphaPass);
-
-	iniFile.GetIfExists("Video_Settings", "TexFmtOverlayEnable", &bTexFmtOverlayEnable);
-	iniFile.GetIfExists("Video_Settings", "TexFmtOverlayCenter", &bTexFmtOverlayCenter);
-	iniFile.GetIfExists("Video_Settings", "WireFrame", &bWireFrame);
-	iniFile.GetIfExists("Video_Settings", "DisableLighting", &bDisableLighting);
-	iniFile.GetIfExists("Video_Settings", "DisableTexturing", &bDisableTexturing);
-	iniFile.GetIfExists("Video_Settings", "DisableFog", &bDisableFog);
-
-	iniFile.GetIfExists("Video_Settings", "EnableOpenCL", &bEnableOpenCL);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "ShowFPS", &bShowFPS), bShowFPS);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "ShowInputDisplay", &bShowInputDisplay), bShowInputDisplay);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "OverlayStats", &bOverlayStats), bOverlayStats);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "OverlayProjStats", &bOverlayProjStats), bOverlayProjStats);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "ShowEFBCopyRegions", &bShowEFBCopyRegions), bShowEFBCopyRegions);
+	
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "DLOptimize", &iCompileDLsLevel), iCompileDLsLevel);
+	
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "DumpTextures", &bDumpTextures), bDumpTextures);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "HiresTextures", &bHiresTextures), bHiresTextures);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "DumpEFBTarget", &bDumpEFBTarget), bDumpEFBTarget);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "DumpFrames", &bDumpFrames), bDumpFrames);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "FreeLook", &bFreeLook), bFreeLook);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "UseFFV1", &bUseFFV1), bUseFFV1);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "AnaglyphStereo", &bAnaglyphStereo), bAnaglyphStereo);
+	
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "AnaglyphStereoSeparation", &iAnaglyphStereoSeparation), iAnaglyphStereoSeparation);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "AnaglyphFocalAngle", &iAnaglyphFocalAngle), iAnaglyphFocalAngle);
+	
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "EnablePixelLigting", &bEnablePixelLighting), bEnablePixelLighting);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "EnablePerPixelDepth", &bEnablePerPixelDepth), bEnablePerPixelDepth);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "ShowShaderErrors", &bShowShaderErrors), bShowShaderErrors);
+	
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "MSAA", &iMultisampleMode), iMultisampleMode);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "EFBScale", &iEFBScale), iEFBScale); // integral
+	
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "DstAlphaPass", &bDstAlphaPass), bDstAlphaPass);
+
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "TexFmtOverlayEnable", &bTexFmtOverlayEnable), bTexFmtOverlayEnable);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "TexFmtOverlayCenter", &bTexFmtOverlayCenter), bTexFmtOverlayCenter);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "WireFrame", &bWireFrame), bWireFrame);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "DisableLighting", &bDisableLighting), bDisableLighting);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "DisableTexturing", &bDisableTexturing), bDisableTexturing);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "DisableFog", &bDisableFog), bDisableFog);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "EnableOpenCL", &bEnableOpenCL), bEnableOpenCL);
 #ifdef _OPENMP
-	iniFile.GetIfExists("Video_Settings", "OMPDecoder", &bOMPDecoder);
+	SET_UISTATE(iniFile.GetIfExists("Video_Settings", "OMPDecoder", &bOMPDecoder), bOMPDecoder);
 #endif
-
-	iniFile.GetIfExists("Video_Enhancements", "ForceFiltering", &bForceFiltering);
-	iniFile.GetIfExists("Video_Enhancements", "MaxAnisotropy", &iMaxAnisotropy);  // NOTE - this is x in (1 << x)
+	SET_UISTATE(iniFile.GetIfExists("Video_Enhancements", "ForceFiltering", &bForceFiltering), bForceFiltering);
+	
+	SET_UISTATE(iniFile.GetIfExists("Video_Enhancements", "MaxAnisotropy", &iMaxAnisotropy), iMaxAnisotropy);  // NOTE - this is x in (1 << x)
 	iniFile.GetIfExists("Video_Enhancements", "PostProcessingShader", &sPostProcessingShader);
-	iniFile.GetIfExists("Video_Enhancements", "Enable3dVision", &b3DVision);
+	
+	SET_UISTATE(iniFile.GetIfExists("Video_Enhancements", "Enable3dVision", &b3DVision), b3DVision);
 
-	iniFile.GetIfExists("Video_Hacks", "EFBAccessEnable", &bEFBAccessEnable);
-	iniFile.GetIfExists("Video_Hacks", "DlistCachingEnable", &bDlistCachingEnable);
-	iniFile.GetIfExists("Video_Hacks", "EFBCopyEnable", &bEFBCopyEnable);
-	iniFile.GetIfExists("Video_Hacks", "EFBCopyDisableHotKey", &bOSDHotKey);
+	SET_UISTATE(iniFile.GetIfExists("Video_Hacks", "EFBAccessEnable", &bEFBAccessEnable), bEFBAccessEnable);
+	SET_UISTATE(iniFile.GetIfExists("Video_Hacks", "DlistCachingEnable", &bDlistCachingEnable), bDlistCachingEnable);
+	SET_UISTATE(iniFile.GetIfExists("Video_Hacks", "EFBCopyEnable", &bEFBCopyEnable), bEFBCopyEnable);
+	SET_UISTATE(iniFile.GetIfExists("Video_Hacks", "EFBCopyDisableHotKey", &bOSDHotKey), bOSDHotKey);
+	
 	iniFile.GetIfExists("Video_Hacks", "EFBToTextureEnable", &bCopyEFBToTexture);
-	iniFile.GetIfExists("Video_Hacks", "EFBScaledCopy", &bCopyEFBScaled);
-	iniFile.GetIfExists("Video_Hacks", "EFBCopyCacheEnable", &bEFBCopyCacheEnable);
-	iniFile.GetIfExists("Video_Hacks", "EFBEmulateFormatChanges", &bEFBEmulateFormatChanges);
-
-	iniFile.GetIfExists("Video_Hardware", "Adapter", &iAdapter);
-
-
-	iniFile.GetIfExists("Video", "ForceFiltering", &bForceFiltering);
-	iniFile.GetIfExists("Video", "MaxAnisotropy", &iMaxAnisotropy);  // NOTE - this is x in (1 << x)
-	iniFile.GetIfExists("Video", "EFBCopyEnable", &bEFBCopyEnable);
-	iniFile.GetIfExists("Video", "EFBCopyDisableHotKey", &bOSDHotKey);
-	iniFile.GetIfExists("Video", "EFBAccessEnable", &bEFBAccessEnable);
-	iniFile.GetIfExists("Video", "EFBToTextureEnable", &bCopyEFBToTexture);	
-	iniFile.GetIfExists("Video", "EFBScaledCopy", &bCopyEFBScaled);
-	iniFile.GetIfExists("Video", "SafeTextureCache", &bSafeTextureCache);
-	iniFile.GetIfExists("Video", "SafeTextureCacheColorSamples", &iSafeTextureCache_ColorSamples);
-
-	iniFile.GetIfExists("Video", "MSAA", &iMultisampleMode);
-	iniFile.GetIfExists("Video", "EFBScale", &iEFBScale);
-	iniFile.GetIfExists("Video", "DstAlphaPass", &bDstAlphaPass);
-	iniFile.GetIfExists("Video", "UseXFB", &bUseXFB);
-	iniFile.GetIfExists("Video", "UseRealXFB", &bUseRealXFB);
+	
+	SET_UISTATE(iniFile.GetIfExists("Video_Hacks", "EFBScaledCopy", &bCopyEFBScaled), bCopyEFBScaled);
+	SET_UISTATE(iniFile.GetIfExists("Video_Hacks", "EFBCopyCacheEnable", &bEFBCopyCacheEnable), bEFBCopyCacheEnable);
+	SET_UISTATE(iniFile.GetIfExists("Video_Hacks", "EFBEmulateFormatChanges", &bEFBEmulateFormatChanges), bEFBEmulateFormatChanges);
+
+	SET_UISTATE(iniFile.GetIfExists("Video_Hardware", "Adapter", &iAdapter), iAdapter);
+	
 	iniFile.GetIfExists("Video", "ProjectionHack", &iPhackvalue[0]);
 	iniFile.GetIfExists("Video", "PH_SZNear", &iPhackvalue[1]);
 	iniFile.GetIfExists("Video", "PH_SZFar", &iPhackvalue[2]);
 	iniFile.GetIfExists("Video", "PH_ExtraParam", &iPhackvalue[3]);
 	iniFile.GetIfExists("Video", "PH_ZNear", &sPhackvalue[0]);
 	iniFile.GetIfExists("Video", "PH_ZFar", &sPhackvalue[1]);
-	iniFile.GetIfExists("Video", "UseNativeMips", &bUseNativeMips);
-	iniFile.GetIfExists("Video", "ZTPSpeedupHack", &bZTPSpeedHack);
-	iniFile.GetIfExists("Video", "DlistCachingEnable", &bDlistCachingEnable);
+
+	SET_UISTATE(iniFile.GetIfExists("Video", "ZTPSpeedupHack", &bZTPSpeedHack), bZTPSpeedHack);
+
+	VerifyValidity();
 }
 
 void VideoConfig::VerifyValidity()
@@ -233,6 +235,7 @@ void VideoConfig::Save(const char *ini_file)
 {
 	IniFile iniFile;
 	iniFile.Load(ini_file);
+
 	iniFile.Set("Hardware", "VSync", bVSync);
 	iniFile.Set("Settings", "AspectRatio", iAspectRatio);
 	iniFile.Set("Settings", "Crop", bCrop);
@@ -260,7 +263,7 @@ void VideoConfig::Save(const char *ini_file)
 	iniFile.Set("Settings", "AnaglyphStereo", bAnaglyphStereo);
 	iniFile.Set("Settings", "AnaglyphStereoSeparation", iAnaglyphStereoSeparation);
 	iniFile.Set("Settings", "AnaglyphFocalAngle", iAnaglyphFocalAngle);
-	iniFile.Set("Settings", "EnablePixelLighting", bEnablePixelLighting);
+	iniFile.Set("Settings", "EnablePixelLigting", bEnablePixelLighting);
 	iniFile.Set("Settings", "EnablePerPixelDepth", bEnablePerPixelDepth);
 	
 
@@ -270,7 +273,7 @@ void VideoConfig::Save(const char *ini_file)
 	iniFile.Set("Settings", "EFBScale", iEFBScale);
 	iniFile.Set("Settings", "TexFmtOverlayEnable", bTexFmtOverlayEnable);
 	iniFile.Set("Settings", "TexFmtOverlayCenter", bTexFmtOverlayCenter);
-	iniFile.Set("Settings", "Wireframe", bWireFrame);
+	iniFile.Set("Settings", "WireFrame", bWireFrame);
 	iniFile.Set("Settings", "DisableLighting", bDisableLighting);
 	iniFile.Set("Settings", "DisableTexturing", bDisableTexturing);
 	iniFile.Set("Settings", "DstAlphaPass", bDstAlphaPass);
@@ -300,168 +303,79 @@ void VideoConfig::Save(const char *ini_file)
 	iniFile.Save(ini_file);
 }
 
-// haxhaxhax
-static void SetUndetermined(bool& val)
+void VideoConfig::GameIniSave(const char* default_ini, const char* game_ini)
 {
-	// lul, storing a u8 inside a bool
-	*reinterpret_cast<u8*>(&val) = 2;
-}
 
-static void SetUndetermined(int& val)
-{
-	val = -1;
-}
-
-void VideoConfig::SetAllUndetermined()
-{
-	// video hardware
-	SetUndetermined(bVSync);
-	SetUndetermined(iAdapter);
-
-	// video settings
-	SetUndetermined(bWidescreenHack);
-	SetUndetermined(iAspectRatio);
-	SetUndetermined(bCrop);
-	SetUndetermined(bUseXFB);
-	SetUndetermined(bUseRealXFB);
-	SetUndetermined(bUseNativeMips);
-
-	SetUndetermined(bSafeTextureCache);
-	SetUndetermined(iSafeTextureCache_ColorSamples);
-
-	SetUndetermined(bShowFPS);
-	SetUndetermined(bShowInputDisplay);
-	SetUndetermined(bOverlayStats);
-	SetUndetermined(bOverlayProjStats);
-	SetUndetermined(bShowEFBCopyRegions);
-	SetUndetermined(iCompileDLsLevel);
-	SetUndetermined(bDumpTextures);
-	SetUndetermined(bHiresTextures);
-	SetUndetermined(bDumpEFBTarget);
-	SetUndetermined(bDumpFrames);
-	SetUndetermined(bFreeLook);
-	SetUndetermined(bUseFFV1);
-	SetUndetermined(bAnaglyphStereo);
-	SetUndetermined(iAnaglyphStereoSeparation);
-	SetUndetermined(iAnaglyphFocalAngle);
-	SetUndetermined(bEnablePixelLighting);
-	SetUndetermined(bEnablePerPixelDepth);
-
-	SetUndetermined(bShowShaderErrors);
-	SetUndetermined(iMultisampleMode);
-	SetUndetermined(iEFBScale);
-
-	SetUndetermined(bDstAlphaPass);
-
-	SetUndetermined(bTexFmtOverlayEnable);
-	SetUndetermined(bTexFmtOverlayCenter);
-	SetUndetermined(bWireFrame);
-	SetUndetermined(bDisableLighting);
-	SetUndetermined(bDisableTexturing);
-	SetUndetermined(bDisableFog);
-
-	SetUndetermined(bEnableOpenCL);
+	IniFile iniFile;
+	iniFile.Load(game_ini);
+
+	#define CHECK_UISTATE(section, key, member){\
+		if (UI_State.member) iniFile.Set((section), (key), (member)); else iniFile.DeleteKey((section), (key)); }
+
+	CHECK_UISTATE("Video_Hardware", "VSync", bVSync);
+	CHECK_UISTATE("Video_Settings", "wideScreenHack", bWidescreenHack);
+	CHECK_UISTATE("Video_Settings", "AspectRatio", iAspectRatio);
+	CHECK_UISTATE("Video_Settings", "Crop", bCrop);
+	CHECK_UISTATE("Video_Settings", "UseXFB", bUseXFB);
+	iniFile.Set("Video_Settings", "UseRealXFB", bUseRealXFB);
+	CHECK_UISTATE("Video_Settings", "UseNativeMips", bUseNativeMips);
+
+	CHECK_UISTATE("Video_Settings", "SafeTextureCache", bSafeTextureCache);
+	iniFile.Set("Video_Settings", "SafeTextureCacheColorSamples", iSafeTextureCache_ColorSamples);
+
+	CHECK_UISTATE("Video_Settings", "ShowFPS", bShowFPS);
+	CHECK_UISTATE("Video_Settings", "ShowInputDisplay", bShowInputDisplay);
+	CHECK_UISTATE("Video_Settings", "OverlayStats", bOverlayStats);
+	CHECK_UISTATE("Video_Settings", "OverlayProjStats", bOverlayProjStats);
+	CHECK_UISTATE("Video_Settings", "ShowEFBCopyRegions", bShowEFBCopyRegions);
+	CHECK_UISTATE("Video_Settings", "DLOptimize", iCompileDLsLevel);
+	CHECK_UISTATE("Video_Settings", "DumpTextures", bDumpTextures);
+	CHECK_UISTATE("Video_Settings", "HiresTextures", bHiresTextures);
+	CHECK_UISTATE("Video_Settings", "DumpEFBTarget", bDumpEFBTarget);
+	CHECK_UISTATE("Video_Settings", "DumpFrames", bDumpFrames);
+	CHECK_UISTATE("Video_Settings", "FreeLook", bFreeLook);
+	CHECK_UISTATE("Video_Settings", "UseFFV1", bUseFFV1);
+	CHECK_UISTATE("Video_Settings", "AnaglyphStereo", bAnaglyphStereo);
+	CHECK_UISTATE("Video_Settings", "AnaglyphStereoSeparation", iAnaglyphStereoSeparation);
+	CHECK_UISTATE("Video_Settings", "AnaglyphFocalAngle", iAnaglyphFocalAngle);
+	CHECK_UISTATE("Video_Settings", "EnablePixelLigting", bEnablePixelLighting);
+	CHECK_UISTATE("Video_Settings", "EnablePerPixelDepth", bEnablePerPixelDepth);
+
+	CHECK_UISTATE("Video_Settings", "ShowShaderErrors", bShowShaderErrors);
+	CHECK_UISTATE("Video_Settings", "MSAA", iMultisampleMode);
+	CHECK_UISTATE("Video_Settings", "EFBScale", iEFBScale); // integral
+
+	CHECK_UISTATE("Video_Settings", "DstAlphaPass", bDstAlphaPass);
+
+	CHECK_UISTATE("Video_Settings", "TexFmtOverlayEnable", bTexFmtOverlayEnable);
+	CHECK_UISTATE("Video_Settings", "TexFmtOverlayCenter", bTexFmtOverlayCenter);
+	CHECK_UISTATE("Video_Settings", "WireFrame", bWireFrame);
+	CHECK_UISTATE("Video_Settings", "DisableLighting", bDisableLighting);
+	CHECK_UISTATE("Video_Settings", "DisableTexturing", bDisableTexturing);
+	CHECK_UISTATE("Video_Settings", "DisableFog", bDisableFog);
+
+	CHECK_UISTATE("Video_Settings", "EnableOpenCL", bEnableOpenCL);
 #ifdef _OPENMP
-	SetUndetermined(bOMPDecoder);
+	CHECK_UISTATE("Video_Settings", "OMPDecoder", bOMPDecoder);
 #endif
 
-	// video enhancements
-	SetUndetermined(bForceFiltering);
-	SetUndetermined(iMaxAnisotropy);
-	//SetUndetermined(sPostProcessingShader);
-	SetUndetermined(b3DVision);
-
-	// video hacks
-	SetUndetermined(bEFBAccessEnable);
-	SetUndetermined(bDlistCachingEnable);
-	SetUndetermined(bEFBCopyEnable);
-	SetUndetermined(bOSDHotKey);
-	SetUndetermined(bCopyEFBToTexture);
-	SetUndetermined(bCopyEFBScaled);
-	SetUndetermined(bEFBCopyCacheEnable);
-	SetUndetermined(bEFBEmulateFormatChanges);
-
-	// this doesn't belong here, o well
-	backend_info = BackendInfo();
-}
+	CHECK_UISTATE("Video_Enhancements", "ForceFiltering", bForceFiltering);
+	CHECK_UISTATE("Video_Enhancements", "MaxAnisotropy", iMaxAnisotropy);  // NOTE - this is x in (1 << x)
+	iniFile.Set("Video_Enhancements", "PostProcessingShader", sPostProcessingShader);
+	CHECK_UISTATE("Video_Enhancements", "Enable3dVision", b3DVision);
 
-void VideoConfig::GameIniSave(const char* game_ini)
-{
-	IniFile ini_file;
-	ini_file.Load(game_ini);
-
-	// video hardware
-	IniFile::Section& vid_hardware = *ini_file.GetOrCreateSection("Video_Hardware");
-	SetIfDetermined(vid_hardware, "VSync", bVSync);
-	SetIfDetermined(vid_hardware, "Adapter", iAdapter);
-
-	// video settings
-	IniFile::Section& vid_settings = *ini_file.GetOrCreateSection("Video_Settings");
-	SetIfDetermined(vid_settings, "wideScreenHack", bWidescreenHack);
-	SetIfDetermined(vid_settings, "AspectRatio", iAspectRatio);
-	SetIfDetermined(vid_settings, "Crop", bCrop);
-	SetIfDetermined(vid_settings, "UseXFB", bUseXFB);
-	SetIfDetermined(vid_settings, "UseRealXFB", bUseRealXFB);
-	SetIfDetermined(vid_settings, "UseNativeMips", bUseNativeMips);
-
-	SetIfDetermined(vid_settings, "SafeTextureCache", bSafeTextureCache);
-	SetIfDetermined(vid_settings, "SafeTextureCacheColorSamples", iSafeTextureCache_ColorSamples);
-
-	SetIfDetermined(vid_settings, "ShowFPS", bShowFPS);
-	SetIfDetermined(vid_settings, "ShowInputDisplay", bShowInputDisplay);
-	SetIfDetermined(vid_settings, "OverlayStats", bOverlayStats);
-	SetIfDetermined(vid_settings, "OverlayProjStats", bOverlayProjStats);
-	SetIfDetermined(vid_settings, "ShowEFBCopyRegions", bShowEFBCopyRegions);
-	SetIfDetermined(vid_settings, "DLOptimize", iCompileDLsLevel);
-	SetIfDetermined(vid_settings, "DumpTextures", bDumpTextures);
-	SetIfDetermined(vid_settings, "HiresTextures", bHiresTextures);
-	SetIfDetermined(vid_settings, "DumpEFBTarget", bDumpEFBTarget);
-	SetIfDetermined(vid_settings, "DumpFrames", bDumpFrames);
-	SetIfDetermined(vid_settings, "FreeLook", bFreeLook);
-	SetIfDetermined(vid_settings, "UseFFV1", bUseFFV1);
-	SetIfDetermined(vid_settings, "AnaglyphStereo", bAnaglyphStereo);
-	SetIfDetermined(vid_settings, "AnaglyphStereoSeparation", iAnaglyphStereoSeparation);
-	SetIfDetermined(vid_settings, "AnaglyphFocalAngle", iAnaglyphFocalAngle);
-	SetIfDetermined(vid_settings, "EnablePixelLighting", bEnablePixelLighting);
-	SetIfDetermined(vid_settings, "EnablePerPixelDepth", bEnablePerPixelDepth);
-
-	SetIfDetermined(vid_settings, "ShowShaderErrors", bShowShaderErrors);
-	SetIfDetermined(vid_settings, "MSAA", iMultisampleMode);
-	SetIfDetermined(vid_settings, "EFBScale", iEFBScale); // integral
-
-	SetIfDetermined(vid_settings, "DstAlphaPass", bDstAlphaPass);
-
-	SetIfDetermined(vid_settings, "TexFmtOverlayEnable", bTexFmtOverlayEnable);
-	SetIfDetermined(vid_settings, "TexFmtOverlayCenter", bTexFmtOverlayCenter);
-	SetIfDetermined(vid_settings, "WireFrame", bWireFrame);
-	SetIfDetermined(vid_settings, "DisableLighting", bDisableLighting);
-	SetIfDetermined(vid_settings, "DisableTexturing", bDisableTexturing);
-	SetIfDetermined(vid_settings, "DisableFog", bDisableFog);
-
-	SetIfDetermined(vid_settings, "EnableOpenCL", bEnableOpenCL);
-#ifdef _OPENMP
-	SetIfDetermined(vid_settings, "OMPDecoder", bOMPDecoder);
-#endif
+	CHECK_UISTATE("Video_Hacks", "EFBAccessEnable", bEFBAccessEnable);
+	CHECK_UISTATE("Video_Hacks", "DlistCachingEnable", bDlistCachingEnable);
+	CHECK_UISTATE("Video_Hacks", "EFBCopyEnable", bEFBCopyEnable);
+	CHECK_UISTATE("Video_Hacks", "EFBCopyDisableHotKey", bOSDHotKey);
+	iniFile.Set("Video_Hacks", "EFBToTextureEnable", bCopyEFBToTexture);
+	CHECK_UISTATE("Video_Hacks", "EFBScaledCopy", bCopyEFBScaled);
+	CHECK_UISTATE("Video_Hacks", "EFBCopyCacheEnable", bEFBCopyCacheEnable);
+	CHECK_UISTATE("Video_Hacks", "EFBEmulateFormatChanges", bEFBEmulateFormatChanges);
+
+	CHECK_UISTATE("Video_Hardware", "Adapter", iAdapter);
 
-	// video enhancements
-	IniFile::Section& vid_enhancements = *ini_file.GetOrCreateSection("Video_Enhancements");
-	SetIfDetermined(vid_enhancements, "ForceFiltering", bForceFiltering);
-	SetIfDetermined(vid_enhancements, "MaxAnisotropy", iMaxAnisotropy);  // NOTE - this is x in (1 << x)
-	//SetIfDetermined(vid_enhancements, "PostProcessingShader", sPostProcessingShader);
-	SetIfDetermined(vid_enhancements, "Enable3dVision", b3DVision);
-
-	// video hacks
-	IniFile::Section& vid_hacks = *ini_file.GetOrCreateSection("Video_Hacks");
-	SetIfDetermined(vid_hacks, "EFBAccessEnable", bEFBAccessEnable);
-	SetIfDetermined(vid_hacks, "DlistCachingEnable", bDlistCachingEnable);
-	SetIfDetermined(vid_hacks, "EFBCopyEnable", bEFBCopyEnable);
-	SetIfDetermined(vid_hacks, "EFBCopyDisableHotKey", bOSDHotKey);
-	SetIfDetermined(vid_hacks, "EFBToTextureEnable", bCopyEFBToTexture);
-	SetIfDetermined(vid_hacks, "EFBScaledCopy", bCopyEFBScaled);
-	SetIfDetermined(vid_hacks, "EFBCopyCacheEnable", bEFBCopyCacheEnable);
-	SetIfDetermined(vid_hacks, "EFBEmulateFormatChanges", bEFBEmulateFormatChanges);
-
-	ini_file.Save(game_ini);
+	iniFile.Save(game_ini);
 }
 
 
diff --git a/Source/Core/VideoCommon/Src/VideoConfig.h b/Source/Core/VideoCommon/Src/VideoConfig.h
index b66bc0b0aa..a9b8eb03c9 100644
--- a/Source/Core/VideoCommon/Src/VideoConfig.h
+++ b/Source/Core/VideoCommon/Src/VideoConfig.h
@@ -27,7 +27,6 @@
 
 #include "Common.h"
 #include "VideoCommon.h"
-#include "IniFile.h"
 
 #include <vector>
 #include <string>
@@ -62,17 +61,22 @@ class IniFile;
 // NEVER inherit from this class.
 struct VideoConfig
 {
-	VideoConfig();
-	void Load(const char *ini_file);
+
+private:
+	// According to new structure-design this member MUST BE private
 	void GameIniLoad(const char *ini_file);
+
+public:
+	VideoConfig();
+	// You can choose what "INI snapshot" you wish to load...
+	// GameIni is loaded over MainIni file only if 'fileCheck' argument is passed with success
+	void Load(const char *main_ini_file, bool fileCheck = false, const char *game_ini_file = "");
+
 	void VerifyValidity();
 	void Save(const char *ini_file);
-	void GameIniSave(const char* game_ini);
+	void GameIniSave(const char* default_ini, const char* game_ini);
 	void UpdateProjectionHack();
 
-	// some hacks used for per-game config
-	void SetAllUndetermined();
-
 	// General
 	bool bVSync;
 
@@ -81,7 +85,7 @@ struct VideoConfig
 	int iAspectRatio;
 	bool bCrop;   // Aspect ratio controls.
 	bool bUseXFB;
-	bool bUseRealXFB;
+	bool bUseRealXFB; // joined to radio button
 	bool bUseNativeMips;
 
 	// OpenCL/OpenMP
@@ -113,7 +117,7 @@ struct VideoConfig
 	
 	// Utility
 	bool bDumpTextures;
-	bool bHiresTextures;
+	bool bHiresTextures;	
 	bool bDumpEFBTarget;
 	bool bDumpFrames;
 	bool bUseFFV1;
@@ -123,15 +127,16 @@ struct VideoConfig
 	int iAnaglyphFocalAngle;
 	bool b3DVision;
 	
+	
 	// Hacks
 	bool bEFBAccessEnable;
-	bool bDlistCachingEnable;
+	bool bDlistCachingEnable;	
 
 	bool bEFBCopyEnable;
 	bool bEFBCopyCacheEnable;
 	bool bEFBEmulateFormatChanges;
 	bool bOSDHotKey;
-	bool bCopyEFBToTexture;	
+	bool bCopyEFBToTexture; // joined to radio button
 	bool bCopyEFBScaled;
 	bool bSafeTextureCache;
 	int iSafeTextureCache_ColorSamples;
@@ -152,8 +157,64 @@ struct VideoConfig
 	// D3D only config, mostly to be merged into the above
 	int iAdapter;
 
+	// UI Controls state
+	struct
+	{
+		// IMPORTANT: each member inside this struct MUST HAVE same name corresponding to data member
+		bool bVSync;
+		bool bWidescreenHack;
+		bool iAspectRatio;
+		bool bCrop;
+		bool bUseXFB;
+		bool bUseNativeMips;
+		bool bEnableOpenCL;
+		bool iMultisampleMode;
+		bool iEFBScale;
+		bool bForceFiltering;
+		bool iMaxAnisotropy;
+		bool bShowFPS;
+		bool bShowInputDisplay;
+		bool bOverlayStats;
+		bool bOverlayProjStats;
+		bool bTexFmtOverlayEnable;
+		bool bTexFmtOverlayCenter;
+		bool bShowEFBCopyRegions;
+		bool bWireFrame;
+		bool bDisableLighting;
+		bool bDisableTexturing;
+		bool bDstAlphaPass;
+		bool bDisableFog;
+		bool bDumpTextures;
+		bool bHiresTextures;
+		bool bDumpEFBTarget;
+		bool bDumpFrames;
+		bool bUseFFV1;
+		bool bFreeLook;
+		bool bAnaglyphStereo;
+		bool b3DVision;
+		bool iAnaglyphStereoSeparation;
+		bool iAnaglyphFocalAngle;
+		bool bEFBAccessEnable;
+		bool bOMPDecoder;
+		bool bDlistCachingEnable;
+		bool bEFBCopyEnable;
+		bool bEFBCopyCacheEnable;
+		bool bEFBEmulateFormatChanges;
+		bool bOSDHotKey;
+		bool bCopyEFBScaled;
+		bool bSafeTextureCache;
+		bool bZTPSpeedHack;
+		bool bEnablePixelLighting;
+		bool bEnablePerPixelDepth;
+		bool iLog;
+		bool iSaveTargetId;
+		bool iCompileDLsLevel;
+		bool bShowShaderErrors;
+		bool iAdapter;
+	} UI_State;
+
 	// Static config per API
-	struct BackendInfo
+	struct
 	{
 		API_TYPE APIType;
 
@@ -167,29 +228,6 @@ struct VideoConfig
 		bool bSupportsFormatReinterpretation;
 		bool bSupportsPixelLighting;
 	} backend_info;
-
-	// haxhaxhax
-	static bool IsUndetermined(const bool& val)
-	{
-		// lul, storing a u8 inside a bool
-		return (*reinterpret_cast<const u8*>(&val) > 1);
-	}
-
-	static bool IsUndetermined(int val)
-	{
-		return (val < 0);
-	}
-
-private:
-
-	template <typename T>
-	void SetIfDetermined(IniFile::Section& sect, const char* key, const T& value)
-	{
-		if (IsUndetermined(value))
-			sect.Delete(key);
-		else
-			sect.Set(key, value);
-	}
 };
 
 extern VideoConfig g_Config;