summaryrefslogtreecommitdiff
path: root/Source
diff options
context:
space:
mode:
Diffstat (limited to 'Source')
-rw-r--r--Source/Plugins/Plugin_PadSimple/Src/AboutDlg.cpp36
-rw-r--r--Source/Plugins/Plugin_PadSimple/Src/AboutDlg.h41
-rw-r--r--Source/Plugins/Plugin_PadSimple/Src/ConfigDlg.cpp196
-rw-r--r--Source/Plugins/Plugin_PadSimple/Src/ConfigDlg.h52
-rw-r--r--Source/Plugins/Plugin_PadSimple/Src/GUI/ConfigDlg.cpp254
-rw-r--r--Source/Plugins/Plugin_PadSimple/Src/GUI/ConfigDlg.h125
-rw-r--r--Source/Plugins/Plugin_PadSimple/Src/PadSimple.cpp733
-rw-r--r--Source/Plugins/Plugin_PadSimple/Src/PadSimple.h89
-rw-r--r--Source/Plugins/Plugin_PadSimple/Src/SConscript3
9 files changed, 1203 insertions, 326 deletions
diff --git a/Source/Plugins/Plugin_PadSimple/Src/AboutDlg.cpp b/Source/Plugins/Plugin_PadSimple/Src/AboutDlg.cpp
deleted file mode 100644
index 7d0d95118a..0000000000
--- a/Source/Plugins/Plugin_PadSimple/Src/AboutDlg.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright (C) 2003-2008 Dolphin Project.
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, version 2.0.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License 2.0 for more details.
-
-// A copy of the GPL 2.0 should have been included with the program.
-// If not, see http://www.gnu.org/licenses/
-
-// Official SVN repository and contact information can be found at
-// http://code.google.com/p/dolphin-emu/
-
-#include "stdafx.h"
-#include "resource.h"
-
-#include "AboutDlg.h"
-
-LRESULT CAboutDlg::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
-{
- CenterWindow(GetParent());
- return(TRUE);
-}
-
-
-LRESULT CAboutDlg::OnCloseCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
-{
- EndDialog(wID);
- return(0);
-}
-
-
diff --git a/Source/Plugins/Plugin_PadSimple/Src/AboutDlg.h b/Source/Plugins/Plugin_PadSimple/Src/AboutDlg.h
deleted file mode 100644
index c9e54183a5..0000000000
--- a/Source/Plugins/Plugin_PadSimple/Src/AboutDlg.h
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright (C) 2003-2008 Dolphin Project.
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, version 2.0.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License 2.0 for more details.
-
-// A copy of the GPL 2.0 should have been included with the program.
-// If not, see http://www.gnu.org/licenses/
-
-// Official SVN repository and contact information can be found at
-// http://code.google.com/p/dolphin-emu/
-
-#pragma once
-
-class CAboutDlg
- : public CDialogImpl<CAboutDlg>
-{
- public:
-
- enum { IDD = IDD_ABOUTPAD };
-
- BEGIN_MSG_MAP(CAboutDlg)
- MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
- COMMAND_ID_HANDLER(IDOK, OnCloseCmd)
- COMMAND_ID_HANDLER(IDCANCEL, OnCloseCmd)
- END_MSG_MAP()
-
-// Handler prototypes (uncomment arguments if needed):
-// LRESULT MessageHandler(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
-// LRESULT CommandHandler(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
-// LRESULT NotifyHandler(int /*idCtrl*/, LPNMHDR /*pnmh*/, BOOL& /*bHandled*/)
-
- LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/);
-
- LRESULT OnCloseCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL & /*bHandled*/);
-};
diff --git a/Source/Plugins/Plugin_PadSimple/Src/ConfigDlg.cpp b/Source/Plugins/Plugin_PadSimple/Src/ConfigDlg.cpp
deleted file mode 100644
index 3cb7c9498f..0000000000
--- a/Source/Plugins/Plugin_PadSimple/Src/ConfigDlg.cpp
+++ /dev/null
@@ -1,196 +0,0 @@
-// Copyright (C) 2003-2008 Dolphin Project.
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, version 2.0.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License 2.0 for more details.
-
-// A copy of the GPL 2.0 should have been included with the program.
-// If not, see http://www.gnu.org/licenses/
-
-// Official SVN repository and contact information can be found at
-// http://code.google.com/p/dolphin-emu/
-
-#include <windowsx.h>
-#include "resource.h"
-
-#include "DirectInputBase.h"
-#include "ConfigDlg.h"
-#define NUMCONTROLS 23
-int m_buttonResources[NUMCONTROLS] =
-{
- IDC_SETMAINLEFT,
- IDC_SETMAINUP,
- IDC_SETMAINRIGHT,
- IDC_SETMAINDOWN,
- IDC_SETSUBLEFT,
- IDC_SETSUBUP,
- IDC_SETSUBRIGHT,
- IDC_SETSUBDOWN,
- IDC_SETDPADLEFT,
- IDC_SETDPADUP,
- IDC_SETDPADRIGHT,
- IDC_SETDPADDOWN,
- IDC_SETA,
- IDC_SETB,
- IDC_SETX,
- IDC_SETY,
- IDC_SETZ,
- IDC_SETL,
- IDC_SETR,
- IDC_SETSTART,
- // CTL_HALFMAIN,
- // CTL_HALFSUB,
- // CTL_HALFTRIGGER,
- // NUMCONTROLS
-};
-
-extern unsigned int keyForControl[NUMCONTROLS];
-extern bool g_rumbleEnable;
-
-LRESULT CConfigDlg::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
-{
- m_dinput.Init(m_hWnd);
-
- CenterWindow(GetParent());
-
- for (int i = 0; i < NUMCONTROLS - 3; i++)
- {
- CButton button = GetDlgItem(m_buttonResources[i]);
- SetButtonText(button, keyForControl[i]);
- }
-
- m_hWaitForKeyButton = NULL;
- CheckDlgButton(IDC_RUMBLE1, g_rumbleEnable);
- SetTimer(1, 50, 0);
- return(TRUE);
-}
-
-
-LRESULT CConfigDlg::OnCommand(UINT /*uMsg*/, WPARAM _wParam, LPARAM _lParam, BOOL& _bHandled)
-{
- // we have not handled it
- _bHandled = FALSE;
-
- // check if it is a key
- for (int i = 0; i < NUMCONTROLS; i++)
- {
- if (m_buttonResources[i] == LOWORD(_wParam))
- {
- m_iKeyWaitingFor = i;
- m_hWaitForKeyButton = GetDlgItem(m_buttonResources[i]);
-
- CButton tmpButton = m_hWaitForKeyButton;
- tmpButton.SetWindowText("Press Key");
-
- _bHandled = TRUE; // yeah we have handled it
- break;
- }
- }
-
- g_rumbleEnable = Button_GetCheck(GetDlgItem(IDC_RUMBLE1)) ? true : false;
- return(TRUE);
-}
-
-
-LRESULT CConfigDlg::OnClose(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
-{
- m_dinput.Free();
-
- EndDialog(0);
- return(0);
-}
-
-
-LRESULT CConfigDlg::OnTimer(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
-{
- if (m_hWaitForKeyButton != NULL)
- {
- m_dinput.Read();
-
- for (int i = 0; i < 255; i++)
- {
- if (m_dinput.diks[i])
- {
- keyForControl[m_iKeyWaitingFor] = i;
- CButton tmpButton = m_hWaitForKeyButton;
- SetButtonText(tmpButton, keyForControl[m_iKeyWaitingFor]);
-
- m_hWaitForKeyButton = NULL;
- break;
- }
- }
- }
-
- return(TRUE);
-}
-
-
-LRESULT CConfigDlg::OnCloseCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
-{
- m_dinput.Free();
-
- EndDialog(wID);
- return(0);
-}
-
-
-void CConfigDlg::SetButtonText(CButton& _rButton, int _key)
-{
- char szTemp[64];
-
- switch (_key)
- {
- case DIK_LEFT:
- strcpy(szTemp, "Left");
- break;
-
- case DIK_UP:
- strcpy(szTemp, "Up");
- break;
-
- case DIK_RIGHT:
- strcpy(szTemp, "Right");
- break;
-
- case DIK_DOWN:
- strcpy(szTemp, "Down");
- break;
-
- case DIK_HOME:
- strcpy(szTemp, "Home");
- break;
-
- case DIK_END:
- strcpy(szTemp, "End");
- break;
-
- case DIK_INSERT:
- strcpy(szTemp, "Ins");
- break;
-
- case DIK_DELETE:
- strcpy(szTemp, "Del");
- break;
-
- case DIK_PGUP:
- strcpy(szTemp, "PgUp");
- break;
-
- case DIK_PGDN:
- strcpy(szTemp, "PgDn");
- break;
-
- default:
- GetKeyNameText(_key << 16, szTemp, 64);
- break;
- }
-
- _rButton.SetWindowText(szTemp);
-}
-
-
diff --git a/Source/Plugins/Plugin_PadSimple/Src/ConfigDlg.h b/Source/Plugins/Plugin_PadSimple/Src/ConfigDlg.h
deleted file mode 100644
index a352340318..0000000000
--- a/Source/Plugins/Plugin_PadSimple/Src/ConfigDlg.h
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright (C) 2003-2008 Dolphin Project.
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, version 2.0.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License 2.0 for more details.
-
-// A copy of the GPL 2.0 should have been included with the program.
-// If not, see http://www.gnu.org/licenses/
-
-// Official SVN repository and contact information can be found at
-// http://code.google.com/p/dolphin-emu/
-
-#pragma once
-
-class CConfigDlg
- : public CDialogImpl<CConfigDlg>
-{
- public:
-
- enum { IDD = IDD_PADCONFIG };
-
- BEGIN_MSG_MAP(CConfigDlg)
- MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
- MESSAGE_HANDLER(WM_COMMAND, OnCommand)
- MESSAGE_HANDLER(WM_TIMER, OnTimer)
- MESSAGE_HANDLER(WM_CLOSE, OnClose)
- COMMAND_ID_HANDLER(IDOK, OnCloseCmd)
- END_MSG_MAP()
-
- private:
-
- HWND m_hWaitForKeyButton;
- int m_iKeyWaitingFor;
- DInput m_dinput;
-
- // Handler prototypes (uncomment arguments if needed):
- // LRESULT MessageHandler(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
- // LRESULT CommandHandler(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
- // LRESULT NotifyHandler(int /*idCtrl*/, LPNMHDR /*pnmh*/, BOOL& /*bHandled*/)
-
- LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/);
- LRESULT OnCommand(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/);
- LRESULT OnTimer(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/);
- LRESULT OnClose(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/);
- LRESULT OnCloseCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL & /*bHandled*/);
- void SetButtonText(CButton& _rButton, int _key);
-};
diff --git a/Source/Plugins/Plugin_PadSimple/Src/GUI/ConfigDlg.cpp b/Source/Plugins/Plugin_PadSimple/Src/GUI/ConfigDlg.cpp
new file mode 100644
index 0000000000..04c88ad283
--- /dev/null
+++ b/Source/Plugins/Plugin_PadSimple/Src/GUI/ConfigDlg.cpp
@@ -0,0 +1,254 @@
+// Copyright (C) 2003-2008 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+
+
+#include "ConfigDlg.h"
+#include "../PadSimple.h"
+//#include "../DirectInputBase.h"
+
+BEGIN_EVENT_TABLE(ConfigDialog,wxDialog)
+ EVT_CLOSE(ConfigDialog::OnClose)
+ EVT_BUTTON(ID_CLOSE,ConfigDialog::OnCloseClick)
+ EVT_CHECKBOX(ID_ATTACHED,ConfigDialog::AttachedCheck)
+ EVT_CHECKBOX(ID_DISABLE,ConfigDialog::DisableCheck)
+ EVT_CHECKBOX(ID_RUMBLE,ConfigDialog::RumbleCheck)
+ EVT_BUTTON(CTL_A,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_B,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_X,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_Y,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_Z,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_START,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_TRIGGER_L,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_L,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_TRIGGER_R,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_R,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_MAINUP,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_MAINDOWN,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_MAINLEFT,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_MAINRIGHT,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_HALFMAIN,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_SUBUP,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_SUBDOWN,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_SUBLEFT,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_SUBRIGHT,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_HALFSUB,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_DPADUP,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_DPADDOWN,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_DPADLEFT,ConfigDialog::OnButtonClick)
+ EVT_BUTTON(CTL_DPADRIGHT,ConfigDialog::OnButtonClick)
+END_EVENT_TABLE()
+
+ConfigDialog::ConfigDialog(wxWindow *parent, wxWindowID id, const wxString &title, const wxPoint &position, const wxSize& size, long style)
+: wxDialog(parent, id, title, position, size, style)
+{
+ clickedButton = NULL;
+ CreateGUIControls();
+}
+
+ConfigDialog::~ConfigDialog()
+{
+}
+
+void ConfigDialog::CreateGUIControls()
+{
+ // Notebook
+ m_Notebook = new wxNotebook(this, ID_NOTEBOOK, wxDefaultPosition, wxDefaultSize);
+
+ // Controller pages
+ m_Controller[0] = new wxPanel(m_Notebook, ID_CONTROLLERPAGE1, wxDefaultPosition, wxDefaultSize);
+ m_Notebook->AddPage(m_Controller[0], wxT("Controller 1"));
+ m_Controller[1] = new wxPanel(m_Notebook, ID_CONTROLLERPAGE2, wxDefaultPosition, wxDefaultSize);
+ m_Notebook->AddPage(m_Controller[1], wxT("Controller 2"));
+ m_Controller[2] = new wxPanel(m_Notebook, ID_CONTROLLERPAGE3, wxDefaultPosition, wxDefaultSize);
+ m_Notebook->AddPage(m_Controller[2], wxT("Controller 3"));
+ m_Controller[3] = new wxPanel(m_Notebook, ID_CONTROLLERPAGE4, wxDefaultPosition, wxDefaultSize);
+ m_Notebook->AddPage(m_Controller[3], wxT("Controller 4"));
+
+ // Standard buttons
+ m_Close = new wxButton(this, ID_CLOSE, wxT("Close"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
+
+ // Put notebook and standard buttons in sizers
+ wxBoxSizer* sSButtons;
+ sSButtons = new wxBoxSizer(wxHORIZONTAL);
+ sSButtons->Add(0, 0, 1, wxEXPAND, 5);
+ sSButtons->Add(m_Close, 0, wxALL, 5);
+
+ wxBoxSizer* sMain;
+ sMain = new wxBoxSizer(wxVERTICAL);
+ sMain->Add(m_Notebook, 1, wxEXPAND|wxALL, 5);
+ sMain->Add(sSButtons, 0, wxEXPAND, 5);
+
+ this->SetSizer(sMain);
+ this->Layout();
+
+ wxArrayString arrayStringFor_DeviceName;
+
+ for(int i = 0; i < 4; i++)
+ {
+ sDevice[i] = new wxStaticBoxSizer(wxVERTICAL, m_Controller[i], wxT("Controller:"));
+ sDeviceTop[i] = new wxBoxSizer(wxHORIZONTAL);
+ sDeviceBottom[i] = new wxBoxSizer(wxHORIZONTAL);
+ m_DeviceName[i] = new wxChoice(m_Controller[i], ID_DEVICENAME, wxDefaultPosition, wxDefaultSize, arrayStringFor_DeviceName, 0, wxDefaultValidator);
+ m_Attached[i] = new wxCheckBox(m_Controller[i], ID_ATTACHED, wxT("Controller attached"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
+ m_Disable[i] = new wxCheckBox(m_Controller[i], ID_DISABLE, wxT("Disable when window looses focus"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
+ m_Rumble[i] = new wxCheckBox(m_Controller[i], ID_RUMBLE, wxT("Enable rumble"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
+ m_Attached[i]->SetValue(pad[i].attached);
+ m_Disable[i]->SetValue(pad[i].disable);
+ m_Rumble[i]->SetValue(pad[i].rumble);
+ m_Rumble[i]->Show(pad[i].type);
+
+ sDeviceTop[i]->Add(m_DeviceName[i], 1, wxEXPAND|wxALL, 1);
+ sDeviceTop[i]->Add(m_Attached[i], 0, wxEXPAND|wxALL, 1);
+ sDeviceBottom[i]->AddStretchSpacer(1);
+ sDeviceBottom[i]->Add(m_Disable[i], 0, wxEXPAND|wxALL, 1);
+ sDeviceBottom[i]->Add(m_Rumble[i], 0, wxEXPAND|wxALL, 1);
+ sDeviceBottom[i]->AddStretchSpacer(1);
+ sDevice[i]->Add(sDeviceTop[i], 0, wxEXPAND|wxALL, 1);
+ sDevice[i]->Add(sDeviceBottom[i], 0, wxEXPAND|wxALL, 1);
+
+ sButtons[i] = new wxStaticBoxSizer(wxVERTICAL, m_Controller[i], wxT("Buttons:"));
+ m_ButtonA[i] = new wxButton(m_Controller[i], CTL_A, wxT("A: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+ m_ButtonB[i] = new wxButton(m_Controller[i], CTL_B, wxT("B: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+ m_ButtonX[i] = new wxButton(m_Controller[i], CTL_X, wxT("X: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+ m_ButtonY[i] = new wxButton(m_Controller[i], CTL_Y, wxT("Y: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+ m_ButtonZ[i] = new wxButton(m_Controller[i], CTL_Z, wxT("Z: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+ m_ButtonStart[i] = new wxButton(m_Controller[i], CTL_START, wxT("Start: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+
+ sButtons[i]->Add(m_ButtonA[i], 0, wxEXPAND|wxALL);
+ sButtons[i]->Add(m_ButtonB[i], 0, wxEXPAND|wxALL);
+ sButtons[i]->Add(m_ButtonX[i], 0, wxEXPAND|wxALL);
+ sButtons[i]->Add(m_ButtonY[i], 0, wxEXPAND|wxALL);
+ sButtons[i]->Add(m_ButtonZ[i], 0, wxEXPAND|wxALL);
+ sButtons[i]->Add(m_ButtonStart[i], 0, wxEXPAND|wxALL);
+
+ sTriggerL[i] = new wxStaticBoxSizer(wxVERTICAL, m_Controller[i], wxT("L Trigger:"));
+ m_TriggerL[i] = new wxButton(m_Controller[i], CTL_TRIGGER_L, wxT("Analog: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+ m_ButtonL[i] = new wxButton(m_Controller[i], CTL_L, wxT("Click: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+ sTriggerR[i] = new wxStaticBoxSizer(wxVERTICAL, m_Controller[i], wxT("R Trigger:"));
+ m_TriggerR[i] = new wxButton(m_Controller[i], CTL_TRIGGER_R, wxT("Analog: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+ m_ButtonR[i] = new wxButton(m_Controller[i], CTL_R, wxT("Click: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+
+ sTriggerL[i]->Add(m_TriggerL[i], 0, wxEXPAND|wxALL);
+ sTriggerL[i]->Add(m_ButtonL[i], 0, wxEXPAND|wxALL);
+ sTriggerR[i]->Add(m_TriggerR[i], 0, wxEXPAND|wxALL);
+ sTriggerR[i]->Add(m_ButtonR[i], 0, wxEXPAND|wxALL);
+
+ sStick[i] = new wxStaticBoxSizer(wxVERTICAL, m_Controller[i], wxT("Main Stick:"));
+ m_StickUp[i] = new wxButton(m_Controller[i], CTL_MAINUP, wxT("Up: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+ m_StickDown[i] = new wxButton(m_Controller[i], CTL_MAINDOWN, wxT("Down: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+ m_StickLeft[i] = new wxButton(m_Controller[i], CTL_MAINLEFT, wxT("Left: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+ m_StickRight[i] = new wxButton(m_Controller[i], CTL_MAINRIGHT, wxT("Right: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+
+ sStick[i]->Add(m_StickUp[i], 0, wxEXPAND|wxALL);
+ sStick[i]->Add(m_StickDown[i], 0, wxEXPAND|wxALL);
+ sStick[i]->Add(m_StickLeft[i], 0, wxEXPAND|wxALL);
+ sStick[i]->Add(m_StickRight[i], 0, wxEXPAND|wxALL);
+
+ sDPad[i] = new wxStaticBoxSizer(wxVERTICAL, m_Controller[i], wxT("D-Pad:"));
+ m_DPadUp[i] = new wxButton(m_Controller[i], CTL_DPADUP, wxT("Up: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+ m_DPadDown[i] = new wxButton(m_Controller[i], CTL_DPADDOWN, wxT("Down: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+ m_DPadLeft[i] = new wxButton(m_Controller[i], CTL_DPADLEFT, wxT("Left: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+ m_DPadRight[i] = new wxButton(m_Controller[i], CTL_DPADRIGHT, wxT("Right: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+
+ sDPad[i]->Add(m_DPadUp[i], 0, wxEXPAND|wxALL);
+ sDPad[i]->Add(m_DPadDown[i], 0, wxEXPAND|wxALL);
+ sDPad[i]->Add(m_DPadLeft[i], 0, wxEXPAND|wxALL);
+ sDPad[i]->Add(m_DPadRight[i], 0, wxEXPAND|wxALL);
+
+ sCStick[i] = new wxStaticBoxSizer(wxVERTICAL, m_Controller[i], wxT("C-Stick:"));
+ m_CStickUp[i] = new wxButton(m_Controller[i], CTL_SUBUP, wxT("Up: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+ m_CStickDown[i] = new wxButton(m_Controller[i], CTL_SUBDOWN, wxT("Down: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+ m_CStickLeft[i] = new wxButton(m_Controller[i], CTL_SUBLEFT, wxT("Left: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+ m_CStickRight[i] = new wxButton(m_Controller[i], CTL_SUBRIGHT, wxT("Right: "), wxDefaultPosition, wxDefaultSize, wxBU_LEFT);
+
+ sCStick[i]->Add(m_CStickUp[i], 0, wxEXPAND|wxALL);
+ sCStick[i]->Add(m_CStickDown[i], 0, wxEXPAND|wxALL);
+ sCStick[i]->Add(m_CStickLeft[i], 0, wxEXPAND|wxALL);
+ sCStick[i]->Add(m_CStickRight[i], 0, wxEXPAND|wxALL);
+
+ sPage[i] = new wxGridBagSizer(0, 0);
+ sPage[i]->SetFlexibleDirection(wxBOTH);
+ sPage[i]->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
+ sPage[i]->Add(sDevice[i], wxGBPosition(0, 0), wxGBSpan(1, 5), wxEXPAND|wxALL, 1);
+ sPage[i]->Add(sButtons[i], wxGBPosition(1, 0), wxGBSpan(3, 1), wxALL, 1);
+ sPage[i]->Add(sTriggerL[i], wxGBPosition(1, 1), wxGBSpan(1, 1), wxALL, 1);
+ sPage[i]->Add(sTriggerR[i], wxGBPosition(2, 1), wxGBSpan(1, 1), wxALL, 1);
+ sPage[i]->Add(sStick[i], wxGBPosition(1, 2), wxGBSpan(2, 1), wxALL, 1);
+ sPage[i]->Add(sDPad[i], wxGBPosition(1, 3), wxGBSpan(2, 1), wxALL, 1);
+ sPage[i]->Add(sCStick[i], wxGBPosition(1, 4), wxGBSpan(2, 1), wxALL, 1);
+ m_Controller[i]->SetSizer(sPage[i]);
+ sPage[i]->Layout();
+ }
+
+ clickedButton->Connect(wxID_ANY, wxEVT_KEY_DOWN,
+ wxKeyEventHandler(ConfigDialog::OnKeyDown),
+ (wxObject*)NULL, this);
+ SetIcon(wxNullIcon);
+ Fit();
+}
+
+void ConfigDialog::OnClose(wxCloseEvent& event)
+{
+ EndModal(0);
+}
+void ConfigDialog::OnKeyDown(wxKeyEvent& event)
+{
+ if(clickedButton != NULL)
+ {
+ int page = m_Notebook->GetSelection();
+ pad[page].keyForControl[clickedButton->GetId()] = event.GetKeyCode();
+ clickedButton->SetLabel(wxString::Format(wxT("%i"), event.GetKeyCode()));
+ }
+ //this is here to see if the event gets processed at all...so far, it doesn't
+ m_ButtonA[0]->SetLabel(wxString::Format(wxT("%i"), event.GetKeyCode()));
+ //clickedButton = NULL;
+ event.Skip();
+}
+void ConfigDialog::OnCloseClick(wxCommandEvent& event)
+{
+ Close();
+}
+
+void ConfigDialog::AttachedCheck(wxCommandEvent& event)
+{
+ int page = m_Notebook->GetSelection();
+ pad[page].attached = m_Attached[page]->GetValue();
+}
+
+void ConfigDialog::DisableCheck(wxCommandEvent& event)
+{
+ int page = m_Notebook->GetSelection();
+ pad[page].disable = m_Disable[page]->GetValue();
+}
+
+void ConfigDialog::RumbleCheck(wxCommandEvent& event)
+{
+ int page = m_Notebook->GetSelection();
+ pad[page].rumble = m_Rumble[page]->GetValue();
+}
+
+void ConfigDialog::OnButtonClick(wxCommandEvent& event)
+{
+ clickedButton = (wxButton *)event.GetEventObject();
+ //wxString oldLabel = clickedButton->GetLabel();
+ clickedButton->SetLabel(wxString::FromAscii("Press Key"));
+
+ //clickedButton->SetLabel(wxString::Format(wxT("%i"), keyPress));
+
+ //clickedButton->SetLabel(wxString::Format(wxT("%s %i"), oldLabel, keyPress));
+
+}
diff --git a/Source/Plugins/Plugin_PadSimple/Src/GUI/ConfigDlg.h b/Source/Plugins/Plugin_PadSimple/Src/GUI/ConfigDlg.h
new file mode 100644
index 0000000000..b71bdc6a4a
--- /dev/null
+++ b/Source/Plugins/Plugin_PadSimple/Src/GUI/ConfigDlg.h
@@ -0,0 +1,125 @@
+// Copyright (C) 2003-2008 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+
+#ifndef __CONFIGDIALOG_h__
+#define __CONFIGDIALOG_h__
+
+#include <wx/wx.h>
+#include <wx/dialog.h>
+#include <wx/textctrl.h>
+#include <wx/button.h>
+#include <wx/stattext.h>
+#include <wx/combobox.h>
+#include <wx/checkbox.h>
+#include <wx/notebook.h>
+#include <wx/panel.h>
+#include <wx/gbsizer.h>
+
+
+#undef CONFIGDIALOG_STYLE
+#define CONFIGDIALOG_STYLE wxCAPTION | wxSYSTEM_MENU | wxDIALOG_NO_PARENT | wxCLOSE_BOX
+
+
+class ConfigDialog : public wxDialog
+{
+ private:
+ DECLARE_EVENT_TABLE();
+
+ public:
+ ConfigDialog(wxWindow *parent, wxWindowID id = 1, const wxString &title = wxT("Pad Configuration"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = CONFIGDIALOG_STYLE);
+ virtual ~ConfigDialog();
+
+ //private:
+ wxNotebook *m_Notebook;
+ wxPanel *m_Controller[4];
+ wxButton *m_Close;
+
+ wxStaticBoxSizer *sDevice[4];
+ wxBoxSizer *sDeviceTop[4];
+ wxBoxSizer *sDeviceBottom[4];
+ wxGridBagSizer* sPage[4];
+ wxStaticBoxSizer *sButtons[4];
+ wxStaticBoxSizer *sTriggerL[4];
+ wxStaticBoxSizer *sTriggerR[4];
+ wxStaticBoxSizer *sStick[4];
+ wxStaticBoxSizer *sCStick[4];
+ wxStaticBoxSizer *sDPad[4];
+
+ wxChoice *m_DeviceName[4];
+ wxCheckBox *m_Attached[4];
+ wxCheckBox *m_Disable[4];
+ wxCheckBox *m_Rumble[4];
+
+ wxButton *m_ButtonA[4];
+ wxButton *m_ButtonB[4];
+ wxButton *m_ButtonX[4];
+ wxButton *m_ButtonY[4];
+ wxButton *m_ButtonZ[4];
+ wxButton *m_ButtonStart[4];
+ wxButton *m_TriggerL[4];
+ wxButton *m_ButtonL[4];
+ wxButton *m_TriggerR[4];
+ wxButton *m_ButtonR[4];
+ wxButton *m_StickUp[4];
+ wxButton *m_StickDown[4];
+ wxButton *m_StickLeft[4];
+ wxButton *m_StickRight[4];
+ wxButton *m_CStickUp[4];
+ wxButton *m_CStickDown[4];
+ wxButton *m_CStickLeft[4];
+ wxButton *m_CStickRight[4];
+ wxButton *m_DPadUp[4];
+ wxButton *m_DPadDown[4];
+ wxButton *m_DPadLeft[4];
+ wxButton *m_DPadRight[4];
+
+ private:
+
+ enum
+ {
+ ////GUI Enum Control ID Start
+ ID_CLOSE = 1000,
+ ID_NOTEBOOK,
+ ID_CONTROLLERPAGE1,
+ ID_CONTROLLERPAGE2,
+ ID_CONTROLLERPAGE3,
+ ID_CONTROLLERPAGE4,
+
+ ID_DEVICENAME,
+ ID_ATTACHED,
+ ID_DISABLE,
+ ID_RUMBLE,
+
+ ID_DUMMY_VALUE_ //don't remove this value unless you have other enum values
+ };
+
+ private:
+ void OnClose(wxCloseEvent& event);
+ void CreateGUIControls();
+ void OnCloseClick(wxCommandEvent& event);
+ void OnKeyDown(wxKeyEvent& event);
+ void AttachedCheck(wxCommandEvent& event);
+ void DisableCheck(wxCommandEvent& event);
+ void RumbleCheck(wxCommandEvent& event);
+ void OnButtonClick(wxCommandEvent& event);
+
+ int keyPress;
+ wxButton *clickedButton;
+ /*DInput m_dinput;*/
+};
+
+#endif
diff --git a/Source/Plugins/Plugin_PadSimple/Src/PadSimple.cpp b/Source/Plugins/Plugin_PadSimple/Src/PadSimple.cpp
new file mode 100644
index 0000000000..59a01e77cd
--- /dev/null
+++ b/Source/Plugins/Plugin_PadSimple/Src/PadSimple.cpp
@@ -0,0 +1,733 @@
+// Copyright (C) 2003-2008 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+
+#ifdef _WIN32
+#define XINPUT_ENABLE
+#endif
+
+#include <stdio.h>
+#include <math.h>
+#include <wx/aboutdlg.h>
+
+#include "Common.h"
+#include "pluginspecs_pad.h"
+#include "PadSimple.h"
+#include "IniFile.h"
+
+#include "GUI/ConfigDlg.h"
+
+#ifdef XINPUT_ENABLE
+#include "XInput.h"
+#endif
+
+#ifdef _WIN32
+
+#include "DirectInputBase.h"
+
+DInput dinput;
+
+#else
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/keysym.h>
+
+Display* GXdsp;
+bool KeyStatus[23];
+#endif
+
+SPads pad[4];
+
+HINSTANCE g_hInstance;
+SPADInitialize g_PADInitialize;
+
+#define RECORD_SIZE (1024 * 128)
+SPADStatus recordBuffer[RECORD_SIZE];
+int count = 0;
+
+void RecordInput(const SPADStatus& _rPADStatus)
+{
+ if (count >= RECORD_SIZE)
+ {
+ return;
+ }
+
+ recordBuffer[count++] = _rPADStatus;
+}
+
+
+const SPADStatus& PlayRecord()
+{
+ if (count >= RECORD_SIZE){return(recordBuffer[0]);}
+
+ return(recordBuffer[count++]);
+}
+
+
+void LoadRecord()
+{
+ FILE* pStream = fopen("c:\\pad-record.bin", "rb");
+
+ if (pStream != NULL)
+ {
+ fread(recordBuffer, 1, RECORD_SIZE * sizeof(SPADStatus), pStream);
+ fclose(pStream);
+ }
+}
+
+
+void SaveRecord()
+{
+ FILE* pStream = fopen("c:\\pad-record.bin", "wb");
+
+ if (pStream != NULL)
+ {
+ fwrite(recordBuffer, 1, RECORD_SIZE * sizeof(SPADStatus), pStream);
+ fclose(pStream);
+ }
+}
+
+
+#ifdef _WIN32
+
+class wxDLLApp : public wxApp
+{
+ bool OnInit()
+ {
+ return true;
+ }
+};
+IMPLEMENT_APP_NO_MAIN(wxDLLApp)
+
+WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst);
+
+BOOL APIENTRY DllMain(HINSTANCE hinstDLL, // DLL module handle
+ DWORD dwReason, // reason called
+ LPVOID lpvReserved) // reserved
+{
+ switch (dwReason)
+ {
+ case DLL_PROCESS_ATTACH:
+ { //use wxInitialize() if you don't want GUI instead of the following 12 lines
+ wxSetInstance((HINSTANCE)hinstDLL);
+ int argc = 0;
+ char **argv = NULL;
+ wxEntryStart(argc, argv);
+ if ( !wxTheApp || !wxTheApp->CallOnInit() )
+ return FALSE;
+ }
+ break;
+
+ case DLL_PROCESS_DETACH:
+ wxEntryCleanup(); //use wxUninitialize() if you don't want GUI
+ break;
+ default:
+ break;
+ }
+
+ g_hInstance = hinstDLL;
+ return(TRUE);
+}
+
+#endif
+
+
+void GetDllInfo(PLUGIN_INFO* _PluginInfo)
+{
+ _PluginInfo->Version = 0x0100;
+ _PluginInfo->Type = PLUGIN_TYPE_PAD;
+
+#ifdef DEBUGFAST
+ sprintf(_PluginInfo->Name, "Dolphin KB/X360pad (DebugFast)");
+#else
+#ifndef _DEBUG
+ sprintf(_PluginInfo->Name, "Dolphin KB/X360pad");
+#else
+ sprintf(_PluginInfo->Name, "Dolphin KB/X360pad (Debug)");
+#endif
+#endif
+
+}
+
+
+void DllAbout(HWND _hParent)
+{
+ wxAboutDialogInfo info;
+ info.AddDeveloper(_T("ector"));
+ info.AddDeveloper(_T("F|RES"));
+ info.SetDescription(_T("Simple keyboard and XInput plugin for dolphin"));
+ wxAboutBox(info);
+}
+
+
+void DllConfig(HWND _hParent)
+{
+ LoadConfig();
+#ifdef _WIN32
+ wxWindow win;
+ win.SetHWND(_hParent);
+ ConfigDialog frame(&win);
+ frame.ShowModal();
+ win.SetHWND(0);
+#else
+ ConfigDialog frame(NULL);
+ frame.ShowModal();
+#endif
+ SaveConfig();
+}
+
+
+void PAD_Initialize(SPADInitialize _PADInitialize)
+{
+#ifdef RECORD_REPLAY
+ LoadRecord();
+#endif
+
+ g_PADInitialize = _PADInitialize;
+#ifdef _WIN32
+ dinput.Init((HWND)g_PADInitialize.hWnd);
+#else
+ GXdsp = (Display*)g_PADInitialize.hWnd;
+#endif
+
+ LoadConfig();
+}
+
+
+void PAD_Shutdown()
+{
+#ifdef RECORD_STORE
+ SaveRecord();
+#endif
+#ifdef _WIN32
+ dinput.Free();
+#endif
+ SaveConfig();
+}
+
+
+const float kDeadZone = 0.1f;
+
+// Implement circular deadzone
+void ScaleStickValues(unsigned char* outx,
+ unsigned char* outy,
+ short inx, short iny)
+{
+ float x = ((float)inx + 0.5f) / 32767.5f;
+ float y = ((float)iny + 0.5f) / 32767.5f;
+
+ if ((x == 0.0f) && (y == 0.0f)) // to be safe
+ {
+ *outx = 0;
+ *outy = 0;
+ return;
+ }
+
+ float magnitude = sqrtf(x * x + y * y);
+ float nx = x / magnitude;
+ float ny = y / magnitude;
+
+ if (magnitude < kDeadZone){magnitude = kDeadZone;}
+
+ magnitude = (magnitude - kDeadZone) / (1.0f - kDeadZone);
+ magnitude *= magnitude; // another power may be more appropriate
+ nx *= magnitude;
+ ny *= magnitude;
+ int ix = (int)(nx * 100);
+ int iy = (int)(ny * 100);
+ *outx = 0x80 + ix;
+ *outy = 0x80 + iy;
+}
+
+
+#ifdef _WIN32
+void DInput_Read(int _numPad, SPADStatus* _pPADStatus)
+{
+ /*We can do all now :D
+ if (_numPad != 0)
+ {
+ return;
+ }*/
+
+ dinput.Read();
+
+ int mainvalue = (dinput.diks[pad[_numPad].keyForControl[CTL_HALFMAIN]] & 0xFF) ? 40 : 100;
+ int subvalue = (dinput.diks[pad[_numPad].keyForControl[CTL_HALFSUB]] & 0xFF) ? 40 : 100;
+ int triggervalueL = (dinput.diks[pad[_numPad].keyForControl[CTL_TRIGGER_L]] & 0xFF) ? 100 : 255;
+ int triggervalueR = (dinput.diks[pad[_numPad].keyForControl[CTL_TRIGGER_R]] & 0xFF) ? 100 : 255;
+
+ // get the new keys
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_MAINLEFT]] & 0xFF){_pPADStatus->stickX -= mainvalue;}
+
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_MAINRIGHT]] & 0xFF){_pPADStatus->stickX += mainvalue;}
+
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_MAINDOWN]] & 0xFF){_pPADStatus->stickY -= mainvalue;}
+
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_MAINUP]] & 0xFF){_pPADStatus->stickY += mainvalue;}
+
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_SUBLEFT]] & 0xFF){_pPADStatus->substickX -= subvalue;}
+
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_SUBRIGHT]] & 0xFF){_pPADStatus->substickX += subvalue;}
+
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_SUBDOWN]] & 0xFF){_pPADStatus->substickY -= subvalue;}
+
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_SUBUP]] & 0xFF){_pPADStatus->substickY += subvalue;}
+
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_L]] & 0xFF)
+ {
+ _pPADStatus->button |= PAD_TRIGGER_L;
+ _pPADStatus->triggerLeft = triggervalueL;
+ }
+
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_R]] & 0xFF)
+ {
+ _pPADStatus->button |= PAD_TRIGGER_R;
+ _pPADStatus->triggerRight = triggervalueR;
+ }
+
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_A]] & 0xFF)
+ {
+ _pPADStatus->button |= PAD_BUTTON_A;
+ _pPADStatus->analogA = 255;
+ }
+
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_B]] & 0xFF)
+ {
+ _pPADStatus->button |= PAD_BUTTON_B;
+ _pPADStatus->analogB = 255;
+ }
+
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_X]] & 0xFF){_pPADStatus->button |= PAD_BUTTON_X;}
+
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_Y]] & 0xFF){_pPADStatus->button |= PAD_BUTTON_Y;}
+
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_Z]] & 0xFF){_pPADStatus->button |= PAD_TRIGGER_Z;}
+
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_DPADUP]] & 0xFF){_pPADStatus->button |= PAD_BUTTON_UP;}
+
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_DPADDOWN]] & 0xFF){_pPADStatus->button |= PAD_BUTTON_DOWN;}
+
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_DPADLEFT]] & 0xFF){_pPADStatus->button |= PAD_BUTTON_LEFT;}
+
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_DPADRIGHT]] & 0xFF){_pPADStatus->button |= PAD_BUTTON_RIGHT;}
+
+ if (dinput.diks[pad[_numPad].keyForControl[CTL_START]] & 0xFF){_pPADStatus->button |= PAD_BUTTON_START;}
+}
+
+void XInput_Read(int _numPAD, SPADStatus* _pPADStatus)
+{
+#ifdef XINPUT_ENABLE
+ const int base = 0x80;
+ XINPUT_STATE xstate;
+ DWORD xresult = XInputGetState(_numPAD, &xstate);
+
+ if ((xresult != ERROR_SUCCESS) && (_numPAD != 0))
+ {
+ return;
+ }
+
+ // In addition, let's .. yes, let's use XINPUT!
+ if (xresult == ERROR_SUCCESS)
+ {
+ const XINPUT_GAMEPAD& pad = xstate.Gamepad;
+
+ if ((_pPADStatus->stickX == base) && (_pPADStatus->stickY == base))
+ {
+ ScaleStickValues(
+ &_pPADStatus->stickX,
+ &_pPADStatus->stickY,
+ pad.sThumbLX,
+ pad.sThumbLY);
+ }
+
+ if ((_pPADStatus->substickX == base) && (_pPADStatus->substickY == base))
+ {
+ ScaleStickValues(
+ &_pPADStatus->substickX,
+ &_pPADStatus->substickY,
+ pad.sThumbRX,
+ pad.sThumbRY);
+ }
+
+ _pPADStatus->triggerLeft = pad.bLeftTrigger;
+ _pPADStatus->triggerRight = pad.bRightTrigger;
+
+ if (pad.bLeftTrigger > 20){_pPADStatus->button |= PAD_TRIGGER_L;}
+
+ if (pad.bRightTrigger > 20){_pPADStatus->button |= PAD_TRIGGER_R;}
+
+ if (pad.wButtons & XINPUT_GAMEPAD_A){_pPADStatus->button |= PAD_BUTTON_A;}
+
+ if (pad.wButtons & XINPUT_GAMEPAD_X){_pPADStatus->button |= PAD_BUTTON_B;}
+
+ if (pad.wButtons & XINPUT_GAMEPAD_B){_pPADStatus->button |= PAD_BUTTON_X;}
+
+ if (pad.wButtons & XINPUT_GAMEPAD_Y){_pPADStatus->button |= PAD_BUTTON_Y;}
+
+ if (pad.wButtons & XINPUT_GAMEPAD_RIGHT_SHOULDER){_pPADStatus->button |= PAD_TRIGGER_Z;}
+
+ if (pad.wButtons & XINPUT_GAMEPAD_START){_pPADStatus->button |= PAD_BUTTON_START;}
+
+ if (pad.wButtons & XINPUT_GAMEPAD_DPAD_LEFT){_pPADStatus->button |= PAD_BUTTON_LEFT;}
+
+ if (pad.wButtons & XINPUT_GAMEPAD_DPAD_RIGHT){_pPADStatus->button |= PAD_BUTTON_RIGHT;}
+
+ if (pad.wButtons & XINPUT_GAMEPAD_DPAD_UP){_pPADStatus->button |= PAD_BUTTON_UP;}
+
+ if (pad.wButtons & XINPUT_GAMEPAD_DPAD_DOWN){_pPADStatus->button |= PAD_BUTTON_DOWN;}
+ }
+#endif
+
+}
+
+
+#endif
+
+#if defined(__linux__)
+// The graphics plugin in the PCSX2 design leaves a lot of the window processing to the pad plugin, weirdly enough.
+void X11_Read(int _numPAD, SPADStatus* _pPADStatus)
+{
+ // Do all the stuff we need to do once per frame here
+ if (_numPAD != 0)
+ {
+ return;
+ }
+ int i;
+ // This code is from Zerofrog's pcsx2 pad plugin
+ XEvent E;
+ //int keyPress=0, keyRelease=0;
+ KeySym key;
+
+ // keyboard input
+ while (XPending(GXdsp) > 0) {
+
+ XNextEvent(GXdsp, &E);
+
+ switch (E.type) {
+ case KeyPress:
+ //_KeyPress(pad, XLookupKeysym((XKeyEvent *)&E, 0)); break;
+ key = XLookupKeysym((XKeyEvent*)&E, 0);
+
+ for (i = 0; i < NUMCONTROLS; i++) {
+ if (key == pad[_numPAD].keyForControl[i]) {
+ KeyStatus[i] = true;
+ break;
+ }
+ }
+ break;
+
+ case KeyRelease:
+ key = XLookupKeysym((XKeyEvent*)&E, 0);
+
+ //_KeyRelease(pad, XLookupKeysym((XKeyEvent *)&E, 0));
+ for (i = 0; i < NUMCONTROLS; i++) {
+ if (key == pad[_numPAD].keyForControl[i]) {
+ KeyStatus[i] = false;
+ break;
+ }
+ }
+ break;
+
+ case FocusIn:
+ XAutoRepeatOff(GXdsp);
+ break;
+
+ case FocusOut:
+ XAutoRepeatOn(GXdsp);
+ break;
+ }
+ }
+
+ int mainvalue = (KeyStatus[20]) ? 40 : 100;
+ int subvalue = (KeyStatus[21]) ? 40 : 100;
+ int triggervalue = (KeyStatus[23]) ? 100 : 255;
+
+ if (KeyStatus[0]){_pPADStatus->stickX -= mainvalue;}
+ if (KeyStatus[1]){_pPADStatus->stickY += mainvalue;}
+ if (KeyStatus[2]){_pPADStatus->stickX += mainvalue;}
+ if (KeyStatus[3]){_pPADStatus->stickY -= mainvalue;}
+
+ if (KeyStatus[4]){_pPADStatus->substickX -= subvalue;}
+ if (KeyStatus[5]){_pPADStatus->substickY += subvalue;}
+ if (KeyStatus[6]){_pPADStatus->substickX += subvalue;}
+ if (KeyStatus[7]){_pPADStatus->substickY -= subvalue;}
+
+ if (KeyStatus[8]){_pPADStatus->button |= PAD_BUTTON_LEFT;}
+ if (KeyStatus[9]){_pPADStatus->button |= PAD_BUTTON_UP;}
+ if (KeyStatus[10]){_pPADStatus->button |= PAD_BUTTON_RIGHT;}
+ if (KeyStatus[11]){_pPADStatus->button |= PAD_BUTTON_DOWN;}
+
+ if (KeyStatus[12]) {
+ _pPADStatus->button |= PAD_BUTTON_A;
+ _pPADStatus->analogA = 255;
+ }
+
+ if (KeyStatus[13]) {
+ _pPADStatus->button |= PAD_BUTTON_B;
+ _pPADStatus->analogB = 255;
+ }
+
+ if (KeyStatus[14]){_pPADStatus->button |= PAD_BUTTON_X;}
+ if (KeyStatus[15]){_pPADStatus->button |= PAD_BUTTON_Y;}
+ if (KeyStatus[16]){_pPADStatus->button |= PAD_TRIGGER_Z;}
+
+ if (KeyStatus[17]) {
+ _pPADStatus->button |= PAD_TRIGGER_L;
+ _pPADStatus->triggerLeft = triggervalue;
+ }
+
+ if (KeyStatus[18]) {
+ _pPADStatus->button |= PAD_TRIGGER_R;
+ _pPADStatus->triggerRight = triggervalue;
+ }
+
+ if (KeyStatus[19]){_pPADStatus->button |= PAD_BUTTON_START;}
+}
+
+
+#endif
+
+void PAD_GetStatus(u8 _numPAD, SPADStatus* _pPADStatus)
+{
+ // check if all is okay
+ if ((_pPADStatus == NULL))
+ {
+ return;
+ }
+
+#ifdef RECORD_REPLAY
+ *_pPADStatus = PlayRecord();
+ return;
+#endif
+
+
+
+
+ const int base = 0x80;
+ // clear pad
+ memset(_pPADStatus, 0, sizeof(SPADStatus));
+
+ _pPADStatus->stickY = base;
+ _pPADStatus->stickX = base;
+ _pPADStatus->substickX = base;
+ _pPADStatus->substickY = base;
+ _pPADStatus->button |= PAD_USE_ORIGIN;
+#ifdef _WIN32
+ // just update pad on focus
+ //if (g_PADInitialize.hWnd != ::GetForegroundWindow())
+ // return;
+#endif
+ _pPADStatus->err = PAD_ERR_NONE;
+
+ // keyboard is hardwired to player 1.
+#ifdef _WIN32
+ DInput_Read(_numPAD, _pPADStatus);
+ XInput_Read(_numPAD, _pPADStatus);
+#elif defined(__linux__)
+ X11_Read(_numPAD, _pPADStatus);
+#endif
+
+#ifdef RECORD_STORE
+ RecordInput(*_pPADStatus);
+#endif
+}
+
+
+// Rough approximation of GC behaviour - needs improvement.
+void PAD_Rumble(u8 _numPAD, unsigned int _uType, unsigned int _uStrength)
+{
+#ifdef _WIN32
+ static int a = 0;
+
+ if ((_uType == 0) || (_uType == 2))
+ {
+ a = 0;
+ }
+ else if (_uType == 1)
+ {
+ a = _uStrength > 2 ? 8000 : 0;
+ }
+
+ a = int ((float)a * 0.96f);
+
+ if (!pad[_numPAD].rumble)
+ {
+ a = 0;
+ }
+
+#ifdef XINPUT_ENABLE
+ XINPUT_VIBRATION vib;
+ vib.wLeftMotorSpeed = a; //_uStrength*100;
+ vib.wRightMotorSpeed = a; //_uStrength*100;
+ XInputSetState(_numPAD, &vib);
+#endif
+#endif
+}
+
+unsigned int PAD_GetAttachedPads()
+{
+ unsigned int connected = 0;
+
+ LoadConfig();
+
+ if(pad[0].attached)
+ connected |= 1;
+ if(pad[1].attached)
+ connected |= 2;
+ if(pad[2].attached)
+ connected |= 4;
+ if(pad[3].attached)
+ connected |= 8;
+
+ return connected;
+}
+
+
+unsigned int SaveLoadState(char* _ptr, BOOL _bSave)
+{
+ return(0);
+}
+
+
+void LoadConfig()
+{
+ // Initialize pads to standard controls
+#ifdef _WIN32
+ const int defaultKeyForControl[NUMCONTROLS] =
+ {
+ DIK_X, //A
+ DIK_Z,
+ DIK_S,
+ DIK_C,
+ DIK_D,
+ DIK_RETURN,
+ DIK_Q,
+ DIK_LCONTROL,
+ DIK_W,
+ DIK_LCONTROL,
+ DIK_UP, //mainstick
+ DIK_DOWN,
+ DIK_LEFT,
+ DIK_RIGHT,
+ DIK_LSHIFT,
+ DIK_I, //substick
+ DIK_K,
+ DIK_J,
+ DIK_L,
+ DIK_LSHIFT,
+ DIK_T, //dpad
+ DIK_G,
+ DIK_F,
+ DIK_H
+ };
+#else
+ const int defaultKeyForControl[NUMCONTROLS] =
+ {
+ XK_Left, //mainstick
+ XK_Up,
+ XK_Right,
+ XK_Down,
+ XK_j, //substick
+ XK_i,
+ XK_l,
+ XK_k,
+ XK_f, //dpad
+ XK_t,
+ XK_h,
+ XK_g,
+ XK_x, //buttons
+ XK_z,
+ XK_s,
+ XK_c,
+ XK_d,
+ XK_q,
+ XK_w,
+ XK_Return,
+ XK_Shift_L,
+ XK_Shift_L,
+ XK_Control_L
+ };
+#endif
+ IniFile file;
+ file.Load("pad.ini");
+
+ for(int i = 0; i < 4; i++)
+ {
+ char SectionName[32];
+ sprintf(SectionName, "PAD%i", i+1);
+
+ if(pad[i].type == 0)
+ {
+ //keyboard settings
+ file.Get(SectionName, "Type", &pad[i].type);
+ file.Get(SectionName, "Attached", &pad[i].attached, false);
+ file.Get(SectionName, "Disable when window looses focus", &pad[i].disable, false);
+
+ for (int x = 0; x < NUMCONTROLS; x++)
+ {
+ file.Get(SectionName, controlNames[x], &pad[i].keyForControl[x], defaultKeyForControl[x]);
+ }
+ }
+ else
+ {
+ //xpad settings
+ file.Get(SectionName, "Type", &pad[i].type);
+ file.Get(SectionName, "Attached", &pad[i].attached, false);
+ file.Get(SectionName, "Disable when window looses focus", &pad[i].disable, false);
+ file.Get(SectionName, "Rumble", &pad[i].rumble, true);
+ file.Get(SectionName, "XPad#", &pad[i].XPad);
+ }
+ }
+}
+
+
+void SaveConfig()
+{
+ IniFile file;
+ file.Load("pad.ini");
+
+ for(int i = 0; i < 4; i++)
+ {
+ char SectionName[32];
+ sprintf(SectionName, "PAD%i", i+1);
+
+ if(pad[i].type == 0)
+ {
+ //keyboard settings
+ file.Set(SectionName, "Type", pad[i].type);
+ file.Set(SectionName, "Attached", pad[i].attached);
+ file.Set(SectionName, "Disable when window looses focus", pad[i].disable);
+
+ for (int x = 0; x < NUMCONTROLS; x++)
+ {
+ file.Set(SectionName, controlNames[x], pad[i].keyForControl[x]);
+ }
+ }
+ else
+ {
+ //xpad settings
+ file.Set(SectionName, "Type", pad[i].type);
+ file.Set(SectionName, "Attached", pad[i].attached);
+ file.Set(SectionName, "Disable when window looses focus", pad[i].disable);
+ file.Set(SectionName, "Rumble", pad[i].rumble);
+ file.Set(SectionName, "XPad#", pad[i].XPad);
+ }
+ }
+ file.Save("pad.ini");
+}
+
+
diff --git a/Source/Plugins/Plugin_PadSimple/Src/PadSimple.h b/Source/Plugins/Plugin_PadSimple/Src/PadSimple.h
new file mode 100644
index 0000000000..45911afd2c
--- /dev/null
+++ b/Source/Plugins/Plugin_PadSimple/Src/PadSimple.h
@@ -0,0 +1,89 @@
+// Copyright (C) 2003-2008 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+
+// controls
+enum
+{
+ CTL_A = 0,
+ CTL_B,
+ CTL_X,
+ CTL_Y,
+ CTL_Z,
+ CTL_START,
+ CTL_TRIGGER_L,
+ CTL_L,
+ CTL_TRIGGER_R,
+ CTL_R,
+ CTL_MAINUP,
+ CTL_MAINDOWN,
+ CTL_MAINLEFT,
+ CTL_MAINRIGHT,
+ CTL_HALFMAIN,
+ CTL_SUBUP,
+ CTL_SUBDOWN,
+ CTL_SUBLEFT,
+ CTL_SUBRIGHT,
+ CTL_HALFSUB,
+ CTL_DPADUP,
+ CTL_DPADDOWN,
+ CTL_DPADLEFT,
+ CTL_DPADRIGHT,
+ NUMCONTROLS
+};
+
+// control names
+static const char* controlNames[] =
+{
+ "A_button",
+ "B_button",
+ "X_button",
+ "Y_button",
+ "Z_trigger",
+ "Start",
+ "Soft_triggerL_switch",
+ "L_button",
+ "Soft_triggerR_switch",
+ "R_button",
+ "Main_stick_up",
+ "Main_stick_down",
+ "Main_stick_left",
+ "Main_stick_right",
+ "Soft_main_switch",
+ "Sub_stick_up",
+ "Sub_stick_down",
+ "Sub_stick_left",
+ "Sub_stick_right",
+ "Soft_sub_switch",
+ "D-Pad_up",
+ "D-Pad_down",
+ "D-Pad_left",
+ "D-Pad_right",
+};
+
+struct SPads {
+ bool type; //keyboard = 0, xpad = 1
+ int XPad; //player# of the xpad
+ bool attached; //pad is "attached" to the gamecube/wii
+ bool disable; //disabled when dolphin isn't in focus
+ bool rumble; //rumble for xpad
+ unsigned int keyForControl[NUMCONTROLS];//keyboard mapping
+};
+
+extern SPads pad[];
+
+void LoadConfig();
+void SaveConfig();
diff --git a/Source/Plugins/Plugin_PadSimple/Src/SConscript b/Source/Plugins/Plugin_PadSimple/Src/SConscript
index 7540cc73a6..1e500b2e00 100644
--- a/Source/Plugins/Plugin_PadSimple/Src/SConscript
+++ b/Source/Plugins/Plugin_PadSimple/Src/SConscript
@@ -9,7 +9,8 @@ else:
output = "../../../../Binary/linux/Plugins/padsimple.so"
files = [
- "main.cpp",
+ "PadSimple.cpp",
+ "GUI/ConfigDlg.cpp",
]
padenv = env.Clone()
generated by cgit v1.2.3 (git 2.25.1) at 2026-09-14 14:42:27 +0000