From 086ec7a9b7982509c43cefaeb884e2bc37350b62 Mon Sep 17 00:00:00 2001 From: Lioncash Date: Wed, 18 Mar 2015 18:00:27 -0400 Subject: [PATCH] DolphinWX: Break up ConfigMain.cpp into separate classes Prior to this, ConfigMain.cpp was a large (52KB) cpp file that contained all of the UI setting code. This breaks up the config code into subclasses of wxPanel, which are then just instantiated to add to the settings wxNoteBook. This keeps all the settings categories separated from one another and also cleans up the code in general. --- Source/Core/DolphinWX/CMakeLists.txt | 9 +- .../DolphinWX/Config/AdvancedConfigPane.cpp | 91 ++ .../DolphinWX/Config/AdvancedConfigPane.h | 31 + .../Core/DolphinWX/Config/AudioConfigPane.cpp | 178 +++ .../Core/DolphinWX/Config/AudioConfigPane.h | 47 + Source/Core/DolphinWX/Config/ConfigMain.cpp | 95 ++ Source/Core/DolphinWX/Config/ConfigMain.h | 51 + .../DolphinWX/Config/GameCubeConfigPane.cpp | 366 +++++ .../DolphinWX/Config/GameCubeConfigPane.h | 43 + .../DolphinWX/Config/GeneralConfigPane.cpp | 167 ++ .../Core/DolphinWX/Config/GeneralConfigPane.h | 43 + .../DolphinWX/Config/InterfaceConfigPane.cpp | 256 +++ .../DolphinWX/Config/InterfaceConfigPane.h | 42 + .../Core/DolphinWX/Config/PathConfigPane.cpp | 196 +++ Source/Core/DolphinWX/Config/PathConfigPane.h | 46 + .../Core/DolphinWX/Config/WiiConfigPane.cpp | 178 +++ Source/Core/DolphinWX/Config/WiiConfigPane.h | 44 + Source/Core/DolphinWX/ConfigMain.cpp | 1382 ----------------- Source/Core/DolphinWX/ConfigMain.h | 278 ---- Source/Core/DolphinWX/DolphinWX.vcxproj | 18 +- .../Core/DolphinWX/DolphinWX.vcxproj.filters | 57 +- Source/Core/DolphinWX/FrameTools.cpp | 2 +- 22 files changed, 1950 insertions(+), 1670 deletions(-) create mode 100644 Source/Core/DolphinWX/Config/AdvancedConfigPane.cpp create mode 100644 Source/Core/DolphinWX/Config/AdvancedConfigPane.h create mode 100644 Source/Core/DolphinWX/Config/AudioConfigPane.cpp create mode 100644 Source/Core/DolphinWX/Config/AudioConfigPane.h create mode 100644 Source/Core/DolphinWX/Config/ConfigMain.cpp create mode 100644 Source/Core/DolphinWX/Config/ConfigMain.h create mode 100644 Source/Core/DolphinWX/Config/GameCubeConfigPane.cpp create mode 100644 Source/Core/DolphinWX/Config/GameCubeConfigPane.h create mode 100644 Source/Core/DolphinWX/Config/GeneralConfigPane.cpp create mode 100644 Source/Core/DolphinWX/Config/GeneralConfigPane.h create mode 100644 Source/Core/DolphinWX/Config/InterfaceConfigPane.cpp create mode 100644 Source/Core/DolphinWX/Config/InterfaceConfigPane.h create mode 100644 Source/Core/DolphinWX/Config/PathConfigPane.cpp create mode 100644 Source/Core/DolphinWX/Config/PathConfigPane.h create mode 100644 Source/Core/DolphinWX/Config/WiiConfigPane.cpp create mode 100644 Source/Core/DolphinWX/Config/WiiConfigPane.h delete mode 100644 Source/Core/DolphinWX/ConfigMain.cpp delete mode 100644 Source/Core/DolphinWX/ConfigMain.h diff --git a/Source/Core/DolphinWX/CMakeLists.txt b/Source/Core/DolphinWX/CMakeLists.txt index 48e637e54a..da4e8856cb 100644 --- a/Source/Core/DolphinWX/CMakeLists.txt +++ b/Source/Core/DolphinWX/CMakeLists.txt @@ -1,12 +1,19 @@ set(GUI_SRCS ARCodeAddEdit.cpp AboutDolphin.cpp - ConfigMain.cpp ControllerConfigDiag.cpp Cheats/CheatSearchTab.cpp Cheats/CheatsWindow.cpp Cheats/CreateCodeDialog.cpp Cheats/GeckoCodeDiag.cpp + Config/AdvancedConfigPane.cpp + Config/AudioConfigPane.cpp + Config/ConfigMain.cpp + Config/GameCubeConfigPane.cpp + Config/GeneralConfigPane.cpp + Config/InterfaceConfigPane.cpp + Config/PathConfigPane.cpp + Config/WiiConfigPane.cpp Debugger/BreakpointDlg.cpp Debugger/BreakpointView.cpp Debugger/BreakpointWindow.cpp diff --git a/Source/Core/DolphinWX/Config/AdvancedConfigPane.cpp b/Source/Core/DolphinWX/Config/AdvancedConfigPane.cpp new file mode 100644 index 0000000000..8dd69d1e3f --- /dev/null +++ b/Source/Core/DolphinWX/Config/AdvancedConfigPane.cpp @@ -0,0 +1,91 @@ +// Copyright 2015 Dolphin Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#include + +#include +#include +#include +#include + +#include "Core/ConfigManager.h" +#include "DolphinWX/Config/AdvancedConfigPane.h" + +AdvancedConfigPane::AdvancedConfigPane(wxWindow* parent, wxWindowID id) + : wxPanel(parent, id) +{ + InitializeGUI(); + LoadGUIValues(); +} + +void AdvancedConfigPane::InitializeGUI() +{ + m_clock_override_checkbox = new wxCheckBox(this, wxID_ANY, _("Enable CPU Clock Override")); + m_clock_override_slider = new wxSlider(this, wxID_ANY, 100, 0, 150); + m_clock_override_text = new wxStaticText(this, wxID_ANY, ""); + + m_clock_override_checkbox->Bind(wxEVT_CHECKBOX, &AdvancedConfigPane::OnClockOverrideCheckBoxChanged, this); + m_clock_override_slider->Bind(wxEVT_SLIDER, &AdvancedConfigPane::OnClockOverrideSliderChanged, this); + + wxStaticText* const clock_override_description = new wxStaticText(this, wxID_ANY, + _("Higher values can make variable-framerate games\n" + "run at a higher framerate, at the expense of CPU.\n" + "Lower values can make variable-framerate games\n" + "run at a lower framerate, saving CPU.\n\n" + "WARNING: Changing this from the default (100%)\n" + "can and will break games and cause glitches.\n" + "Do so at your own risk. Please do not report\n" + "bugs that occur with a non-default clock.\n")); + + wxBoxSizer* const clock_override_checkbox_sizer = new wxBoxSizer(wxHORIZONTAL); + clock_override_checkbox_sizer->Add(m_clock_override_checkbox); + + wxBoxSizer* const clock_override_slider_sizer = new wxBoxSizer(wxHORIZONTAL); + clock_override_slider_sizer->Add(m_clock_override_slider, 1, wxALL, 5); + clock_override_slider_sizer->Add(m_clock_override_text, 1, wxALL, 5); + + wxBoxSizer* const clock_override_description_sizer = new wxBoxSizer(wxHORIZONTAL); + clock_override_description_sizer->Add(clock_override_description, 1, wxALL, 5); + + wxStaticBoxSizer* const cpu_options_sizer = new wxStaticBoxSizer(wxVERTICAL, this, _("CPU Options")); + cpu_options_sizer->Add(clock_override_checkbox_sizer); + cpu_options_sizer->Add(clock_override_slider_sizer); + cpu_options_sizer->Add(clock_override_description_sizer); + + wxBoxSizer* const main_sizer = new wxBoxSizer(wxVERTICAL); + main_sizer->Add(cpu_options_sizer , 0, wxEXPAND | wxALL, 5); + + SetSizer(main_sizer); +} + +void AdvancedConfigPane::LoadGUIValues() +{ + int ocFactor = (int)(std::log2f(SConfig::GetInstance().m_OCFactor) * 25.f + 100.f + 0.5f); + m_clock_override_checkbox->SetValue(SConfig::GetInstance().m_OCEnable); + m_clock_override_slider ->SetValue(ocFactor); + UpdateCPUClock(); +} + +void AdvancedConfigPane::OnClockOverrideCheckBoxChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_OCEnable = m_clock_override_checkbox->IsChecked(); + m_clock_override_slider->Enable(SConfig::GetInstance().m_OCEnable); + UpdateCPUClock(); +} + +void AdvancedConfigPane::OnClockOverrideSliderChanged(wxCommandEvent& event) +{ + // Vaguely exponential scaling? + SConfig::GetInstance().m_OCFactor = std::exp2f((m_clock_override_slider->GetValue() - 100.f) / 25.f); + UpdateCPUClock(); +} + +void AdvancedConfigPane::UpdateCPUClock() +{ + bool wii = SConfig::GetInstance().m_LocalCoreStartupParameter.bWii; + int percent = (int)(std::roundf(SConfig::GetInstance().m_OCFactor * 100.f)); + int clock = (int)(std::roundf(SConfig::GetInstance().m_OCFactor * (wii ? 729.f : 486.f))); + + m_clock_override_text->SetLabel(SConfig::GetInstance().m_OCEnable ? wxString::Format("%d %% (%d mhz)", percent, clock) : ""); +} diff --git a/Source/Core/DolphinWX/Config/AdvancedConfigPane.h b/Source/Core/DolphinWX/Config/AdvancedConfigPane.h new file mode 100644 index 0000000000..e59a1b84a6 --- /dev/null +++ b/Source/Core/DolphinWX/Config/AdvancedConfigPane.h @@ -0,0 +1,31 @@ +// Copyright 2015 Dolphin Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#pragma once + +#include + +class wxCheckBox; +class wxCommandEvent; +class wxSlider; +class wxStaticText; + +class AdvancedConfigPane final : public wxPanel +{ +public: + AdvancedConfigPane(wxWindow* parent, wxWindowID id); + +private: + void InitializeGUI(); + void LoadGUIValues(); + + void OnClockOverrideCheckBoxChanged(wxCommandEvent&); + void OnClockOverrideSliderChanged(wxCommandEvent&); + + void UpdateCPUClock(); + + wxCheckBox* m_clock_override_checkbox; + wxSlider* m_clock_override_slider; + wxStaticText* m_clock_override_text; +}; diff --git a/Source/Core/DolphinWX/Config/AudioConfigPane.cpp b/Source/Core/DolphinWX/Config/AudioConfigPane.cpp new file mode 100644 index 0000000000..d005620dd4 --- /dev/null +++ b/Source/Core/DolphinWX/Config/AudioConfigPane.cpp @@ -0,0 +1,178 @@ +// Copyright 2015 Dolphin Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "AudioCommon/AudioCommon.h" +#include "Core/ConfigManager.h" +#include "Core/Core.h" +#include "DolphinWX/WxUtils.h" +#include "DolphinWX/Config/AudioConfigPane.h" + +AudioConfigPane::AudioConfigPane(wxWindow* parent, wxWindowID id) + : wxPanel(parent, id) +{ + InitializeGUI(); + LoadGUIValues(); + RefreshGUI(); +} + +void AudioConfigPane::InitializeGUI() +{ + m_dsp_engine_strings.Add(_("DSP HLE emulation (fast)")); + m_dsp_engine_strings.Add(_("DSP LLE recompiler")); + m_dsp_engine_strings.Add(_("DSP LLE interpreter (slow)")); + + m_dsp_engine_radiobox = new wxRadioBox(this, wxID_ANY, _("DSP Emulator Engine"), wxDefaultPosition, wxDefaultSize, m_dsp_engine_strings, 0, wxRA_SPECIFY_ROWS); + m_dpl2_decoder_checkbox = new wxCheckBox(this, wxID_ANY, _("Dolby Pro Logic II decoder")); + m_volume_slider = new wxSlider(this, wxID_ANY, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_VERTICAL | wxSL_INVERSE); + m_volume_text = new wxStaticText(this, wxID_ANY, ""); + m_audio_backend_choice = new wxChoice(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, m_audio_backend_strings); + m_audio_latency_spinctrl = new wxSpinCtrl(this, wxID_ANY, "", wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 0, 30); + + m_dsp_engine_radiobox->Bind(wxEVT_RADIOBOX, &AudioConfigPane::OnDSPEngineRadioBoxChanged, this); + m_dpl2_decoder_checkbox->Bind(wxEVT_CHECKBOX, &AudioConfigPane::OnDPL2DecoderCheckBoxChanged, this); + m_volume_slider->Bind(wxEVT_SLIDER, &AudioConfigPane::OnVolumeSliderChanged, this); + m_audio_backend_choice->Bind(wxEVT_CHOICE, &AudioConfigPane::OnAudioBackendChanged, this); + m_audio_latency_spinctrl->Bind(wxEVT_SPINCTRL, &AudioConfigPane::OnLatencySpinCtrlChanged, this); + + m_audio_backend_choice->SetToolTip(_("Changing this will have no effect while the emulator is running.")); + m_audio_latency_spinctrl->SetToolTip(_("Sets the latency (in ms). Higher values may reduce audio crackling. OpenAL backend only.")); +#if defined(__APPLE__) + m_dpl2_decoder_checkbox->SetToolTip(_("Enables Dolby Pro Logic II emulation using 5.1 surround. Not available on OS X.")); +#else + m_dpl2_decoder_checkbox->SetToolTip(_("Enables Dolby Pro Logic II emulation using 5.1 surround. OpenAL or Pulse backends only.")); +#endif + + wxStaticBoxSizer* const dsp_engine_sizer = new wxStaticBoxSizer(wxVERTICAL, this, _("Sound Settings")); + dsp_engine_sizer->Add(m_dsp_engine_radiobox, 0, wxALL | wxEXPAND, 5); + dsp_engine_sizer->Add(m_dpl2_decoder_checkbox, 0, wxALL, 5); + + wxStaticBoxSizer* const volume_sizer = new wxStaticBoxSizer(wxVERTICAL, this, _("Volume")); + volume_sizer->Add(m_volume_slider, 1, wxLEFT | wxRIGHT, 13); + volume_sizer->Add(m_volume_text, 0, wxALIGN_CENTER | wxALL, 5); + + wxGridBagSizer* const backend_grid_sizer = new wxGridBagSizer(); + backend_grid_sizer->Add(new wxStaticText(this, wxID_ANY, _("Audio Backend:")), wxGBPosition(0, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxALL, 5); + backend_grid_sizer->Add(m_audio_backend_choice, wxGBPosition(0, 1), wxDefaultSpan, wxALL, 5); + backend_grid_sizer->Add(new wxStaticText(this, wxID_ANY, _("Latency:")), wxGBPosition(1, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxALL, 5); + backend_grid_sizer->Add(m_audio_latency_spinctrl, wxGBPosition(1, 1), wxDefaultSpan, wxALL, 5); + + wxStaticBoxSizer* const backend_static_box_sizer = new wxStaticBoxSizer(wxHORIZONTAL, this, _("Backend Settings")); + backend_static_box_sizer->Add(backend_grid_sizer, 0, wxEXPAND); + + wxBoxSizer* const dsp_audio_sizer = new wxBoxSizer(wxHORIZONTAL); + dsp_audio_sizer->Add(dsp_engine_sizer, 1, wxEXPAND | wxALL, 5); + dsp_audio_sizer->Add(volume_sizer, 0, wxEXPAND | wxALL, 5); + + wxBoxSizer* const main_sizer = new wxBoxSizer(wxVERTICAL); + main_sizer->Add(dsp_audio_sizer, 0, wxALL | wxEXPAND); + main_sizer->Add(backend_static_box_sizer, 0, wxALL | wxEXPAND, 5); + + SetSizerAndFit(main_sizer); +} + +void AudioConfigPane::LoadGUIValues() +{ + PopulateBackendChoiceBox(); + + const SCoreStartupParameter& startup_params = SConfig::GetInstance().m_LocalCoreStartupParameter; + + // Audio DSP Engine + if (startup_params.bDSPHLE) + m_dsp_engine_radiobox->SetSelection(0); + else + m_dsp_engine_radiobox->SetSelection(SConfig::GetInstance().m_DSPEnableJIT ? 1 : 2); + + m_volume_slider->Enable(SupportsVolumeChanges(SConfig::GetInstance().sBackend)); + m_volume_slider->SetValue(SConfig::GetInstance().m_Volume); + + m_volume_text->SetLabel(wxString::Format("%d %%", SConfig::GetInstance().m_Volume)); + + m_dpl2_decoder_checkbox->Enable(std::string(SConfig::GetInstance().sBackend) == BACKEND_OPENAL + || std::string(SConfig::GetInstance().sBackend) == BACKEND_PULSEAUDIO); + m_dpl2_decoder_checkbox->SetValue(startup_params.bDPL2Decoder); + + m_audio_latency_spinctrl->Enable(std::string(SConfig::GetInstance().sBackend) == BACKEND_OPENAL); + m_audio_latency_spinctrl->SetValue(startup_params.iLatency); +} + +void AudioConfigPane::RefreshGUI() +{ + if (Core::IsRunning()) + { + m_audio_latency_spinctrl->Disable(); + m_audio_backend_choice->Disable(); + m_dpl2_decoder_checkbox->Disable(); + m_dsp_engine_radiobox->Disable(); + } +} + +void AudioConfigPane::OnDSPEngineRadioBoxChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_LocalCoreStartupParameter.bDSPHLE = m_dsp_engine_radiobox->GetSelection() == 0; + SConfig::GetInstance().m_DSPEnableJIT = m_dsp_engine_radiobox->GetSelection() == 1; + AudioCommon::UpdateSoundStream(); +} + +void AudioConfigPane::OnDPL2DecoderCheckBoxChanged(wxCommandEvent&) +{ + SConfig::GetInstance().m_LocalCoreStartupParameter.bDPL2Decoder = m_dpl2_decoder_checkbox->IsChecked(); +} + +void AudioConfigPane::OnVolumeSliderChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_Volume = m_volume_slider->GetValue(); + AudioCommon::UpdateSoundStream(); + m_volume_text->SetLabel(wxString::Format("%d %%", m_volume_slider->GetValue())); +} + +void AudioConfigPane::OnAudioBackendChanged(wxCommandEvent& event) +{ + m_volume_slider->Enable(SupportsVolumeChanges(WxStrToStr(m_audio_backend_choice->GetStringSelection()))); + m_audio_latency_spinctrl->Enable(WxStrToStr(m_audio_backend_choice->GetStringSelection()) == BACKEND_OPENAL); + m_dpl2_decoder_checkbox->Enable(WxStrToStr(m_audio_backend_choice->GetStringSelection()) == BACKEND_OPENAL || + WxStrToStr(m_audio_backend_choice->GetStringSelection()) == BACKEND_PULSEAUDIO); + + // Don't save the translated BACKEND_NULLSOUND string + SConfig::GetInstance().sBackend = m_audio_backend_choice->GetSelection() ? + WxStrToStr(m_audio_backend_choice->GetStringSelection()) : BACKEND_NULLSOUND; + + AudioCommon::UpdateSoundStream(); +} + +void AudioConfigPane::OnLatencySpinCtrlChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_LocalCoreStartupParameter.iLatency = m_audio_latency_spinctrl->GetValue(); +} + +void AudioConfigPane::PopulateBackendChoiceBox() +{ + for (const std::string& backend : AudioCommon::GetSoundBackends()) + { + m_audio_backend_choice->Append(wxGetTranslation(StrToWxStr(backend))); + + int num = m_audio_backend_choice->FindString(StrToWxStr(SConfig::GetInstance().sBackend)); + m_audio_backend_choice->SetSelection(num); + } +} + +bool AudioConfigPane::SupportsVolumeChanges(const std::string& backend) +{ + //FIXME: this one should ask the backend whether it supports it. + // but getting the backend from string etc. is probably + // too much just to enable/disable a stupid slider... + return (backend == BACKEND_COREAUDIO || + backend == BACKEND_OPENAL || + backend == BACKEND_XAUDIO2); +} diff --git a/Source/Core/DolphinWX/Config/AudioConfigPane.h b/Source/Core/DolphinWX/Config/AudioConfigPane.h new file mode 100644 index 0000000000..cb5171dbf5 --- /dev/null +++ b/Source/Core/DolphinWX/Config/AudioConfigPane.h @@ -0,0 +1,47 @@ +// Copyright 2015 Dolphin Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#pragma once + +#include +#include +#include + +class wxCheckBox; +class wxChoice; +class wxCommandEvent; +class wxRadioBox; +class wxSlider; +class wxSpinCtrl; +class wxStaticText; + +class AudioConfigPane final : public wxPanel +{ +public: + AudioConfigPane(wxWindow* parent, wxWindowID id); + +private: + void InitializeGUI(); + void LoadGUIValues(); + void RefreshGUI(); + + void PopulateBackendChoiceBox(); + static bool SupportsVolumeChanges(const std::string&); + + void OnDSPEngineRadioBoxChanged(wxCommandEvent&); + void OnDPL2DecoderCheckBoxChanged(wxCommandEvent&); + void OnVolumeSliderChanged(wxCommandEvent&); + void OnAudioBackendChanged(wxCommandEvent&); + void OnLatencySpinCtrlChanged(wxCommandEvent&); + + wxArrayString m_dsp_engine_strings; + wxArrayString m_audio_backend_strings; + + wxRadioBox* m_dsp_engine_radiobox; + wxCheckBox* m_dpl2_decoder_checkbox; + wxSlider* m_volume_slider; + wxStaticText* m_volume_text; + wxChoice* m_audio_backend_choice; + wxSpinCtrl* m_audio_latency_spinctrl; +}; diff --git a/Source/Core/DolphinWX/Config/ConfigMain.cpp b/Source/Core/DolphinWX/Config/ConfigMain.cpp new file mode 100644 index 0000000000..5b0a15e78b --- /dev/null +++ b/Source/Core/DolphinWX/Config/ConfigMain.cpp @@ -0,0 +1,95 @@ +// Copyright 2013 Dolphin Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#include +#include +#include +#include + +#include "Common/CommonTypes.h" +#include "Core/ConfigManager.h" +#include "DolphinWX/WxUtils.h" +#include "DolphinWX/Config/AdvancedConfigPane.h" +#include "DolphinWX/Config/AudioConfigPane.h" +#include "DolphinWX/Config/ConfigMain.h" +#include "DolphinWX/Config/GameCubeConfigPane.h" +#include "DolphinWX/Config/GeneralConfigPane.h" +#include "DolphinWX/Config/InterfaceConfigPane.h" +#include "DolphinWX/Config/PathConfigPane.h" +#include "DolphinWX/Config/WiiConfigPane.h" + +BEGIN_EVENT_TABLE(CConfigMain, wxDialog) + +EVT_CLOSE(CConfigMain::OnClose) +EVT_BUTTON(wxID_OK, CConfigMain::OnOk) + +END_EVENT_TABLE() + +CConfigMain::CConfigMain(wxWindow* parent, wxWindowID id, const wxString& title, + const wxPoint& position, const wxSize& size, long style) + : wxDialog(parent, id, title, position, size, style) +{ + // Control refreshing of the ISOs list + bRefreshList = false; + + CreateGUIControls(); +} + +CConfigMain::~CConfigMain() +{ +} + +void CConfigMain::SetSelectedTab(int tab) +{ + // TODO : this is just a quick and dirty way to do it, possible cleanup + + switch (tab) + { + case ID_AUDIOPAGE: + Notebook->SetSelection(2); + break; + } +} + +void CConfigMain::CreateGUIControls() +{ + // Create the notebook and pages + Notebook = new wxNotebook(this, ID_NOTEBOOK); + wxPanel* const general_pane = new GeneralConfigPane(Notebook, ID_GENERALPAGE); + wxPanel* const interface_pane = new InterfaceConfigPane(Notebook, ID_DISPLAYPAGE); + wxPanel* const audio_pane = new AudioConfigPane(Notebook, ID_AUDIOPAGE); + wxPanel* const gamecube_pane = new GameCubeConfigPane(Notebook, ID_GAMECUBEPAGE); + wxPanel* const wii_pane = new WiiConfigPane(Notebook, ID_WIIPAGE); + wxPanel* const path_pane = new PathConfigPane(Notebook, ID_PATHSPAGE); + wxPanel* const advanced_pane = new AdvancedConfigPane(Notebook, ID_ADVANCEDPAGE); + + Notebook->AddPage(general_pane, _("General")); + Notebook->AddPage(interface_pane, _("Interface")); + Notebook->AddPage(audio_pane, _("Audio")); + Notebook->AddPage(gamecube_pane, _("GameCube")); + Notebook->AddPage(wii_pane, _("Wii")); + Notebook->AddPage(path_pane, _("Paths")); + Notebook->AddPage(advanced_pane, _("Advanced")); + + wxBoxSizer* const main_sizer = new wxBoxSizer(wxVERTICAL); + main_sizer->Add(Notebook, 1, wxEXPAND | wxALL, 5); + main_sizer->Add(CreateButtonSizer(wxOK), 0, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 5); + + SetSizerAndFit(main_sizer); + Center(); + SetFocus(); +} + +void CConfigMain::OnClose(wxCloseEvent& WXUNUSED(event)) +{ + EndModal((bRefreshList) ? wxID_OK : wxID_CANCEL); +} + +void CConfigMain::OnOk(wxCommandEvent& WXUNUSED(event)) +{ + Close(); + + // Save the config. Dolphin crashes too often to only save the settings on closing + SConfig::GetInstance().SaveSettings(); +} diff --git a/Source/Core/DolphinWX/Config/ConfigMain.h b/Source/Core/DolphinWX/Config/ConfigMain.h new file mode 100644 index 0000000000..9a276f3aa7 --- /dev/null +++ b/Source/Core/DolphinWX/Config/ConfigMain.h @@ -0,0 +1,51 @@ +// Copyright 2013 Dolphin Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#pragma once + +#include +#include "Common/CommonTypes.h" + +class wxNotebook; +class wxPanel; +class wxWindow; + +class CConfigMain : public wxDialog +{ +public: + + CConfigMain(wxWindow* parent, + wxWindowID id = wxID_ANY, + const wxString& title = _("Dolphin Configuration"), + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxDEFAULT_DIALOG_STYLE); + virtual ~CConfigMain(); + + void SetSelectedTab(int tab); + + enum + { + ID_NOTEBOOK = 1000, + ID_GENERALPAGE, + ID_DISPLAYPAGE, + ID_AUDIOPAGE, + ID_GAMECUBEPAGE, + ID_WIIPAGE, + ID_PATHSPAGE, + ID_ADVANCEDPAGE, + }; + +private: + void CreateGUIControls(); + void OnClose(wxCloseEvent& event); + void OnOk(wxCommandEvent& event); + + wxNotebook* Notebook; + + bool bRefreshList; + +private: + DECLARE_EVENT_TABLE(); +}; diff --git a/Source/Core/DolphinWX/Config/GameCubeConfigPane.cpp b/Source/Core/DolphinWX/Config/GameCubeConfigPane.cpp new file mode 100644 index 0000000000..729dcab754 --- /dev/null +++ b/Source/Core/DolphinWX/Config/GameCubeConfigPane.cpp @@ -0,0 +1,366 @@ +// Copyright 2015 Dolphin Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "Common/CommonPaths.h" +#include "Common/FileUtil.h" +#include "Core/ConfigManager.h" +#include "Core/Core.h" +#include "Core/NetPlayProto.h" +#include "Core/HW/EXI.h" +#include "Core/HW/GCMemcard.h" +#include "DolphinWX/WxUtils.h" +#include "DolphinWX/Config/GameCubeConfigPane.h" + +#define DEV_NONE_STR _trans("") +#define DEV_DUMMY_STR _trans("Dummy") + +#define EXIDEV_MEMCARD_STR _trans("Memory Card") +#define EXIDEV_MEMDIR_STR _trans("GCI Folder") +#define EXIDEV_MIC_STR _trans("Mic") +#define EXIDEV_BBA_STR "BBA" +#define EXIDEV_AGP_STR "Advance Game Port" +#define EXIDEV_AM_BB_STR _trans("AM-Baseboard") +#define EXIDEV_GECKO_STR "USBGecko" + +GameCubeConfigPane::GameCubeConfigPane(wxWindow* parent, wxWindowID id) + : wxPanel(parent, id) +{ + InitializeGUI(); + LoadGUIValues(); + RefreshGUI(); +} + +void GameCubeConfigPane::InitializeGUI() +{ + m_ipl_language_strings.Add(_("English")); + m_ipl_language_strings.Add(_("German")); + m_ipl_language_strings.Add(_("French")); + m_ipl_language_strings.Add(_("Spanish")); + m_ipl_language_strings.Add(_("Italian")); + m_ipl_language_strings.Add(_("Dutch")); + + m_system_lang_choice = new wxChoice(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, m_ipl_language_strings); + m_system_lang_choice->SetToolTip(_("Sets the GameCube system language.")); + m_system_lang_choice->Bind(wxEVT_CHOICE, &GameCubeConfigPane::OnSystemLanguageChange, this); + + m_skip_bios_checkbox = new wxCheckBox(this, wxID_ANY, _("Skip BIOS")); + m_skip_bios_checkbox->Bind(wxEVT_CHECKBOX, &GameCubeConfigPane::OnSkipBiosCheckBoxChanged, this); + + if (!File::Exists(File::GetUserPath(D_GCUSER_IDX) + DIR_SEP + USA_DIR + DIR_SEP GC_IPL) && + !File::Exists(File::GetSysDirectory() + GC_SYS_DIR + DIR_SEP + USA_DIR + DIR_SEP GC_IPL) && + !File::Exists(File::GetUserPath(D_GCUSER_IDX) + DIR_SEP + JAP_DIR + DIR_SEP GC_IPL) && + !File::Exists(File::GetSysDirectory() + GC_SYS_DIR + DIR_SEP + JAP_DIR + DIR_SEP GC_IPL) && + !File::Exists(File::GetUserPath(D_GCUSER_IDX) + DIR_SEP + EUR_DIR + DIR_SEP GC_IPL) && + !File::Exists(File::GetSysDirectory() + GC_SYS_DIR + DIR_SEP + EUR_DIR + DIR_SEP GC_IPL)) + { + m_skip_bios_checkbox->Disable(); + m_skip_bios_checkbox->SetToolTip(_("Put BIOS roms in User/GC/{region}.")); + } + + // Device settings + // EXI Devices + wxStaticText* GCEXIDeviceText[3] = { + new wxStaticText(this, wxID_ANY, _("Slot A")), + new wxStaticText(this, wxID_ANY, _("Slot B")), + new wxStaticText(this, wxID_ANY, "SP1"), + }; + + m_exi_devices[0] = new wxChoice(this, wxID_ANY); + m_exi_devices[0]->Bind(wxEVT_CHOICE, &GameCubeConfigPane::OnSlotAChanged, this); + m_exi_devices[1] = new wxChoice(this, wxID_ANY); + m_exi_devices[1]->Bind(wxEVT_CHOICE, &GameCubeConfigPane::OnSlotBChanged, this); + m_exi_devices[2] = new wxChoice(this, wxID_ANY); + m_exi_devices[2]->Bind(wxEVT_CHOICE, &GameCubeConfigPane::OnSP1Changed, this); + m_exi_devices[2]->SetToolTip(_("Serial Port 1 - This is the port which devices such as the net adapter use.")); + + m_memcard_path[0] = new wxButton(this, wxID_ANY, "...", wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT); + m_memcard_path[0]->Bind(wxEVT_BUTTON, &GameCubeConfigPane::OnSlotAButtonClick, this); + m_memcard_path[1] = new wxButton(this, wxID_ANY, "...", wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT); + m_memcard_path[1]->Bind(wxEVT_BUTTON, &GameCubeConfigPane::OnSlotBButtonClick, this); + + // Populate the GameCube page + wxGridBagSizer* const sGamecubeIPLSettings = new wxGridBagSizer(); + sGamecubeIPLSettings->Add(m_skip_bios_checkbox, wxGBPosition(0, 0), wxGBSpan(1, 2), wxALL, 5); + sGamecubeIPLSettings->Add(new wxStaticText(this, wxID_ANY, _("System Language:")), + wxGBPosition(1, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxLEFT | wxRIGHT | wxBOTTOM, 5); + sGamecubeIPLSettings->Add(m_system_lang_choice, wxGBPosition(1, 1), wxDefaultSpan, wxLEFT | wxRIGHT | wxBOTTOM, 5); + + wxStaticBoxSizer* const sbGamecubeIPLSettings = new wxStaticBoxSizer(wxVERTICAL, this, _("IPL Settings")); + sbGamecubeIPLSettings->Add(sGamecubeIPLSettings); + wxStaticBoxSizer* const sbGamecubeDeviceSettings = new wxStaticBoxSizer(wxVERTICAL, this, _("Device Settings")); + wxGridBagSizer* const sbGamecubeEXIDevSettings = new wxGridBagSizer(10, 10); + + for (int i = 0; i < 3; ++i) + { + sbGamecubeEXIDevSettings->Add(GCEXIDeviceText[i], wxGBPosition(i, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL); + sbGamecubeEXIDevSettings->Add(m_exi_devices[i], wxGBPosition(i, 1), wxGBSpan(1, (i < 2) ? 1 : 2), wxALIGN_CENTER_VERTICAL); + + if (i < 2) + sbGamecubeEXIDevSettings->Add(m_memcard_path[i], wxGBPosition(i, 2), wxDefaultSpan, wxALIGN_CENTER_VERTICAL); + + if (NetPlay::IsNetPlayRunning()) + m_exi_devices[i]->Disable(); + } + sbGamecubeDeviceSettings->Add(sbGamecubeEXIDevSettings, 0, wxALL, 5); + + wxBoxSizer* const main_sizer = new wxBoxSizer(wxVERTICAL); + main_sizer->Add(sbGamecubeIPLSettings, 0, wxEXPAND | wxALL, 5); + main_sizer->Add(sbGamecubeDeviceSettings, 0, wxEXPAND | wxALL, 5); + + SetSizer(main_sizer); +} + +void GameCubeConfigPane::LoadGUIValues() +{ + const SCoreStartupParameter& startup_params = SConfig::GetInstance().m_LocalCoreStartupParameter; + + m_system_lang_choice->SetSelection(startup_params.SelectedLanguage); + m_skip_bios_checkbox->SetValue(startup_params.bHLE_BS2); + + wxArrayString slot_devices; + slot_devices.Add(_(DEV_NONE_STR)); + slot_devices.Add(_(DEV_DUMMY_STR)); + slot_devices.Add(_(EXIDEV_MEMCARD_STR)); + slot_devices.Add(_(EXIDEV_MEMDIR_STR)); + slot_devices.Add(_(EXIDEV_GECKO_STR)); + slot_devices.Add(_(EXIDEV_AGP_STR)); + +#if HAVE_PORTAUDIO + slot_devices.Add(_(EXIDEV_MIC_STR)); +#endif + + wxArrayString sp1_devices; + sp1_devices.Add(_(DEV_NONE_STR)); + sp1_devices.Add(_(DEV_DUMMY_STR)); + sp1_devices.Add(_(EXIDEV_BBA_STR)); + sp1_devices.Add(_(EXIDEV_AM_BB_STR)); + + for (int i = 0; i < 3; ++i) + { + bool isMemcard = false; + + // Add strings to the wxChoice list, the third wxChoice is the SP1 slot + if (i == 2) + m_exi_devices[i]->Append(sp1_devices); + else + m_exi_devices[i]->Append(slot_devices); + + switch (SConfig::GetInstance().m_EXIDevice[i]) + { + case EXIDEVICE_NONE: + m_exi_devices[i]->SetStringSelection(slot_devices[0]); + break; + case EXIDEVICE_MEMORYCARD: + isMemcard = m_exi_devices[i]->SetStringSelection(slot_devices[2]); + break; + case EXIDEVICE_MEMORYCARDFOLDER: + m_exi_devices[i]->SetStringSelection(slot_devices[3]); + break; + case EXIDEVICE_GECKO: + m_exi_devices[i]->SetStringSelection(slot_devices[4]); + break; + case EXIDEVICE_AGP: + isMemcard = m_exi_devices[i]->SetStringSelection(slot_devices[5]); + break; + case EXIDEVICE_MIC: + m_exi_devices[i]->SetStringSelection(slot_devices[6]); + break; + case EXIDEVICE_ETH: + m_exi_devices[i]->SetStringSelection(sp1_devices[2]); + break; + case EXIDEVICE_AM_BASEBOARD: + m_exi_devices[i]->SetStringSelection(sp1_devices[3]); + break; + case EXIDEVICE_DUMMY: + default: + m_exi_devices[i]->SetStringSelection(slot_devices[1]); + break; + } + + if (!isMemcard && i < 2) + m_memcard_path[i]->Disable(); + } +} + +void GameCubeConfigPane::RefreshGUI() +{ + if (Core::IsRunning()) + { + m_system_lang_choice->Disable(); + m_skip_bios_checkbox->Disable(); + } +} + +void GameCubeConfigPane::OnSystemLanguageChange(wxCommandEvent& event) +{ + SConfig::GetInstance().m_LocalCoreStartupParameter.SelectedLanguage = m_system_lang_choice->GetSelection(); + + // TODO: Signal back to config_main to set bRefreshList to true. +} + +void GameCubeConfigPane::OnSkipBiosCheckBoxChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_LocalCoreStartupParameter.bHLE_BS2 = m_skip_bios_checkbox->IsChecked(); +} + +void GameCubeConfigPane::OnSlotAChanged(wxCommandEvent& event) +{ + ChooseEXIDevice(event.GetString(), 0); +} + +void GameCubeConfigPane::OnSlotBChanged(wxCommandEvent& event) +{ + ChooseEXIDevice(event.GetString(), 1); +} + +void GameCubeConfigPane::OnSP1Changed(wxCommandEvent& event) +{ + ChooseEXIDevice(event.GetString(), 2); +} + +void GameCubeConfigPane::OnSlotAButtonClick(wxCommandEvent& event) +{ + ChooseSlotPath(true, SConfig::GetInstance().m_EXIDevice[0]); +} + +void GameCubeConfigPane::OnSlotBButtonClick(wxCommandEvent& event) +{ + ChooseSlotPath(false, SConfig::GetInstance().m_EXIDevice[1]); +} + +void GameCubeConfigPane::ChooseEXIDevice(const wxString& deviceName, int deviceNum) +{ + TEXIDevices tempType; + + if (!deviceName.compare(_(EXIDEV_MEMCARD_STR))) + tempType = EXIDEVICE_MEMORYCARD; + else if (!deviceName.compare(_(EXIDEV_MEMDIR_STR))) + tempType = EXIDEVICE_MEMORYCARDFOLDER; + else if (!deviceName.compare(_(EXIDEV_MIC_STR))) + tempType = EXIDEVICE_MIC; + else if (!deviceName.compare(EXIDEV_BBA_STR)) + tempType = EXIDEVICE_ETH; + else if (!deviceName.compare(EXIDEV_AGP_STR)) + tempType = EXIDEVICE_AGP; + else if (!deviceName.compare(_(EXIDEV_AM_BB_STR))) + tempType = EXIDEVICE_AM_BASEBOARD; + else if (!deviceName.compare(EXIDEV_GECKO_STR)) + tempType = EXIDEVICE_GECKO; + else if (!deviceName.compare(_(DEV_NONE_STR))) + tempType = EXIDEVICE_NONE; + else + tempType = EXIDEVICE_DUMMY; + + // Gray out the memcard path button if we're not on a memcard or AGP + if (tempType == EXIDEVICE_MEMORYCARD || tempType == EXIDEVICE_AGP) + m_memcard_path[deviceNum]->Enable(); + else if (deviceNum == 0 || deviceNum == 1) + m_memcard_path[deviceNum]->Disable(); + + SConfig::GetInstance().m_EXIDevice[deviceNum] = tempType; + + if (Core::IsRunning()) + { + // Change plugged device! :D + ExpansionInterface::ChangeDevice( + (deviceNum == 1) ? 1 : 0, // SlotB is on channel 1, slotA and SP1 are on 0 + tempType, // The device enum to change to + (deviceNum == 2) ? 2 : 0); // SP1 is device 2, slots are device 0 + } +} + +void GameCubeConfigPane::ChooseSlotPath(bool is_slot_a, TEXIDevices device_type) +{ + bool memcard = (device_type == EXIDEVICE_MEMORYCARD); + std::string path; + std::string cardname; + std::string ext; + std::string pathA = SConfig::GetInstance().m_strMemoryCardA; + std::string pathB = SConfig::GetInstance().m_strMemoryCardB; + if (!memcard) + { + pathA = SConfig::GetInstance().m_strGbaCartA; + pathB = SConfig::GetInstance().m_strGbaCartB; + } + SplitPath(is_slot_a ? pathA : pathB, &path, &cardname, &ext); + std::string filename = WxStrToStr(wxFileSelector( + _("Choose a file to open"), + StrToWxStr(path), + StrToWxStr(cardname), + StrToWxStr(ext), + memcard ? _("GameCube Memory Cards (*.raw,*.gcp)") + "|*.raw;*.gcp" : _("Game Boy Advance Carts (*.gba)") + "|*.gba")); + + if (!filename.empty()) + { + if (File::Exists(filename)) + { + if (memcard) + { + GCMemcard memorycard(filename); + if (!memorycard.IsValid()) + { + WxUtils::ShowErrorDialog(wxString::Format(_("Cannot use that file as a memory card.\n%s\n" \ + "is not a valid GameCube memory card file"), filename.c_str())); + return; + } + } + } +#ifdef _WIN32 + if (!strncmp(File::GetExeDirectory().c_str(), filename.c_str(), File::GetExeDirectory().size())) + { + // If the Exe Directory Matches the prefix of the filename, we still need to verify + // that the next character is a directory separator character, otherwise we may create an invalid path + char next_char = filename.at(File::GetExeDirectory().size()) + 1; + if (next_char == '/' || next_char == '\\') + { + filename.erase(0, File::GetExeDirectory().size() + 1); + filename = "./" + filename; + } + } + std::replace(filename.begin(), filename.end(), '\\', '/'); +#endif + + // also check that the path isn't used for the other memcard... + if (filename.compare(is_slot_a ? pathB : pathA) != 0) + { + if (memcard) + { + if (is_slot_a) + SConfig::GetInstance().m_strMemoryCardA = filename; + else + SConfig::GetInstance().m_strMemoryCardB = filename; + } + else + { + if (is_slot_a) + SConfig::GetInstance().m_strGbaCartA = filename; + else + SConfig::GetInstance().m_strGbaCartB = filename; + } + + if (Core::IsRunning()) + { + // Change memcard to the new file + ExpansionInterface::ChangeDevice( + is_slot_a ? 0 : 1, // SlotA: channel 0, SlotB channel 1 + device_type, + 0); // SP1 is device 2, slots are device 0 + } + } + else + { + WxUtils::ShowErrorDialog(_("Are you trying to use the same file in both slots?")); + } + } +} diff --git a/Source/Core/DolphinWX/Config/GameCubeConfigPane.h b/Source/Core/DolphinWX/Config/GameCubeConfigPane.h new file mode 100644 index 0000000000..346cc01639 --- /dev/null +++ b/Source/Core/DolphinWX/Config/GameCubeConfigPane.h @@ -0,0 +1,43 @@ +// Copyright 2015 Dolphin Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#pragma once + +#include +#include + +class wxButton; +class wxCommandEvent; +class wxCheckBox; +class wxChoice; +class wxString; + +class GameCubeConfigPane final : public wxPanel +{ +public: + GameCubeConfigPane(wxWindow* parent, wxWindowID id); + +private: + void InitializeGUI(); + void LoadGUIValues(); + void RefreshGUI(); + + void OnSystemLanguageChange(wxCommandEvent&); + void OnSkipBiosCheckBoxChanged(wxCommandEvent&); + void OnSlotAChanged(wxCommandEvent&); + void OnSlotBChanged(wxCommandEvent&); + void OnSP1Changed(wxCommandEvent&); + void OnSlotAButtonClick(wxCommandEvent&); + void OnSlotBButtonClick(wxCommandEvent&); + + void ChooseEXIDevice(const wxString& device_name, int device_id); + void ChooseSlotPath(bool is_slot_a, TEXIDevices device_type); + + wxArrayString m_ipl_language_strings; + + wxChoice* m_system_lang_choice; + wxCheckBox* m_skip_bios_checkbox; + wxChoice* m_exi_devices[3]; + wxButton* m_memcard_path[2]; +}; diff --git a/Source/Core/DolphinWX/Config/GeneralConfigPane.cpp b/Source/Core/DolphinWX/Config/GeneralConfigPane.cpp new file mode 100644 index 0000000000..f9c089d655 --- /dev/null +++ b/Source/Core/DolphinWX/Config/GeneralConfigPane.cpp @@ -0,0 +1,167 @@ +// Copyright 2015 Dolphin Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#include +#include +#include +#include +#include +#include +#include + +#include "Core/ConfigManager.h" +#include "Core/Core.h" +#include "Core/PowerPC/PowerPC.h" +#include "DolphinWX/Frame.h" +#include "DolphinWX/Main.h" +#include "DolphinWX/Config/GeneralConfigPane.h" +#include "DolphinWX/Debugger/CodeWindow.h" + + +struct CPUCore +{ + int CPUid; + wxString name; +}; +static const CPUCore cpu_cores[] = { + { 0, _("Interpreter (VERY slow)") }, +#ifdef _M_X86_64 + { 1, _("JIT Recompiler (recommended)") }, + { 2, _("JITIL Recompiler (slower, experimental)") }, +#elif defined(_M_ARM_32) + { 3, _("Arm JIT (experimental)") }, +#elif defined(_M_ARM_64) + { 4, _("Arm64 JIT (experimental)") }, +#endif +}; + +GeneralConfigPane::GeneralConfigPane(wxWindow* parent, wxWindowID id) + : wxPanel(parent, id) +{ + InitializeGUI(); + LoadGUIValues(); + RefreshGUI(); +} + +void GeneralConfigPane::InitializeGUI() +{ + m_frame_limit_array_string.Add(_("Off")); + m_frame_limit_array_string.Add(_("Auto")); + for (int i = 5; i <= 120; i += 5) // from 5 to 120 + m_frame_limit_array_string.Add(wxString::Format("%i", i)); + + for (const CPUCore& cpu_core : cpu_cores) + m_cpu_engine_array_string.Add(cpu_core.name); + + m_dual_core_checkbox = new wxCheckBox(this, wxID_ANY, _("Enable Dual Core (speedup)")); + m_idle_skip_checkbox = new wxCheckBox(this, wxID_ANY, _("Enable Idle Skipping (speedup)")); + m_cheats_checkbox = new wxCheckBox(this, wxID_ANY, _("Enable Cheats")); + m_force_ntscj_checkbox = new wxCheckBox(this, wxID_ANY, _("Force Console as NTSC-J")); + m_frame_limit_choice = new wxChoice(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, m_frame_limit_array_string); + m_cpu_engine_radiobox = new wxRadioBox(this, wxID_ANY, _("CPU Emulator Engine"), wxDefaultPosition, wxDefaultSize, m_cpu_engine_array_string, 0, wxRA_SPECIFY_ROWS); + + m_dual_core_checkbox->SetToolTip(_("Splits the CPU and GPU threads so they can be run on separate cores.\nProvides major speed improvements on most modern PCs, but can cause occasional crashes/glitches.")); + m_idle_skip_checkbox->SetToolTip(_("Attempt to detect and skip wait-loops.\nIf unsure, leave this checked.")); + m_cheats_checkbox->SetToolTip(_("Enables the use of Action Replay and Gecko cheats.")); + m_force_ntscj_checkbox->SetToolTip(_("Forces NTSC-J mode for using the Japanese ROM font.\nIf left unchecked, Dolphin defaults to NTSC-U and automatically enables this setting when playing Japanese games.")); + m_frame_limit_choice->SetToolTip(_("Limits the game speed to the specified number of frames per second (full speed is 60 for NTSC and 50 for PAL).")); + + m_dual_core_checkbox->Bind(wxEVT_CHECKBOX, &GeneralConfigPane::OnDualCoreCheckBoxChanged, this); + m_idle_skip_checkbox->Bind(wxEVT_CHECKBOX, &GeneralConfigPane::OnIdleSkipCheckBoxChanged, this); + m_cheats_checkbox->Bind(wxEVT_CHECKBOX, &GeneralConfigPane::OnCheatCheckBoxChanged, this); + m_force_ntscj_checkbox->Bind(wxEVT_CHECKBOX, &GeneralConfigPane::OnForceNTSCJCheckBoxChanged, this); + m_frame_limit_choice->Bind(wxEVT_CHOICE, &GeneralConfigPane::OnFrameLimitChoiceChanged, this); + m_cpu_engine_radiobox->Bind(wxEVT_RADIOBOX, &GeneralConfigPane::OnCPUEngineRadioBoxChanged, this); + + wxBoxSizer* const frame_limit_sizer = new wxBoxSizer(wxHORIZONTAL); + frame_limit_sizer->Add(new wxStaticText(this, wxID_ANY, _("Framelimit:")), 0, wxALIGN_CENTER_VERTICAL | wxLEFT | wxRIGHT | wxBOTTOM, 5); + frame_limit_sizer->Add(m_frame_limit_choice, 0, wxLEFT | wxRIGHT | wxBOTTOM | wxEXPAND, 5); + + wxStaticBoxSizer* const basic_settings_sizer = new wxStaticBoxSizer(wxVERTICAL, this, _("Basic Settings")); + basic_settings_sizer->Add(m_dual_core_checkbox, 0, wxALL, 5); + basic_settings_sizer->Add(m_idle_skip_checkbox, 0, wxALL, 5); + basic_settings_sizer->Add(m_cheats_checkbox, 0, wxALL, 5); + basic_settings_sizer->Add(frame_limit_sizer); + + wxStaticBoxSizer* const advanced_settings_sizer = new wxStaticBoxSizer(wxVERTICAL, this, _("Advanced Settings")); + advanced_settings_sizer->Add(m_cpu_engine_radiobox, 0, wxALL, 5); + advanced_settings_sizer->Add(m_force_ntscj_checkbox, 0, wxALL, 5); + + wxBoxSizer* const main_sizer = new wxBoxSizer(wxVERTICAL); + main_sizer->Add(basic_settings_sizer, 0, wxEXPAND | wxALL, 5); + main_sizer->Add(advanced_settings_sizer, 0, wxEXPAND | wxALL, 5); + + SetSizer(main_sizer); +} + +void GeneralConfigPane::LoadGUIValues() +{ + const SCoreStartupParameter& startup_params = SConfig::GetInstance().m_LocalCoreStartupParameter; + + m_dual_core_checkbox->SetValue(startup_params.bCPUThread); + m_idle_skip_checkbox->SetValue(startup_params.bSkipIdle); + m_cheats_checkbox->SetValue(startup_params.bEnableCheats); + m_force_ntscj_checkbox->SetValue(startup_params.bForceNTSCJ); + m_frame_limit_choice->SetSelection(SConfig::GetInstance().m_Framelimit); + + for (size_t i = 0; i < (sizeof(cpu_cores) / sizeof(CPUCore)); ++i) + { + if (cpu_cores[i].CPUid == startup_params.iCPUCore) + m_cpu_engine_radiobox->SetSelection(i); + } +} + +void GeneralConfigPane::RefreshGUI() +{ + if (Core::IsRunning()) + { + m_dual_core_checkbox->Disable(); + m_idle_skip_checkbox->Disable(); + m_cheats_checkbox->Disable(); + m_force_ntscj_checkbox->Disable(); + m_cpu_engine_radiobox->Disable(); + } +} + +void GeneralConfigPane::OnDualCoreCheckBoxChanged(wxCommandEvent& event) +{ + if (Core::IsRunning()) + return; + + SConfig::GetInstance().m_LocalCoreStartupParameter.bCPUThread = m_dual_core_checkbox->IsChecked(); +} + +void GeneralConfigPane::OnIdleSkipCheckBoxChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_LocalCoreStartupParameter.bSkipIdle = m_idle_skip_checkbox->IsChecked(); +} + +void GeneralConfigPane::OnCheatCheckBoxChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_LocalCoreStartupParameter.bSkipIdle = m_cheats_checkbox->IsChecked(); +} + +void GeneralConfigPane::OnForceNTSCJCheckBoxChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_LocalCoreStartupParameter.bForceNTSCJ = m_force_ntscj_checkbox->IsChecked(); +} + +void GeneralConfigPane::OnFrameLimitChoiceChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_Framelimit = m_frame_limit_choice->GetSelection(); +} + +void GeneralConfigPane::OnCPUEngineRadioBoxChanged(wxCommandEvent& event) +{ + const int selection = m_cpu_engine_radiobox->GetSelection(); + + if (main_frame->g_pCodeWindow) + { + + bool using_interp = (SConfig::GetInstance().m_LocalCoreStartupParameter.iCPUCore == PowerPC::CORE_INTERPRETER); + main_frame->g_pCodeWindow->GetMenuBar()->Check(IDM_INTERPRETER, using_interp); + } + + SConfig::GetInstance().m_LocalCoreStartupParameter.iCPUCore = cpu_cores[selection].CPUid; +} diff --git a/Source/Core/DolphinWX/Config/GeneralConfigPane.h b/Source/Core/DolphinWX/Config/GeneralConfigPane.h new file mode 100644 index 0000000000..ca8f267251 --- /dev/null +++ b/Source/Core/DolphinWX/Config/GeneralConfigPane.h @@ -0,0 +1,43 @@ +// Copyright 2015 Dolphin Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#pragma once + +#include +#include + +class wxCheckBox; +class wxCommandEvent; +class wxChoice; +class wxRadioBox; + +class GeneralConfigPane final : public wxPanel +{ +public: + GeneralConfigPane(wxWindow* parent, wxWindowID id); + +private: + void InitializeGUI(); + void LoadGUIValues(); + void RefreshGUI(); + + void OnDualCoreCheckBoxChanged(wxCommandEvent&); + void OnIdleSkipCheckBoxChanged(wxCommandEvent&); + void OnCheatCheckBoxChanged(wxCommandEvent&); + void OnForceNTSCJCheckBoxChanged(wxCommandEvent&); + void OnFrameLimitChoiceChanged(wxCommandEvent&); + void OnCPUEngineRadioBoxChanged(wxCommandEvent&); + + wxArrayString m_frame_limit_array_string; + wxArrayString m_cpu_engine_array_string; + + wxCheckBox* m_dual_core_checkbox; + wxCheckBox* m_idle_skip_checkbox; + wxCheckBox* m_cheats_checkbox; + wxCheckBox* m_force_ntscj_checkbox; + + wxChoice* m_frame_limit_choice; + + wxRadioBox* m_cpu_engine_radiobox; +}; diff --git a/Source/Core/DolphinWX/Config/InterfaceConfigPane.cpp b/Source/Core/DolphinWX/Config/InterfaceConfigPane.cpp new file mode 100644 index 0000000000..44412a2bba --- /dev/null +++ b/Source/Core/DolphinWX/Config/InterfaceConfigPane.cpp @@ -0,0 +1,256 @@ +// Copyright 2015 Dolphin Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#include + +#include +#include +#include +#include +#include +#include + +#include "Common/CommonPaths.h" +#include "Common/FileSearch.h" +#include "Common/FileUtil.h" +#include "Core/ConfigManager.h" +#include "Core/HotkeyManager.h" +#include "DolphinWX/Frame.h" +#include "DolphinWX/InputConfigDiag.h" +#include "DolphinWX/Main.h" +#include "DolphinWX/WxUtils.h" +#include "DolphinWX/Config/InterfaceConfigPane.h" + +#if defined(HAVE_XRANDR) && HAVE_XRANDR +#include "DolphinWX/X11Utils.h" +#endif + +static const wxLanguage language_ids[] = +{ + wxLANGUAGE_DEFAULT, + + wxLANGUAGE_CATALAN, + wxLANGUAGE_CZECH, + wxLANGUAGE_GERMAN, + wxLANGUAGE_ENGLISH, + wxLANGUAGE_SPANISH, + wxLANGUAGE_FRENCH, + wxLANGUAGE_ITALIAN, + wxLANGUAGE_HUNGARIAN, + wxLANGUAGE_DUTCH, + wxLANGUAGE_NORWEGIAN_BOKMAL, + wxLANGUAGE_POLISH, + wxLANGUAGE_PORTUGUESE, + wxLANGUAGE_PORTUGUESE_BRAZILIAN, + wxLANGUAGE_SERBIAN, + wxLANGUAGE_SWEDISH, + wxLANGUAGE_TURKISH, + + wxLANGUAGE_GREEK, + wxLANGUAGE_RUSSIAN, + wxLANGUAGE_HEBREW, + wxLANGUAGE_ARABIC, + wxLANGUAGE_FARSI, + wxLANGUAGE_KOREAN, + wxLANGUAGE_JAPANESE, + wxLANGUAGE_CHINESE_SIMPLIFIED, + wxLANGUAGE_CHINESE_TRADITIONAL, +}; + +InterfaceConfigPane::InterfaceConfigPane(wxWindow* parent, wxWindowID id) + : wxPanel(parent, id) +{ + InitializeGUI(); + LoadGUIValues(); +} + +void InterfaceConfigPane::InitializeGUI() +{ + // GUI language arrayStrings + // keep these in sync with the langIds array at the beginning of this file + m_interface_lang_strings.Add(_("")); + m_interface_lang_strings.Add(L"Catal\u00E0"); // Catalan + m_interface_lang_strings.Add(L"\u010Ce\u0161tina"); // Czech + m_interface_lang_strings.Add(L"Deutsch"); // German + m_interface_lang_strings.Add(L"English"); // English + m_interface_lang_strings.Add(L"Espa\u00F1ol"); // Spanish + m_interface_lang_strings.Add(L"Fran\u00E7ais"); // French + m_interface_lang_strings.Add(L"Italiano"); // Italian + m_interface_lang_strings.Add(L"Magyar"); // Hungarian + m_interface_lang_strings.Add(L"Nederlands"); // Dutch + m_interface_lang_strings.Add(L"Norsk bokm\u00E5l"); // Norwegian + m_interface_lang_strings.Add(L"Polski"); // Polish + m_interface_lang_strings.Add(L"Portugu\u00EAs"); // Portuguese + m_interface_lang_strings.Add(L"Portugu\u00EAs (Brasil)"); // Portuguese (Brazil) + m_interface_lang_strings.Add(L"Srpski"); // Serbian + m_interface_lang_strings.Add(L"Svenska"); // Swedish + m_interface_lang_strings.Add(L"T\u00FCrk\u00E7e"); // Turkish + m_interface_lang_strings.Add(L"\u0395\u03BB\u03BB\u03B7\u03BD\u03B9\u03BA\u03AC"); // Greek + m_interface_lang_strings.Add(L"\u0420\u0443\u0441\u0441\u043A\u0438\u0439"); // Russian + m_interface_lang_strings.Add(L"\u05E2\u05D1\u05E8\u05D9\u05EA"); // Hebrew + m_interface_lang_strings.Add(L"\u0627\u0644\u0639\u0631\u0628\u064A\u0629"); // Arabic + m_interface_lang_strings.Add(L"\u0641\u0627\u0631\u0633\u06CC"); // Farsi + m_interface_lang_strings.Add(L"\uD55C\uAD6D\uC5B4"); // Korean + m_interface_lang_strings.Add(L"\u65E5\u672C\u8A9E"); // Japanese + m_interface_lang_strings.Add(L"\u7B80\u4F53\u4E2D\u6587"); // Simplified Chinese + m_interface_lang_strings.Add(L"\u7E41\u9AD4\u4E2D\u6587"); // Traditional Chinese + + m_confirm_stop_checkbox = new wxCheckBox(this, wxID_ANY, _("Confirm on Stop")); + m_panic_handlers_checkbox = new wxCheckBox(this, wxID_ANY, _("Use Panic Handlers")); + m_osd_messages_checkbox = new wxCheckBox(this, wxID_ANY, _("On-Screen Display Messages")); + m_pause_focus_lost_checkbox = new wxCheckBox(this, wxID_ANY, _("Pause on Focus Lost")); + m_interface_lang_choice = new wxChoice(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, m_interface_lang_strings); + m_hotkey_config_button = new wxButton(this, wxID_ANY, _("Hotkeys"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT); + m_theme_choice = new wxChoice(this, wxID_ANY); + + m_confirm_stop_checkbox->Bind(wxEVT_CHECKBOX, &InterfaceConfigPane::OnConfirmStopCheckBoxChanged, this); + m_panic_handlers_checkbox->Bind(wxEVT_CHECKBOX, &InterfaceConfigPane::OnPanicHandlersCheckBoxChanged, this); + m_osd_messages_checkbox->Bind(wxEVT_CHECKBOX, &InterfaceConfigPane::OnOSDMessagesCheckBoxChanged, this); + m_pause_focus_lost_checkbox->Bind(wxEVT_CHECKBOX, &InterfaceConfigPane::OnPauseOnFocusLostCheckBoxChanged, this); + m_interface_lang_choice->Bind(wxEVT_CHOICE, &InterfaceConfigPane::OnInterfaceLanguageChoiceChanged, this); + m_theme_choice->Bind(wxEVT_CHOICE, &InterfaceConfigPane::OnThemeSelected, this); + + m_confirm_stop_checkbox->SetToolTip(_("Show a confirmation box before stopping a game.")); + m_panic_handlers_checkbox->SetToolTip(_("Show a message box when a potentially serious error has occurred.\nDisabling this may avoid annoying and non-fatal messages, but it may result in major crashes having no explanation at all.")); + m_osd_messages_checkbox->SetToolTip(_("Display messages over the emulation screen area.\nThese messages include memory card writes, video backend and CPU information, and JIT cache clearing.")); + m_pause_focus_lost_checkbox->SetToolTip(_("Pauses the emulator when focus is taken away from the emulation window.")); + m_interface_lang_choice->SetToolTip(_("Change the language of the user interface.\nRequires restart.")); + + wxBoxSizer* const language_sizer = new wxBoxSizer(wxHORIZONTAL); + language_sizer->Add(new wxStaticText(this, wxID_ANY, _("Language:")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5); + language_sizer->Add(m_interface_lang_choice, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5); + language_sizer->AddStretchSpacer(); + language_sizer->Add(m_hotkey_config_button, 0, wxALIGN_RIGHT | wxALL, 5); + + wxBoxSizer* const theme_sizer = new wxBoxSizer(wxHORIZONTAL); + theme_sizer->Add(new wxStaticText(this, wxID_ANY, _("Theme:")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5); + theme_sizer->Add(m_theme_choice, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5); + theme_sizer->AddStretchSpacer(); + + wxStaticBoxSizer* const main_static_box_sizer = new wxStaticBoxSizer(wxVERTICAL, this, _("Interface Settings")); + main_static_box_sizer->Add(m_confirm_stop_checkbox, 0, wxALL, 5); + main_static_box_sizer->Add(m_panic_handlers_checkbox, 0, wxALL, 5); + main_static_box_sizer->Add(m_osd_messages_checkbox, 0, wxALL, 5); + main_static_box_sizer->Add(m_pause_focus_lost_checkbox, 0, wxALL, 5); + main_static_box_sizer->Add(theme_sizer, 0, wxEXPAND | wxALL, 5); + main_static_box_sizer->Add(language_sizer, 0, wxEXPAND | wxALL, 5); + + wxBoxSizer* const main_box_sizer = new wxBoxSizer(wxVERTICAL); + main_box_sizer->Add(main_static_box_sizer, 0, wxEXPAND | wxALL, 5); + + SetSizer(main_box_sizer); +} + +void InterfaceConfigPane::LoadGUIValues() +{ + const SCoreStartupParameter& startup_params = SConfig::GetInstance().m_LocalCoreStartupParameter; + + m_confirm_stop_checkbox->SetValue(startup_params.bConfirmStop); + m_panic_handlers_checkbox->SetValue(startup_params.bUsePanicHandlers); + m_osd_messages_checkbox->SetValue(startup_params.bOnScreenDisplayMessages); + m_pause_focus_lost_checkbox->SetValue(SConfig::GetInstance().m_PauseOnFocusLost); + + for (size_t i = 0; i < sizeof(language_ids) / sizeof(wxLanguage); i++) + { + if (language_ids [i] == SConfig::GetInstance().m_InterfaceLanguage) + { + m_interface_lang_choice->SetSelection(i); + break; + } + } + + LoadThemes(); +} + +void InterfaceConfigPane::LoadThemes() +{ + CFileSearch::XStringVector theme_dirs; + theme_dirs.push_back(File::GetUserPath(D_THEMES_IDX)); + theme_dirs.push_back(File::GetSysDirectory() + THEMES_DIR); + + CFileSearch cfs(CFileSearch::XStringVector(1, "*"), theme_dirs); + auto const& sv = cfs.GetFileNames(); + for (const std::string& filename : sv) + { + std::string name, ext; + SplitPath(filename, nullptr, &name, &ext); + + name += ext; + const wxString wxname = StrToWxStr(name); + if (-1 == m_theme_choice->FindString(wxname)) + m_theme_choice->Append(wxname); + } + + m_theme_choice->SetStringSelection(StrToWxStr(SConfig::GetInstance().m_LocalCoreStartupParameter.theme_name)); +} + +void InterfaceConfigPane::OnHotkeyConfigButtonClicked(wxCommandEvent& event) +{ + bool was_init = false; + + InputConfig* const hotkey_plugin = HotkeyManagerEmu::GetConfig(); + + // check if game is running + if (g_controller_interface.IsInit()) + { + was_init = true; + } + else + { +#if defined(HAVE_X11) && HAVE_X11 + Window win = X11Utils::XWindowFromHandle(GetHandle()); + HotkeyManagerEmu::Initialize(reinterpret_cast(win)); +#else + HotkeyManagerEmu::Initialize(reinterpret_cast(GetHandle())); +#endif + } + + InputConfigDialog m_ConfigFrame(this, *hotkey_plugin, _("Dolphin Hotkeys")); + m_ConfigFrame.ShowModal(); + + // if game isn't running + if (!was_init) + HotkeyManagerEmu::Shutdown(); + + // Update the GUI in case menu accelerators were changed + main_frame->UpdateGUI(); +} + +void InterfaceConfigPane::OnConfirmStopCheckBoxChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_LocalCoreStartupParameter.bConfirmStop = m_confirm_stop_checkbox->IsChecked(); +} + +void InterfaceConfigPane::OnPanicHandlersCheckBoxChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_LocalCoreStartupParameter.bUsePanicHandlers = m_panic_handlers_checkbox->IsChecked(); + SetEnableAlert(m_panic_handlers_checkbox->IsChecked()); +} + +void InterfaceConfigPane::OnOSDMessagesCheckBoxChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_LocalCoreStartupParameter.bOnScreenDisplayMessages = m_osd_messages_checkbox->IsChecked(); +} + +void InterfaceConfigPane::OnInterfaceLanguageChoiceChanged(wxCommandEvent& event) +{ + if (SConfig::GetInstance().m_InterfaceLanguage != language_ids[m_interface_lang_choice->GetSelection()]) + SuccessAlertT("You must restart Dolphin in order for the change to take effect."); + + SConfig::GetInstance().m_InterfaceLanguage = language_ids[m_interface_lang_choice->GetSelection()]; +} + +void InterfaceConfigPane::OnPauseOnFocusLostCheckBoxChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_PauseOnFocusLost = m_pause_focus_lost_checkbox->IsChecked(); +} + +void InterfaceConfigPane::OnThemeSelected(wxCommandEvent& event) +{ + SConfig::GetInstance().m_LocalCoreStartupParameter.theme_name = WxStrToStr(m_theme_choice->GetStringSelection()); + + main_frame->InitBitmaps(); + main_frame->UpdateGameList(); +} + diff --git a/Source/Core/DolphinWX/Config/InterfaceConfigPane.h b/Source/Core/DolphinWX/Config/InterfaceConfigPane.h new file mode 100644 index 0000000000..5dd35638ef --- /dev/null +++ b/Source/Core/DolphinWX/Config/InterfaceConfigPane.h @@ -0,0 +1,42 @@ +// Copyright 2015 Dolphin Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#pragma once + +#include +#include + +class wxButton; +class wxCheckBox; +class wxChoice; +class wxCommandEvent; + +class InterfaceConfigPane final : public wxPanel +{ +public: + InterfaceConfigPane(wxWindow* parent, wxWindowID id); + +private: + void InitializeGUI(); + void LoadGUIValues(); + void LoadThemes(); + + void OnHotkeyConfigButtonClicked(wxCommandEvent&); + void OnConfirmStopCheckBoxChanged(wxCommandEvent&); + void OnPanicHandlersCheckBoxChanged(wxCommandEvent&); + void OnOSDMessagesCheckBoxChanged(wxCommandEvent&); + void OnInterfaceLanguageChoiceChanged(wxCommandEvent&); + void OnPauseOnFocusLostCheckBoxChanged(wxCommandEvent&); + void OnThemeSelected(wxCommandEvent&); + + wxArrayString m_interface_lang_strings; + + wxButton* m_hotkey_config_button; + wxCheckBox* m_confirm_stop_checkbox; + wxCheckBox* m_panic_handlers_checkbox; + wxCheckBox* m_osd_messages_checkbox; + wxCheckBox* m_pause_focus_lost_checkbox; + wxChoice* m_interface_lang_choice; + wxChoice* m_theme_choice; +}; diff --git a/Source/Core/DolphinWX/Config/PathConfigPane.cpp b/Source/Core/DolphinWX/Config/PathConfigPane.cpp new file mode 100644 index 0000000000..f35faccc21 --- /dev/null +++ b/Source/Core/DolphinWX/Config/PathConfigPane.cpp @@ -0,0 +1,196 @@ +// Copyright 2015 Dolphin Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "Core/ConfigManager.h" +#include "Core/Core.h" +#include "DiscIO/NANDContentLoader.h" +#include "DolphinWX/Frame.h" +#include "DolphinWX/Main.h" +#include "DolphinWX/WxUtils.h" +#include "DolphinWX/Config/PathConfigPane.h" + +PathConfigPane::PathConfigPane(wxWindow* panel, wxWindowID id) + : wxPanel(panel, id) +{ + InitializeGUI(); + LoadGUIValues(); + RefreshGUI(); +} + +void PathConfigPane::InitializeGUI() +{ + m_iso_paths_listbox = new wxListBox(this, wxID_ANY); + m_recursive_iso_paths_checkbox = new wxCheckBox(this, wxID_ANY, _("Search Subfolders")); + m_add_iso_path_button = new wxButton(this, wxID_ANY, _("Add...")); + m_remove_iso_path_button = new wxButton(this, wxID_ANY, _("Remove")); + m_remove_iso_path_button->Disable(); + + m_default_iso_filepicker = new wxFilePickerCtrl(this, wxID_ANY, wxEmptyString, _("Choose a default ISO:"), + _("All GC/Wii files (elf, dol, gcm, iso, wbfs, ciso, gcz, wad)") + wxString::Format("|*.elf;*.dol;*.gcm;*.iso;*.wbfs;*.ciso;*.gcz;*.wad|%s", wxGetTranslation(wxALL_FILES)), + wxDefaultPosition, wxDefaultSize, wxFLP_USE_TEXTCTRL | wxFLP_OPEN); + m_dvd_root_dirpicker = new wxDirPickerCtrl(this, wxID_ANY, wxEmptyString, _("Choose a DVD root directory:"), wxDefaultPosition, wxDefaultSize, wxDIRP_USE_TEXTCTRL); + m_apploader_path_filepicker = new wxFilePickerCtrl(this, wxID_ANY, wxEmptyString, _("Choose file to use as apploader: (applies to discs constructed from directories only)"), + _("apploader (.img)") + wxString::Format("|*.img|%s", wxGetTranslation(wxALL_FILES)), + wxDefaultPosition, wxDefaultSize, wxFLP_USE_TEXTCTRL | wxFLP_OPEN); + m_nand_root_dirpicker = new wxDirPickerCtrl(this, wxID_ANY, wxEmptyString, _("Choose a NAND root directory:"), wxDefaultPosition, wxDefaultSize, wxDIRP_USE_TEXTCTRL); + + m_iso_paths_listbox->Bind(wxEVT_LISTBOX, &PathConfigPane::OnISOPathSelectionChanged, this); + m_recursive_iso_paths_checkbox->Bind(wxEVT_CHECKBOX, &PathConfigPane::OnRecursiveISOCheckBoxChanged, this); + m_add_iso_path_button->Bind(wxEVT_BUTTON, &PathConfigPane::OnAddISOPath, this); + m_remove_iso_path_button->Bind(wxEVT_BUTTON, &PathConfigPane::OnRemoveISOPath, this); + m_default_iso_filepicker->Bind(wxEVT_FILEPICKER_CHANGED, &PathConfigPane::OnDefaultISOChanged, this); + m_dvd_root_dirpicker->Bind(wxEVT_DIRPICKER_CHANGED, &PathConfigPane::OnDVDRootChanged, this); + m_apploader_path_filepicker->Bind(wxEVT_FILEPICKER_CHANGED, &PathConfigPane::OnApploaderPathChanged, this); + m_nand_root_dirpicker->Bind(wxEVT_DIRPICKER_CHANGED, &PathConfigPane::OnNANDRootChanged, this); + + wxBoxSizer* const iso_button_sizer = new wxBoxSizer(wxHORIZONTAL); + iso_button_sizer->Add(m_recursive_iso_paths_checkbox, 0, wxALL | wxALIGN_CENTER); + iso_button_sizer->AddStretchSpacer(); + iso_button_sizer->Add(m_add_iso_path_button, 0, wxALL); + iso_button_sizer->Add(m_remove_iso_path_button, 0, wxALL); + + wxStaticBoxSizer* const iso_listbox_sizer = new wxStaticBoxSizer(wxVERTICAL, this, _("ISO Directories")); + iso_listbox_sizer->Add(m_iso_paths_listbox, 1, wxEXPAND | wxALL, 0); + iso_listbox_sizer->Add(iso_button_sizer, 0, wxEXPAND | wxALL, 5); + + wxGridBagSizer* const picker_sizer = new wxGridBagSizer(); + picker_sizer->Add(new wxStaticText(this, wxID_ANY, _("Default ISO:")), + wxGBPosition(0, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxALL, 5); + picker_sizer->Add(m_default_iso_filepicker, wxGBPosition(0, 1), wxDefaultSpan, wxEXPAND | wxALL, 5); + picker_sizer->Add(new wxStaticText(this, wxID_ANY, _("DVD Root:")), + wxGBPosition(1, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxALL, 5); + picker_sizer->Add(m_dvd_root_dirpicker, wxGBPosition(1, 1), wxDefaultSpan, wxEXPAND | wxALL, 5); + picker_sizer->Add(new wxStaticText(this, wxID_ANY, _("Apploader:")), + wxGBPosition(2, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxALL, 5); + picker_sizer->Add(m_apploader_path_filepicker, wxGBPosition(2, 1), wxDefaultSpan, wxEXPAND | wxALL, 5); + picker_sizer->Add(new wxStaticText(this, wxID_ANY, _("Wii NAND Root:")), + wxGBPosition(3, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxALL, 5); + picker_sizer->Add(m_nand_root_dirpicker, wxGBPosition(3, 1), wxDefaultSpan, wxEXPAND | wxALL, 5); + picker_sizer->AddGrowableCol(1); + + // Populate the Paths page + wxBoxSizer* const main_sizer = new wxBoxSizer(wxVERTICAL); + main_sizer->Add(iso_listbox_sizer, 1, wxEXPAND | wxALL, 5); + main_sizer->Add(picker_sizer, 0, wxEXPAND | wxALL, 5); + + SetSizer(main_sizer); +} + +void PathConfigPane::LoadGUIValues() +{ + const SCoreStartupParameter& startup_params = SConfig::GetInstance().m_LocalCoreStartupParameter; + + m_recursive_iso_paths_checkbox->SetValue(SConfig::GetInstance().m_RecursiveISOFolder); + m_default_iso_filepicker->SetPath(StrToWxStr(startup_params.m_strDefaultISO)); + m_dvd_root_dirpicker->SetPath(StrToWxStr(startup_params.m_strDVDRoot)); + m_apploader_path_filepicker->SetPath(StrToWxStr(startup_params.m_strApploader)); + m_nand_root_dirpicker->SetPath(StrToWxStr(SConfig::GetInstance().m_NANDPath)); + + // Update selected ISO paths + for (const std::string& folder : SConfig::GetInstance().m_ISOFolder) + m_iso_paths_listbox->Append(StrToWxStr(folder)); +} + +void PathConfigPane::RefreshGUI() +{ + if (Core::IsRunning()) + Disable(); +} + +void PathConfigPane::OnISOPathSelectionChanged(wxCommandEvent& event) +{ + m_remove_iso_path_button->Enable(m_iso_paths_listbox->GetSelection() != wxNOT_FOUND); +} + +void PathConfigPane::OnRecursiveISOCheckBoxChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_RecursiveISOFolder = m_recursive_iso_paths_checkbox->IsChecked(); + + // TODO: Fire an event back to ConfigMain, setting bRefreshList to true. +} + +void PathConfigPane::OnAddISOPath(wxCommandEvent& event) +{ + wxDirDialog dialog(this, _("Choose a directory to add"), wxGetHomeDir(), + wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST); + + if (dialog.ShowModal() == wxID_OK) + { + if (m_iso_paths_listbox->FindString(dialog.GetPath()) != wxNOT_FOUND) + { + WxUtils::ShowErrorDialog(_("The chosen directory is already in the list.")); + } + else + { + // TODO: Send event back to ConfigMain setting bRefreshList to true. + m_iso_paths_listbox->Append(dialog.GetPath()); + } + } + + SaveISOPathChanges(); +} + +void PathConfigPane::OnRemoveISOPath(wxCommandEvent& event) +{ + // TODO: Set event back to ConfigMain to set bRefreshList to true. + m_iso_paths_listbox->Delete(m_iso_paths_listbox->GetSelection()); + + // This seems to not be activated on Windows when it should be. wxw bug? +#ifdef _WIN32 + OnISOPathSelectionChanged(wxCommandEvent()); +#endif + + SaveISOPathChanges(); +} + +void PathConfigPane::OnDefaultISOChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_LocalCoreStartupParameter.m_strDefaultISO = WxStrToStr(m_default_iso_filepicker->GetPath()); +} + +void PathConfigPane::OnDVDRootChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_LocalCoreStartupParameter.m_strDVDRoot = WxStrToStr(m_dvd_root_dirpicker->GetPath()); +} + +void PathConfigPane::OnApploaderPathChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_LocalCoreStartupParameter.m_strApploader = WxStrToStr(m_apploader_path_filepicker->GetPath()); +} + +void PathConfigPane::OnNANDRootChanged(wxCommandEvent& event) +{ + std::string nand_path = + SConfig::GetInstance().m_NANDPath = + WxStrToStr(m_nand_root_dirpicker->GetPath()); + + File::SetUserPath(D_WIIROOT_IDX, nand_path); + m_nand_root_dirpicker->SetPath(StrToWxStr(nand_path)); + + SConfig::GetInstance().m_SYSCONF->UpdateLocation(); + DiscIO::cUIDsys::AccessInstance().UpdateLocation(); + DiscIO::CSharedContent::AccessInstance().UpdateLocation(); + + main_frame->UpdateWiiMenuChoice(); +} + +void PathConfigPane::SaveISOPathChanges() +{ + SConfig::GetInstance().m_ISOFolder.clear(); + + for (unsigned int i = 0; i < m_iso_paths_listbox->GetCount(); i++) + SConfig::GetInstance().m_ISOFolder.push_back(WxStrToStr(m_iso_paths_listbox->GetStrings()[i])); +} + diff --git a/Source/Core/DolphinWX/Config/PathConfigPane.h b/Source/Core/DolphinWX/Config/PathConfigPane.h new file mode 100644 index 0000000000..596733a5f7 --- /dev/null +++ b/Source/Core/DolphinWX/Config/PathConfigPane.h @@ -0,0 +1,46 @@ +// Copyright 2015 Dolphin Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#pragma once + +#include + +class wxButton; +class wxCheckBox; +class wxCommandEvent; +class wxListBox; +class wxDirPickerCtrl; +class wxFilePickerCtrl; + +class PathConfigPane final : public wxPanel +{ +public: + PathConfigPane(wxWindow* parent, wxWindowID id); + +private: + void InitializeGUI(); + void LoadGUIValues(); + void RefreshGUI(); + + void OnISOPathSelectionChanged(wxCommandEvent&); + void OnRecursiveISOCheckBoxChanged(wxCommandEvent&); + void OnAddISOPath(wxCommandEvent&); + void OnRemoveISOPath(wxCommandEvent&); + void OnDefaultISOChanged(wxCommandEvent&); + void OnDVDRootChanged(wxCommandEvent&); + void OnApploaderPathChanged(wxCommandEvent&); + void OnNANDRootChanged(wxCommandEvent&); + + void SaveISOPathChanges(); + + wxListBox* m_iso_paths_listbox; + wxCheckBox* m_recursive_iso_paths_checkbox; + wxButton* m_add_iso_path_button; + wxButton* m_remove_iso_path_button; + + wxDirPickerCtrl* m_dvd_root_dirpicker; + wxDirPickerCtrl* m_nand_root_dirpicker; + wxFilePickerCtrl* m_default_iso_filepicker; + wxFilePickerCtrl* m_apploader_path_filepicker; +}; diff --git a/Source/Core/DolphinWX/Config/WiiConfigPane.cpp b/Source/Core/DolphinWX/Config/WiiConfigPane.cpp new file mode 100644 index 0000000000..31b957ce89 --- /dev/null +++ b/Source/Core/DolphinWX/Config/WiiConfigPane.cpp @@ -0,0 +1,178 @@ +// Copyright 2015 Dolphin Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#include +#include +#include +#include +#include + +#include "Core/ConfigManager.h" +#include "Core/Core.h" +#include "Core/IPC_HLE/WII_IPC_HLE.h" +#include "DolphinWX/WxUtils.h" +#include "DolphinWX/Config/WiiConfigPane.h" + +WiiConfigPane::WiiConfigPane(wxWindow* parent, wxWindowID id) + : wxPanel(parent, id) +{ + InitializeGUI(); + LoadGUIValues(); + RefreshGUI(); +} + +void WiiConfigPane::InitializeGUI() +{ + m_aspect_ratio_strings.Add("4:3"); + m_aspect_ratio_strings.Add("16:9"); + + m_system_language_strings.Add(_("Japanese")); + m_system_language_strings.Add(_("English")); + m_system_language_strings.Add(_("German")); + m_system_language_strings.Add(_("French")); + m_system_language_strings.Add(_("Spanish")); + m_system_language_strings.Add(_("Italian")); + m_system_language_strings.Add(_("Dutch")); + m_system_language_strings.Add(_("Simplified Chinese")); + m_system_language_strings.Add(_("Traditional Chinese")); + m_system_language_strings.Add(_("Korean")); + + m_screensaver_checkbox = new wxCheckBox(this, wxID_ANY, _("Enable Screen Saver")); + m_pal60_mode_checkbox = new wxCheckBox(this, wxID_ANY, _("Use PAL60 Mode (EuRGB60)")); + m_aspect_ratio_choice = new wxChoice(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, m_aspect_ratio_strings); + m_system_language_choice = new wxChoice(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, m_system_language_strings); + m_sd_card_checkbox = new wxCheckBox(this, wxID_ANY, _("Insert SD Card")); + m_connect_keyboard_checkbox = new wxCheckBox(this, wxID_ANY, _("Connect USB Keyboard")); + + m_screensaver_checkbox->Bind(wxEVT_CHECKBOX, &WiiConfigPane::OnScreenSaverCheckBoxChanged, this); + m_pal60_mode_checkbox->Bind(wxEVT_CHECKBOX, &WiiConfigPane::OnPAL60CheckBoxChanged, this); + m_aspect_ratio_choice->Bind(wxEVT_CHOICE, &WiiConfigPane::OnAspectRatioChoiceChanged, this); + m_system_language_choice->Bind(wxEVT_CHOICE, &WiiConfigPane::OnSystemLanguageChoiceChanged, this); + m_sd_card_checkbox->Bind(wxEVT_CHECKBOX, &WiiConfigPane::OnSDCardCheckBoxChanged, this); + m_connect_keyboard_checkbox->Bind(wxEVT_CHECKBOX, &WiiConfigPane::OnConnectKeyboardCheckBoxChanged, this); + + m_screensaver_checkbox->SetToolTip(_("Dims the screen after five minutes of inactivity.")); + m_pal60_mode_checkbox->SetToolTip(_("Sets the Wii display mode to 60Hz (480i) instead of 50Hz (576i) for PAL games.\nMay not work for all games.")); + m_system_language_choice->SetToolTip(_("Sets the Wii system language.")); + m_sd_card_checkbox->SetToolTip(_("Saved to /Wii/sd.raw (default size is 128mb)")); + m_connect_keyboard_checkbox->SetToolTip(_("May cause slow down in Wii Menu and some games.")); + + wxGridBagSizer* const misc_settings_grid_sizer = new wxGridBagSizer(); + misc_settings_grid_sizer->Add(m_screensaver_checkbox, wxGBPosition(0, 0), wxGBSpan(1, 2), wxALL, 5); + misc_settings_grid_sizer->Add(m_pal60_mode_checkbox, wxGBPosition(1, 0), wxGBSpan(1, 2), wxALL, 5); + misc_settings_grid_sizer->Add(new wxStaticText(this, wxID_ANY, _("Aspect Ratio:")), wxGBPosition(2, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxALL, 5); + misc_settings_grid_sizer->Add(m_aspect_ratio_choice, wxGBPosition(2, 1), wxDefaultSpan, wxALL, 5); + misc_settings_grid_sizer->Add(new wxStaticText(this, wxID_ANY, _("System Language:")), wxGBPosition(3, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxALL, 5); + misc_settings_grid_sizer->Add(m_system_language_choice, wxGBPosition(3, 1), wxDefaultSpan, wxALL, 5); + + wxStaticBoxSizer* const misc_settings_static_sizer = new wxStaticBoxSizer(wxVERTICAL, this, _("Misc Settings")); + misc_settings_static_sizer->Add(misc_settings_grid_sizer); + + wxStaticBoxSizer* const device_settings_sizer = new wxStaticBoxSizer(wxVERTICAL, this, _("Device Settings")); + device_settings_sizer->Add(m_sd_card_checkbox, 0, wxALL, 5); + device_settings_sizer->Add(m_connect_keyboard_checkbox, 0, wxALL, 5); + + wxBoxSizer* const main_sizer = new wxBoxSizer(wxVERTICAL); + main_sizer->Add(misc_settings_static_sizer, 0, wxEXPAND | wxALL, 5); + main_sizer->Add(device_settings_sizer, 0, wxEXPAND | wxALL, 5); + + SetSizer(main_sizer); +} + +void WiiConfigPane::LoadGUIValues() +{ + m_screensaver_checkbox->SetValue(!!SConfig::GetInstance().m_SYSCONF->GetData("IPL.SSV")); + m_pal60_mode_checkbox->SetValue(!!SConfig::GetInstance().m_SYSCONF->GetData("IPL.E60")); + m_aspect_ratio_choice->SetSelection(SConfig::GetInstance().m_SYSCONF->GetData("IPL.AR")); + m_system_language_choice->SetSelection(SConfig::GetInstance().m_SYSCONF->GetData("IPL.LNG")); + + m_sd_card_checkbox->SetValue(SConfig::GetInstance().m_WiiSDCard); + m_connect_keyboard_checkbox->SetValue(SConfig::GetInstance().m_WiiKeyboard); +} + +void WiiConfigPane::RefreshGUI() +{ + if (Core::IsRunning()) + { + m_screensaver_checkbox->Disable(); + m_pal60_mode_checkbox->Disable(); + m_aspect_ratio_choice->Disable(); + m_system_language_choice->Disable(); + } +} + +void WiiConfigPane::OnScreenSaverCheckBoxChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_SYSCONF->SetData("IPL.SSV", m_screensaver_checkbox->IsChecked()); +} + +void WiiConfigPane::OnPAL60CheckBoxChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_SYSCONF->SetData("IPL.E60", m_pal60_mode_checkbox->IsChecked()); +} + +void WiiConfigPane::OnSDCardCheckBoxChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_WiiSDCard = m_sd_card_checkbox->IsChecked(); + WII_IPC_HLE_Interface::SDIO_EventNotify(); +} + +void WiiConfigPane::OnConnectKeyboardCheckBoxChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_WiiKeyboard = m_connect_keyboard_checkbox->IsChecked(); +} + +void WiiConfigPane::OnSystemLanguageChoiceChanged(wxCommandEvent& event) +{ + int wii_system_lang = m_system_language_choice->GetSelection(); + SConfig::GetInstance().m_SYSCONF->SetData("IPL.LNG", wii_system_lang); + u8 country_code = GetSADRCountryCode(wii_system_lang); + + if (!SConfig::GetInstance().m_SYSCONF->SetArrayData("IPL.SADR", &country_code, 1)) + WxUtils::ShowErrorDialog(_("Failed to update country code in SYSCONF")); +} + +void WiiConfigPane::OnAspectRatioChoiceChanged(wxCommandEvent& event) +{ + SConfig::GetInstance().m_SYSCONF->SetData("IPL.AR", m_aspect_ratio_choice->GetSelection()); +} + +// Change from IPL.LNG value to IPL.SADR country code +u8 WiiConfigPane::GetSADRCountryCode(int language) +{ + //http://wiibrew.org/wiki/Country_Codes + u8 country_code = language; + switch (country_code) + { + case 0: //Japanese + country_code = 1; //Japan + break; + case 1: //English + country_code = 49; //USA + break; + case 2: //German + country_code = 78; //Germany + break; + case 3: //French + country_code = 77; //France + break; + case 4: //Spanish + country_code = 105; //Spain + break; + case 5: //Italian + country_code = 83; //Italy + break; + case 6: //Dutch + country_code = 94; //Netherlands + break; + case 7: //Simplified Chinese + case 8: //Traditional Chinese + country_code = 157; //China + break; + case 9: //Korean + country_code = 136; //Korea + break; + } + return country_code; +} diff --git a/Source/Core/DolphinWX/Config/WiiConfigPane.h b/Source/Core/DolphinWX/Config/WiiConfigPane.h new file mode 100644 index 0000000000..b7ab61b5a4 --- /dev/null +++ b/Source/Core/DolphinWX/Config/WiiConfigPane.h @@ -0,0 +1,44 @@ +// Copyright 2015 Dolphin Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#pragma once + +#include +#include +#include "Common/CommonTypes.h" + +class wxCheckBox; +class wxChoice; +class wxCommandEvent; + +class WiiConfigPane final : public wxPanel +{ +public: + WiiConfigPane(wxWindow* parent, wxWindowID id); + +private: + void InitializeGUI(); + void LoadGUIValues(); + void RefreshGUI(); + + void OnScreenSaverCheckBoxChanged(wxCommandEvent&); + void OnPAL60CheckBoxChanged(wxCommandEvent&); + void OnSDCardCheckBoxChanged(wxCommandEvent&); + void OnConnectKeyboardCheckBoxChanged(wxCommandEvent&); + void OnSystemLanguageChoiceChanged(wxCommandEvent&); + void OnAspectRatioChoiceChanged(wxCommandEvent&); + + static u8 GetSADRCountryCode(int language); + + wxArrayString m_system_language_strings; + wxArrayString m_aspect_ratio_strings; + + wxCheckBox* m_screensaver_checkbox; + wxCheckBox* m_pal60_mode_checkbox; + wxCheckBox* m_sd_card_checkbox; + wxCheckBox* m_connect_keyboard_checkbox; + wxChoice* m_system_language_choice; + wxChoice* m_aspect_ratio_choice; + wxChoice* m_sensor_bar_position_choice; +}; diff --git a/Source/Core/DolphinWX/ConfigMain.cpp b/Source/Core/DolphinWX/ConfigMain.cpp deleted file mode 100644 index 841b4fa53b..0000000000 --- a/Source/Core/DolphinWX/ConfigMain.cpp +++ /dev/null @@ -1,1382 +0,0 @@ -// Copyright 2013 Dolphin Emulator Project -// Licensed under GPLv2 -// Refer to the license.txt file included. - -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "AudioCommon/AudioCommon.h" - -#include "Common/CommonPaths.h" -#include "Common/CommonTypes.h" -#include "Common/FileSearch.h" -#include "Common/SysConf.h" - -#include "Core/ConfigManager.h" -#include "Core/Core.h" -#include "Core/HotkeyManager.h" -#include "Core/Movie.h" -#include "Core/NetPlayProto.h" -#include "Core/HW/EXI.h" -#include "Core/HW/GCMemcard.h" -#include "Core/HW/SI.h" -#include "Core/HW/DSPHLE/DSPHLE.h" -#include "Core/HW/DSPLLE/DSPLLE.h" -#include "Core/IPC_HLE/WII_IPC_HLE.h" -#include "Core/PowerPC/PowerPC.h" - -#include "DiscIO/NANDContentLoader.h" - -#include "DolphinWX/ConfigMain.h" -#include "DolphinWX/Frame.h" -#include "DolphinWX/Globals.h" -#include "DolphinWX/HotkeyDlg.h" -#include "DolphinWX/InputConfigDiag.h" -#include "DolphinWX/Main.h" -#include "DolphinWX/WxUtils.h" -#include "DolphinWX/Debugger/CodeWindow.h" - -#include "InputCommon/InputConfig.h" - -#include "VideoCommon/VideoBackendBase.h" - -#define TEXT_BOX(page, text) new wxStaticText(page, wxID_ANY, text) - -struct CPUCore -{ - int CPUid; - const char *name; -}; -const CPUCore CPUCores[] = { - {0, wxTRANSLATE("Interpreter (VERY slow)")}, -#ifdef _M_X86_64 - {1, wxTRANSLATE("JIT Recompiler (recommended)")}, - {2, wxTRANSLATE("JITIL Recompiler (slower, experimental)")}, -#elif defined(_M_ARM_32) - {3, wxTRANSLATE("Arm JIT (experimental)")}, -#elif defined(_M_ARM_64) - {4, wxTRANSLATE("Arm64 JIT (experimental)")}, -#endif -}; - -// keep these in sync with CConfigMain::InitializeGUILists -static const wxLanguage langIds[] = -{ - wxLANGUAGE_DEFAULT, - - wxLANGUAGE_CATALAN, - wxLANGUAGE_CZECH, - wxLANGUAGE_GERMAN, - wxLANGUAGE_ENGLISH, - wxLANGUAGE_SPANISH, - wxLANGUAGE_FRENCH, - wxLANGUAGE_ITALIAN, - wxLANGUAGE_HUNGARIAN, - wxLANGUAGE_DUTCH, - wxLANGUAGE_NORWEGIAN_BOKMAL, - wxLANGUAGE_POLISH, - wxLANGUAGE_PORTUGUESE, - wxLANGUAGE_PORTUGUESE_BRAZILIAN, - wxLANGUAGE_SERBIAN, - wxLANGUAGE_SWEDISH, - wxLANGUAGE_TURKISH, - - wxLANGUAGE_GREEK, - wxLANGUAGE_RUSSIAN, - wxLANGUAGE_HEBREW, - wxLANGUAGE_ARABIC, - wxLANGUAGE_FARSI, - wxLANGUAGE_KOREAN, - wxLANGUAGE_JAPANESE, - wxLANGUAGE_CHINESE_SIMPLIFIED, - wxLANGUAGE_CHINESE_TRADITIONAL, -}; - -// Strings for Device Selections -#define DEV_NONE_STR _trans("") -#define DEV_DUMMY_STR _trans("Dummy") - -#define EXIDEV_MEMCARD_STR _trans("Memory Card") -#define EXIDEV_MEMDIR_STR _trans("GCI Folder") -#define EXIDEV_MIC_STR _trans("Mic") -#define EXIDEV_BBA_STR "BBA" -#define EXIDEV_AGP_STR "Advance Game Port" -#define EXIDEV_AM_BB_STR _trans("AM-Baseboard") -#define EXIDEV_GECKO_STR "USBGecko" - -#ifdef WIN32 -//only used with xgettext to be picked up as translatable string. -//win32 does not have wx on its path, the provided wxALL_FILES -//translation does not work there. -#define unusedALL_FILES wxTRANSLATE("All files (*.*)|*.*"); -#endif - -BEGIN_EVENT_TABLE(CConfigMain, wxDialog) - -EVT_CLOSE(CConfigMain::OnClose) -EVT_BUTTON(wxID_OK, CConfigMain::OnOk) - - -EVT_CHECKBOX(ID_CPUTHREAD, CConfigMain::CoreSettingsChanged) -EVT_CHECKBOX(ID_IDLESKIP, CConfigMain::CoreSettingsChanged) -EVT_CHECKBOX(ID_ENABLECHEATS, CConfigMain::CoreSettingsChanged) -EVT_CHOICE(ID_FRAMELIMIT, CConfigMain::CoreSettingsChanged) - -EVT_RADIOBOX(ID_CPUENGINE, CConfigMain::CoreSettingsChanged) -EVT_CHECKBOX(ID_NTSCJ, CConfigMain::CoreSettingsChanged) -EVT_SLIDER(ID_OVERCLOCK, CConfigMain::CoreSettingsChanged) -EVT_CHECKBOX(ID_ENABLEOVERCLOCK, CConfigMain::CoreSettingsChanged) - -EVT_RADIOBOX(ID_DSPENGINE, CConfigMain::AudioSettingsChanged) -EVT_CHECKBOX(ID_ENABLE_THROTTLE, CConfigMain::AudioSettingsChanged) -EVT_CHECKBOX(ID_DPL2DECODER, CConfigMain::AudioSettingsChanged) -EVT_CHOICE(ID_BACKEND, CConfigMain::AudioSettingsChanged) -EVT_SLIDER(ID_VOLUME, CConfigMain::AudioSettingsChanged) - -EVT_CHECKBOX(ID_INTERFACE_CONFIRMSTOP, CConfigMain::DisplaySettingsChanged) -EVT_CHECKBOX(ID_INTERFACE_USEPANICHANDLERS, CConfigMain::DisplaySettingsChanged) -EVT_CHECKBOX(ID_INTERFACE_ONSCREENDISPLAYMESSAGES, CConfigMain::DisplaySettingsChanged) -EVT_CHECKBOX(ID_INTERFACE_PAUSEONFOCUSLOST, CConfigMain::DisplaySettingsChanged) -EVT_CHOICE(ID_INTERFACE_LANG, CConfigMain::DisplaySettingsChanged) -EVT_BUTTON(ID_HOTKEY_CONFIG, CConfigMain::DisplaySettingsChanged) - - -EVT_CHOICE(ID_GC_SRAM_LNG, CConfigMain::GCSettingsChanged) -EVT_CHECKBOX(ID_GC_ALWAYS_HLE_BS2, CConfigMain::GCSettingsChanged) - -EVT_CHOICE(ID_GC_EXIDEVICE_SLOTA, CConfigMain::GCSettingsChanged) -EVT_BUTTON(ID_GC_EXIDEVICE_SLOTA_PATH, CConfigMain::GCSettingsChanged) -EVT_CHOICE(ID_GC_EXIDEVICE_SLOTB, CConfigMain::GCSettingsChanged) -EVT_BUTTON(ID_GC_EXIDEVICE_SLOTB_PATH, CConfigMain::GCSettingsChanged) -EVT_CHOICE(ID_GC_EXIDEVICE_SP1, CConfigMain::GCSettingsChanged) - -EVT_CHECKBOX(ID_WII_IPL_SSV, CConfigMain::WiiSettingsChanged) -EVT_CHECKBOX(ID_WII_IPL_E60, CConfigMain::WiiSettingsChanged) -EVT_CHOICE(ID_WII_IPL_AR, CConfigMain::WiiSettingsChanged) -EVT_CHOICE(ID_WII_IPL_LNG, CConfigMain::WiiSettingsChanged) - -EVT_CHECKBOX(ID_WII_SD_CARD, CConfigMain::WiiSettingsChanged) -EVT_CHECKBOX(ID_WII_KEYBOARD, CConfigMain::WiiSettingsChanged) - - -EVT_LISTBOX(ID_ISOPATHS, CConfigMain::ISOPathsSelectionChanged) -EVT_CHECKBOX(ID_RECURSIVEISOPATH, CConfigMain::RecursiveDirectoryChanged) -EVT_BUTTON(ID_ADDISOPATH, CConfigMain::AddRemoveISOPaths) -EVT_BUTTON(ID_REMOVEISOPATH, CConfigMain::AddRemoveISOPaths) - -EVT_FILEPICKER_CHANGED(ID_DEFAULTISO, CConfigMain::DefaultISOChanged) -EVT_DIRPICKER_CHANGED(ID_DVDROOT, CConfigMain::DVDRootChanged) -EVT_FILEPICKER_CHANGED(ID_APPLOADERPATH, CConfigMain::ApploaderPathChanged) -EVT_DIRPICKER_CHANGED(ID_NANDROOT, CConfigMain::NANDRootChanged) - - -END_EVENT_TABLE() - -CConfigMain::CConfigMain(wxWindow* parent, wxWindowID id, const wxString& title, - const wxPoint& position, const wxSize& size, long style) - : wxDialog(parent, id, title, position, size, style) -{ - // Control refreshing of the ISOs list - bRefreshList = false; - - CreateGUIControls(); - - // Update selected ISO paths - for (const std::string& folder : SConfig::GetInstance().m_ISOFolder) - { - ISOPaths->Append(StrToWxStr(folder)); - } -} - -CConfigMain::~CConfigMain() -{ -} - -void CConfigMain::SetSelectedTab(int tab) -{ - // TODO : this is just a quick and dirty way to do it, possible cleanup - - switch (tab) - { - case ID_AUDIOPAGE: - Notebook->SetSelection(2); - break; - } -} - -// Used to restrict changing of some options while emulator is running -void CConfigMain::UpdateGUI() -{ - if (Core::IsRunning()) - { - // Disable the Core stuff on GeneralPage - CPUThread->Disable(); - SkipIdle->Disable(); - EnableCheats->Disable(); - - CPUEngine->Disable(); - ForceNTSCJ->Disable(); - - // Disable stuff on AudioPage - DSPEngine->Disable(); - DPL2Decoder->Disable(); - Latency->Disable(); - - // Disable stuff on GamecubePage - GCSystemLang->Disable(); - GCAlwaysHLE_BS2->Disable(); - - // Disable stuff on WiiPage - WiiScreenSaver->Disable(); - WiiPAL60->Disable(); - WiiAspectRatio->Disable(); - WiiSystemLang->Disable(); - - // Disable stuff on PathsPage - PathsPage->Disable(); - } -} -void CConfigMain::InitializeGUILists() -{ - // General page - // Framelimit - arrayStringFor_Framelimit.Add(_("Off")); - arrayStringFor_Framelimit.Add(_("Auto")); - for (int i = 5; i <= 120; i += 5) // from 5 to 120 - arrayStringFor_Framelimit.Add(wxString::Format("%i", i)); - - // Emulator Engine - for (const CPUCore& CPUCores_a : CPUCores) - arrayStringFor_CPUEngine.Add(wxGetTranslation(CPUCores_a.name)); - - // DSP Engine - arrayStringFor_DSPEngine.Add(_("DSP HLE emulation (fast)")); - arrayStringFor_DSPEngine.Add(_("DSP LLE recompiler")); - arrayStringFor_DSPEngine.Add(_("DSP LLE interpreter (slow)")); - - // GameCube page - // GC Language arrayStrings - arrayStringFor_GCSystemLang.Add(_("English")); - arrayStringFor_GCSystemLang.Add(_("German")); - arrayStringFor_GCSystemLang.Add(_("French")); - arrayStringFor_GCSystemLang.Add(_("Spanish")); - arrayStringFor_GCSystemLang.Add(_("Italian")); - arrayStringFor_GCSystemLang.Add(_("Dutch")); - - - // Wii page - // Sensorbar Position - arrayStringFor_WiiSensBarPos.Add(_("Bottom")); - arrayStringFor_WiiSensBarPos.Add(_("Top")); - - // Aspect ratio - arrayStringFor_WiiAspectRatio.Add("4:3"); - arrayStringFor_WiiAspectRatio.Add("16:9"); - - // Wii Language arrayStrings - arrayStringFor_WiiSystemLang = arrayStringFor_GCSystemLang; - arrayStringFor_WiiSystemLang.Insert(_("Japanese"), 0); - arrayStringFor_WiiSystemLang.Add(_("Simplified Chinese")); - arrayStringFor_WiiSystemLang.Add(_("Traditional Chinese")); - arrayStringFor_WiiSystemLang.Add(_("Korean")); - - // GUI language arrayStrings - // keep these in sync with the langIds array at the beginning of this file - arrayStringFor_InterfaceLang.Add(_("")); - - arrayStringFor_InterfaceLang.Add(L"Catal\u00E0"); // Catalan - arrayStringFor_InterfaceLang.Add(L"\u010Ce\u0161tina"); // Czech - arrayStringFor_InterfaceLang.Add(L"Deutsch"); // German - arrayStringFor_InterfaceLang.Add(L"English"); // English - arrayStringFor_InterfaceLang.Add(L"Espa\u00F1ol"); // Spanish - arrayStringFor_InterfaceLang.Add(L"Fran\u00E7ais"); // French - arrayStringFor_InterfaceLang.Add(L"Italiano"); // Italian - arrayStringFor_InterfaceLang.Add(L"Magyar"); // Hungarian - arrayStringFor_InterfaceLang.Add(L"Nederlands"); // Dutch - arrayStringFor_InterfaceLang.Add(L"Norsk bokm\u00E5l"); // Norwegian - arrayStringFor_InterfaceLang.Add(L"Polski"); // Polish - arrayStringFor_InterfaceLang.Add(L"Portugu\u00EAs"); // Portuguese - arrayStringFor_InterfaceLang.Add(L"Portugu\u00EAs (Brasil)"); // Portuguese (Brazil) - arrayStringFor_InterfaceLang.Add(L"Srpski"); // Serbian - arrayStringFor_InterfaceLang.Add(L"Svenska"); // Swedish - arrayStringFor_InterfaceLang.Add(L"T\u00FCrk\u00E7e"); // Turkish - - arrayStringFor_InterfaceLang.Add(L"\u0395\u03BB\u03BB\u03B7\u03BD\u03B9\u03BA\u03AC"); // Greek - arrayStringFor_InterfaceLang.Add(L"\u0420\u0443\u0441\u0441\u043A\u0438\u0439"); // Russian - arrayStringFor_InterfaceLang.Add(L"\u05E2\u05D1\u05E8\u05D9\u05EA"); // Hebrew - arrayStringFor_InterfaceLang.Add(L"\u0627\u0644\u0639\u0631\u0628\u064A\u0629"); // Arabic - arrayStringFor_InterfaceLang.Add(L"\u0641\u0627\u0631\u0633\u06CC"); // Farsi - arrayStringFor_InterfaceLang.Add(L"\uD55C\uAD6D\uC5B4"); // Korean - arrayStringFor_InterfaceLang.Add(L"\u65E5\u672C\u8A9E"); // Japanese - arrayStringFor_InterfaceLang.Add(L"\u7B80\u4F53\u4E2D\u6587"); // Simplified Chinese - arrayStringFor_InterfaceLang.Add(L"\u7E41\u9AD4\u4E2D\u6587"); // Traditional Chinese -} - -void CConfigMain::InitializeGUIValues() -{ - const SCoreStartupParameter& startup_params = SConfig::GetInstance().m_LocalCoreStartupParameter; - - // General - Basic - CPUThread->SetValue(startup_params.bCPUThread); - SkipIdle->SetValue(startup_params.bSkipIdle); - EnableCheats->SetValue(startup_params.bEnableCheats); - Framelimit->SetSelection(SConfig::GetInstance().m_Framelimit); - int ocFactor = (int)(log2f(SConfig::GetInstance().m_OCFactor) * 25.f + 100.f + 0.5f); - EnableOC->SetValue(SConfig::GetInstance().m_OCEnable); - OCSlider->SetValue(ocFactor); - UpdateCPUClock(); - - // General - Advanced - for (unsigned int a = 0; a < (sizeof(CPUCores) / sizeof(CPUCore)); ++a) - if (CPUCores[a].CPUid == startup_params.iCPUCore) - CPUEngine->SetSelection(a); - ForceNTSCJ->SetValue(startup_params.bForceNTSCJ); - - - // Display - Interface - ConfirmStop->SetValue(startup_params.bConfirmStop); - UsePanicHandlers->SetValue(startup_params.bUsePanicHandlers); - OnScreenDisplayMessages->SetValue(startup_params.bOnScreenDisplayMessages); - PauseOnFocusLost->SetValue(SConfig::GetInstance().m_PauseOnFocusLost); - // need redesign - for (unsigned int i = 0; i < sizeof(langIds) / sizeof(wxLanguage); i++) - { - if (langIds[i] == SConfig::GetInstance().m_InterfaceLanguage) - { - InterfaceLang->SetSelection(i); - break; - } - } - - // Audio DSP Engine - if (startup_params.bDSPHLE) - DSPEngine->SetSelection(0); - else - DSPEngine->SetSelection(SConfig::GetInstance().m_DSPEnableJIT ? 1 : 2); - - // Audio - VolumeSlider->Enable(SupportsVolumeChanges(SConfig::GetInstance().sBackend)); - VolumeSlider->SetValue(SConfig::GetInstance().m_Volume); - VolumeText->SetLabel(wxString::Format("%d %%", SConfig::GetInstance().m_Volume)); - DPL2Decoder->Enable(std::string(SConfig::GetInstance().sBackend) == BACKEND_OPENAL - || std::string(SConfig::GetInstance().sBackend) == BACKEND_PULSEAUDIO); - DPL2Decoder->SetValue(startup_params.bDPL2Decoder); - Latency->Enable(std::string(SConfig::GetInstance().sBackend) == BACKEND_OPENAL); - Latency->SetValue(startup_params.iLatency); - // add backends to the list - AddAudioBackends(); - - - // GameCube - IPL - GCSystemLang->SetSelection(startup_params.SelectedLanguage); - GCAlwaysHLE_BS2->SetValue(startup_params.bHLE_BS2); - - // GameCube - Devices - wxArrayString SlotDevices; - SlotDevices.Add(_(DEV_NONE_STR)); - SlotDevices.Add(_(DEV_DUMMY_STR)); - SlotDevices.Add(_(EXIDEV_MEMCARD_STR)); - SlotDevices.Add(_(EXIDEV_MEMDIR_STR)); - SlotDevices.Add(_(EXIDEV_GECKO_STR)); - SlotDevices.Add(_(EXIDEV_AGP_STR)); - -#if HAVE_PORTAUDIO - SlotDevices.Add(_(EXIDEV_MIC_STR)); -#endif - - wxArrayString SP1Devices; - SP1Devices.Add(_(DEV_NONE_STR)); - SP1Devices.Add(_(DEV_DUMMY_STR)); - SP1Devices.Add(_(EXIDEV_BBA_STR)); - SP1Devices.Add(_(EXIDEV_AM_BB_STR)); - - - for (int i = 0; i < 3; ++i) - { - bool isMemcard = false; - - // Add strings to the wxChoice list, the third wxChoice is the SP1 slot - if (i == 2) - GCEXIDevice[i]->Append(SP1Devices); - else - GCEXIDevice[i]->Append(SlotDevices); - - switch (SConfig::GetInstance().m_EXIDevice[i]) - { - case EXIDEVICE_NONE: - GCEXIDevice[i]->SetStringSelection(SlotDevices[0]); - break; - case EXIDEVICE_MEMORYCARD: - isMemcard = GCEXIDevice[i]->SetStringSelection(SlotDevices[2]); - break; - case EXIDEVICE_MEMORYCARDFOLDER: - GCEXIDevice[i]->SetStringSelection(SlotDevices[3]); - break; - case EXIDEVICE_GECKO: - GCEXIDevice[i]->SetStringSelection(SlotDevices[4]); - break; - case EXIDEVICE_AGP: - isMemcard = GCEXIDevice[i]->SetStringSelection(SlotDevices[5]); - break; - case EXIDEVICE_MIC: - GCEXIDevice[i]->SetStringSelection(SlotDevices[6]); - break; - case EXIDEVICE_ETH: - GCEXIDevice[i]->SetStringSelection(SP1Devices[2]); - break; - case EXIDEVICE_AM_BASEBOARD: - GCEXIDevice[i]->SetStringSelection(SP1Devices[3]); - break; - case EXIDEVICE_DUMMY: - default: - GCEXIDevice[i]->SetStringSelection(SlotDevices[1]); - break; - } - if (!isMemcard && i < 2) - GCMemcardPath[i]->Disable(); - } - - // Wii - Misc - WiiScreenSaver->SetValue(!!SConfig::GetInstance().m_SYSCONF->GetData("IPL.SSV")); - WiiPAL60->SetValue(!!SConfig::GetInstance().m_SYSCONF->GetData("IPL.E60")); - WiiAspectRatio->SetSelection(SConfig::GetInstance().m_SYSCONF->GetData("IPL.AR")); - WiiSystemLang->SetSelection(SConfig::GetInstance().m_SYSCONF->GetData("IPL.LNG")); - - // Wii - Devices - WiiSDCard->SetValue(SConfig::GetInstance().m_WiiSDCard); - WiiKeyboard->SetValue(SConfig::GetInstance().m_WiiKeyboard); - - - // Paths - RecursiveISOPath->SetValue(SConfig::GetInstance().m_RecursiveISOFolder); - DefaultISO->SetPath(StrToWxStr(startup_params.m_strDefaultISO)); - DVDRoot->SetPath(StrToWxStr(startup_params.m_strDVDRoot)); - ApploaderPath->SetPath(StrToWxStr(startup_params.m_strApploader)); - NANDRoot->SetPath(StrToWxStr(SConfig::GetInstance().m_NANDPath)); -} - -void CConfigMain::InitializeGUITooltips() -{ - // General - Basic - CPUThread->SetToolTip(_("Splits the CPU and GPU threads so they can be run on separate cores.\nProvides major speed improvements on most modern PCs, but can cause occasional crashes/glitches.")); - SkipIdle->SetToolTip(_("Attempt to detect and skip wait-loops.\nIf unsure, leave this checked.")); - EnableCheats->SetToolTip(_("Enables the use of Action Replay and Gecko cheats.")); - Framelimit->SetToolTip(_("Limits the game speed to the specified number of frames per second (full speed is 60 for NTSC and 50 for PAL).")); - - // General - Advanced - ForceNTSCJ->SetToolTip(_("Forces NTSC-J mode for using the Japanese ROM font.\nIf left unchecked, Dolphin defaults to NTSC-U and automatically enables this setting when playing Japanese games.")); - - // Display - Interface - ConfirmStop->SetToolTip(_("Show a confirmation box before stopping a game.")); - UsePanicHandlers->SetToolTip(_("Show a message box when a potentially serious error has occurred.\nDisabling this may avoid annoying and non-fatal messages, but it may result in major crashes having no explanation at all.")); - OnScreenDisplayMessages->SetToolTip(_("Display messages over the emulation screen area.\nThese messages include memory card writes, video backend and CPU information, and JIT cache clearing.")); - PauseOnFocusLost->SetToolTip(_("Pauses the emulator when focus is taken away from the emulation window.")); - - InterfaceLang->SetToolTip(_("Change the language of the user interface.\nRequires restart.")); - - // Audio - Backend - BackendSelection->SetToolTip(_("Changing this will have no effect while the emulator is running.")); - - // GameCube - IPL - GCSystemLang->SetToolTip(_("Sets the GameCube system language.")); - - // GameCube - Devices - GCEXIDevice[2]->SetToolTip(_("Serial Port 1 - This is the port which devices such as the net adapter use.")); - - // Wii - Misc - WiiScreenSaver->SetToolTip(_("Dims the screen after five minutes of inactivity.")); - WiiPAL60->SetToolTip(_("Sets the Wii display mode to 60Hz (480i) instead of 50Hz (576i) for PAL games.\nMay not work for all games.")); - WiiSystemLang->SetToolTip(_("Sets the Wii system language.")); - - // Wii - Devices - WiiSDCard->SetToolTip(_("Saved to /Wii/sd.raw (default size is 128mb)")); - WiiKeyboard->SetToolTip(_("May cause slow down in Wii Menu and some games.")); - -#if defined(__APPLE__) - DPL2Decoder->SetToolTip(_("Enables Dolby Pro Logic II emulation using 5.1 surround. Not available on OS X.")); -#else - DPL2Decoder->SetToolTip(_("Enables Dolby Pro Logic II emulation using 5.1 surround. OpenAL or Pulse backends only.")); -#endif - - Latency->SetToolTip(_("Sets the latency (in ms). Higher values may reduce audio crackling. OpenAL backend only.")); -} - -void CConfigMain::CreateGUIControls() -{ - InitializeGUILists(); - - // Create the notebook and pages - Notebook = new wxNotebook(this, ID_NOTEBOOK); - wxPanel* const GeneralPage = new wxPanel(Notebook, ID_GENERALPAGE); - wxPanel* const DisplayPage = new wxPanel(Notebook, ID_DISPLAYPAGE); - wxPanel* const AudioPage = new wxPanel(Notebook, ID_AUDIOPAGE); - wxPanel* const GamecubePage = new wxPanel(Notebook, ID_GAMECUBEPAGE); - wxPanel* const WiiPage = new wxPanel(Notebook, ID_WIIPAGE); - wxPanel* const AdvancedPage = new wxPanel(Notebook, ID_ADVANCEDPAGE); - PathsPage = new wxPanel(Notebook, ID_PATHSPAGE); - - Notebook->AddPage(GeneralPage, _("General")); - Notebook->AddPage(DisplayPage, _("Interface")); - Notebook->AddPage(AudioPage, _("Audio")); - Notebook->AddPage(GamecubePage, _("GameCube")); - Notebook->AddPage(WiiPage, _("Wii")); - Notebook->AddPage(PathsPage, _("Paths")); - Notebook->AddPage(AdvancedPage, _("Advanced")); - - // General page - // Core Settings - Basic - CPUThread = new wxCheckBox(GeneralPage, ID_CPUTHREAD, _("Enable Dual Core (speedup)")); - SkipIdle = new wxCheckBox(GeneralPage, ID_IDLESKIP, _("Enable Idle Skipping (speedup)")); - EnableCheats = new wxCheckBox(GeneralPage, ID_ENABLECHEATS, _("Enable Cheats")); - // Framelimit - Framelimit = new wxChoice(GeneralPage, ID_FRAMELIMIT, wxDefaultPosition, wxDefaultSize, arrayStringFor_Framelimit); - // Core Settings - Advanced - CPUEngine = new wxRadioBox(GeneralPage, ID_CPUENGINE, _("CPU Emulator Engine"), wxDefaultPosition, wxDefaultSize, arrayStringFor_CPUEngine, 0, wxRA_SPECIFY_ROWS); - ForceNTSCJ = new wxCheckBox(GeneralPage, ID_NTSCJ, _("Force Console as NTSC-J")); - - // Populate the General settings - wxBoxSizer* sFramelimit = new wxBoxSizer(wxHORIZONTAL); - sFramelimit->Add(TEXT_BOX(GeneralPage, _("Framelimit:")), 0, wxALIGN_CENTER_VERTICAL | wxLEFT | wxRIGHT | wxBOTTOM, 5); - sFramelimit->Add(Framelimit, 0, wxLEFT | wxRIGHT | wxBOTTOM | wxEXPAND, 5); - - wxStaticBoxSizer* const sbBasic = new wxStaticBoxSizer(wxVERTICAL, GeneralPage, _("Basic Settings")); - sbBasic->Add(CPUThread, 0, wxALL, 5); - sbBasic->Add(SkipIdle, 0, wxALL, 5); - sbBasic->Add(EnableCheats, 0, wxALL, 5); - sbBasic->Add(sFramelimit); - - wxStaticBoxSizer* const sbAdvanced = new wxStaticBoxSizer(wxVERTICAL, GeneralPage, _("Advanced Settings")); - sbAdvanced->Add(CPUEngine, 0, wxALL, 5); - sbAdvanced->Add(ForceNTSCJ, 0, wxALL, 5); - - wxBoxSizer* const sGeneralPage = new wxBoxSizer(wxVERTICAL); - sGeneralPage->Add(sbBasic, 0, wxEXPAND | wxALL, 5); - sGeneralPage->Add(sbAdvanced, 0, wxEXPAND | wxALL, 5); - GeneralPage->SetSizer(sGeneralPage); - - // Interface Language - InterfaceLang = new wxChoice(DisplayPage, ID_INTERFACE_LANG, wxDefaultPosition, wxDefaultSize, arrayStringFor_InterfaceLang); - // Hotkey configuration - HotkeyConfig = new wxButton(DisplayPage, ID_HOTKEY_CONFIG, _("Hotkeys"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT); - // Interface settings - ConfirmStop = new wxCheckBox(DisplayPage, ID_INTERFACE_CONFIRMSTOP, _("Confirm on Stop")); - UsePanicHandlers = new wxCheckBox(DisplayPage, ID_INTERFACE_USEPANICHANDLERS, _("Use Panic Handlers")); - OnScreenDisplayMessages = new wxCheckBox(DisplayPage, ID_INTERFACE_ONSCREENDISPLAYMESSAGES, _("On-Screen Display Messages")); - PauseOnFocusLost = new wxCheckBox(DisplayPage, ID_INTERFACE_PAUSEONFOCUSLOST, _("Pause on Focus Lost")); - - wxBoxSizer* sInterface = new wxBoxSizer(wxHORIZONTAL); - sInterface->Add(TEXT_BOX(DisplayPage, _("Language:")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5); - sInterface->Add(InterfaceLang, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5); - sInterface->AddStretchSpacer(); - sInterface->Add(HotkeyConfig, 0, wxALIGN_RIGHT | wxALL, 5); - - // theme selection - auto const theme_selection = new wxChoice(DisplayPage, wxID_ANY); - - CFileSearch::XStringVector theme_dirs; - theme_dirs.push_back(File::GetUserPath(D_THEMES_IDX)); - theme_dirs.push_back(File::GetSysDirectory() + THEMES_DIR); - - CFileSearch cfs(CFileSearch::XStringVector(1, "*"), theme_dirs); - auto const& sv = cfs.GetFileNames(); - std::for_each(sv.begin(), sv.end(), [theme_selection](const std::string& filename) - { - std::string name, ext; - SplitPath(filename, nullptr, &name, &ext); - - name += ext; - auto const wxname = StrToWxStr(name); - if (-1 == theme_selection->FindString(wxname)) - theme_selection->Append(wxname); - }); - - theme_selection->SetStringSelection(StrToWxStr(SConfig::GetInstance().m_LocalCoreStartupParameter.theme_name)); - - // std::function = avoid error on msvc - theme_selection->Bind(wxEVT_CHOICE, std::function([theme_selection](wxEvent&) - { - SConfig::GetInstance().m_LocalCoreStartupParameter.theme_name = WxStrToStr(theme_selection->GetStringSelection()); - main_frame->InitBitmaps(); - main_frame->UpdateGameList(); - })); - - auto const scInterface = new wxBoxSizer(wxHORIZONTAL); - scInterface->Add(TEXT_BOX(DisplayPage, _("Theme:")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5); - scInterface->Add(theme_selection, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5); - scInterface->AddStretchSpacer(); - - sbInterface = new wxStaticBoxSizer(wxVERTICAL, DisplayPage, _("Interface Settings")); - sbInterface->Add(ConfirmStop, 0, wxALL, 5); - sbInterface->Add(UsePanicHandlers, 0, wxALL, 5); - sbInterface->Add(OnScreenDisplayMessages, 0, wxALL, 5); - sbInterface->Add(PauseOnFocusLost, 0, wxALL, 5); - sbInterface->Add(scInterface, 0, wxEXPAND | wxALL, 5); - sbInterface->Add(sInterface, 0, wxEXPAND | wxALL, 5); - sDisplayPage = new wxBoxSizer(wxVERTICAL); - sDisplayPage->Add(sbInterface, 0, wxEXPAND | wxALL, 5); - DisplayPage->SetSizer(sDisplayPage); - - - // Audio page - DSPEngine = new wxRadioBox(AudioPage, ID_DSPENGINE, _("DSP Emulator Engine"), wxDefaultPosition, wxDefaultSize, arrayStringFor_DSPEngine, 0, wxRA_SPECIFY_ROWS); - DPL2Decoder = new wxCheckBox(AudioPage, ID_DPL2DECODER, _("Dolby Pro Logic II decoder")); - VolumeSlider = new wxSlider(AudioPage, ID_VOLUME, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_VERTICAL | wxSL_INVERSE); - VolumeText = new wxStaticText(AudioPage, wxID_ANY, ""); - BackendSelection = new wxChoice(AudioPage, ID_BACKEND, wxDefaultPosition, wxDefaultSize, wxArrayBackends, 0, wxDefaultValidator, wxEmptyString); - Latency = new wxSpinCtrl(AudioPage, ID_LATENCY, "", wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 0, 30); - - Latency->Bind(wxEVT_SPINCTRL, &CConfigMain::AudioSettingsChanged, this); - - if (Core::IsRunning()) - { - Latency->Disable(); - BackendSelection->Disable(); - DPL2Decoder->Disable(); - } - - // Create sizer and add items to dialog - wxStaticBoxSizer *sbAudioSettings = new wxStaticBoxSizer(wxVERTICAL, AudioPage, _("Sound Settings")); - sbAudioSettings->Add(DSPEngine, 0, wxALL | wxEXPAND, 5); - sbAudioSettings->Add(DPL2Decoder, 0, wxALL, 5); - - wxStaticBoxSizer *sbVolume = new wxStaticBoxSizer(wxVERTICAL, AudioPage, _("Volume")); - sbVolume->Add(VolumeSlider, 1, wxLEFT | wxRIGHT, 13); - sbVolume->Add(VolumeText, 0, wxALIGN_CENTER | wxALL, 5); - - wxGridBagSizer *sBackend = new wxGridBagSizer(); - sBackend->Add(TEXT_BOX(AudioPage, _("Audio Backend:")), wxGBPosition(0, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxALL, 5); - sBackend->Add(BackendSelection, wxGBPosition(0, 1), wxDefaultSpan, wxALL, 5); - sBackend->Add(TEXT_BOX(AudioPage, _("Latency:")), wxGBPosition(1, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxALL, 5); - sBackend->Add(Latency, wxGBPosition(1, 1), wxDefaultSpan, wxALL, 5); - wxStaticBoxSizer *sbBackend = new wxStaticBoxSizer(wxHORIZONTAL, AudioPage, _("Backend Settings")); - sbBackend->Add(sBackend, 0, wxEXPAND); - - wxBoxSizer *sAudio = new wxBoxSizer(wxHORIZONTAL); - sAudio->Add(sbAudioSettings, 1, wxEXPAND | wxALL, 5); - sAudio->Add(sbVolume, 0, wxEXPAND | wxALL, 5); - - sAudioPage = new wxBoxSizer(wxVERTICAL); - sAudioPage->Add(sAudio, 0, wxALL | wxEXPAND); - sAudioPage->Add(sbBackend, 0, wxALL | wxEXPAND, 5); - AudioPage->SetSizerAndFit(sAudioPage); - - - // GameCube page - // IPL settings - GCSystemLang = new wxChoice(GamecubePage, ID_GC_SRAM_LNG, wxDefaultPosition, wxDefaultSize, arrayStringFor_GCSystemLang); - GCAlwaysHLE_BS2 = new wxCheckBox(GamecubePage, ID_GC_ALWAYS_HLE_BS2, _("Skip BIOS")); - - if (!File::Exists(File::GetUserPath(D_GCUSER_IDX) + DIR_SEP + USA_DIR + DIR_SEP GC_IPL) && - !File::Exists(File::GetSysDirectory() + GC_SYS_DIR + DIR_SEP + USA_DIR + DIR_SEP GC_IPL) && - !File::Exists(File::GetUserPath(D_GCUSER_IDX) + DIR_SEP + JAP_DIR + DIR_SEP GC_IPL) && - !File::Exists(File::GetSysDirectory() + GC_SYS_DIR + DIR_SEP + JAP_DIR + DIR_SEP GC_IPL) && - !File::Exists(File::GetUserPath(D_GCUSER_IDX) + DIR_SEP + EUR_DIR + DIR_SEP GC_IPL) && - !File::Exists(File::GetSysDirectory() + GC_SYS_DIR + DIR_SEP + EUR_DIR + DIR_SEP GC_IPL)) - { - GCAlwaysHLE_BS2->Disable(); - GCAlwaysHLE_BS2->SetToolTip(_("Put BIOS roms in User/GC/{region}.")); - } - - // Device settings - // EXI Devices - wxStaticText* GCEXIDeviceText[3]; - GCEXIDeviceText[0] = TEXT_BOX(GamecubePage, _("Slot A")); - GCEXIDeviceText[1] = TEXT_BOX(GamecubePage, _("Slot B")); - GCEXIDeviceText[2] = TEXT_BOX(GamecubePage, "SP1"); - GCEXIDevice[0] = new wxChoice(GamecubePage, ID_GC_EXIDEVICE_SLOTA); - GCEXIDevice[1] = new wxChoice(GamecubePage, ID_GC_EXIDEVICE_SLOTB); - GCEXIDevice[2] = new wxChoice(GamecubePage, ID_GC_EXIDEVICE_SP1); - GCMemcardPath[0] = new wxButton(GamecubePage, ID_GC_EXIDEVICE_SLOTA_PATH, "...", - wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT); - GCMemcardPath[1] = new wxButton(GamecubePage, ID_GC_EXIDEVICE_SLOTB_PATH, "...", - wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT); - - // Populate the GameCube page - sGamecubeIPLSettings = new wxGridBagSizer(); - sGamecubeIPLSettings->Add(GCAlwaysHLE_BS2, wxGBPosition(0, 0), wxGBSpan(1, 2), wxALL, 5); - sGamecubeIPLSettings->Add(TEXT_BOX(GamecubePage, _("System Language:")), - wxGBPosition(1, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxLEFT | wxRIGHT | wxBOTTOM, 5); - sGamecubeIPLSettings->Add(GCSystemLang, wxGBPosition(1, 1), wxDefaultSpan, wxLEFT | wxRIGHT | wxBOTTOM, 5); - - sbGamecubeIPLSettings = new wxStaticBoxSizer(wxVERTICAL, GamecubePage, _("IPL Settings")); - sbGamecubeIPLSettings->Add(sGamecubeIPLSettings); - wxStaticBoxSizer *sbGamecubeDeviceSettings = new wxStaticBoxSizer(wxVERTICAL, GamecubePage, _("Device Settings")); - wxGridBagSizer* sbGamecubeEXIDevSettings = new wxGridBagSizer(10, 10); - for (int i = 0; i < 3; ++i) - { - sbGamecubeEXIDevSettings->Add(GCEXIDeviceText[i], wxGBPosition(i, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL); - sbGamecubeEXIDevSettings->Add(GCEXIDevice[i], wxGBPosition(i, 1), wxGBSpan(1, (i < 2) ? 1 : 2), wxALIGN_CENTER_VERTICAL); - if (i < 2) - sbGamecubeEXIDevSettings->Add(GCMemcardPath[i], wxGBPosition(i, 2), wxDefaultSpan, wxALIGN_CENTER_VERTICAL); - if (NetPlay::IsNetPlayRunning()) - GCEXIDevice[i]->Disable(); - } - sbGamecubeDeviceSettings->Add(sbGamecubeEXIDevSettings, 0, wxALL, 5); - - sGamecubePage = new wxBoxSizer(wxVERTICAL); - sGamecubePage->Add(sbGamecubeIPLSettings, 0, wxEXPAND | wxALL, 5); - sGamecubePage->Add(sbGamecubeDeviceSettings, 0, wxEXPAND | wxALL, 5); - GamecubePage->SetSizer(sGamecubePage); - - // Wii page - // Misc Settings - WiiScreenSaver = new wxCheckBox(WiiPage, ID_WII_IPL_SSV, _("Enable Screen Saver")); - WiiPAL60 = new wxCheckBox(WiiPage, ID_WII_IPL_E60, _("Use PAL60 Mode (EuRGB60)")); - WiiAspectRatio = new wxChoice(WiiPage, ID_WII_IPL_AR, wxDefaultPosition, wxDefaultSize, arrayStringFor_WiiAspectRatio); - WiiSystemLang = new wxChoice(WiiPage, ID_WII_IPL_LNG, wxDefaultPosition, wxDefaultSize, arrayStringFor_WiiSystemLang); - - // Device Settings - WiiSDCard = new wxCheckBox(WiiPage, ID_WII_SD_CARD, _("Insert SD Card")); - WiiKeyboard = new wxCheckBox(WiiPage, ID_WII_KEYBOARD, _("Connect USB Keyboard")); - - // Populate the Wii Page - sWiiIPLSettings = new wxGridBagSizer(); - sWiiIPLSettings->Add(WiiScreenSaver, wxGBPosition(0, 0), wxGBSpan(1, 2), wxALL, 5); - sWiiIPLSettings->Add(WiiPAL60, wxGBPosition(1, 0), wxGBSpan(1, 2), wxALL, 5); - sWiiIPLSettings->Add(TEXT_BOX(WiiPage, _("Aspect Ratio:")), - wxGBPosition(2, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxALL, 5); - sWiiIPLSettings->Add(WiiAspectRatio, wxGBPosition(2, 1), wxDefaultSpan, wxALL, 5); - sWiiIPLSettings->Add(TEXT_BOX(WiiPage, _("System Language:")), - wxGBPosition(3, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxALL, 5); - sWiiIPLSettings->Add(WiiSystemLang, wxGBPosition(3, 1), wxDefaultSpan, wxALL, 5); - sbWiiIPLSettings = new wxStaticBoxSizer(wxVERTICAL, WiiPage, _("Misc Settings")); - sbWiiIPLSettings->Add(sWiiIPLSettings); - - sbWiiDeviceSettings = new wxStaticBoxSizer(wxVERTICAL, WiiPage, _("Device Settings")); - sbWiiDeviceSettings->Add(WiiSDCard, 0, wxALL, 5); - sbWiiDeviceSettings->Add(WiiKeyboard, 0, wxALL, 5); - - sWiiPage = new wxBoxSizer(wxVERTICAL); - sWiiPage->Add(sbWiiIPLSettings, 0, wxEXPAND | wxALL, 5); - sWiiPage->Add(sbWiiDeviceSettings, 0, wxEXPAND | wxALL, 5); - WiiPage->SetSizer(sWiiPage); - - - // Paths page - ISOPaths = new wxListBox(PathsPage, ID_ISOPATHS, wxDefaultPosition, wxDefaultSize, arrayStringFor_ISOPaths, wxLB_SINGLE); - RecursiveISOPath = new wxCheckBox(PathsPage, ID_RECURSIVEISOPATH, _("Search Subfolders")); - AddISOPath = new wxButton(PathsPage, ID_ADDISOPATH, _("Add...")); - RemoveISOPath = new wxButton(PathsPage, ID_REMOVEISOPATH, _("Remove")); - RemoveISOPath->Disable(); - - DefaultISO = new wxFilePickerCtrl(PathsPage, ID_DEFAULTISO, wxEmptyString, _("Choose a default ISO:"), - _("All GC/Wii files (elf, dol, gcm, iso, wbfs, ciso, gcz, wad)") + wxString::Format("|*.elf;*.dol;*.gcm;*.iso;*.wbfs;*.ciso;*.gcz;*.wad|%s", wxGetTranslation(wxALL_FILES)), - wxDefaultPosition, wxDefaultSize, wxFLP_USE_TEXTCTRL | wxFLP_OPEN); - DVDRoot = new wxDirPickerCtrl(PathsPage, ID_DVDROOT, wxEmptyString, _("Choose a DVD root directory:"), wxDefaultPosition, wxDefaultSize, wxDIRP_USE_TEXTCTRL); - ApploaderPath = new wxFilePickerCtrl(PathsPage, ID_APPLOADERPATH, wxEmptyString, _("Choose file to use as apploader: (applies to discs constructed from directories only)"), - _("apploader (.img)") + wxString::Format("|*.img|%s", wxGetTranslation(wxALL_FILES)), - wxDefaultPosition, wxDefaultSize, wxFLP_USE_TEXTCTRL | wxFLP_OPEN); - NANDRoot = new wxDirPickerCtrl(PathsPage, ID_NANDROOT, wxEmptyString, _("Choose a NAND root directory:"), wxDefaultPosition, wxDefaultSize, wxDIRP_USE_TEXTCTRL); - - // Populate the settings - wxBoxSizer* sISOButtons = new wxBoxSizer(wxHORIZONTAL); - sISOButtons->Add(RecursiveISOPath, 0, wxALL | wxALIGN_CENTER, 0); - sISOButtons->AddStretchSpacer(); - sISOButtons->Add(AddISOPath, 0, wxALL, 0); - sISOButtons->Add(RemoveISOPath, 0, wxALL, 0); - sbISOPaths = new wxStaticBoxSizer(wxVERTICAL, PathsPage, _("ISO Directories")); - sbISOPaths->Add(ISOPaths, 1, wxEXPAND | wxALL, 0); - sbISOPaths->Add(sISOButtons, 0, wxEXPAND | wxALL, 5); - - sOtherPaths = new wxGridBagSizer(); - sOtherPaths->Add(TEXT_BOX(PathsPage, _("Default ISO:")), - wxGBPosition(0, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxALL, 5); - sOtherPaths->Add(DefaultISO, wxGBPosition(0, 1), wxDefaultSpan, wxEXPAND | wxALL, 5); - sOtherPaths->Add(TEXT_BOX(PathsPage, _("DVD Root:")), - wxGBPosition(1, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxALL, 5); - sOtherPaths->Add(DVDRoot, wxGBPosition(1, 1), wxDefaultSpan, wxEXPAND | wxALL, 5); - sOtherPaths->Add(TEXT_BOX(PathsPage, _("Apploader:")), - wxGBPosition(2, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxALL, 5); - sOtherPaths->Add(ApploaderPath, wxGBPosition(2, 1), wxDefaultSpan, wxEXPAND | wxALL, 5); - sOtherPaths->Add(TEXT_BOX(PathsPage, _("Wii NAND Root:")), - wxGBPosition(3, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxALL, 5); - sOtherPaths->Add(NANDRoot, wxGBPosition(3, 1), wxDefaultSpan, wxEXPAND | wxALL, 5); - sOtherPaths->AddGrowableCol(1); - - // Populate the Paths page - sPathsPage = new wxBoxSizer(wxVERTICAL); - sPathsPage->Add(sbISOPaths, 1, wxEXPAND | wxALL, 5); - sPathsPage->Add(sOtherPaths, 0, wxEXPAND | wxALL, 5); - PathsPage->SetSizer(sPathsPage); - - wxBoxSizer* sMain = new wxBoxSizer(wxVERTICAL); - sMain->Add(Notebook, 1, wxEXPAND | wxALL, 5); - sMain->Add(CreateButtonSizer(wxOK), 0, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 5); - - wxStaticBoxSizer* sbCPUOptions = new wxStaticBoxSizer(wxVERTICAL, AdvancedPage, _("CPU Options")); - wxBoxSizer* bOverclockEnable = new wxBoxSizer(wxHORIZONTAL); - wxBoxSizer* bOverclock = new wxBoxSizer(wxHORIZONTAL); - wxBoxSizer* bOverclockDesc = new wxBoxSizer(wxHORIZONTAL); - EnableOC = new wxCheckBox(AdvancedPage, ID_ENABLEOVERCLOCK, _("Enable CPU Clock Override")); - OCSlider = new wxSlider(AdvancedPage, ID_OVERCLOCK, 100, 0, 150, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL); - wxStaticText* OCDescription = new wxStaticText(AdvancedPage, wxID_ANY, - _("Higher values can make variable-framerate games\n" - "run at a higher framerate, at the expense of CPU.\n" - "Lower values can make variable-framerate games\n" - "run at a lower framerate, saving CPU.\n\n" - "WARNING: Changing this from the default (100%)\n" - "can and will break games and cause glitches.\n" - "Do so at your own risk. Please do not report\n" - "bugs that occur with a non-default clock.\n")); - OCText = new wxStaticText(AdvancedPage, wxID_ANY, ""); - bOverclockEnable->Add(EnableOC); - bOverclock->Add(OCSlider, 1, wxALL, 5); - bOverclock->Add(OCText, 1, wxALL, 5); - bOverclockDesc->Add(OCDescription, 1, wxALL, 5); - sbCPUOptions->Add(bOverclockEnable); - sbCPUOptions->Add(bOverclock); - sbCPUOptions->Add(bOverclockDesc); - wxBoxSizer* const sAdvancedPage = new wxBoxSizer(wxVERTICAL); - sAdvancedPage->Add(sbCPUOptions, 0, wxEXPAND | wxALL, 5); - AdvancedPage->SetSizer(sAdvancedPage); - - InitializeGUIValues(); - InitializeGUITooltips(); - - UpdateGUI(); - - SetSizerAndFit(sMain); - Center(); - SetFocus(); -} - -void CConfigMain::OnClose(wxCloseEvent& WXUNUSED(event)) -{ - EndModal((bRefreshList) ? wxID_OK : wxID_CANCEL); -} - -void CConfigMain::OnOk(wxCommandEvent& WXUNUSED(event)) -{ - Close(); - - // Save the config. Dolphin crashes too often to only save the settings on closing - SConfig::GetInstance().SaveSettings(); -} - -void CConfigMain::UpdateCPUClock() -{ - bool wii = SConfig::GetInstance().m_LocalCoreStartupParameter.bWii; - int percent = (int)(roundf(SConfig::GetInstance().m_OCFactor * 100.f)); - int clock = (int)(roundf(SConfig::GetInstance().m_OCFactor * (wii ? 729.f : 486.f))); - OCText->SetLabel(SConfig::GetInstance().m_OCEnable ? wxString::Format("%d %% (%d mhz)", percent, clock) : ""); -} - -// Core settings -void CConfigMain::CoreSettingsChanged(wxCommandEvent& event) -{ - SCoreStartupParameter& startup_params = SConfig::GetInstance().m_LocalCoreStartupParameter; - - switch (event.GetId()) - { - // Core - Basic - case ID_CPUTHREAD: - if (Core::IsRunning()) - return; - startup_params.bCPUThread = CPUThread->IsChecked(); - break; - case ID_IDLESKIP: - startup_params.bSkipIdle = SkipIdle->IsChecked(); - break; - case ID_ENABLECHEATS: - startup_params.bEnableCheats = EnableCheats->IsChecked(); - break; - case ID_FRAMELIMIT: - SConfig::GetInstance().m_Framelimit = Framelimit->GetSelection(); - break; - // Core - Advanced - case ID_CPUENGINE: - startup_params.iCPUCore = CPUCores[CPUEngine->GetSelection()].CPUid; - if (main_frame->g_pCodeWindow) - { - bool using_interp = (startup_params.iCPUCore == PowerPC::CORE_INTERPRETER); - main_frame->g_pCodeWindow->GetMenuBar()->Check(IDM_INTERPRETER, using_interp); - } - break; - case ID_NTSCJ: - startup_params.bForceNTSCJ = ForceNTSCJ->IsChecked(); - break; - case ID_ENABLEOVERCLOCK: - SConfig::GetInstance().m_OCEnable = EnableOC->IsChecked(); - OCSlider->Enable(SConfig::GetInstance().m_OCEnable); - UpdateCPUClock(); - break; - case ID_OVERCLOCK: - // Vaguely exponential scaling? - SConfig::GetInstance().m_OCFactor = exp2f((OCSlider->GetValue() - 100.f) / 25.f); - UpdateCPUClock(); - break; - } -} - -// Display and Interface settings -void CConfigMain::DisplaySettingsChanged(wxCommandEvent& event) -{ - switch (event.GetId()) - { - // Display - Interface - case ID_INTERFACE_CONFIRMSTOP: - SConfig::GetInstance().m_LocalCoreStartupParameter.bConfirmStop = ConfirmStop->IsChecked(); - break; - case ID_INTERFACE_USEPANICHANDLERS: - SConfig::GetInstance().m_LocalCoreStartupParameter.bUsePanicHandlers = UsePanicHandlers->IsChecked(); - SetEnableAlert(UsePanicHandlers->IsChecked()); - break; - case ID_INTERFACE_ONSCREENDISPLAYMESSAGES: - SConfig::GetInstance().m_LocalCoreStartupParameter.bOnScreenDisplayMessages = OnScreenDisplayMessages->IsChecked(); - SetEnableAlert(OnScreenDisplayMessages->IsChecked()); - break; - case ID_INTERFACE_PAUSEONFOCUSLOST: - SConfig::GetInstance().m_PauseOnFocusLost = PauseOnFocusLost->IsChecked(); - break; - case ID_INTERFACE_LANG: - if (SConfig::GetInstance().m_InterfaceLanguage != langIds[InterfaceLang->GetSelection()]) - SuccessAlertT("You must restart Dolphin in order for the change to take effect."); - SConfig::GetInstance().m_InterfaceLanguage = langIds[InterfaceLang->GetSelection()]; - break; - case ID_HOTKEY_CONFIG: - { - bool was_init = false; - - InputConfig* const hotkey_plugin = HotkeyManagerEmu::GetConfig(); - - // check if game is running - if (g_controller_interface.IsInit()) - { - was_init = true; - } - else - { -#if defined(HAVE_X11) && HAVE_X11 - Window win = X11Utils::XWindowFromHandle(GetHandle()); - HotkeyManagerEmu::Initialize(reinterpret_cast(win)); -#else - HotkeyManagerEmu::Initialize(reinterpret_cast(GetHandle())); -#endif - } - - InputConfigDialog m_ConfigFrame(this, *hotkey_plugin, _("Dolphin Hotkeys")); - m_ConfigFrame.ShowModal(); - - // if game isn't running - if (!was_init) - { - HotkeyManagerEmu::Shutdown(); - } - } - // Update the GUI in case menu accelerators were changed - main_frame->UpdateGUI(); - break; - } -} - -void CConfigMain::AudioSettingsChanged(wxCommandEvent& event) -{ - switch (event.GetId()) - { - case ID_DSPENGINE: - SConfig::GetInstance().m_LocalCoreStartupParameter.bDSPHLE = DSPEngine->GetSelection() == 0; - SConfig::GetInstance().m_DSPEnableJIT = DSPEngine->GetSelection() == 1; - AudioCommon::UpdateSoundStream(); - break; - - case ID_VOLUME: - SConfig::GetInstance().m_Volume = VolumeSlider->GetValue(); - AudioCommon::UpdateSoundStream(); - VolumeText->SetLabel(wxString::Format("%d %%", VolumeSlider->GetValue())); - break; - - case ID_DPL2DECODER: - SConfig::GetInstance().m_LocalCoreStartupParameter.bDPL2Decoder = DPL2Decoder->IsChecked(); - break; - - case ID_BACKEND: - VolumeSlider->Enable(SupportsVolumeChanges(WxStrToStr(BackendSelection->GetStringSelection()))); - Latency->Enable(WxStrToStr(BackendSelection->GetStringSelection()) == BACKEND_OPENAL); - DPL2Decoder->Enable(WxStrToStr(BackendSelection->GetStringSelection()) == BACKEND_OPENAL - || WxStrToStr(BackendSelection->GetStringSelection()) == BACKEND_PULSEAUDIO); - // Don't save the translated BACKEND_NULLSOUND string - SConfig::GetInstance().sBackend = BackendSelection->GetSelection() ? - WxStrToStr(BackendSelection->GetStringSelection()) : BACKEND_NULLSOUND; - AudioCommon::UpdateSoundStream(); - break; - - case ID_LATENCY: - SConfig::GetInstance().m_LocalCoreStartupParameter.iLatency = Latency->GetValue(); - break; - - default: - break; - } -} - -void CConfigMain::AddAudioBackends() -{ - for (const std::string& backend : AudioCommon::GetSoundBackends()) - { - BackendSelection->Append(wxGetTranslation(StrToWxStr(backend))); - int num = BackendSelection-> - FindString(StrToWxStr(SConfig::GetInstance().sBackend)); - BackendSelection->SetSelection(num); - } -} - -bool CConfigMain::SupportsVolumeChanges(std::string backend) -{ - //FIXME: this one should ask the backend whether it supports it. - // but getting the backend from string etc. is probably - // too much just to enable/disable a stupid slider... - return (backend == BACKEND_COREAUDIO || - backend == BACKEND_OPENAL || - backend == BACKEND_XAUDIO2); -} - - -// GC settings -// ----------------------- -void CConfigMain::GCSettingsChanged(wxCommandEvent& event) -{ - int exidevice = 0; - switch (event.GetId()) - { - // GameCube - IPL - case ID_GC_SRAM_LNG: - SConfig::GetInstance().m_LocalCoreStartupParameter.SelectedLanguage = GCSystemLang->GetSelection(); - bRefreshList = true; - break; - // GameCube - IPL Settings - case ID_GC_ALWAYS_HLE_BS2: - SConfig::GetInstance().m_LocalCoreStartupParameter.bHLE_BS2 = GCAlwaysHLE_BS2->IsChecked(); - break; - // GameCube - Devices - case ID_GC_EXIDEVICE_SP1: - exidevice++; - case ID_GC_EXIDEVICE_SLOTB: - exidevice++; - case ID_GC_EXIDEVICE_SLOTA: - ChooseEXIDevice(event.GetString(), exidevice); - break; - case ID_GC_EXIDEVICE_SLOTA_PATH: - ChooseSlotPath(true, SConfig::GetInstance().m_EXIDevice[0]); - break; - case ID_GC_EXIDEVICE_SLOTB_PATH: - ChooseSlotPath(false, SConfig::GetInstance().m_EXIDevice[1]); - break; - } -} - -void CConfigMain::ChooseSlotPath(bool isSlotA, TEXIDevices device_type) -{ - bool memcard = (device_type == EXIDEVICE_MEMORYCARD); - std::string path; - std::string cardname; - std::string ext; - std::string pathA = SConfig::GetInstance().m_strMemoryCardA; - std::string pathB = SConfig::GetInstance().m_strMemoryCardB; - if (!memcard) - { - pathA = SConfig::GetInstance().m_strGbaCartA; - pathB = SConfig::GetInstance().m_strGbaCartB; - } - SplitPath(isSlotA ? pathA : pathB, &path, &cardname, &ext); - std::string filename = WxStrToStr(wxFileSelector( - _("Choose a file to open"), - StrToWxStr(path), - StrToWxStr(cardname), - StrToWxStr(ext), - memcard ? _("GameCube Memory Cards (*.raw,*.gcp)") + "|*.raw;*.gcp" : _("Game Boy Advance Carts (*.gba)") + "|*.gba")); - - if (!filename.empty()) - { - if (File::Exists(filename)) - { - if (memcard) - { - GCMemcard memorycard(filename); - if (!memorycard.IsValid()) - { - WxUtils::ShowErrorDialog(wxString::Format(_("Cannot use that file as a memory card.\n%s\n" \ - "is not a valid GameCube memory card file"), filename.c_str())); - return; - } - } - } -#ifdef _WIN32 - if (!strncmp(File::GetExeDirectory().c_str(), filename.c_str(), File::GetExeDirectory().size())) - { - // If the Exe Directory Matches the prefix of the filename, we still need to verify - // that the next character is a directory separator character, otherwise we may create an invalid path - char next_char = filename.at(File::GetExeDirectory().size()) + 1; - if (next_char == '/' || next_char == '\\') - { - filename.erase(0, File::GetExeDirectory().size() + 1); - filename = "./" + filename; - } - } - std::replace(filename.begin(), filename.end(), '\\', '/'); -#endif - - // also check that the path isn't used for the other memcard... - if (filename.compare(isSlotA ? pathB : pathA) != 0) - { - if (memcard) - { - if (isSlotA) - SConfig::GetInstance().m_strMemoryCardA = filename; - else - SConfig::GetInstance().m_strMemoryCardB = filename; - } - else - { - if (isSlotA) - SConfig::GetInstance().m_strGbaCartA = filename; - else - SConfig::GetInstance().m_strGbaCartB = filename; - } - - if (Core::IsRunning()) - { - // Change memcard to the new file - ExpansionInterface::ChangeDevice( - isSlotA ? 0 : 1, // SlotA: channel 0, SlotB channel 1 - device_type, - 0); // SP1 is device 2, slots are device 0 - } - } - else - { - WxUtils::ShowErrorDialog(_("Are you trying to use the same file in both slots?")); - } - } -} - -void CConfigMain::ChooseEXIDevice(wxString deviceName, int deviceNum) -{ - TEXIDevices tempType; - - if (!deviceName.compare(_(EXIDEV_MEMCARD_STR))) - tempType = EXIDEVICE_MEMORYCARD; - else if (!deviceName.compare(_(EXIDEV_MEMDIR_STR))) - tempType = EXIDEVICE_MEMORYCARDFOLDER; - else if (!deviceName.compare(_(EXIDEV_MIC_STR))) - tempType = EXIDEVICE_MIC; - else if (!deviceName.compare(EXIDEV_BBA_STR)) - tempType = EXIDEVICE_ETH; - else if (!deviceName.compare(EXIDEV_AGP_STR)) - tempType = EXIDEVICE_AGP; - else if (!deviceName.compare(_(EXIDEV_AM_BB_STR))) - tempType = EXIDEVICE_AM_BASEBOARD; - else if (!deviceName.compare(EXIDEV_GECKO_STR)) - tempType = EXIDEVICE_GECKO; - else if (!deviceName.compare(_(DEV_NONE_STR))) - tempType = EXIDEVICE_NONE; - else - tempType = EXIDEVICE_DUMMY; - - // Gray out the memcard path button if we're not on a memcard or AGP - if (tempType == EXIDEVICE_MEMORYCARD || tempType == EXIDEVICE_AGP) - GCMemcardPath[deviceNum]->Enable(); - else if (deviceNum == 0 || deviceNum == 1) - GCMemcardPath[deviceNum]->Disable(); - - SConfig::GetInstance().m_EXIDevice[deviceNum] = tempType; - - if (Core::IsRunning()) - { - // Change plugged device! :D - ExpansionInterface::ChangeDevice( - (deviceNum == 1) ? 1 : 0, // SlotB is on channel 1, slotA and SP1 are on 0 - tempType, // The device enum to change to - (deviceNum == 2) ? 2 : 0); // SP1 is device 2, slots are device 0 - } -} - - - - -// Wii settings -// ------------------- -void CConfigMain::WiiSettingsChanged(wxCommandEvent& event) -{ - switch (event.GetId()) - { - // Wii - SYSCONF settings - case ID_WII_IPL_SSV: - SConfig::GetInstance().m_SYSCONF->SetData("IPL.SSV", WiiScreenSaver->IsChecked()); - break; - case ID_WII_IPL_E60: - SConfig::GetInstance().m_SYSCONF->SetData("IPL.E60", WiiPAL60->IsChecked()); - break; - case ID_WII_IPL_AR: - SConfig::GetInstance().m_SYSCONF->SetData("IPL.AR", WiiAspectRatio->GetSelection()); - break; - case ID_WII_IPL_LNG: - { - int wii_system_lang = WiiSystemLang->GetSelection(); - SConfig::GetInstance().m_SYSCONF->SetData("IPL.LNG", wii_system_lang); - u8 country_code = GetSADRCountryCode(wii_system_lang); - if (!SConfig::GetInstance().m_SYSCONF->SetArrayData("IPL.SADR", &country_code, 1)) - { - WxUtils::ShowErrorDialog(_("Failed to update country code in SYSCONF")); - } - break; - } - // Wii - Devices - case ID_WII_SD_CARD: - SConfig::GetInstance().m_WiiSDCard = WiiSDCard->IsChecked(); - WII_IPC_HLE_Interface::SDIO_EventNotify(); - break; - case ID_WII_KEYBOARD: - SConfig::GetInstance().m_WiiKeyboard = WiiKeyboard->IsChecked(); - break; - } -} - - -// Paths settings -// ------------------- -void CConfigMain::ISOPathsSelectionChanged(wxCommandEvent& WXUNUSED(event)) -{ - RemoveISOPath->Enable(ISOPaths->GetSelection() != wxNOT_FOUND); -} - -void CConfigMain::AddRemoveISOPaths(wxCommandEvent& event) -{ - if (event.GetId() == ID_ADDISOPATH) - { - wxDirDialog dialog(this, _("Choose a directory to add"), wxGetHomeDir(), - wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST); - - if (dialog.ShowModal() == wxID_OK) - { - if (ISOPaths->FindString(dialog.GetPath()) != -1) - { - WxUtils::ShowErrorDialog(_("The chosen directory is already in the list.")); - } - else - { - bRefreshList = true; - ISOPaths->Append(dialog.GetPath()); - } - } - } - else - { - bRefreshList = true; - ISOPaths->Delete(ISOPaths->GetSelection()); - - // This seems to not be activated on Windows when it should be. wxw bug? -#ifdef _WIN32 - ISOPathsSelectionChanged(wxCommandEvent()); -#endif - } - - // Save changes right away - SConfig::GetInstance().m_ISOFolder.clear(); - - for (unsigned int i = 0; i < ISOPaths->GetCount(); i++) - SConfig::GetInstance().m_ISOFolder.push_back(WxStrToStr(ISOPaths->GetStrings()[i])); -} - -void CConfigMain::RecursiveDirectoryChanged(wxCommandEvent& WXUNUSED(event)) -{ - SConfig::GetInstance().m_RecursiveISOFolder = RecursiveISOPath->IsChecked(); - bRefreshList = true; -} - -void CConfigMain::DefaultISOChanged(wxFileDirPickerEvent& WXUNUSED(event)) -{ - SConfig::GetInstance().m_LocalCoreStartupParameter.m_strDefaultISO = WxStrToStr(DefaultISO->GetPath()); -} - -void CConfigMain::DVDRootChanged(wxFileDirPickerEvent& WXUNUSED(event)) -{ - SConfig::GetInstance().m_LocalCoreStartupParameter.m_strDVDRoot = WxStrToStr(DVDRoot->GetPath()); -} - -void CConfigMain::ApploaderPathChanged(wxFileDirPickerEvent& WXUNUSED(event)) -{ - SConfig::GetInstance().m_LocalCoreStartupParameter.m_strApploader = WxStrToStr(ApploaderPath->GetPath()); -} - -void CConfigMain::NANDRootChanged(wxFileDirPickerEvent& WXUNUSED(event)) -{ - std::string NANDPath = - SConfig::GetInstance().m_NANDPath = - WxStrToStr(NANDRoot->GetPath()); - File::SetUserPath(D_WIIROOT_IDX, NANDPath); - NANDRoot->SetPath(StrToWxStr(NANDPath)); - SConfig::GetInstance().m_SYSCONF->UpdateLocation(); - DiscIO::cUIDsys::AccessInstance().UpdateLocation(); - DiscIO::CSharedContent::AccessInstance().UpdateLocation(); - main_frame->UpdateWiiMenuChoice(); -} - -// GFX backend selection -void CConfigMain::OnSelectionChanged(wxCommandEvent& ev) -{ - g_video_backend = g_available_video_backends[ev.GetInt()]; - SConfig::GetInstance().m_LocalCoreStartupParameter.m_strVideoBackend = g_video_backend->GetName(); -} - -void CConfigMain::OnConfig(wxCommandEvent&) -{ - if (g_video_backend) - g_video_backend->ShowConfig(this); -} - -// Change from IPL.LNG value to IPL.SADR country code -inline u8 CConfigMain::GetSADRCountryCode(int language) -{ - //http://wiibrew.org/wiki/Country_Codes - u8 country_code = language; - switch (country_code) - { - case 0: //Japanese - country_code = 1; //Japan - break; - case 1: //English - country_code = 49; //USA - break; - case 2: //German - country_code = 78; //Germany - break; - case 3: //French - country_code = 77; //France - break; - case 4: //Spanish - country_code = 105; //Spain - break; - case 5: //Italian - country_code = 83; //Italy - break; - case 6: //Dutch - country_code = 94; //Netherlands - break; - case 7: //Simplified Chinese - case 8: //Traditional Chinese - country_code = 157; //China - break; - case 9: //Korean - country_code = 136; //Korea - break; - } - return country_code; -} diff --git a/Source/Core/DolphinWX/ConfigMain.h b/Source/Core/DolphinWX/ConfigMain.h deleted file mode 100644 index 0e65f06f56..0000000000 --- a/Source/Core/DolphinWX/ConfigMain.h +++ /dev/null @@ -1,278 +0,0 @@ -// Copyright 2013 Dolphin Emulator Project -// Licensed under GPLv2 -// Refer to the license.txt file included. - -#pragma once - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "Common/CommonTypes.h" -#if defined(HAVE_XRANDR) && HAVE_XRANDR -#include "DolphinWX/X11Utils.h" -#endif - -class wxBoxSizer; -class wxButton; -class wxCheckBox; -class wxChoice; -class wxDirPickerCtrl; -class wxFileDirPickerEvent; -class wxFilePickerCtrl; -class wxGridBagSizer; -class wxListBox; -class wxNotebook; -class wxPanel; -class wxRadioBox; -class wxSlider; -class wxSpinCtrl; -class wxSpinEvent; -class wxStaticBoxSizer; -class wxStaticText; -class wxWindow; - -class CConfigMain : public wxDialog -{ -public: - - CConfigMain(wxWindow* parent, - wxWindowID id = wxID_ANY, - const wxString& title = _("Dolphin Configuration"), - const wxPoint& pos = wxDefaultPosition, - const wxSize& size = wxDefaultSize, - long style = wxDEFAULT_DIALOG_STYLE); - virtual ~CConfigMain(); - - void OnOk(wxCommandEvent& event); - void CloseClick(wxCommandEvent& event); - void OnSelectionChanged(wxCommandEvent& event); - void OnConfig(wxCommandEvent& event); - void SetSelectedTab(int tab); - - bool bRefreshList; - - enum - { - ID_NOTEBOOK = 1000, - ID_GENERALPAGE, - ID_DISPLAYPAGE, - ID_AUDIOPAGE, - ID_GAMECUBEPAGE, - ID_WIIPAGE, - ID_PATHSPAGE, - ID_ADVANCEDPAGE, - }; - -private: - enum - { - ID_CPUTHREAD = 1010, - ID_IDLESKIP, - ID_ENABLECHEATS, - ID_ENABLEOVERCLOCK, - ID_FRAMELIMIT, - ID_OVERCLOCK, - - ID_CPUENGINE, - - ID_NTSCJ, - - // Audio Settings - ID_DSPENGINE, - ID_ENABLE_HLE_AUDIO, - ID_ENABLE_THROTTLE, - ID_DPL2DECODER, - ID_LATENCY, - ID_BACKEND, - ID_VOLUME, - - // Interface settings - ID_INTERFACE_CONFIRMSTOP, - ID_INTERFACE_USEPANICHANDLERS, - ID_INTERFACE_ONSCREENDISPLAYMESSAGES, - ID_INTERFACE_PAUSEONFOCUSLOST, - ID_INTERFACE_LANG, - ID_HOTKEY_CONFIG, - - ID_GC_SRAM_LNG, - ID_GC_ALWAYS_HLE_BS2, - - ID_GC_EXIDEVICE_SLOTA, - ID_GC_EXIDEVICE_SLOTA_PATH, - ID_GC_EXIDEVICE_SLOTB, - ID_GC_EXIDEVICE_SLOTB_PATH, - ID_GC_EXIDEVICE_SP1, - - ID_WII_IPL_SSV, - ID_WII_IPL_E60, - ID_WII_IPL_AR, - ID_WII_IPL_LNG, - - ID_WII_SD_CARD, - ID_WII_KEYBOARD, - - - ID_ISOPATHS, - ID_RECURSIVEISOPATH, - ID_ADDISOPATH, - ID_REMOVEISOPATH, - - ID_DEFAULTISO, - ID_DVDROOT, - ID_APPLOADERPATH, - ID_NANDROOT, - - ID_DSP_CB, - ID_DSP_CONFIG, - ID_DSP_ABOUT, - }; - - wxNotebook* Notebook; - wxPanel* PathsPage; - - // Basic - wxCheckBox* CPUThread; - wxCheckBox* SkipIdle; - wxCheckBox* EnableCheats; - wxChoice* Framelimit; - - // Advanced - wxRadioBox* CPUEngine; - wxCheckBox* ForceNTSCJ; - wxSlider* OCSlider; - wxStaticText* OCText; - wxCheckBox* EnableOC; - - - wxBoxSizer* sDisplayPage; // Display settings - wxStaticBoxSizer* sbInterface; // Display and Interface sections - - - // Audio - wxBoxSizer* sAudioPage; // GC settings - wxRadioBox* DSPEngine; - wxSlider* VolumeSlider; - wxStaticText* VolumeText; - wxCheckBox* DPL2Decoder; - wxArrayString wxArrayBackends; - wxChoice* BackendSelection; - wxSpinCtrl* Latency; - - // Interface - wxCheckBox* ConfirmStop; - wxCheckBox* UsePanicHandlers; - wxCheckBox* OnScreenDisplayMessages; - wxCheckBox* PauseOnFocusLost; - wxChoice* InterfaceLang; - wxButton* HotkeyConfig; - - - wxBoxSizer* sGamecubePage; // GC settings - wxStaticBoxSizer* sbGamecubeIPLSettings; - wxGridBagSizer* sGamecubeIPLSettings; - - // IPL - wxChoice* GCSystemLang; - wxCheckBox* GCAlwaysHLE_BS2; - - // Device - wxChoice* GCEXIDevice[3]; - wxButton* GCMemcardPath[2]; - - wxBoxSizer* sWiiPage; // Wii settings - wxStaticBoxSizer* /*sbWiimoteSettings, **/sbWiiIPLSettings, *sbWiiDeviceSettings; // Wiimote, Misc and Device sections - wxGridBagSizer* /*sWiimoteSettings, **/sWiiIPLSettings; - - // Misc - wxCheckBox* WiiScreenSaver; - wxCheckBox* WiiPAL60; - wxChoice* WiiAspectRatio; - wxChoice* WiiSystemLang; - - // Device - wxCheckBox* WiiSDCard; - wxCheckBox* WiiKeyboard; - - - wxBoxSizer* sPathsPage; // Paths settings - wxStaticBoxSizer* sbISOPaths; - wxGridBagSizer* sOtherPaths; - - // ISO Directories - wxListBox* ISOPaths; - wxCheckBox* RecursiveISOPath; - wxButton* AddISOPath; - wxButton* RemoveISOPath; - - // DefaultISO, DVD Root, Apploader, NANDPath - wxFilePickerCtrl* DefaultISO; - wxDirPickerCtrl* DVDRoot; - wxFilePickerCtrl* ApploaderPath; - wxDirPickerCtrl* NANDRoot; - - // Graphics - wxChoice* GraphicSelection; - wxButton* GraphicConfig; - - wxButton* m_Ok; - - FILE* pStream; - - wxArrayString arrayStringFor_Framelimit; - wxArrayString arrayStringFor_CPUEngine; - wxArrayString arrayStringFor_DSPEngine; - wxArrayString arrayStringFor_FullscreenResolution; - wxArrayString arrayStringFor_InterfaceLang; - wxArrayString arrayStringFor_GCSystemLang; - wxArrayString arrayStringFor_WiiSensBarPos; - wxArrayString arrayStringFor_WiiAspectRatio; - wxArrayString arrayStringFor_WiiSystemLang; - wxArrayString arrayStringFor_ISOPaths; - - void InitializeGUILists(); - void InitializeGUIValues(); - void InitializeGUITooltips(); - - void CreateGUIControls(); - void UpdateGUI(); - void OnClose(wxCloseEvent& event); - - void UpdateCPUClock(); - void CoreSettingsChanged(wxCommandEvent& event); - - void DisplaySettingsChanged(wxCommandEvent& event); - void OnSpin(wxSpinEvent& event); - - void AudioSettingsChanged(wxCommandEvent& event); - void AddAudioBackends(); - - void GCSettingsChanged(wxCommandEvent& event); - void ChooseSlotPath(bool isSlotA, TEXIDevices device_type); - void ChooseEXIDevice(wxString deviceName, int deviceNum); - - void WiiSettingsChanged(wxCommandEvent& event); - // Change from IPL.LNG value to country code - inline u8 GetSADRCountryCode(int language); - - void ISOPathsSelectionChanged(wxCommandEvent& event); - void RecursiveDirectoryChanged(wxCommandEvent& event); - void AddRemoveISOPaths(wxCommandEvent& event); - void DefaultISOChanged(wxFileDirPickerEvent& event); - void DVDRootChanged(wxFileDirPickerEvent& event); - void ApploaderPathChanged(wxFileDirPickerEvent& WXUNUSED(event)); - void NANDRootChanged(wxFileDirPickerEvent& event); - -private: - DECLARE_EVENT_TABLE(); - - static bool SupportsVolumeChanges(std::string backend); -}; diff --git a/Source/Core/DolphinWX/DolphinWX.vcxproj b/Source/Core/DolphinWX/DolphinWX.vcxproj index 033c70e7d3..d1592b7516 100644 --- a/Source/Core/DolphinWX/DolphinWX.vcxproj +++ b/Source/Core/DolphinWX/DolphinWX.vcxproj @@ -54,7 +54,14 @@ - + + + + + + + + @@ -101,14 +108,21 @@ + + + + + + + - + diff --git a/Source/Core/DolphinWX/DolphinWX.vcxproj.filters b/Source/Core/DolphinWX/DolphinWX.vcxproj.filters index 7bfd1dbb8d..9d71b2f175 100644 --- a/Source/Core/DolphinWX/DolphinWX.vcxproj.filters +++ b/Source/Core/DolphinWX/DolphinWX.vcxproj.filters @@ -25,6 +25,9 @@ {d6bc4dd6-06ed-46ad-b327-04afb26e10ec} + + {9d8b4144-f335-4fa4-b995-852533298474} + @@ -121,9 +124,6 @@ GUI - - GUI - GUI @@ -166,6 +166,30 @@ GUI + + GUI\Config + + + GUI\Config + + + GUI\Config + + + GUI\Config + + + GUI\Config + + + GUI\Config + + + GUI\Config + + + GUI\Config + @@ -258,9 +282,6 @@ GUI - - GUI - GUI @@ -300,6 +321,30 @@ GUI + + GUI\Config + + + GUI\Config + + + GUI\Config + + + GUI\Config + + + GUI\Config + + + GUI\Config + + + GUI\Config + + + GUI\Config + diff --git a/Source/Core/DolphinWX/FrameTools.cpp b/Source/Core/DolphinWX/FrameTools.cpp index 65689012dd..544263ab7f 100644 --- a/Source/Core/DolphinWX/FrameTools.cpp +++ b/Source/Core/DolphinWX/FrameTools.cpp @@ -65,7 +65,6 @@ #include "DiscIO/NANDContentLoader.h" #include "DolphinWX/AboutDolphin.h" -#include "DolphinWX/ConfigMain.h" #include "DolphinWX/ControllerConfigDiag.h" #include "DolphinWX/FifoPlayerDlg.h" #include "DolphinWX/Frame.h" @@ -81,6 +80,7 @@ #include "DolphinWX/WXInputBase.h" #include "DolphinWX/WxUtils.h" #include "DolphinWX/Cheats/CheatsWindow.h" +#include "DolphinWX/Config/ConfigMain.h" #include "DolphinWX/Debugger/BreakpointWindow.h" #include "DolphinWX/Debugger/CodeWindow.h" #include "DolphinWX/Debugger/WatchWindow.h"