Start of converting the plugin to use wxwindows

still not working


git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@638 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
nakeee 2008-09-23 09:28:37 +00:00
parent 65d59e8d6a
commit 385e3276bb
9 changed files with 1203 additions and 326 deletions

View File

@ -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);
}

View File

@ -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*/);
};

View File

@ -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);
}

View File

@ -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);
};

View File

@ -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));
}

View File

@ -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

View File

@ -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");
}

View File

@ -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();

View File

@ -9,7 +9,8 @@ else:
output = "../../../../Binary/linux/Plugins/padsimple.so" output = "../../../../Binary/linux/Plugins/padsimple.so"
files = [ files = [
"main.cpp", "PadSimple.cpp",
"GUI/ConfigDlg.cpp",
] ]
padenv = env.Clone() padenv = env.Clone()