2014-11-21 18:01:22 +00:00
|
|
|
#include <array>
|
2014-02-22 22:36:30 +00:00
|
|
|
#include <map>
|
|
|
|
#include <string>
|
|
|
|
#include <utility>
|
|
|
|
#include <wx/button.h>
|
|
|
|
#include <wx/checkbox.h>
|
|
|
|
#include <wx/choice.h>
|
|
|
|
#include <wx/defs.h>
|
|
|
|
#include <wx/dialog.h>
|
|
|
|
#include <wx/event.h>
|
|
|
|
#include <wx/gdicmn.h>
|
|
|
|
#include <wx/sizer.h>
|
|
|
|
#include <wx/slider.h>
|
|
|
|
#include <wx/stattext.h>
|
|
|
|
#include <wx/string.h>
|
|
|
|
#include <wx/translation.h>
|
|
|
|
#include <wx/window.h>
|
|
|
|
#include <wx/windowid.h>
|
|
|
|
|
2014-09-08 01:06:58 +00:00
|
|
|
#include "Common/CommonTypes.h"
|
2014-02-22 22:36:30 +00:00
|
|
|
#include "Common/FileUtil.h"
|
|
|
|
#include "Common/IniFile.h"
|
|
|
|
#include "Common/SysConf.h"
|
|
|
|
#include "Core/ConfigManager.h"
|
|
|
|
#include "Core/Core.h"
|
2014-11-24 02:43:15 +00:00
|
|
|
#include "Core/Movie.h"
|
2014-02-17 10:18:15 +00:00
|
|
|
#include "Core/NetPlayProto.h"
|
2014-11-22 20:29:13 +00:00
|
|
|
#include "Core/HW/GCPad.h"
|
|
|
|
#include "Core/HW/SI.h"
|
2014-02-17 10:18:15 +00:00
|
|
|
#include "Core/HW/Wiimote.h"
|
|
|
|
#include "Core/HW/WiimoteReal/WiimoteReal.h"
|
2014-11-22 21:39:48 +00:00
|
|
|
#include "DolphinWX/ControllerConfigDiag.h"
|
2014-02-22 22:36:30 +00:00
|
|
|
#include "DolphinWX/InputConfigDiag.h"
|
2010-07-03 08:04:10 +00:00
|
|
|
|
2014-11-22 20:29:13 +00:00
|
|
|
#if defined(HAVE_XRANDR) && HAVE_XRANDR
|
2014-12-01 08:53:32 +00:00
|
|
|
#include "DolphinWX/X11Utils.h"
|
2014-11-22 20:29:13 +00:00
|
|
|
#endif
|
|
|
|
|
2014-11-22 21:39:48 +00:00
|
|
|
const std::array<wxString, 7> ControllerConfigDiag::m_gc_pad_type_strs = {{
|
2014-11-22 20:29:13 +00:00
|
|
|
_("None"),
|
|
|
|
_("Standard Controller"),
|
|
|
|
_("Steering Wheel"),
|
|
|
|
_("Dance Mat"),
|
|
|
|
_("TaruKonga (Bongos)"),
|
|
|
|
_("GBA"),
|
|
|
|
_("AM-Baseboard")
|
|
|
|
}};
|
|
|
|
|
2014-11-22 21:39:48 +00:00
|
|
|
ControllerConfigDiag::ControllerConfigDiag(wxWindow* const parent)
|
|
|
|
: wxDialog(parent, -1, _("Dolphin Controller Configuration"))
|
2010-07-03 08:04:10 +00:00
|
|
|
{
|
2011-08-06 14:38:23 +00:00
|
|
|
wxBoxSizer* const main_sizer = new wxBoxSizer(wxVERTICAL);
|
|
|
|
|
2014-11-21 18:01:22 +00:00
|
|
|
// Combine all UI controls into their own encompassing sizer.
|
|
|
|
wxBoxSizer* control_sizer = new wxBoxSizer(wxVERTICAL);
|
|
|
|
control_sizer->Add(CreateGamecubeSizer(), 0, wxEXPAND | wxALL, 5);
|
|
|
|
control_sizer->Add(CreateWiimoteConfigSizer(), 0, wxEXPAND | wxALL, 5);
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2014-11-21 18:01:22 +00:00
|
|
|
main_sizer->Add(control_sizer, 0, wxEXPAND);
|
|
|
|
main_sizer->Add(CreateButtonSizer(wxOK | wxCANCEL), 0, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 5);
|
|
|
|
|
2014-11-22 21:39:48 +00:00
|
|
|
Bind(wxEVT_BUTTON, &ControllerConfigDiag::Save, this, wxID_OK);
|
|
|
|
Bind(wxEVT_BUTTON, &ControllerConfigDiag::Cancel, this, wxID_CANCEL);
|
2014-11-21 18:01:22 +00:00
|
|
|
|
|
|
|
SetSizerAndFit(main_sizer);
|
|
|
|
Center();
|
|
|
|
}
|
2011-08-06 14:38:23 +00:00
|
|
|
|
2014-11-22 21:39:48 +00:00
|
|
|
wxStaticBoxSizer* ControllerConfigDiag::CreateGamecubeSizer()
|
2014-11-21 18:01:22 +00:00
|
|
|
{
|
|
|
|
wxStaticBoxSizer* const gamecube_static_sizer = new wxStaticBoxSizer(wxHORIZONTAL, this, _("GameCube Controllers"));
|
|
|
|
wxFlexGridSizer* const gamecube_flex_sizer = new wxFlexGridSizer(3, 5, 5);
|
|
|
|
|
|
|
|
wxStaticText* pad_labels[4];
|
|
|
|
wxChoice* pad_type_choices[4];
|
|
|
|
wxButton* config_buttons[4];
|
|
|
|
|
|
|
|
for (int i = 0; i < 4; i++)
|
|
|
|
{
|
2014-11-22 03:33:46 +00:00
|
|
|
pad_labels[i] = new wxStaticText(this, wxID_ANY, wxString::Format(_("Port %i"), i + 1));
|
2014-11-21 18:01:22 +00:00
|
|
|
|
2014-11-22 20:29:13 +00:00
|
|
|
// Create an ID for the config button.
|
|
|
|
const wxWindowID button_id = wxWindow::NewControlId();
|
|
|
|
m_gc_port_config_ids.insert(std::make_pair(button_id, i));
|
|
|
|
config_buttons[i] = new wxButton(this, button_id, _("Configure"), wxDefaultPosition, wxSize(100, 25));
|
2014-11-22 21:39:48 +00:00
|
|
|
config_buttons[i]->Bind(wxEVT_BUTTON, &ControllerConfigDiag::OnGameCubeConfigButton, this);
|
2014-11-22 20:29:13 +00:00
|
|
|
|
|
|
|
// Create a control ID for the choice boxes on the fly.
|
|
|
|
const wxWindowID choice_id = wxWindow::NewControlId();
|
|
|
|
m_gc_port_choice_ids.insert(std::make_pair(choice_id, i));
|
|
|
|
|
2014-11-21 18:01:22 +00:00
|
|
|
// Only add AM-Baseboard to the first pad.
|
|
|
|
if (i == 0)
|
2014-11-22 20:29:13 +00:00
|
|
|
pad_type_choices[i] = new wxChoice(this, choice_id, wxDefaultPosition, wxDefaultSize, m_gc_pad_type_strs.size(), m_gc_pad_type_strs.data());
|
2014-11-21 18:01:22 +00:00
|
|
|
else
|
2014-11-22 20:29:13 +00:00
|
|
|
pad_type_choices[i] = new wxChoice(this, choice_id, wxDefaultPosition, wxDefaultSize, m_gc_pad_type_strs.size() - 1, m_gc_pad_type_strs.data());
|
|
|
|
|
2014-11-22 21:39:48 +00:00
|
|
|
pad_type_choices[i]->Bind(wxEVT_CHOICE, &ControllerConfigDiag::OnGameCubePortChanged, this);
|
2014-11-21 18:01:22 +00:00
|
|
|
|
2014-11-24 02:43:15 +00:00
|
|
|
// Disable controller type selection for certain circumstances.
|
|
|
|
if (NetPlay::IsNetPlayRunning() || Movie::IsMovieActive())
|
|
|
|
pad_type_choices[i]->Disable();
|
|
|
|
|
2014-11-22 20:29:13 +00:00
|
|
|
// Set the saved pad type as the default choice.
|
|
|
|
switch (SConfig::GetInstance().m_SIDevice[i])
|
|
|
|
{
|
|
|
|
case SIDEVICE_GC_CONTROLLER:
|
|
|
|
pad_type_choices[i]->SetStringSelection(m_gc_pad_type_strs[1]);
|
|
|
|
break;
|
|
|
|
case SIDEVICE_GC_STEERING:
|
|
|
|
pad_type_choices[i]->SetStringSelection(m_gc_pad_type_strs[2]);
|
|
|
|
break;
|
|
|
|
case SIDEVICE_DANCEMAT:
|
|
|
|
pad_type_choices[i]->SetStringSelection(m_gc_pad_type_strs[3]);
|
|
|
|
break;
|
|
|
|
case SIDEVICE_GC_TARUKONGA:
|
|
|
|
pad_type_choices[i]->SetStringSelection(m_gc_pad_type_strs[4]);
|
|
|
|
break;
|
|
|
|
case SIDEVICE_GC_GBA:
|
|
|
|
pad_type_choices[i]->SetStringSelection(m_gc_pad_type_strs[5]);
|
|
|
|
break;
|
|
|
|
case SIDEVICE_AM_BASEBOARD:
|
|
|
|
pad_type_choices[i]->SetStringSelection(m_gc_pad_type_strs[6]);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
pad_type_choices[i]->SetStringSelection(m_gc_pad_type_strs[0]);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add to the sizer
|
2014-11-21 18:01:22 +00:00
|
|
|
gamecube_flex_sizer->Add(pad_labels[i], 0, wxALIGN_CENTER_VERTICAL);
|
|
|
|
gamecube_flex_sizer->Add(pad_type_choices[i], 0, wxALIGN_CENTER_VERTICAL);
|
2014-11-22 04:10:13 +00:00
|
|
|
gamecube_flex_sizer->Add(config_buttons[i], 1, wxEXPAND);
|
2014-11-21 18:01:22 +00:00
|
|
|
}
|
|
|
|
|
2014-11-22 03:33:46 +00:00
|
|
|
gamecube_static_sizer->Add(gamecube_flex_sizer, 1, wxEXPAND, 5);
|
2014-11-21 18:01:22 +00:00
|
|
|
return gamecube_static_sizer;
|
|
|
|
}
|
|
|
|
|
2014-11-22 21:39:48 +00:00
|
|
|
wxStaticBoxSizer* ControllerConfigDiag::CreateWiimoteConfigSizer()
|
2014-11-21 18:01:22 +00:00
|
|
|
{
|
2011-08-06 14:38:23 +00:00
|
|
|
wxStaticText* wiimote_label[4];
|
|
|
|
wxChoice* wiimote_source_ch[4];
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2013-05-18 08:31:37 +00:00
|
|
|
for (unsigned int i = 0; i < MAX_WIIMOTES; ++i)
|
2011-08-06 14:38:23 +00:00
|
|
|
{
|
2014-09-02 02:02:38 +00:00
|
|
|
wxString wiimote_str = wxString::Format(_("Wiimote %i"), i + 1);
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2014-11-21 18:01:22 +00:00
|
|
|
static const std::array<wxString, 4> src_choices = {{
|
|
|
|
_("None"), _("Emulated Wiimote"), _("Real Wiimote"), _("Hybrid Wiimote")
|
|
|
|
}};
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2013-04-19 13:21:45 +00:00
|
|
|
// reserve four ids, so that we can calculate the index from the ids later on
|
2011-08-06 14:38:23 +00:00
|
|
|
// Stupid wx 2.8 doesn't support reserving sequential IDs, so we need to do that more complicated..
|
|
|
|
int source_ctrl_id = wxWindow::NewControlId();
|
|
|
|
m_wiimote_index_from_ctrl_id.insert(std::pair<wxWindowID, unsigned int>(source_ctrl_id, i));
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2011-08-06 14:38:23 +00:00
|
|
|
int config_bt_id = wxWindow::NewControlId();
|
|
|
|
m_wiimote_index_from_conf_bt_id.insert(std::pair<wxWindowID, unsigned int>(config_bt_id, i));
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2014-09-02 02:02:38 +00:00
|
|
|
wiimote_label[i] = new wxStaticText(this, wxID_ANY, wiimote_str);
|
2014-11-21 18:01:22 +00:00
|
|
|
wiimote_source_ch[i] = new wxChoice(this, source_ctrl_id, wxDefaultPosition, wxDefaultSize, src_choices.size(), src_choices.data());
|
2014-11-22 21:39:48 +00:00
|
|
|
wiimote_source_ch[i]->Bind(wxEVT_CHOICE, &ControllerConfigDiag::SelectSource, this);
|
2011-08-06 14:38:23 +00:00
|
|
|
wiimote_configure_bt[i] = new wxButton(this, config_bt_id, _("Configure"));
|
2014-11-22 21:39:48 +00:00
|
|
|
wiimote_configure_bt[i]->Bind(wxEVT_BUTTON, &ControllerConfigDiag::ConfigEmulatedWiimote, this);
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2014-11-24 02:43:15 +00:00
|
|
|
// Disable controller type selection for certain circumstances.
|
|
|
|
if (NetPlay::IsNetPlayRunning() || Movie::IsMovieActive())
|
|
|
|
wiimote_source_ch[i]->Disable();
|
|
|
|
|
2011-08-06 14:38:23 +00:00
|
|
|
m_orig_wiimote_sources[i] = g_wiimote_sources[i];
|
|
|
|
wiimote_source_ch[i]->Select(m_orig_wiimote_sources[i]);
|
|
|
|
if (m_orig_wiimote_sources[i] != WIIMOTE_SRC_EMU && m_orig_wiimote_sources[i] != WIIMOTE_SRC_HYBRID)
|
|
|
|
wiimote_configure_bt[i]->Disable();
|
|
|
|
}
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2011-08-06 14:38:23 +00:00
|
|
|
// "Wiimotes" layout
|
2014-11-21 16:55:18 +00:00
|
|
|
wxStaticBoxSizer* const wiimote_group = new wxStaticBoxSizer(wxVERTICAL,this, _("Wiimotes"));
|
|
|
|
wxBoxSizer* const wiimote_control_section = new wxBoxSizer(wxHORIZONTAL);
|
2011-08-06 14:38:23 +00:00
|
|
|
wxFlexGridSizer* const wiimote_sizer = new wxFlexGridSizer(3, 5, 5);
|
|
|
|
for (unsigned int i = 0; i < 4; ++i)
|
|
|
|
{
|
|
|
|
wiimote_sizer->Add(wiimote_label[i], 0, wxALIGN_CENTER_VERTICAL);
|
|
|
|
wiimote_sizer->Add(wiimote_source_ch[i], 0, wxALIGN_CENTER_VERTICAL);
|
|
|
|
wiimote_sizer->Add(wiimote_configure_bt[i]);
|
|
|
|
}
|
2014-11-21 16:55:18 +00:00
|
|
|
wiimote_control_section->Add(wiimote_sizer, 1, wxEXPAND, 5 );
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2014-11-21 18:01:22 +00:00
|
|
|
// Disable some controls when emulation is running
|
|
|
|
if (Core::GetState() != Core::CORE_UNINITIALIZED && NetPlay::IsNetPlayRunning())
|
|
|
|
{
|
|
|
|
for (int i = 0; i < 4; ++i)
|
|
|
|
{
|
|
|
|
wiimote_label[i]->Disable();
|
|
|
|
wiimote_source_ch[i]->Disable();
|
|
|
|
}
|
|
|
|
}
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2014-11-21 18:01:22 +00:00
|
|
|
wiimote_group->Add(wiimote_control_section, 0, wxEXPAND | wxALL);
|
|
|
|
wiimote_group->AddSpacer(5);
|
|
|
|
wiimote_group->Add(CreateBalanceBoardSizer(), 0, wxEXPAND | wxALL);
|
2014-11-22 03:33:46 +00:00
|
|
|
wiimote_group->AddSpacer(5);
|
2014-11-21 18:01:22 +00:00
|
|
|
wiimote_group->Add(CreateRealWiimoteSizer(), 0, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM);
|
2014-11-22 03:33:46 +00:00
|
|
|
wiimote_group->AddSpacer(5);
|
2014-11-21 18:01:22 +00:00
|
|
|
wiimote_group->Add(CreateGeneralWiimoteSettingsSizer(), 0, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM);
|
2013-10-29 05:23:17 +00:00
|
|
|
|
2014-11-21 18:01:22 +00:00
|
|
|
return wiimote_group;
|
|
|
|
}
|
2013-10-29 05:23:17 +00:00
|
|
|
|
2014-11-22 21:39:48 +00:00
|
|
|
wxStaticBoxSizer* ControllerConfigDiag::CreateBalanceBoardSizer()
|
2014-11-21 18:01:22 +00:00
|
|
|
{
|
2013-05-18 12:30:20 +00:00
|
|
|
wxStaticBoxSizer* const bb_group = new wxStaticBoxSizer(wxHORIZONTAL, this, _("Balance Board"));
|
|
|
|
wxFlexGridSizer* const bb_sizer = new wxFlexGridSizer(1, 5, 5);
|
|
|
|
int source_ctrl_id = wxWindow::NewControlId();
|
2014-11-21 18:01:22 +00:00
|
|
|
|
2013-05-18 12:30:20 +00:00
|
|
|
m_wiimote_index_from_ctrl_id.insert(std::pair<wxWindowID, unsigned int>(source_ctrl_id, WIIMOTE_BALANCE_BOARD));
|
2013-10-29 05:23:17 +00:00
|
|
|
|
2014-11-21 18:01:22 +00:00
|
|
|
static const std::array<wxString, 2> src_choices = {{
|
|
|
|
("None"), _("Real Balance Board")
|
|
|
|
}};
|
|
|
|
|
|
|
|
wxChoice* const bb_source = new wxChoice(this, source_ctrl_id, wxDefaultPosition, wxDefaultSize, src_choices.size(), src_choices.data());
|
2014-11-22 21:39:48 +00:00
|
|
|
bb_source->Bind(wxEVT_CHOICE, &ControllerConfigDiag::SelectSource, this);
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2013-05-18 12:30:20 +00:00
|
|
|
m_orig_wiimote_sources[WIIMOTE_BALANCE_BOARD] = g_wiimote_sources[WIIMOTE_BALANCE_BOARD];
|
|
|
|
bb_source->Select(m_orig_wiimote_sources[WIIMOTE_BALANCE_BOARD] ? 1 : 0);
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2013-05-18 12:30:20 +00:00
|
|
|
bb_sizer->Add(bb_source, 0, wxALIGN_CENTER_VERTICAL);
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2014-11-21 18:01:22 +00:00
|
|
|
bb_group->Add(bb_sizer, 1, wxEXPAND, 5);
|
2013-10-29 05:23:17 +00:00
|
|
|
|
2014-11-21 18:01:22 +00:00
|
|
|
// Disable when emulation is running.
|
|
|
|
if (Core::GetState() != Core::CORE_UNINITIALIZED)
|
|
|
|
bb_source->Disable();
|
2011-08-06 14:38:23 +00:00
|
|
|
|
2014-11-21 18:01:22 +00:00
|
|
|
return bb_group;
|
|
|
|
}
|
2013-10-29 05:23:17 +00:00
|
|
|
|
2014-11-22 21:39:48 +00:00
|
|
|
wxStaticBoxSizer* ControllerConfigDiag::CreateRealWiimoteSizer()
|
2014-11-21 18:01:22 +00:00
|
|
|
{
|
2011-08-06 14:38:23 +00:00
|
|
|
// "Real wiimotes" controls
|
2014-03-06 04:02:34 +00:00
|
|
|
wxButton* const refresh_btn = new wxButton(this, -1, _("Refresh"));
|
2014-11-22 21:39:48 +00:00
|
|
|
refresh_btn->Bind(wxEVT_BUTTON, &ControllerConfigDiag::RefreshRealWiimotes, this);
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2013-02-08 05:17:51 +00:00
|
|
|
wxStaticBoxSizer* const real_wiimotes_group = new wxStaticBoxSizer(wxVERTICAL, this, _("Real Wiimotes"));
|
2013-02-11 23:58:56 +00:00
|
|
|
wxBoxSizer* const real_wiimotes_sizer = new wxBoxSizer(wxHORIZONTAL);
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2013-02-08 05:17:51 +00:00
|
|
|
if (!WiimoteReal::g_wiimote_scanner.IsReady())
|
|
|
|
real_wiimotes_group->Add(new wxStaticText(this, -1, _("A supported bluetooth device could not be found.\n"
|
2014-11-21 18:01:22 +00:00
|
|
|
"You must manually connect your wiimotes.")), 0, wxALIGN_CENTER | wxALL, 5);
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2013-02-11 23:58:56 +00:00
|
|
|
wxCheckBox* const continuous_scanning = new wxCheckBox(this, wxID_ANY, _("Continuous Scanning"));
|
2014-11-22 21:39:48 +00:00
|
|
|
continuous_scanning->Bind(wxEVT_CHECKBOX, &ControllerConfigDiag::OnContinuousScanning, this);
|
2013-02-11 23:58:56 +00:00
|
|
|
continuous_scanning->SetValue(SConfig::GetInstance().m_WiimoteContinuousScanning);
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2013-02-11 23:58:56 +00:00
|
|
|
real_wiimotes_sizer->Add(continuous_scanning, 0, wxALIGN_CENTER_VERTICAL);
|
|
|
|
real_wiimotes_sizer->AddStretchSpacer(1);
|
|
|
|
real_wiimotes_sizer->Add(refresh_btn, 0, wxALL | wxALIGN_CENTER, 5);
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2013-02-15 09:00:31 +00:00
|
|
|
real_wiimotes_group->Add(real_wiimotes_sizer, 0, wxEXPAND);
|
2011-06-02 19:32:34 +00:00
|
|
|
|
2014-11-21 18:01:22 +00:00
|
|
|
return real_wiimotes_group;
|
|
|
|
}
|
|
|
|
|
2014-11-22 21:39:48 +00:00
|
|
|
wxStaticBoxSizer* ControllerConfigDiag::CreateGeneralWiimoteSettingsSizer()
|
2014-11-21 18:01:22 +00:00
|
|
|
{
|
2011-06-02 19:32:34 +00:00
|
|
|
const wxString str[] = { _("Bottom"), _("Top") };
|
|
|
|
wxChoice* const WiiSensBarPos = new wxChoice(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, 2, str);
|
2014-03-06 04:02:34 +00:00
|
|
|
wxSlider* const WiiSensBarSens = new wxSlider(this, wxID_ANY, 0, 0, 4);
|
2011-06-02 19:32:34 +00:00
|
|
|
wxSlider* const WiimoteSpkVolume = new wxSlider(this, wxID_ANY, 0, 0, 127);
|
|
|
|
wxCheckBox* const WiimoteMotor = new wxCheckBox(this, wxID_ANY, _("Wiimote Motor"));
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2014-09-05 12:32:48 +00:00
|
|
|
auto wiimote_speaker = new wxCheckBox(this, wxID_ANY, _("Enable Speaker Data"));
|
2014-11-22 21:39:48 +00:00
|
|
|
wiimote_speaker->Bind(wxEVT_CHECKBOX, &ControllerConfigDiag::OnEnableSpeaker, this);
|
2014-09-05 12:32:48 +00:00
|
|
|
wiimote_speaker->SetValue(SConfig::GetInstance().m_WiimoteEnableSpeaker);
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2011-06-02 19:32:34 +00:00
|
|
|
wxStaticText* const WiiSensBarPosText = new wxStaticText(this, wxID_ANY, _("Sensor Bar Position:"));
|
|
|
|
wxStaticText* const WiiSensBarSensText = new wxStaticText(this, wxID_ANY, _("IR Sensitivity:"));
|
|
|
|
wxStaticText* const WiiSensBarSensMinText = new wxStaticText(this, wxID_ANY, _("Min"));
|
|
|
|
wxStaticText* const WiiSensBarSensMaxText = new wxStaticText(this, wxID_ANY, _("Max"));
|
|
|
|
wxStaticText* const WiimoteSpkVolumeText = new wxStaticText(this, wxID_ANY, _("Speaker Volume:"));
|
|
|
|
wxStaticText* const WiimoteSpkVolumeMinText = new wxStaticText(this, wxID_ANY, _("Min"));
|
|
|
|
wxStaticText* const WiimoteSpkVolumeMaxText = new wxStaticText(this, wxID_ANY, _("Max"));
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2011-08-06 14:38:23 +00:00
|
|
|
// With some GTK themes, no minimum size will be applied - so do this manually here
|
2011-06-02 19:32:34 +00:00
|
|
|
WiiSensBarSens->SetMinSize(wxSize(100,-1));
|
|
|
|
WiimoteSpkVolume->SetMinSize(wxSize(100,-1));
|
|
|
|
|
2011-08-06 14:38:23 +00:00
|
|
|
// Disable some controls when emulation is running
|
2011-06-02 19:32:34 +00:00
|
|
|
if (Core::GetState() != Core::CORE_UNINITIALIZED)
|
|
|
|
{
|
|
|
|
WiiSensBarPos->Disable();
|
|
|
|
WiiSensBarSens->Disable();
|
|
|
|
WiimoteSpkVolume->Disable();
|
|
|
|
WiimoteMotor->Disable();
|
|
|
|
WiiSensBarPosText->Disable();
|
|
|
|
WiiSensBarSensText->Disable();
|
|
|
|
WiiSensBarSensMinText->Disable();
|
|
|
|
WiiSensBarSensMaxText->Disable();
|
|
|
|
WiimoteSpkVolumeText->Disable();
|
|
|
|
WiimoteSpkVolumeMinText->Disable();
|
|
|
|
WiimoteSpkVolumeMaxText->Disable();
|
|
|
|
}
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2011-08-06 14:38:23 +00:00
|
|
|
// "General Settings" initialization
|
2011-06-02 19:32:34 +00:00
|
|
|
WiiSensBarPos->SetSelection(SConfig::GetInstance().m_SYSCONF->GetData<u8>("BT.BAR"));
|
|
|
|
WiiSensBarSens->SetValue(SConfig::GetInstance().m_SYSCONF->GetData<u32>("BT.SENS"));
|
|
|
|
WiimoteSpkVolume->SetValue(SConfig::GetInstance().m_SYSCONF->GetData<u8>("BT.SPKV"));
|
|
|
|
WiimoteMotor->SetValue(SConfig::GetInstance().m_SYSCONF->GetData<bool>("BT.MOT"));
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2014-11-22 21:39:48 +00:00
|
|
|
WiiSensBarPos->Bind(wxEVT_CHOICE, &ControllerConfigDiag::OnSensorBarPos, this);
|
|
|
|
WiiSensBarSens->Bind(wxEVT_SLIDER, &ControllerConfigDiag::OnSensorBarSensitivity, this);
|
|
|
|
WiimoteSpkVolume->Bind(wxEVT_SLIDER, &ControllerConfigDiag::OnSpeakerVolume, this);
|
|
|
|
WiimoteMotor->Bind(wxEVT_CHECKBOX, &ControllerConfigDiag::OnMotor, this);
|
2011-06-02 19:32:34 +00:00
|
|
|
|
2011-08-06 14:38:23 +00:00
|
|
|
// "General Settings" layout
|
2011-06-02 19:32:34 +00:00
|
|
|
wxStaticBoxSizer* const general_sizer = new wxStaticBoxSizer(wxVERTICAL, this, _("General Settings"));
|
|
|
|
wxFlexGridSizer* const choice_sizer = new wxFlexGridSizer(2, 5, 5);
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2011-06-02 19:32:34 +00:00
|
|
|
wxBoxSizer* const sensbarsens_sizer = new wxBoxSizer(wxHORIZONTAL);
|
2011-08-06 14:38:23 +00:00
|
|
|
sensbarsens_sizer->Add(WiiSensBarSensMinText, 0, wxALIGN_CENTER_VERTICAL);
|
2011-06-02 19:32:34 +00:00
|
|
|
sensbarsens_sizer->Add(WiiSensBarSens);
|
2011-08-06 14:38:23 +00:00
|
|
|
sensbarsens_sizer->Add(WiiSensBarSensMaxText, 0, wxALIGN_CENTER_VERTICAL);
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2011-06-02 19:32:34 +00:00
|
|
|
wxBoxSizer* const spkvol_sizer = new wxBoxSizer(wxHORIZONTAL);
|
2011-08-06 14:38:23 +00:00
|
|
|
spkvol_sizer->Add(WiimoteSpkVolumeMinText, 0, wxALIGN_CENTER_VERTICAL);
|
2011-06-02 19:32:34 +00:00
|
|
|
spkvol_sizer->Add(WiimoteSpkVolume);
|
2011-08-06 14:38:23 +00:00
|
|
|
spkvol_sizer->Add(WiimoteSpkVolumeMaxText, 0, wxALIGN_CENTER_VERTICAL);
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2011-08-06 14:38:23 +00:00
|
|
|
choice_sizer->Add(WiiSensBarPosText, 0, wxALIGN_CENTER_VERTICAL);
|
2011-06-02 19:32:34 +00:00
|
|
|
choice_sizer->Add(WiiSensBarPos);
|
2011-08-06 14:38:23 +00:00
|
|
|
choice_sizer->Add(WiiSensBarSensText, 0, wxALIGN_CENTER_VERTICAL);
|
2011-06-02 19:32:34 +00:00
|
|
|
choice_sizer->Add(sensbarsens_sizer);
|
2011-08-06 14:38:23 +00:00
|
|
|
choice_sizer->Add(WiimoteSpkVolumeText, 0, wxALIGN_CENTER_VERTICAL);
|
2011-06-02 19:32:34 +00:00
|
|
|
choice_sizer->Add(spkvol_sizer);
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2011-08-06 14:38:23 +00:00
|
|
|
wxGridSizer* const general_wiimote_sizer = new wxGridSizer(1, 5, 5);
|
|
|
|
general_wiimote_sizer->Add(WiimoteMotor);
|
2014-09-05 12:32:48 +00:00
|
|
|
general_wiimote_sizer->Add(wiimote_speaker, 0);
|
2014-11-22 03:35:56 +00:00
|
|
|
|
2011-06-02 19:32:34 +00:00
|
|
|
general_sizer->Add(choice_sizer);
|
2011-08-06 14:38:23 +00:00
|
|
|
general_sizer->Add(general_wiimote_sizer);
|
2011-06-02 19:32:34 +00:00
|
|
|
|
2014-11-21 18:01:22 +00:00
|
|
|
return general_sizer;
|
2014-11-21 16:55:18 +00:00
|
|
|
}
|
|
|
|
|
2011-08-06 14:38:23 +00:00
|
|
|
|
2014-11-22 21:39:48 +00:00
|
|
|
void ControllerConfigDiag::ConfigEmulatedWiimote(wxCommandEvent& ev)
|
2010-07-03 08:04:10 +00:00
|
|
|
{
|
2014-11-22 20:29:13 +00:00
|
|
|
InputConfig* const wiimote_plugin = Wiimote::GetConfig();
|
|
|
|
bool was_init = false;
|
|
|
|
if (g_controller_interface.IsInit()) // check if game is running
|
|
|
|
{
|
|
|
|
was_init = true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
#if defined(HAVE_X11) && HAVE_X11
|
|
|
|
Window win = X11Utils::XWindowFromHandle(GetHandle());
|
|
|
|
Wiimote::Initialize(reinterpret_cast<void*>(win));
|
|
|
|
#else
|
|
|
|
Wiimote::Initialize(reinterpret_cast<void*>(GetHandle()));
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
InputConfigDialog m_ConfigFrame(this, *wiimote_plugin, _trans("Dolphin Emulated Wiimote Configuration"), m_wiimote_index_from_conf_bt_id[ev.GetId()]);
|
|
|
|
m_ConfigFrame.ShowModal();
|
|
|
|
m_ConfigFrame.Destroy();
|
|
|
|
if (!was_init) // if game isn't running
|
|
|
|
{
|
|
|
|
Wiimote::Shutdown();
|
|
|
|
}
|
|
|
|
|
|
|
|
//InputConfigDialog* const m_emu_config_diag = new InputConfigDialog(this, *Wiimote::GetConfig(), _trans("Dolphin Emulated Wiimote Configuration"), m_wiimote_index_from_conf_bt_id[ev.GetId()]);
|
|
|
|
//m_emu_config_diag->ShowModal();
|
|
|
|
//m_emu_config_diag->Destroy();
|
2010-07-03 08:04:10 +00:00
|
|
|
}
|
|
|
|
|
2014-11-22 21:39:48 +00:00
|
|
|
void ControllerConfigDiag::RefreshRealWiimotes(wxCommandEvent&)
|
2010-07-03 08:04:10 +00:00
|
|
|
{
|
|
|
|
WiimoteReal::Refresh();
|
|
|
|
}
|
|
|
|
|
2014-11-22 21:39:48 +00:00
|
|
|
void ControllerConfigDiag::SelectSource(wxCommandEvent& event)
|
2010-07-03 08:04:10 +00:00
|
|
|
{
|
2011-02-23 03:06:16 +00:00
|
|
|
// This needs to be changed now in order for refresh to work right.
|
|
|
|
// Revert if the dialog is canceled.
|
2011-08-06 14:38:23 +00:00
|
|
|
int index = m_wiimote_index_from_ctrl_id[event.GetId()];
|
2013-10-29 05:23:17 +00:00
|
|
|
|
2014-03-10 11:30:55 +00:00
|
|
|
if (index != WIIMOTE_BALANCE_BOARD)
|
2013-05-18 12:30:20 +00:00
|
|
|
{
|
|
|
|
WiimoteReal::ChangeWiimoteSource(index, event.GetInt());
|
|
|
|
if (g_wiimote_sources[index] != WIIMOTE_SRC_EMU && g_wiimote_sources[index] != WIIMOTE_SRC_HYBRID)
|
|
|
|
wiimote_configure_bt[index]->Disable();
|
|
|
|
else
|
|
|
|
wiimote_configure_bt[index]->Enable();
|
|
|
|
}
|
2011-08-06 14:38:23 +00:00
|
|
|
else
|
2013-05-18 12:30:20 +00:00
|
|
|
{
|
2013-10-29 05:23:17 +00:00
|
|
|
WiimoteReal::ChangeWiimoteSource(index, event.GetInt() ? WIIMOTE_SRC_REAL : WIIMOTE_SRC_NONE);
|
2013-05-18 12:30:20 +00:00
|
|
|
}
|
2011-02-23 03:06:16 +00:00
|
|
|
}
|
2011-01-07 15:18:00 +00:00
|
|
|
|
2014-11-22 21:39:48 +00:00
|
|
|
void ControllerConfigDiag::RevertSource()
|
2011-02-23 03:06:16 +00:00
|
|
|
{
|
2013-05-18 12:30:20 +00:00
|
|
|
for (int i = 0; i < MAX_BBMOTES; ++i)
|
2011-08-06 14:38:23 +00:00
|
|
|
g_wiimote_sources[i] = m_orig_wiimote_sources[i];
|
2010-07-03 08:04:10 +00:00
|
|
|
}
|
|
|
|
|
2014-11-22 21:39:48 +00:00
|
|
|
void ControllerConfigDiag::Save(wxCommandEvent& event)
|
2010-07-03 08:04:10 +00:00
|
|
|
{
|
2011-02-28 20:40:15 +00:00
|
|
|
std::string ini_filename = File::GetUserPath(D_CONFIG_IDX) + WIIMOTE_INI_NAME ".ini";
|
2010-07-03 08:04:10 +00:00
|
|
|
|
|
|
|
IniFile inifile;
|
|
|
|
inifile.Load(ini_filename);
|
|
|
|
|
|
|
|
for (unsigned int i=0; i<MAX_WIIMOTES; ++i)
|
|
|
|
{
|
|
|
|
std::string secname("Wiimote");
|
|
|
|
secname += (char)('1' + i);
|
2014-02-08 05:50:37 +00:00
|
|
|
IniFile::Section& sec = *inifile.GetOrCreateSection(secname);
|
2010-07-03 08:04:10 +00:00
|
|
|
|
|
|
|
sec.Set("Source", (int)g_wiimote_sources[i]);
|
|
|
|
}
|
2013-10-29 05:23:17 +00:00
|
|
|
|
2013-05-18 12:30:20 +00:00
|
|
|
std::string secname("BalanceBoard");
|
2014-02-08 05:50:37 +00:00
|
|
|
IniFile::Section& sec = *inifile.GetOrCreateSection(secname);
|
2013-05-18 12:30:20 +00:00
|
|
|
sec.Set("Source", (int)g_wiimote_sources[WIIMOTE_BALANCE_BOARD]);
|
2010-07-03 08:04:10 +00:00
|
|
|
|
|
|
|
inifile.Save(ini_filename);
|
|
|
|
|
2011-03-15 21:57:00 +00:00
|
|
|
event.Skip();
|
2010-07-22 07:55:35 +00:00
|
|
|
}
|
2011-02-23 03:06:16 +00:00
|
|
|
|
2014-11-22 21:39:48 +00:00
|
|
|
void ControllerConfigDiag::Cancel(wxCommandEvent& event)
|
2011-02-23 03:06:16 +00:00
|
|
|
{
|
2011-08-06 14:38:23 +00:00
|
|
|
RevertSource();
|
2011-03-15 21:57:00 +00:00
|
|
|
event.Skip();
|
2011-02-23 03:06:16 +00:00
|
|
|
}
|
2014-11-22 20:29:13 +00:00
|
|
|
|
2014-11-22 21:39:48 +00:00
|
|
|
void ControllerConfigDiag::OnGameCubePortChanged(wxCommandEvent& event)
|
2014-11-22 20:29:13 +00:00
|
|
|
{
|
|
|
|
const unsigned int device_num = m_gc_port_choice_ids[event.GetId()];
|
|
|
|
const wxString device_name = event.GetString();
|
|
|
|
|
|
|
|
SIDevices tempType;
|
|
|
|
if (device_name == m_gc_pad_type_strs[1])
|
|
|
|
tempType = SIDEVICE_GC_CONTROLLER;
|
|
|
|
else if (device_name == m_gc_pad_type_strs[2])
|
|
|
|
tempType = SIDEVICE_GC_STEERING;
|
|
|
|
else if (device_name == m_gc_pad_type_strs[3])
|
|
|
|
tempType = SIDEVICE_DANCEMAT;
|
|
|
|
else if (device_name == m_gc_pad_type_strs[4])
|
|
|
|
tempType = SIDEVICE_GC_TARUKONGA;
|
|
|
|
else if (device_name == m_gc_pad_type_strs[5])
|
|
|
|
tempType = SIDEVICE_GC_GBA;
|
|
|
|
else if (device_name == m_gc_pad_type_strs[6])
|
|
|
|
tempType = SIDEVICE_AM_BASEBOARD;
|
|
|
|
else
|
|
|
|
tempType = SIDEVICE_NONE;
|
|
|
|
|
|
|
|
SConfig::GetInstance().m_SIDevice[device_num] = tempType;
|
|
|
|
|
|
|
|
if (Core::IsRunning())
|
|
|
|
SerialInterface::ChangeDevice(tempType, device_num);
|
|
|
|
}
|
|
|
|
|
2014-11-22 21:39:48 +00:00
|
|
|
void ControllerConfigDiag::OnGameCubeConfigButton(wxCommandEvent& event)
|
2014-11-22 20:29:13 +00:00
|
|
|
{
|
|
|
|
InputConfig* const pad_plugin = Pad::GetConfig();
|
|
|
|
const int port_num = m_gc_port_config_ids[event.GetId()];
|
|
|
|
|
|
|
|
bool was_init = false;
|
|
|
|
|
|
|
|
// 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());
|
|
|
|
Pad::Initialize(reinterpret_cast<void*>(win));
|
|
|
|
#else
|
|
|
|
Pad::Initialize(reinterpret_cast<void*>(GetHandle()));
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
InputConfigDialog m_ConfigFrame(this, *pad_plugin, _trans("Dolphin GCPad Configuration"), port_num);
|
|
|
|
m_ConfigFrame.ShowModal();
|
|
|
|
m_ConfigFrame.Destroy();
|
|
|
|
|
|
|
|
// if game isn't running
|
|
|
|
if (!was_init)
|
|
|
|
Pad::Shutdown();
|
|
|
|
}
|