ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

nJoy: Improvements to the configuration, the SaveById option should now be simpler and better 

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1977 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
John Peterson 2009-01-21 18:09:31 +00:00
parent 1b12bc38ac
commit 7f9dc55fbc
9 changed files with 439 additions and 435 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

278
Source/Plugins/Plugin_nJoy_SDL/Src/Config.cpp
View File

@ -30,21 +30,23 @@
////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////
//////////////////////// ///////////////////////////////////////////////////////////////////////
// Include // Include
// ¯¯¯¯¯¯¯¯¯ // ¯¯¯¯¯¯¯¯¯
#include "nJoy.h" #include "nJoy.h"
#include "Common.h" #include "Common.h"
Config g_Config; Config g_Config;
extern ConfigBox* m_frame;
//////////////////////////////////
// Run when created
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
Config::Config() Config::Config()
{ {
//memset(this, 0, sizeof(Config)); // Clear the memory // Clear the memory
//memset(this, 0, sizeof(Config));
bSaveByID.resize(4); // Set vector size
bSquareToCircle.resize(4);
SDiagonal.resize(4);
} }
@ -88,147 +90,83 @@ void DEBUG_QUIT()
} }
/* Check for duplicate Joypad names. If we find a duplicate notify the user about it. */ /////////////////////////////////////////////////////////////////////////////////////
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
int Config::CheckForDuplicateJoypads(bool OK)
{
// Count the number of duplicate names
int NumDuplicates = 0, Duplicate = 0;
for(u32 i = 0; i < 4; i++)
{
for(u32 j = 0; j < 4; j++)
{
// Avoid potential crash
if(joysticks[i].ID >= SDL_NumJoysticks() || joysticks[j].ID >= SDL_NumJoysticks()) continue;
if (i == j) continue; // Don't compare to itself
if (! memcmp(&joyinfo[joysticks[i].ID], &joyinfo[joysticks[j].ID], sizeof(joyinfo)))
{
// If one of them is not enabled, then there is no problem
if(!joysticks[i].enabled || !joysticks[j].enabled) continue;
// If oen of them don't save by ID, then there is no problem
if(!g_Config.bSaveByID.at(i) || !g_Config.bSaveByID.at(j)) continue;
//PanicAlert("%i %i", i, j);
NumDuplicates++;
Duplicate = i;
}
}
}
/////////////////////////////////////////////////////////////////////////
// Notify the user about the multiple devices
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
if(NumDuplicates > 0)
{
std::string ExtendedText;
std::string MainText =
"You have selected SaveByID for several identical joypads with the name '%s', because nJoy"
" has no way of separating between them the settings for the last one will now be saved."
" This may not be the settings you have intended to save. It is therefore recommended"
" that you either unselect SaveByID for all but one of the identical joypads"
" or disable them entirely."
" If you are aware of this issue and want to keep the same settings for the identical"
" pads you can ignore this message.";
if (OK) // We got here from the OK button
{
ExtendedText =
"\n\n[Select 'OK' to return to the configuration window. Select 'Cancel' to ignore this"
" message and close the configuration window and don't show this message again.]";
}
else
{
ExtendedText =
"\n\n[Select 'Cancel' if you don't want to see this information again.]";
}
bool ret = PanicYesNo((MainText + ExtendedText).c_str(), joyinfo[joysticks[Duplicate].ID].Name);
if (ret)
g_Config.bSaveByIDNotice = false;
return ret ? 4 : 16;
}
return -1;
}
// Save settings to file // Save settings to file
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
void Config::Save(bool CheckedForDuplicates) void Config::Save(int Slot)
{ {
// Load ini file // Load ini file
IniFile file; IniFile file;
file.Load("nJoy.ini"); file.Load("nJoy.ini");
// Show potential warning // ==================================================================
if(!CheckedForDuplicates && g_Config.bSaveByIDNotice) CheckForDuplicateJoypads(false); // Global settings
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
file.Set("General", "ShowAdvanced", g_Config.bShowAdvanced); file.Set("General", "ShowAdvanced", g_Config.bShowAdvanced);
file.Set("General", "SaveByIDNotice", g_Config.bSaveByIDNotice); file.Set("General", "SaveByID", g_Config.bSaveByID);
// ========================
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
{ {
// Should we save this slot?
if (Slot != -1 && Slot != i) continue;
// ==================================================================
// Slot specific settings only
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
std::string SectionName = StringFromFormat("PAD%i", i+1); std::string SectionName = StringFromFormat("PAD%i", i+1);
file.Set(SectionName.c_str(), "enabled", joysticks[i].enabled); file.Set(SectionName.c_str(), "enabled", PadMapping[i].enabled);
// Save the physical device ID // Save the physical device ID
file.Set(SectionName.c_str(), "joy_id", joysticks[i].ID); file.Set(SectionName.c_str(), "joy_id", PadMapping[i].ID);
file.Set(SectionName.c_str(), "SaveByID", g_Config.bSaveByID.at(i)); // ===================
/* Don't save anything more from the disabled joypads, if a joypad is enabled we can run
this again after any settings are changed for it */
if(!joysticks[i].enabled) continue;
////////////////////////////////////// // ==================================================================
// Save joypad specific settings // Joypad or slot specific settings
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Current joypad device ID: joysticks[i].ID // Current joypad device ID: PadMapping[i].ID
// Current joypad name: joyinfo[joysticks[i].ID].Name // Current joypad name: joyinfo[PadMapping[i].ID].Name
if(g_Config.bSaveByID.at(i)) if(g_Config.bSaveByID)
{ {
/* Save joypad specific settings. Check for "joysticks[i].ID < SDL_NumJoysticks()" to /* Save joypad specific settings. Check for "PadMapping[i].ID < SDL_NumJoysticks()" to
avoid reading a joyinfo that does't exist */ avoid reading a joyinfo that does't exist */
if(joysticks[i].ID >= SDL_NumJoysticks()) continue; if(PadMapping[i].ID >= SDL_NumJoysticks()) continue;
//PanicAlert("%i", m_frame->m_Joyname[0]->GetSelection());
//if(i == 0) PanicAlert("%i", joysticks[i].buttons[CTL_START]);
//PanicAlert("%s", joyinfo[joysticks[i].ID].Name);
// Create a new section name after the joypad name // Create a new section name after the joypad name
SectionName = joyinfo[joysticks[i].ID].Name; SectionName = joyinfo[PadMapping[i].ID].Name;
} }
file.Set(SectionName.c_str(), "l_shoulder", joysticks[i].buttons[CTL_L_SHOULDER]); file.Set(SectionName.c_str(), "l_shoulder", PadMapping[i].buttons[CTL_L_SHOULDER]);
file.Set(SectionName.c_str(), "r_shoulder", joysticks[i].buttons[CTL_R_SHOULDER]); file.Set(SectionName.c_str(), "r_shoulder", PadMapping[i].buttons[CTL_R_SHOULDER]);
file.Set(SectionName.c_str(), "a_button", joysticks[i].buttons[CTL_A_BUTTON]); file.Set(SectionName.c_str(), "a_button", PadMapping[i].buttons[CTL_A_BUTTON]);
file.Set(SectionName.c_str(), "b_button", joysticks[i].buttons[CTL_B_BUTTON]); file.Set(SectionName.c_str(), "b_button", PadMapping[i].buttons[CTL_B_BUTTON]);
file.Set(SectionName.c_str(), "x_button", joysticks[i].buttons[CTL_X_BUTTON]); file.Set(SectionName.c_str(), "x_button", PadMapping[i].buttons[CTL_X_BUTTON]);
file.Set(SectionName.c_str(), "y_button", joysticks[i].buttons[CTL_Y_BUTTON]); file.Set(SectionName.c_str(), "y_button", PadMapping[i].buttons[CTL_Y_BUTTON]);
file.Set(SectionName.c_str(), "z_trigger", joysticks[i].buttons[CTL_Z_TRIGGER]); file.Set(SectionName.c_str(), "z_trigger", PadMapping[i].buttons[CTL_Z_TRIGGER]);
file.Set(SectionName.c_str(), "start_button", joysticks[i].buttons[CTL_START]); file.Set(SectionName.c_str(), "start_button", PadMapping[i].buttons[CTL_START]);
file.Set(SectionName.c_str(), "dpad", joysticks[i].dpad); file.Set(SectionName.c_str(), "dpad", PadMapping[i].dpad);
file.Set(SectionName.c_str(), "dpad_up", joysticks[i].dpad2[CTL_D_PAD_UP]); file.Set(SectionName.c_str(), "dpad_up", PadMapping[i].dpad2[CTL_D_PAD_UP]);
file.Set(SectionName.c_str(), "dpad_down", joysticks[i].dpad2[CTL_D_PAD_DOWN]); file.Set(SectionName.c_str(), "dpad_down", PadMapping[i].dpad2[CTL_D_PAD_DOWN]);
file.Set(SectionName.c_str(), "dpad_left", joysticks[i].dpad2[CTL_D_PAD_LEFT]); file.Set(SectionName.c_str(), "dpad_left", PadMapping[i].dpad2[CTL_D_PAD_LEFT]);
file.Set(SectionName.c_str(), "dpad_right", joysticks[i].dpad2[CTL_D_PAD_RIGHT]); file.Set(SectionName.c_str(), "dpad_right", PadMapping[i].dpad2[CTL_D_PAD_RIGHT]);
file.Set(SectionName.c_str(), "main_x", joysticks[i].axis[CTL_MAIN_X]); file.Set(SectionName.c_str(), "main_x", PadMapping[i].axis[CTL_MAIN_X]);
file.Set(SectionName.c_str(), "main_y", joysticks[i].axis[CTL_MAIN_Y]); file.Set(SectionName.c_str(), "main_y", PadMapping[i].axis[CTL_MAIN_Y]);
file.Set(SectionName.c_str(), "sub_x", joysticks[i].axis[CTL_SUB_X]); file.Set(SectionName.c_str(), "sub_x", PadMapping[i].axis[CTL_SUB_X]);
file.Set(SectionName.c_str(), "sub_y", joysticks[i].axis[CTL_SUB_Y]); file.Set(SectionName.c_str(), "sub_y", PadMapping[i].axis[CTL_SUB_Y]);
file.Set(SectionName.c_str(), "deadzone", joysticks[i].deadzone); file.Set(SectionName.c_str(), "deadzone", PadMapping[i].deadzone);
file.Set(SectionName.c_str(), "halfpress", joysticks[i].halfpress); file.Set(SectionName.c_str(), "halfpress", PadMapping[i].halfpress);
file.Set(SectionName.c_str(), "controllertype", joysticks[i].controllertype); file.Set(SectionName.c_str(), "controllertype", PadMapping[i].controllertype);
file.Set(SectionName.c_str(), "TriggerType", joysticks[i].triggertype); file.Set(SectionName.c_str(), "TriggerType", PadMapping[i].triggertype);
file.Set(SectionName.c_str(), "eventnum", joysticks[i].eventnum); file.Set(SectionName.c_str(), "eventnum", PadMapping[i].eventnum);
file.Set(SectionName.c_str(), "Diagonal", g_Config.SDiagonal.at(i).c_str()); file.Set(SectionName.c_str(), "Diagonal", PadMapping[i].SDiagonal);
file.Set(SectionName.c_str(), "SquareToCircle", g_Config.bSquareToCircle.at(i)); file.Set(SectionName.c_str(), "SquareToCircle", PadMapping[i].bSquareToCircle);
// ======================================
// Debugging
//if(m_frame) m_frame->LogMsg("Saved: %s %i\n", SectionName.c_str(), PadMapping[i].triggertype);
} }
file.Save("nJoy.ini"); file.Save("nJoy.ini");
@ -236,74 +174,82 @@ void Config::Save(bool CheckedForDuplicates)
// Load settings from file // Load settings from file
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
void Config::Load(bool config) void Config::Load(bool ChangePad, bool ChangeSaveByID)
{ {
// Load file
IniFile file; IniFile file;
file.Load("nJoy.ini"); file.Load("nJoy.ini");
std::vector<std::string> Duplicates; bool Tmp; // Tmp storage
// ==================================================================
// Global settings
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
file.Get("General", "ShowAdvanced", &g_Config.bShowAdvanced, false); file.Get("General", "ShowAdvanced", &g_Config.bShowAdvanced, false);
file.Get("General", "SaveByIDNotice", &g_Config.bSaveByIDNotice, true); if(!ChangeSaveByID)
{
file.Get("General", "SaveByID", &Tmp, false); g_Config.bSaveByID = Tmp;
}
// =============
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
{ {
std::string SectionName = StringFromFormat("PAD%i", i+1); std::string SectionName = StringFromFormat("PAD%i", i+1);
// Don't update this when we are loading settings from the ConfigBox // Don't update this when we are loading settings from the ConfigBox
if(!config) if(!ChangePad)
{ {
file.Get(SectionName.c_str(), "joy_id", &joysticks[i].ID, 0); file.Get(SectionName.c_str(), "joy_id", &PadMapping[i].ID, 0);
file.Get(SectionName.c_str(), "enabled", &joysticks[i].enabled, 1); file.Get(SectionName.c_str(), "enabled", &PadMapping[i].enabled, 1);
} }
bool Tmp; // ==================================================================
file.Get(SectionName.c_str(), "SaveByID", &Tmp, false); // Joypad or slot specific settings
g_Config.bSaveByID.at(i) = Tmp;
//////////////////////////////////////
// Load joypad specific settings
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Current joypad device ID: joysticks[i].ID // Current joypad device ID: PadMapping[i].ID
// Current joypad name: joyinfo[joysticks[i].ID].Name // Current joypad name: joyinfo[PadMapping[i].ID].Name
if(g_Config.bSaveByID.at(i)) if(g_Config.bSaveByID)
{ {
/* Prevent a crash from illegal access to joyinfo that will only have values for /* Prevent a crash from illegal access to joyinfo that will only have values for
the current amount of connected joysticks */ the current amount of connected PadMapping */
if(joysticks[i].ID >= SDL_NumJoysticks()) continue; if(PadMapping[i].ID >= SDL_NumJoysticks()) continue;
//PanicAlert("%i %i",joysticks[i].ID, SDL_NumJoysticks()); //PanicAlert("%i %i",PadMapping[i].ID, SDL_NumJoysticks());
//PanicAlert("%s", joyinfo[joysticks[i].ID].Name); //PanicAlert("%s", joyinfo[PadMapping[i].ID].Name);
// Create a section name // Create a section name
SectionName = joyinfo[joysticks[i].ID].Name; SectionName = joyinfo[PadMapping[i].ID].Name;
} }
file.Get(SectionName.c_str(), "l_shoulder", &joysticks[i].buttons[CTL_L_SHOULDER], 4); file.Get(SectionName.c_str(), "l_shoulder", &PadMapping[i].buttons[CTL_L_SHOULDER], 4);
file.Get(SectionName.c_str(), "r_shoulder", &joysticks[i].buttons[CTL_R_SHOULDER], 5); file.Get(SectionName.c_str(), "r_shoulder", &PadMapping[i].buttons[CTL_R_SHOULDER], 5);
file.Get(SectionName.c_str(), "a_button", &joysticks[i].buttons[CTL_A_BUTTON], 0); file.Get(SectionName.c_str(), "a_button", &PadMapping[i].buttons[CTL_A_BUTTON], 0);
file.Get(SectionName.c_str(), "b_button", &joysticks[i].buttons[CTL_B_BUTTON], 1); file.Get(SectionName.c_str(), "b_button", &PadMapping[i].buttons[CTL_B_BUTTON], 1);
file.Get(SectionName.c_str(), "x_button", &joysticks[i].buttons[CTL_X_BUTTON], 3); file.Get(SectionName.c_str(), "x_button", &PadMapping[i].buttons[CTL_X_BUTTON], 3);
file.Get(SectionName.c_str(), "y_button", &joysticks[i].buttons[CTL_Y_BUTTON], 2); file.Get(SectionName.c_str(), "y_button", &PadMapping[i].buttons[CTL_Y_BUTTON], 2);
file.Get(SectionName.c_str(), "z_trigger", &joysticks[i].buttons[CTL_Z_TRIGGER], 7); file.Get(SectionName.c_str(), "z_trigger", &PadMapping[i].buttons[CTL_Z_TRIGGER], 7);
file.Get(SectionName.c_str(), "start_button", &joysticks[i].buttons[CTL_START], 9); file.Get(SectionName.c_str(), "start_button", &PadMapping[i].buttons[CTL_START], 9);
file.Get(SectionName.c_str(), "dpad", &joysticks[i].dpad, 0); file.Get(SectionName.c_str(), "dpad", &PadMapping[i].dpad, 0);
file.Get(SectionName.c_str(), "dpad_up", &joysticks[i].dpad2[CTL_D_PAD_UP], 0); file.Get(SectionName.c_str(), "dpad_up", &PadMapping[i].dpad2[CTL_D_PAD_UP], 0);
file.Get(SectionName.c_str(), "dpad_down", &joysticks[i].dpad2[CTL_D_PAD_DOWN], 0); file.Get(SectionName.c_str(), "dpad_down", &PadMapping[i].dpad2[CTL_D_PAD_DOWN], 0);
file.Get(SectionName.c_str(), "dpad_left", &joysticks[i].dpad2[CTL_D_PAD_LEFT], 0); file.Get(SectionName.c_str(), "dpad_left", &PadMapping[i].dpad2[CTL_D_PAD_LEFT], 0);
file.Get(SectionName.c_str(), "dpad_right", &joysticks[i].dpad2[CTL_D_PAD_RIGHT], 0); file.Get(SectionName.c_str(), "dpad_right", &PadMapping[i].dpad2[CTL_D_PAD_RIGHT], 0);
file.Get(SectionName.c_str(), "main_x", &joysticks[i].axis[CTL_MAIN_X], 0); file.Get(SectionName.c_str(), "main_x", &PadMapping[i].axis[CTL_MAIN_X], 0);
file.Get(SectionName.c_str(), "main_y", &joysticks[i].axis[CTL_MAIN_Y], 1); file.Get(SectionName.c_str(), "main_y", &PadMapping[i].axis[CTL_MAIN_Y], 1);
file.Get(SectionName.c_str(), "sub_x", &joysticks[i].axis[CTL_SUB_X], 2); file.Get(SectionName.c_str(), "sub_x", &PadMapping[i].axis[CTL_SUB_X], 2);
file.Get(SectionName.c_str(), "sub_y", &joysticks[i].axis[CTL_SUB_Y], 3); file.Get(SectionName.c_str(), "sub_y", &PadMapping[i].axis[CTL_SUB_Y], 3);
file.Get(SectionName.c_str(), "deadzone", &joysticks[i].deadzone, 9); file.Get(SectionName.c_str(), "deadzone", &PadMapping[i].deadzone, 9);
file.Get(SectionName.c_str(), "halfpress", &joysticks[i].halfpress, -1); file.Get(SectionName.c_str(), "halfpress", &PadMapping[i].halfpress, -1);
file.Get(SectionName.c_str(), "controllertype", &joysticks[i].controllertype, 0); file.Get(SectionName.c_str(), "controllertype", &PadMapping[i].controllertype, 0);
file.Get(SectionName.c_str(), "TriggerType", &joysticks[i].triggertype, 0); file.Get(SectionName.c_str(), "TriggerType", &PadMapping[i].triggertype, 0);
file.Get(SectionName.c_str(), "eventnum", &joysticks[i].eventnum, 0); file.Get(SectionName.c_str(), "eventnum", &PadMapping[i].eventnum, 0);
file.Get(SectionName.c_str(), "Diagonal", &g_Config.SDiagonal.at(i), "100%"); file.Get(SectionName.c_str(), "Diagonal", &PadMapping[i].SDiagonal, "100%");
file.Get(SectionName.c_str(), "SquareToCircle", &Tmp, false); g_Config.bSquareToCircle.at(i) = Tmp; file.Get(SectionName.c_str(), "SquareToCircle", &Tmp, false); PadMapping[i].bSquareToCircle = Tmp;
// =============================
// Debugging
//if(m_frame) m_frame->LogMsg("%i: Load triggertype: %s %i\n", i, SectionName.c_str(), PadMapping[i].triggertype);
} }
} }

10
Source/Plugins/Plugin_nJoy_SDL/Src/Config.h
View File

@ -21,17 +21,13 @@
struct Config struct Config
{ {
Config(); Config();
void Load(bool Config = false); void Load(bool ChangePad = false, bool ChangeSaveByID = false);
void Save(bool CheckedForDuplicates = false); void Save(int Slot = -1);
int CheckForDuplicateJoypads(bool OK); int CheckForDuplicateJoypads(bool OK);
// General // General
bool bShowAdvanced; // Only allow one of these bool bShowAdvanced; // Only allow one of these
std::vector<bool> bSaveByID; bool bSaveByIDNotice; bool bSaveByID;
// Joystick
std::vector<std::string> SDiagonal;
std::vector<bool> bSquareToCircle;
}; };
extern Config g_Config; extern Config g_Config;

51
Source/Plugins/Plugin_nJoy_SDL/Src/GUI/ConfigAdvanced.cpp
View File

@ -50,7 +50,7 @@ bool StrangeHack = true;
void ConfigBox::PadGetStatus() void ConfigBox::PadGetStatus()
{ {
// Return if it's not detected // Return if it's not detected
if(joysticks[notebookpage].ID >= SDL_NumJoysticks()) if(PadMapping[notebookpage].ID >= SDL_NumJoysticks())
{ {
m_TStatusIn[notebookpage]->SetLabel(wxT("Not connected")); m_TStatusIn[notebookpage]->SetLabel(wxT("Not connected"));
m_TStatusOut[notebookpage]->SetLabel(wxT("Not connected")); m_TStatusOut[notebookpage]->SetLabel(wxT("Not connected"));
@ -59,7 +59,7 @@ void ConfigBox::PadGetStatus()
} }
// Return if it's not enabled // Return if it's not enabled
if (!joysticks[notebookpage].enabled) if (!PadMapping[notebookpage].enabled)
{ {
m_TStatusIn[notebookpage]->SetLabel(wxT("Not enabled")); m_TStatusIn[notebookpage]->SetLabel(wxT("Not enabled"));
m_TStatusOut[notebookpage]->SetLabel(wxT("Not enabled")); m_TStatusOut[notebookpage]->SetLabel(wxT("Not enabled"));
@ -68,8 +68,8 @@ void ConfigBox::PadGetStatus()
} }
// Get physical device status // Get physical device status
int PhysicalDevice = joysticks[notebookpage].ID; int PhysicalDevice = PadMapping[notebookpage].ID;
int TriggerType = joysticks[notebookpage].triggertype; int TriggerType = PadMapping[notebookpage].triggertype;
// Get pad status // Get pad status
GetJoyState(notebookpage); GetJoyState(notebookpage);
@ -78,8 +78,8 @@ void ConfigBox::PadGetStatus()
// Analog stick // Analog stick
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Set Deadzones perhaps out of function // Set Deadzones perhaps out of function
//int deadzone = (int)(((float)(128.00/100.00)) * (float)(joysticks[_numPAD].deadzone+1)); //int deadzone = (int)(((float)(128.00/100.00)) * (float)(PadMapping[_numPAD].deadzone+1));
//int deadzone2 = (int)(((float)(-128.00/100.00)) * (float)(joysticks[_numPAD].deadzone+1)); //int deadzone2 = (int)(((float)(-128.00/100.00)) * (float)(PadMapping[_numPAD].deadzone+1));
// Get original values // Get original values
int main_x = joystate[notebookpage].axis[CTL_MAIN_X]; int main_x = joystate[notebookpage].axis[CTL_MAIN_X];
@ -89,7 +89,7 @@ void ConfigBox::PadGetStatus()
// Get adjusted values // Get adjusted values
int main_x_after = main_x, main_y_after = main_y; int main_x_after = main_x, main_y_after = main_y;
if(g_Config.bSquareToCircle.at(notebookpage)) if(PadMapping[notebookpage].bSquareToCircle)
{ {
std::vector<int> main_xy = Pad_Square_to_Circle(main_x, main_y, notebookpage); std::vector<int> main_xy = Pad_Square_to_Circle(main_x, main_y, notebookpage);
main_x_after = main_xy.at(0); main_x_after = main_xy.at(0);
@ -143,7 +143,7 @@ void ConfigBox::PadGetStatus()
int TriggerRight = joystate[notebookpage].axis[CTL_R_SHOULDER]; int TriggerRight = joystate[notebookpage].axis[CTL_R_SHOULDER];
// Convert the triggers values // Convert the triggers values
if (joysticks[notebookpage].triggertype == CTL_TRIGGER_SDL) if (PadMapping[notebookpage].triggertype == CTL_TRIGGER_SDL)
{ {
TriggerLeft = Pad_Convert(TriggerLeft); TriggerLeft = Pad_Convert(TriggerLeft);
TriggerRight = Pad_Convert(TriggerRight); TriggerRight = Pad_Convert(TriggerRight);
@ -169,19 +169,19 @@ void ConfigBox::PadGetStatus()
std::string ShowStatus(int VirtualController) std::string ShowStatus(int VirtualController)
{ {
// Check if it's enabled // Check if it's enabled
if (!joysticks[VirtualController].enabled) return "Disabled"; if (!PadMapping[VirtualController].enabled) return StringFromFormat("%i disabled", VirtualController);
// Save the physical device // Save the physical device
int PhysicalDevice = joysticks[VirtualController].ID; int PhysicalDevice = PadMapping[VirtualController].ID;
// Make local shortcut // Make local shortcut
SDL_Joystick *joy = joystate[VirtualController].joy; SDL_Joystick *joy = joystate[VirtualController].joy;
// Make shortcuts for all pads // Make shortcuts for all pads
SDL_Joystick *joy0 = joystate[joysticks[0].ID].joy; SDL_Joystick *joy0 = joystate[PadMapping[0].ID].joy;
SDL_Joystick *joy1 = joystate[joysticks[1].ID].joy; SDL_Joystick *joy1 = joystate[PadMapping[1].ID].joy;
SDL_Joystick *joy2 = joystate[joysticks[2].ID].joy; SDL_Joystick *joy2 = joystate[PadMapping[2].ID].joy;
SDL_Joystick *joy3 = joystate[joysticks[3].ID].joy; SDL_Joystick *joy3 = joystate[PadMapping[3].ID].joy;
// Temporary storage // Temporary storage
std::string StrAxes, StrHats, StrBut; std::string StrAxes, StrHats, StrBut;
@ -193,10 +193,6 @@ std::string ShowStatus(int VirtualController)
int Hats = joyinfo[PhysicalDevice].NumHats; int Hats = joyinfo[PhysicalDevice].NumHats;
int Buttons = joyinfo[PhysicalDevice].NumButtons; int Buttons = joyinfo[PhysicalDevice].NumButtons;
// More status
int controllertype = joysticks[VirtualController].controllertype;
int triggertype = joysticks[VirtualController].triggertype;
// Update the internal values // Update the internal values
SDL_JoystickUpdate(); SDL_JoystickUpdate();
@ -218,20 +214,25 @@ std::string ShowStatus(int VirtualController)
} }
return StringFromFormat( return StringFromFormat(
"joysticks.ID: %i %i %i %i\n" "PadMapping\n"
"joysticks.controllertype, triggertype: %i %i\n" "ID: %i %i %i %i\n"
"Controllertype: %i %i %i %i\n"
"SquareToCircle: %i %i %i %i\n\n"
"Handles: %i %i %i %i\n" "Handles: %i %i %i %i\n"
"XInput: %i %i %i\n" "XInput: %i %i %i\n"
"Axes: %s\n" "Axes: %s\n"
"Hats: %s\n" "Hats: %s\n"
"But: %s\n" "But: %s\n"
"Device: Ax: %i Balls:%i But:%i Hats:%i", "Device: Ax: %i Balls:%i But:%i Hats:%i",
joysticks[0].ID, joysticks[1].ID, joysticks[2].ID, joysticks[3].ID, PadMapping[0].ID, PadMapping[1].ID, PadMapping[2].ID, PadMapping[3].ID,
controllertype, triggertype, PadMapping[0].controllertype, PadMapping[1].controllertype, PadMapping[2].controllertype, PadMapping[3].controllertype,
PadMapping[0].bSquareToCircle, PadMapping[1].bSquareToCircle, PadMapping[2].bSquareToCircle, PadMapping[3].bSquareToCircle,
joy0, joy1, joy2, joy3, joy0, joy1, joy2, joy3,
#ifdef _WIN32
XInput::IsConnected(0), XInput::GetXI(0, XI_TRIGGER_L), XInput::GetXI(0, XI_TRIGGER_R), #ifdef _WIN32
#endif XInput::IsConnected(0), XInput::GetXI(0, XI_TRIGGER_L), XInput::GetXI(0, XI_TRIGGER_R),
#endif
StrAxes.c_str(), StrHats.c_str(), StrBut.c_str(), StrAxes.c_str(), StrHats.c_str(), StrBut.c_str(),
Axes, Balls, Hats, Buttons Axes, Balls, Hats, Buttons
); );

230
Source/Plugins/Plugin_nJoy_SDL/Src/GUI/ConfigBox.cpp
View File

@ -40,7 +40,7 @@
#include "Images/controller.xpm" #include "Images/controller.xpm"
extern CONTROLLER_INFO *joyinfo; extern CONTROLLER_INFO *joyinfo;
//extern CONTROLLER_MAPPING joysticks[4]; //extern CONTROLLER_MAPPING PadMapping[4];
extern bool emulator_running; extern bool emulator_running;
// D-Pad type // D-Pad type
@ -70,17 +70,20 @@ BEGIN_EVENT_TABLE(ConfigBox,wxDialog)
EVT_NOTEBOOK_PAGE_CHANGED(ID_NOTEBOOK, ConfigBox::NotebookPageChanged) EVT_NOTEBOOK_PAGE_CHANGED(ID_NOTEBOOK, ConfigBox::NotebookPageChanged)
// Change and enable or disable gamepad // Change and enable or disable gamepad
EVT_COMBOBOX(IDC_JOYNAME, ConfigBox::ChangeJoystick) EVT_COMBOBOX(IDC_JOYNAME, ConfigBox::ChangeSettings)
EVT_CHECKBOX(IDC_JOYATTACH, ConfigBox::EnableDisable) EVT_CHECKBOX(IDC_JOYATTACH, ConfigBox::ChangeSettings)
// Settings // Other settings
EVT_CHECKBOX(IDC_SAVEBYID, ConfigBox::ChangeSettings) EVT_CHECKBOX(IDC_SAVEBYID, ConfigBox::ChangeSettings)
EVT_CHECKBOX(IDC_SAVEBYIDNOTICE, ConfigBox::ChangeSettings)
EVT_CHECKBOX(IDC_SHOWADVANCED, ConfigBox::ChangeSettings) EVT_CHECKBOX(IDC_SHOWADVANCED, ConfigBox::ChangeSettings)
EVT_COMBOBOX(IDCB_MAINSTICK_DIAGONAL, ConfigBox::ChangeSettings) EVT_COMBOBOX(IDCB_MAINSTICK_DIAGONAL, ConfigBox::ChangeSettings)
EVT_COMBOBOX(IDC_CONTROLTYPE, ConfigBox::ChangeSettings)
EVT_COMBOBOX(IDC_TRIGGERTYPE, ConfigBox::ChangeSettings)
EVT_COMBOBOX(IDC_DEADZONE, ConfigBox::ChangeSettings)
// Advanced settings
EVT_COMBOBOX(IDCB_MAINSTICK_DIAGONAL, ConfigBox::ChangeSettings)
EVT_CHECKBOX(IDCB_MAINSTICK_S_TO_C, ConfigBox::ChangeSettings) EVT_CHECKBOX(IDCB_MAINSTICK_S_TO_C, ConfigBox::ChangeSettings)
EVT_COMBOBOX(IDC_CONTROLTYPE, ConfigBox::ChangeControllertype)
EVT_COMBOBOX(IDC_TRIGGERTYPE, ConfigBox::ChangeControllertype)
EVT_BUTTON(IDB_SHOULDER_L, ConfigBox::GetButtons) EVT_BUTTON(IDB_SHOULDER_L, ConfigBox::GetButtons)
EVT_BUTTON(IDB_SHOULDER_R, ConfigBox::GetButtons) EVT_BUTTON(IDB_SHOULDER_R, ConfigBox::GetButtons)
@ -113,6 +116,9 @@ ConfigBox::ConfigBox(wxWindow *parent, wxWindowID id, const wxString &title,
// Define values // Define values
notebookpage = 0; notebookpage = 0;
g_Pressed = 0; g_Pressed = 0;
Debugging = false;
m_TCDebugging = NULL;
ControlsCreated = false;
// Create controls // Create controls
CreateGUIControls(); CreateGUIControls();
@ -185,16 +191,9 @@ void ConfigBox::OKClick(wxCommandEvent& event)
{ {
if (event.GetId() == ID_OK) if (event.GetId() == ID_OK)
{ {
// Check for duplicate joypads DoSave(); // Save settings
if(g_Config.bSaveByIDNotice) g_Config.Load(); // Reload settings to PadMapping
{ if(Debugging) PanicAlert("Done");
int Tmp = g_Config.CheckForDuplicateJoypads(true);
if (Tmp == wxOK) return; else if (Tmp == wxNO) g_Config.bSaveByIDNotice = false;
}
for(int i = 0; i < 4; i++) SaveButtonMapping(i); // Update joysticks array
DoSave(false, true); // Save settings
g_Config.Load(); // Reload settings
Close(); // Call OnClose() Close(); // Call OnClose()
} }
} }
@ -205,11 +204,34 @@ void ConfigBox::CancelClick(wxCommandEvent& event)
{ {
if (event.GetId() == ID_CANCEL) if (event.GetId() == ID_CANCEL)
{ {
g_Config.Load(); // Reload settings // Forget all potential changes to PadMapping by loading the last saved settings
g_Config.Load();
Close(); // Call OnClose() Close(); // Call OnClose()
} }
} }
// Debugging
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
void ConfigBox::LogMsg(const char* format, ...)
{
if(Debugging)
{
const int MaxMsgSize = 1024*2;
char buffer[MaxMsgSize];
va_list args;
va_start(args, format);
CharArrayFromFormatV(buffer, MaxMsgSize, format, args);
va_end(args);
// Add timestamp
std::string StrTmp = buffer;
//StrTmp += Common::Timer::GetTimeFormatted();
if(m_TCDebugging) m_TCDebugging->AppendText(StrTmp.c_str());
}
}
////////////////////////////////////// //////////////////////////////////////
// Save Settings // Save Settings
@ -219,9 +241,10 @@ void ConfigBox::CancelClick(wxCommandEvent& event)
1. Closing the configuration window 1. Closing the configuration window
2. Changing the gamepad 2. Changing the gamepad
3. When the gamepad is enabled or disbled */ 3. When the gamepad is enabled or disbled
4. When we change saving mode (by Id or by slot)
void ConfigBox::DoSave(bool ChangePad, bool CheckedForDuplicates) */
void ConfigBox::DoSave(bool ChangePad, int Slot)
{ {
// Replace "" with "-1" before we are saving // Replace "" with "-1" before we are saving
ToBlank(false); ToBlank(false);
@ -230,55 +253,64 @@ void ConfigBox::DoSave(bool ChangePad, bool CheckedForDuplicates)
{ {
// Since we are selecting the pad to save to by the Id we can't update it when we change the pad // Since we are selecting the pad to save to by the Id we can't update it when we change the pad
for(int i = 0; i < 4; i++) SaveButtonMapping(i, true); for(int i = 0; i < 4; i++) SaveButtonMapping(i, true);
g_Config.Save(CheckedForDuplicates); //LogMsg("Old Id: %s | %i %i\n", joyinfo[PadMapping[notebookpage].ID].Name.c_str(), notebookpage, Slot);
g_Config.Save(Slot);
// Now we can update the ID // Now we can update the ID
joysticks[notebookpage].ID = m_Joyname[notebookpage]->GetSelection(); PadMapping[notebookpage].ID = m_Joyname[notebookpage]->GetSelection();
//LogMsg("New Id: %s\n", joyinfo[PadMapping[notebookpage].ID].Name.c_str());
} }
else else
{ {
for(int i = 0; i < 4; i++) SaveButtonMapping(i); for(int i = 0; i < 4; i++) SaveButtonMapping(i);
g_Config.Save(CheckedForDuplicates); g_Config.Save(Slot);
} }
// Then change it back // Then change it back
ToBlank(); ToBlank();
} }
// Enable or disable joystick and update the GUI // OnSaveById
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
void ConfigBox::EnableDisable(wxCommandEvent& event) void ConfigBox::OnSaveById()
{ {
// We will enable this device // Save current settings
joysticks[notebookpage].enabled = !joysticks[notebookpage].enabled; DoSave(false, notebookpage);
// Update the GUI // Update the setting and load the settings
g_Config.bSaveByID = m_CBSaveByID[notebookpage]->IsChecked();
g_Config.Load(false, true);
// Update GUI and PadMapping[]
UpdateGUI(notebookpage); UpdateGUI(notebookpage);
SaveButtonMapping(notebookpage);
} }
// Change Joystick // Change Joystick
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
/* Function: When changing the joystick we save and load the settings and update the joysticks /* Function: When changing the joystick we save and load the settings and update the PadMapping
and joystate array */ and joystate array */
void ConfigBox::DoChangeJoystick() void ConfigBox::DoChangeJoystick()
{ {
// Before changing the pad we save potential changes (to support SaveByID) // Close the current pad
if (PadMapping[notebookpage].enabled) PadClose(notebookpage);
// Before changing the pad we save potential changes to the current pad (to support SaveByID)
DoSave(true); DoSave(true);
// Load the settings for the new Id // Load the settings for the new Id
g_Config.Load(true); g_Config.Load(true);
UpdateGUI(notebookpage); // Update the GUI UpdateGUI(notebookpage); // Update the GUI
// Remap the controller // Open the new pad
if (joysticks[notebookpage].enabled) if (PadMapping[notebookpage].enabled) PadOpen(notebookpage);
{
//Console::Print("Id: %i\n", joysticks[notebookpage].ID);
if (SDL_JoystickOpened(joysticks[notebookpage].ID)) SDL_JoystickClose(joystate[notebookpage].joy);
joystate[notebookpage].joy = SDL_JoystickOpen(joysticks[notebookpage].ID);
}
} }
void ConfigBox::ChangeJoystick(wxCommandEvent& event) void ConfigBox::PadOpen(int Open) // Open for slot 1, 2, 3 or 4
{ {
DoChangeJoystick(); joystate[Open].joy = SDL_JoystickOpen(PadMapping[Open].ID);
}
void ConfigBox::PadClose(int Close) // Close for slot 1, 2, 3 or 4
{
if (SDL_JoystickOpened(PadMapping[Close].ID)) SDL_JoystickClose(joystate[Close].joy);
} }
// Notebook page changed // Notebook page changed
@ -287,13 +319,14 @@ void ConfigBox::NotebookPageChanged(wxNotebookEvent& event)
{ {
int oldnotebookpage = notebookpage; int oldnotebookpage = notebookpage;
notebookpage = event.GetSelection(); notebookpage = event.GetSelection();
int OldId = joysticks[oldnotebookpage].ID; int OldId = PadMapping[oldnotebookpage].ID;
int NewId = joysticks[notebookpage].ID; int NewId = PadMapping[notebookpage].ID;
// Check if it has changed. If it has save the old Id and load the new Id // Check if it has changed. If it has save the old Id and load the new Id
if(OldId != NewId) if(OldId != NewId) DoChangeJoystick();
DoChangeJoystick();
// Update GUI
if(ControlsCreated) UpdateGUI(notebookpage);
} }
// Replace the harder to understand -1 with "" for the sake of user friendliness // Replace the harder to understand -1 with "" for the sake of user friendliness
@ -318,18 +351,26 @@ void ConfigBox::ToBlank(bool ToBlank)
////////////////////////////////// //////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
// Change settings // Change settings
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
void ConfigBox::UpdateAllSlots(int Slot)
{
for (int i = 0; i < 4; i++)
{
if (joyinfo[PadMapping[i].ID].Name == joyinfo[PadMapping[Slot].ID].Name)
SaveButtonMapping(i, false, Slot);
//LogMsg("%i: %s\n", i, joyinfo[PadMapping[i].ID].Name.c_str());
UpdateGUI(i);
};
}
void ConfigBox::ChangeSettings( wxCommandEvent& event ) void ConfigBox::ChangeSettings( wxCommandEvent& event )
{ {
switch(event.GetId()) switch(event.GetId())
{ {
case IDC_SAVEBYID: case IDC_SAVEBYID:
g_Config.bSaveByID.at(notebookpage) = m_CBSaveByID[notebookpage]->IsChecked(); OnSaveById();
break; break;
case IDC_SAVEBYIDNOTICE:
g_Config.bSaveByIDNotice = m_CBSaveByIDNotice[notebookpage]->IsChecked();
break;
case IDC_SHOWADVANCED: case IDC_SHOWADVANCED:
g_Config.bShowAdvanced = m_CBShowAdvanced[notebookpage]->IsChecked(); g_Config.bShowAdvanced = m_CBShowAdvanced[notebookpage]->IsChecked();
@ -341,35 +382,52 @@ void ConfigBox::ChangeSettings( wxCommandEvent& event )
SizeWindow(); SizeWindow();
break; break;
case IDCB_MAINSTICK_DIAGONAL: case IDC_CONTROLTYPE:
g_Config.SDiagonal.at(notebookpage) = m_CoBDiagonal[notebookpage]->GetLabel().mb_str(); case IDC_TRIGGERTYPE:
SaveButtonMapping(notebookpage);
UpdateGUI(notebookpage);
break; break;
case IDCB_MAINSTICK_S_TO_C: case IDC_JOYNAME:
g_Config.bSquareToCircle.at(notebookpage) = m_CBS_to_C[notebookpage]->IsChecked(); DoChangeJoystick();
break; break;
case IDC_JOYATTACH:
// We will enable this device
int Enable = PadMapping[notebookpage].enabled = !PadMapping[notebookpage].enabled;
// Close or open pad handle
if(Enable) PadOpen(notebookpage); else PadClose(notebookpage);
// Update the GUI
UpdateGUI(notebookpage);
return; // Don't save this for all slots
} }
// Update all slots that use this device
if(g_Config.bSaveByID) UpdateAllSlots(notebookpage);
} }
///////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
// Update GUI // Update GUI
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Called from: ChangeControllertype() // Called from: CreateGUIControls(), ChangeControllertype()
void ConfigBox::UpdateGUI(int _notebookpage) void ConfigBox::UpdateGUI(int _notebookpage)
{ {
// Update the GUI from joysticks[] // Update the GUI from PadMapping[]
UpdateGUIKeys(_notebookpage); UpdateGUIKeys(_notebookpage);
// Controller type settings // Collect status
bool Hat = (joysticks[_notebookpage].controllertype == CTL_DPAD_HAT); bool Hat = (PadMapping[_notebookpage].controllertype == CTL_DPAD_HAT);
long Left, Right; long Left, Right;
m_JoyShoulderL[_notebookpage]->GetValue().ToLong(&Left); m_JoyShoulderL[_notebookpage]->GetValue().ToLong(&Left);
m_JoyShoulderR[_notebookpage]->GetValue().ToLong(&Right); m_JoyShoulderR[_notebookpage]->GetValue().ToLong(&Right);
bool AnalogTrigger = (Left >= 1000 || Right >= 1000); bool AnalogTrigger = (Left >= 1000 || Right >= 1000);
#ifdef _WIN32 #ifdef _WIN32
bool XInput = XInput::IsConnected(0); bool XInput = XInput::IsConnected(0);
#endif #endif
// Hat type selection
m_JoyDpadUp[_notebookpage]->Show(!Hat); m_JoyDpadUp[_notebookpage]->Show(!Hat);
m_JoyDpadLeft[_notebookpage]->Show(!Hat); m_JoyDpadLeft[_notebookpage]->Show(!Hat);
m_JoyDpadRight[_notebookpage]->Show(!Hat); m_JoyDpadRight[_notebookpage]->Show(!Hat);
@ -387,23 +445,13 @@ void ConfigBox::UpdateGUI(int _notebookpage)
wxT("Select a hat by pressing the hat in any direction") : wxT("")); wxT("Select a hat by pressing the hat in any direction") : wxT(""));
// General settings // General settings
m_CBSaveByID[_notebookpage]->SetValue(g_Config.bSaveByID.at(_notebookpage)); m_CBSaveByID[_notebookpage]->SetValue(g_Config.bSaveByID);
m_CBSaveByIDNotice[_notebookpage]->SetValue(g_Config.bSaveByIDNotice);
m_CBShowAdvanced[_notebookpage]->SetValue(g_Config.bShowAdvanced); m_CBShowAdvanced[_notebookpage]->SetValue(g_Config.bShowAdvanced);
// Controller type values LogMsg("Update: %i\n", g_Config.bSaveByID);
#ifdef _WIN32
if (!XInput) m_TriggerType[_notebookpage]->SetSelection(CTL_TRIGGER_SDL);
#else
m_TriggerType[_notebookpage]->SetSelection(CTL_TRIGGER_SDL);
#endif
// Advanced settings
m_CoBDiagonal[_notebookpage]->SetValue(wxString::FromAscii(g_Config.SDiagonal.at(_notebookpage).c_str()));
m_CBS_to_C[_notebookpage]->SetValue(g_Config.bSquareToCircle.at(_notebookpage));
// Disabled pages // Disabled pages
bool Enabled = joysticks[_notebookpage].enabled; bool Enabled = PadMapping[_notebookpage].enabled;
// There is no FindItem in linux so this doesn't work // There is no FindItem in linux so this doesn't work
#ifdef _WIN32 #ifdef _WIN32
// Enable or disable all buttons // Enable or disable all buttons
@ -423,8 +471,10 @@ void ConfigBox::UpdateGUI(int _notebookpage)
// Repaint the background // Repaint the background
m_Controller[_notebookpage]->Refresh(); m_Controller[_notebookpage]->Refresh();
} }
///////////////////////////////
// Populate the config window
// Paint the background
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
void ConfigBox::OnPaint( wxPaintEvent &event ) void ConfigBox::OnPaint( wxPaintEvent &event )
{ {
@ -432,7 +482,7 @@ void ConfigBox::OnPaint( wxPaintEvent &event )
wxPaintDC dcWin(m_pKeys[notebookpage]); wxPaintDC dcWin(m_pKeys[notebookpage]);
PrepareDC( dcWin ); PrepareDC( dcWin );
if(joysticks[notebookpage].enabled) if(PadMapping[notebookpage].enabled)
dcWin.DrawBitmap( WxStaticBitmap1_BITMAP, 94, 0, true ); dcWin.DrawBitmap( WxStaticBitmap1_BITMAP, 94, 0, true );
else else
dcWin.DrawBitmap( WxStaticBitmap1_BITMAPGray, 94, 0, true ); dcWin.DrawBitmap( WxStaticBitmap1_BITMAPGray, 94, 0, true );
@ -497,7 +547,7 @@ void ConfigBox::CreateGUIControls()
{ {
for(int x = 0; x < SDL_NumJoysticks(); x++) for(int x = 0; x < SDL_NumJoysticks(); x++)
{ {
arrayStringFor_Joyname.Add(wxString::FromAscii(joyinfo[x].Name)); arrayStringFor_Joyname.Add(wxString::FromAscii(joyinfo[x].Name.c_str()));
} }
} }
else else
@ -709,14 +759,10 @@ void ConfigBox::CreateGUIControls()
// Create objects for general settings 3 // Create objects for general settings 3
m_gGenSettingsID[i] = new wxStaticBoxSizer( wxVERTICAL, m_Controller[i], wxT("Settings") ); m_gGenSettingsID[i] = new wxStaticBoxSizer( wxVERTICAL, m_Controller[i], wxT("Settings") );
m_CBSaveByID[i] = new wxCheckBox(m_Controller[i], IDC_SAVEBYID, wxT("Save by ID"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator); m_CBSaveByID[i] = new wxCheckBox(m_Controller[i], IDC_SAVEBYID, wxT("Save by ID"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
m_CBSaveByIDNotice[i] = new wxCheckBox(m_Controller[i], IDC_SAVEBYIDNOTICE, wxT("Notify"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
m_CBShowAdvanced[i] = new wxCheckBox(m_Controller[i], IDC_SHOWADVANCED, wxT("Show advanced settings"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator); m_CBShowAdvanced[i] = new wxCheckBox(m_Controller[i], IDC_SHOWADVANCED, wxT("Show advanced settings"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
// Populate general settings 3 // Populate general settings 3
m_sSaveByID[i] = new wxBoxSizer(wxHORIZONTAL); m_gGenSettingsID[i]->Add(m_CBSaveByID[i], 0, wxEXPAND | wxALL, 3);
m_sSaveByID[i]->Add(m_CBSaveByID[i], 0, wxEXPAND | wxALL, 0);
m_sSaveByID[i]->Add(m_CBSaveByIDNotice[i], 0, wxEXPAND | wxLEFT, 2);
m_gGenSettingsID[i]->Add(m_sSaveByID[i], 0, wxEXPAND | wxALL, 3);
m_gGenSettingsID[i]->Add(m_CBShowAdvanced[i], 0, wxEXPAND | wxALL, 3); m_gGenSettingsID[i]->Add(m_CBShowAdvanced[i], 0, wxEXPAND | wxALL, 3);
// Create tooltips // Create tooltips
@ -728,13 +774,10 @@ void ConfigBox::CreateGUIControls()
)); ));
m_CBSaveByID[i]->SetToolTip(wxString::Format(wxT( m_CBSaveByID[i]->SetToolTip(wxString::Format(wxT(
"Map these settings to the selected controller device instead of to the" "Map these settings to the selected controller device instead of to the"
"\nselected controller number (%i). This may be a more convenient way" "\nselected slot (1, 2, 3 or 4). This may be a more convenient way"
"\nto save your settings if you have multiple controllers.") "\nto save your settings if you have multiple controllers.")
, i+1 , i+1
)); ));
m_CBSaveByIDNotice[i]->SetToolTip(wxString::Format(wxT(
"Show a notification message if you have selected this option for multiple identical joypads.")
));
// Populate settings // Populate settings
m_sSettings[i] = new wxBoxSizer ( wxHORIZONTAL ); m_sSettings[i] = new wxBoxSizer ( wxHORIZONTAL );
@ -846,9 +889,6 @@ void ConfigBox::CreateGUIControls()
m_ControlType[i]->Enable(false); m_ControlType[i]->Enable(false);
} }
// Set dialog items from saved values
//UpdateGUIKeys(i);
// Update GUI // Update GUI
UpdateGUI(i); UpdateGUI(i);
} // end of loop } // end of loop
@ -875,15 +915,23 @@ void ConfigBox::CreateGUIControls()
// -------------------------------------------------------------------- // --------------------------------------------------------------------
// Debugging // Debugging
// ----------------------------- // -----------------------------
//m_pStatusBar = new wxStaticText(this, IDT_DEBUGGING, wxT("Debugging"), wxPoint(150, 100), wxDefaultSize); /*m_pStatusBar = new wxStaticText(this, IDT_DEBUGGING, wxT("Debugging"), wxPoint(135, 100), wxDefaultSize);
//m_pStatusBar2 = new wxStaticText(this, IDT_DEBUGGING2, wxT("Debugging2"), wxPoint(150, 200), wxDefaultSize); //m_pStatusBar2 = new wxStaticText(this, IDT_DEBUGGING2, wxT("Debugging2"), wxPoint(125, 200), wxDefaultSize);
//m_pStatusBar->SetLabel(wxString::Format("Debugging text")); //m_pStatusBar->SetLabel(wxString::Format("Debugging text"));
m_TCDebugging = new wxTextCtrl(this, IDT_DEBUGGING3, _T(""), wxDefaultPosition, wxSize(400, 400),
wxTE_RICH | wxTE_MULTILINE | wxTE_DONTWRAP | wxNO_BORDER);
wxBoxSizer * m_LogSizer = new wxBoxSizer(wxVERTICAL);
m_LogSizer->Add(m_TCDebugging, 0, wxEXPAND | (wxALL), 0);
m_MainSizer->Add(m_LogSizer, 0, wxEXPAND | ( wxLEFT | wxRIGHT | wxBOTTOM), 5);*/
// -------------------------------------------------------------------- // --------------------------------------------------------------------
// Set window size // Set window size
// ----------------------------- // -----------------------------
SizeWindow(); SizeWindow();
Center(); Center();
// All done
ControlsCreated = true;
} }
void ConfigBox::SizeWindow() void ConfigBox::SizeWindow()

25
Source/Plugins/Plugin_nJoy_SDL/Src/GUI/ConfigBox.h
View File

@ -69,6 +69,9 @@ class ConfigBox : public wxDialog
// Debugging // Debugging
wxStaticText* m_pStatusBar, * m_pStatusBar2; wxStaticText* m_pStatusBar, * m_pStatusBar2;
wxTextCtrl* m_TCDebugging;
bool Debugging;
void LogMsg(const char* format, ...);
// Status window // Status window
int BoxW, BoxH; int BoxW, BoxH;
@ -107,10 +110,9 @@ class ConfigBox : public wxDialog
wxBoxSizer* m_sSettings[4]; // General settings 2 wxBoxSizer* m_sSettings[4]; // General settings 2
wxStaticBoxSizer *m_gGenSettings[4]; wxStaticBoxSizer *m_gGenSettings[4];
wxBoxSizer *m_sSaveByID[4];
wxStaticBoxSizer *m_gGenSettingsID[4]; wxStaticBoxSizer *m_gGenSettingsID[4];
wxGridBagSizer * m_gGBGenSettings[4]; wxGridBagSizer * m_gGBGenSettings[4];
wxCheckBox *m_CBSaveByID[4], *m_CBSaveByIDNotice[4], *m_CBShowAdvanced[4]; wxCheckBox *m_CBSaveByID[4], *m_CBShowAdvanced[4];
wxStaticText *m_TSControltype[4], *m_TSTriggerType[4]; wxStaticText *m_TSControltype[4], *m_TSTriggerType[4];
wxStaticBoxSizer *m_gStatusIn[4], *m_gStatusInSettings[4]; // Advanced settings wxStaticBoxSizer *m_gStatusIn[4], *m_gStatusInSettings[4]; // Advanced settings
@ -185,7 +187,8 @@ class ConfigBox : public wxDialog
wxStaticBitmap *m_controllerimage[4], wxStaticBitmap *m_controllerimage[4],
*m_bmpSquare[4], *m_bmpDot[4], *m_bmpSquareOut[4], *m_bmpDotOut[4]; *m_bmpSquare[4], *m_bmpDot[4], *m_bmpSquareOut[4], *m_bmpDotOut[4];
int notebookpage; int notebookpage; bool ControlsCreated;
private: private:
enum enum
{ {
@ -207,7 +210,7 @@ class ConfigBox : public wxDialog
IDG_CONTROLLERTYPE, IDC_CONTROLTYPE, IDC_TRIGGERTYPE, // Controller type IDG_CONTROLLERTYPE, IDC_CONTROLTYPE, IDC_TRIGGERTYPE, // Controller type
IDC_SAVEBYID, IDC_SAVEBYIDNOTICE, IDC_SHOWADVANCED, // Settings IDC_SAVEBYID, IDC_SHOWADVANCED, // Settings
ID_INSTATUS1, ID_INSTATUS2, ID_INSTATUS3, ID_INSTATUS4, // Advanced status ID_INSTATUS1, ID_INSTATUS2, ID_INSTATUS3, ID_INSTATUS4, // Advanced status
ID_STATUSBMP1, ID_STATUSBMP2, ID_STATUSBMP3, ID_STATUSBMP4, ID_STATUSBMP1, ID_STATUSBMP2, ID_STATUSBMP3, ID_STATUSBMP4,
@ -290,7 +293,7 @@ class ConfigBox : public wxDialog
IDT_DPADTYPE, IDT_TRIGGERTYPE, IDT_DPADTYPE, IDT_TRIGGERTYPE,
IDT_WEBSITE, IDT_WEBSITE,
IDT_DEBUGGING, IDT_DEBUGGING2, IDT_DEBUGGING, IDT_DEBUGGING2, IDT_DEBUGGING3,
// ============ // ============
ID_DUMMY_VALUE_ //don't remove this value unless you have other enum values ID_DUMMY_VALUE_ //don't remove this value unless you have other enum values
@ -300,13 +303,12 @@ class ConfigBox : public wxDialog
void AboutClick(wxCommandEvent& event); void AboutClick(wxCommandEvent& event);
void OKClick(wxCommandEvent& event); void OKClick(wxCommandEvent& event);
void CancelClick(wxCommandEvent& event); void CancelClick(wxCommandEvent& event);
void DoSave(bool ChangePad = false, bool CheckedForDuplicates = false); void DoSave(bool ChangePad = false, int Slot = -1);
void ChangeJoystick(wxCommandEvent& event); void DoChangeJoystick(); void DoChangeJoystick(); void PadOpen(int Open); void PadClose(int Close);
void ChangeControllertype(wxCommandEvent& event); void UpdateGUI(int _notebookpage);
void EnableDisable(wxCommandEvent& event); void UpdateGUI(int _notebookpage);
void ChangeSettings(wxCommandEvent& event); // Settings void ChangeSettings(wxCommandEvent& event); void UpdateAllSlots(int Slot); // Settings
void ComboChange(wxCommandEvent& event); void ComboChange(wxCommandEvent& event);
void OnClose(wxCloseEvent& event); void OnClose(wxCloseEvent& event);
@ -316,8 +318,9 @@ class ConfigBox : public wxDialog
void PadGetStatus(); void Update(); void PadGetStatus(); void Update();
void UpdateGUIKeys(int controller); void UpdateGUIKeys(int controller);
void SaveButtonMapping(int controller, bool DontChangeId = false); void SaveButtonMapping(int controller, bool DontChangeId = false, int FromSlot = -1);
void ToBlank(bool ToBlank = true); void ToBlank(bool ToBlank = true);
void OnSaveById();
void NotebookPageChanged(wxNotebookEvent& event); void NotebookPageChanged(wxNotebookEvent& event);

145
Source/Plugins/Plugin_nJoy_SDL/Src/GUI/ConfigJoypad.cpp
View File

@ -40,7 +40,7 @@
#include "Images/controller.xpm" #include "Images/controller.xpm"
extern CONTROLLER_INFO *joyinfo; extern CONTROLLER_INFO *joyinfo;
//extern CONTROLLER_MAPPING joysticks[4]; //extern CONTROLLER_MAPPING PadMapping[4];
extern bool emulator_running; extern bool emulator_running;
//////////////////////// ////////////////////////
@ -53,115 +53,115 @@ void ConfigBox::UpdateGUIKeys(int controller)
wxString tmp; wxString tmp;
// Update selected gamepad // Update selected gamepad
m_Joyname[controller]->SetSelection(joysticks[controller].ID); m_Joyname[controller]->SetSelection(PadMapping[controller].ID);
// Update the enabled checkbox // Update the enabled checkbox
m_Joyattach[controller]->SetValue(joysticks[controller].enabled); m_Joyattach[controller]->SetValue(PadMapping[controller].enabled);
tmp << joysticks[controller].buttons[CTL_L_SHOULDER]; m_JoyShoulderL[controller]->SetValue(tmp); tmp.clear(); tmp << PadMapping[controller].buttons[CTL_L_SHOULDER]; m_JoyShoulderL[controller]->SetValue(tmp); tmp.clear();
tmp << joysticks[controller].buttons[CTL_R_SHOULDER]; m_JoyShoulderR[controller]->SetValue(tmp); tmp.clear(); tmp << PadMapping[controller].buttons[CTL_R_SHOULDER]; m_JoyShoulderR[controller]->SetValue(tmp); tmp.clear();
tmp << joysticks[controller].buttons[CTL_A_BUTTON]; m_JoyButtonA[controller]->SetValue(tmp); tmp.clear(); tmp << PadMapping[controller].buttons[CTL_A_BUTTON]; m_JoyButtonA[controller]->SetValue(tmp); tmp.clear();
tmp << joysticks[controller].buttons[CTL_B_BUTTON]; m_JoyButtonB[controller]->SetValue(tmp); tmp.clear(); tmp << PadMapping[controller].buttons[CTL_B_BUTTON]; m_JoyButtonB[controller]->SetValue(tmp); tmp.clear();
tmp << joysticks[controller].buttons[CTL_X_BUTTON]; m_JoyButtonX[controller]->SetValue(tmp); tmp.clear(); tmp << PadMapping[controller].buttons[CTL_X_BUTTON]; m_JoyButtonX[controller]->SetValue(tmp); tmp.clear();
tmp << joysticks[controller].buttons[CTL_Y_BUTTON]; m_JoyButtonY[controller]->SetValue(tmp); tmp.clear(); tmp << PadMapping[controller].buttons[CTL_Y_BUTTON]; m_JoyButtonY[controller]->SetValue(tmp); tmp.clear();
tmp << joysticks[controller].buttons[CTL_Z_TRIGGER]; m_JoyButtonZ[controller]->SetValue(tmp); tmp.clear(); tmp << PadMapping[controller].buttons[CTL_Z_TRIGGER]; m_JoyButtonZ[controller]->SetValue(tmp); tmp.clear();
tmp << joysticks[controller].buttons[CTL_START]; m_JoyButtonStart[controller]->SetValue(tmp); tmp.clear(); tmp << PadMapping[controller].buttons[CTL_START]; m_JoyButtonStart[controller]->SetValue(tmp); tmp.clear();
tmp << joysticks[controller].halfpress; m_JoyButtonHalfpress[controller]->SetValue(tmp); tmp.clear(); tmp << PadMapping[controller].halfpress; m_JoyButtonHalfpress[controller]->SetValue(tmp); tmp.clear();
tmp << joysticks[controller].axis[CTL_MAIN_X]; m_JoyAnalogMainX[controller]->SetValue(tmp); tmp.clear(); tmp << PadMapping[controller].axis[CTL_MAIN_X]; m_JoyAnalogMainX[controller]->SetValue(tmp); tmp.clear();
tmp << joysticks[controller].axis[CTL_MAIN_Y]; m_JoyAnalogMainY[controller]->SetValue(tmp); tmp.clear(); tmp << PadMapping[controller].axis[CTL_MAIN_Y]; m_JoyAnalogMainY[controller]->SetValue(tmp); tmp.clear();
tmp << joysticks[controller].axis[CTL_SUB_X]; m_JoyAnalogSubX[controller]->SetValue(tmp); tmp.clear(); tmp << PadMapping[controller].axis[CTL_SUB_X]; m_JoyAnalogSubX[controller]->SetValue(tmp); tmp.clear();
tmp << joysticks[controller].axis[CTL_SUB_Y]; m_JoyAnalogSubY[controller]->SetValue(tmp); tmp.clear(); tmp << PadMapping[controller].axis[CTL_SUB_Y]; m_JoyAnalogSubY[controller]->SetValue(tmp); tmp.clear();
// Update the deadzone and controller type controls // Update the deadzone and controller type controls
m_ControlType[controller]->SetSelection(joysticks[controller].controllertype); m_ControlType[controller]->SetSelection(PadMapping[controller].controllertype);
m_TriggerType[controller]->SetSelection(joysticks[controller].triggertype); m_TriggerType[controller]->SetSelection(PadMapping[controller].triggertype);
m_Deadzone[controller]->SetSelection(joysticks[controller].deadzone); m_Deadzone[controller]->SetSelection(PadMapping[controller].deadzone);
m_CoBDiagonal[controller]->SetValue(wxString::FromAscii(PadMapping[controller].SDiagonal.c_str()));
m_CBS_to_C[controller]->SetValue(PadMapping[controller].bSquareToCircle);
LogMsg("bSquareToCircle: %i\n", PadMapping[controller].bSquareToCircle);
// Update D-Pad // Update D-Pad
if(joysticks[controller].controllertype == CTL_DPAD_HAT) if(PadMapping[controller].controllertype == CTL_DPAD_HAT)
{ {
tmp << joysticks[controller].dpad; m_JoyDpadUp[controller]->SetValue(tmp); tmp.clear(); tmp << PadMapping[controller].dpad; m_JoyDpadUp[controller]->SetValue(tmp); tmp.clear();
} }
else else
{ {
tmp << joysticks[controller].dpad2[CTL_D_PAD_UP]; m_JoyDpadUp[controller]->SetValue(tmp); tmp.clear(); tmp << PadMapping[controller].dpad2[CTL_D_PAD_UP]; m_JoyDpadUp[controller]->SetValue(tmp); tmp.clear();
tmp << joysticks[controller].dpad2[CTL_D_PAD_DOWN]; m_JoyDpadDown[controller]->SetValue(tmp); tmp.clear(); tmp << PadMapping[controller].dpad2[CTL_D_PAD_DOWN]; m_JoyDpadDown[controller]->SetValue(tmp); tmp.clear();
tmp << joysticks[controller].dpad2[CTL_D_PAD_LEFT]; m_JoyDpadLeft[controller]->SetValue(tmp); tmp.clear(); tmp << PadMapping[controller].dpad2[CTL_D_PAD_LEFT]; m_JoyDpadLeft[controller]->SetValue(tmp); tmp.clear();
tmp << joysticks[controller].dpad2[CTL_D_PAD_RIGHT]; m_JoyDpadRight[controller]->SetValue(tmp); tmp.clear(); tmp << PadMapping[controller].dpad2[CTL_D_PAD_RIGHT]; m_JoyDpadRight[controller]->SetValue(tmp); tmp.clear();
} }
} }
/* Populate the joysticks array with the dialog items settings, for example /* Populate the PadMapping array with the dialog items settings (for example
selected joystick, enabled or disabled status and so on */ selected joystick, enabled or disabled status and so on) */
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
void ConfigBox::SaveButtonMapping(int controller, bool DontChangeId) void ConfigBox::SaveButtonMapping(int controller, bool DontChangeId, int FromSlot)
{ {
// Temporary storage // Temporary storage
wxString tmp; wxString tmp;
long value; long value;
// Save from or to the same or different slots
if (FromSlot == -1) FromSlot = controller;
// Replace "" with "-1" // Replace "" with "-1"
ToBlank(false); ToBlank(false);
// Set enabled or disable status and other settings // Set enabled or disable status and other settings
if(!DontChangeId) joysticks[controller].ID = m_Joyname[controller]->GetSelection(); if(!DontChangeId) PadMapping[controller].ID = m_Joyname[FromSlot]->GetSelection();
joysticks[controller].enabled = m_Joyattach[controller]->GetValue(); if(FromSlot == controller) PadMapping[controller].enabled = m_Joyattach[FromSlot]->GetValue(); // Only enable one
joysticks[controller].controllertype = m_ControlType[controller]->GetSelection(); PadMapping[controller].controllertype = m_ControlType[FromSlot]->GetSelection();
joysticks[controller].triggertype = m_TriggerType[controller]->GetSelection(); PadMapping[controller].triggertype = m_TriggerType[FromSlot]->GetSelection();
joysticks[controller].deadzone = m_Deadzone[controller]->GetSelection(); PadMapping[controller].deadzone = m_Deadzone[FromSlot]->GetSelection();
PadMapping[controller].SDiagonal = m_CoBDiagonal[FromSlot]->GetLabel().mb_str();
PadMapping[controller].bSquareToCircle = m_CBS_to_C[FromSlot]->IsChecked();
// The analog buttons // The analog buttons
m_JoyAnalogMainX[controller]->GetValue().ToLong(&value); joysticks[controller].axis[CTL_MAIN_X] = value; tmp.clear(); m_JoyAnalogMainX[FromSlot]->GetValue().ToLong(&value); PadMapping[controller].axis[CTL_MAIN_X] = value; tmp.clear();
m_JoyAnalogMainY[controller]->GetValue().ToLong(&value); joysticks[controller].axis[CTL_MAIN_Y] = value; tmp.clear(); m_JoyAnalogMainY[FromSlot]->GetValue().ToLong(&value); PadMapping[controller].axis[CTL_MAIN_Y] = value; tmp.clear();
m_JoyAnalogSubX[controller]->GetValue().ToLong(&value); joysticks[controller].axis[CTL_SUB_X] = value; tmp.clear(); m_JoyAnalogSubX[FromSlot]->GetValue().ToLong(&value); PadMapping[controller].axis[CTL_SUB_X] = value; tmp.clear();
m_JoyAnalogSubY[controller]->GetValue().ToLong(&value); joysticks[controller].axis[CTL_SUB_Y] = value; tmp.clear(); m_JoyAnalogSubY[FromSlot]->GetValue().ToLong(&value); PadMapping[controller].axis[CTL_SUB_Y] = value; tmp.clear();
// The shoulder buttons // The shoulder buttons
m_JoyShoulderL[controller]->GetValue().ToLong(&value); joysticks[controller].buttons[CTL_L_SHOULDER] = value; m_JoyShoulderL[FromSlot]->GetValue().ToLong(&value); PadMapping[controller].buttons[CTL_L_SHOULDER] = value;
m_JoyShoulderR[controller]->GetValue().ToLong(&value); joysticks[controller].buttons[CTL_R_SHOULDER] = value; m_JoyShoulderR[FromSlot]->GetValue().ToLong(&value); PadMapping[controller].buttons[CTL_R_SHOULDER] = value;
// The digital buttons // The digital buttons
m_JoyButtonA[controller]->GetValue().ToLong(&value); joysticks[controller].buttons[CTL_A_BUTTON] = value; tmp.clear(); m_JoyButtonA[FromSlot]->GetValue().ToLong(&value); PadMapping[controller].buttons[CTL_A_BUTTON] = value; tmp.clear();
m_JoyButtonB[controller]->GetValue().ToLong(&value); joysticks[controller].buttons[CTL_B_BUTTON] = value; tmp.clear(); m_JoyButtonB[FromSlot]->GetValue().ToLong(&value); PadMapping[controller].buttons[CTL_B_BUTTON] = value; tmp.clear();
m_JoyButtonX[controller]->GetValue().ToLong(&value); joysticks[controller].buttons[CTL_X_BUTTON] = value; tmp.clear(); m_JoyButtonX[FromSlot]->GetValue().ToLong(&value); PadMapping[controller].buttons[CTL_X_BUTTON] = value; tmp.clear();
m_JoyButtonY[controller]->GetValue().ToLong(&value); joysticks[controller].buttons[CTL_Y_BUTTON] = value; tmp.clear(); m_JoyButtonY[FromSlot]->GetValue().ToLong(&value); PadMapping[controller].buttons[CTL_Y_BUTTON] = value; tmp.clear();
m_JoyButtonZ[controller]->GetValue().ToLong(&value); joysticks[controller].buttons[CTL_Z_TRIGGER] = value; tmp.clear(); m_JoyButtonZ[FromSlot]->GetValue().ToLong(&value); PadMapping[controller].buttons[CTL_Z_TRIGGER] = value; tmp.clear();
m_JoyButtonStart[controller]->GetValue().ToLong(&value); joysticks[controller].buttons[CTL_START] = value; tmp.clear(); m_JoyButtonStart[FromSlot]->GetValue().ToLong(&value); PadMapping[controller].buttons[CTL_START] = value; tmp.clear();
LogMsg("SaveButtonMapping: Key:%i From:%i To:%i\n", m_TriggerType[FromSlot]->GetSelection(), FromSlot, controller);
// The halfpress button // The halfpress button
m_JoyButtonHalfpress[controller]->GetValue().ToLong(&value); joysticks[controller].halfpress = value; tmp.clear(); m_JoyButtonHalfpress[FromSlot]->GetValue().ToLong(&value); PadMapping[controller].halfpress = value; tmp.clear();
// The digital pad // The digital pad
if(joysticks[controller].controllertype == CTL_DPAD_HAT) if(PadMapping[controller].controllertype == CTL_DPAD_HAT)
{ {
m_JoyDpadUp[controller]->GetValue().ToLong(&value); joysticks[controller].dpad = value; tmp.clear(); m_JoyDpadUp[FromSlot]->GetValue().ToLong(&value); PadMapping[controller].dpad = value; tmp.clear();
} }
else else
{ {
m_JoyDpadUp[controller]->GetValue().ToLong(&value); joysticks[controller].dpad2[CTL_D_PAD_UP] = value; tmp.clear(); m_JoyDpadUp[FromSlot]->GetValue().ToLong(&value); PadMapping[controller].dpad2[CTL_D_PAD_UP] = value; tmp.clear();
m_JoyDpadDown[controller]->GetValue().ToLong(&value); joysticks[controller].dpad2[CTL_D_PAD_DOWN] = value; tmp.clear(); m_JoyDpadDown[FromSlot]->GetValue().ToLong(&value); PadMapping[controller].dpad2[CTL_D_PAD_DOWN] = value; tmp.clear();
m_JoyDpadLeft[controller]->GetValue().ToLong(&value); joysticks[controller].dpad2[CTL_D_PAD_LEFT] = value; tmp.clear(); m_JoyDpadLeft[FromSlot]->GetValue().ToLong(&value); PadMapping[controller].dpad2[CTL_D_PAD_LEFT] = value; tmp.clear();
m_JoyDpadRight[controller]->GetValue().ToLong(&value); joysticks[controller].dpad2[CTL_D_PAD_RIGHT] = value; tmp.clear(); m_JoyDpadRight[FromSlot]->GetValue().ToLong(&value); PadMapping[controller].dpad2[CTL_D_PAD_RIGHT] = value; tmp.clear();
} }
// Replace "-1" with "" // Replace "-1" with ""
ToBlank(); ToBlank();
} }
// Change controller type
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Called from: When the controller type is changed
void ConfigBox::ChangeControllertype(wxCommandEvent& event)
{
SaveButtonMapping(notebookpage);
UpdateGUI(notebookpage);
}
// Update the textbox for the buttons // Update the textbox for the buttons
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
void ConfigBox::SetButtonText(int id, char text[128]) void ConfigBox::SetButtonText(int id, char text[128])
@ -271,8 +271,8 @@ void ConfigBox::DoGetButtons(int GetId)
int Controller = notebookpage; int Controller = notebookpage;
// Get the controller and trigger type // Get the controller and trigger type
int ControllerType = joysticks[Controller].controllertype; int ControllerType = PadMapping[Controller].controllertype;
int TriggerType = joysticks[Controller].triggertype; int TriggerType = PadMapping[Controller].triggertype;
// Collect the accepted buttons for this slot // Collect the accepted buttons for this slot
bool LeftRight = (GetId == IDB_SHOULDER_L || GetId == IDB_SHOULDER_R); bool LeftRight = (GetId == IDB_SHOULDER_L || GetId == IDB_SHOULDER_R);
@ -287,11 +287,11 @@ void ConfigBox::DoGetButtons(int GetId)
|| (GetId >= IDB_DPAD_UP && GetId <= IDB_DPAD_RIGHT && ControllerType == CTL_DPAD_CUSTOM); // Or the custom hat mode || (GetId >= IDB_DPAD_UP && GetId <= IDB_DPAD_RIGHT && ControllerType == CTL_DPAD_CUSTOM); // Or the custom hat mode
bool Hat = (GetId >= IDB_DPAD_UP && GetId <= IDB_DPAD_RIGHT) // All DPads bool Hat = (GetId >= IDB_DPAD_UP && GetId <= IDB_DPAD_RIGHT) // All DPads
&& (joysticks[Controller].controllertype == CTL_DPAD_HAT); // Not with the hat option defined && (PadMapping[Controller].controllertype == CTL_DPAD_HAT); // Not with the hat option defined
/* Open a new joystick. Joysticks[controller].GetId is the system GetId of the physical joystick /* Open a new joystick. Joysticks[controller].GetId is the system GetId of the physical joystick
that is mapped to controller, for example 0, 1, 2, 3 for the first four joysticks */ that is mapped to controller, for example 0, 1, 2, 3 for the first four PadMapping */
SDL_Joystick *joy = SDL_JoystickOpen(joysticks[Controller].ID); SDL_Joystick *joy = SDL_JoystickOpen(PadMapping[Controller].ID);
// Get the number of axes, hats and buttons // Get the number of axes, hats and buttons
int buttons = SDL_JoystickNumButtons(joy); int buttons = SDL_JoystickNumButtons(joy);
@ -475,6 +475,13 @@ void ConfigBox::DoGetButtons(int GetId)
// Update the button mapping and GUI // Update the button mapping and GUI
SaveButtonMapping(Controller); SaveButtonMapping(Controller);
UpdateGUI(Controller); UpdateGUI(Controller);
/* Update the button mapping for all slots that use this device. (It doesn't make sense to have several slots
controlled by the same device, but several DirectInput instances of different but identical devices may possible
have the same id, I don't know. So we have to do this. The user may also have selected the same device for
several disabled slots. */
if(g_Config.bSaveByID) UpdateAllSlots(Controller);
} }
// If we got a bad button // If we got a bad button
@ -491,7 +498,7 @@ void ConfigBox::DoGetButtons(int GetId)
// ======================== Process results // ======================== Process results
// We don't need this gamepad handle any more // We don't need this gamepad handle any more
if(SDL_JoystickOpened(joysticks[Controller].ID)) SDL_JoystickClose(joy); if(SDL_JoystickOpened(PadMapping[Controller].ID)) SDL_JoystickClose(joy);
// Debugging // Debugging
//Console::Print("IsRunning: %i\n", m_ButtonMappingTimer->IsRunning()); //Console::Print("IsRunning: %i\n", m_ButtonMappingTimer->IsRunning());

2
Source/Plugins/Plugin_nJoy_SDL/Src/Rumble.cpp
View File

@ -172,7 +172,7 @@ void Pad_Use_Rumble(u8 _numPAD, SPADStatus* _pPADStatus)
#elif defined(__linux__) #elif defined(__linux__)
if (!fd) if (!fd)
{ {
sprintf(device_file_name, "/dev/input/event%d", joysticks[_numPAD].eventnum); //TODO: Make dynamic // sprintf(device_file_name, "/dev/input/event%d", PadMapping[_numPAD].eventnum); //TODO: Make dynamic //
/* Open device */ /* Open device */
fd = open(device_file_name, O_RDWR); fd = open(device_file_name, O_RDWR);

126
Source/Plugins/Plugin_nJoy_SDL/Src/nJoy.cpp
View File

@ -47,18 +47,18 @@
// Variables guide // Variables guide
/* ¯¯¯¯¯¯¯¯¯ /* ¯¯¯¯¯¯¯¯¯
Joyinfo: A hardcoded struct of with gamepad info that is populate by Search_Devices() Joyinfo[1, 2, 3, 4, ..., number of attached devices]: Gamepad info that is populate by Search_Devices()
Joysticks: A custom struct with the button mapping PadMapping[1, 2, 3 and 4]: The button mapping
Joystate: A custom struct with the current button states Joystate[1, 2, 3 and 4]: The current button states
The arrays joysticks[] and joystate[] are numbered 0 to 3 for the four different virtual The arrays PadMapping[] and joystate[] are numbered 0 to 3 for the four different virtual
controllers. Joysticks[].ID will have the number of the physical input device mapped to that controllers. Joysticks[].ID will have the number of the physical input device mapped to that
controller (this value range between 0 and the total number of connected physical devices). The controller (this value range between 0 and the total number of connected physical devices). The
mapping of a certain physical device to joystate[].joy is initially done by Initialize(), but mapping of a certain physical device to joystate[].joy is initially done by Initialize(), but
for the configuration we can remap that, like in ConfigBox::ChangeJoystick(). for the configuration we can remap that, like in ConfigBox::ChangeJoystick().
The joyinfo[] array holds the physical gamepad info for a certain physical device. It's therefore The joyinfo[] array holds the physical gamepad info for a certain physical device. It's therefore
used as joyinfo[joysticks[controller].ID] if we want to get the joyinfo for a certain joystick. used as joyinfo[PadMapping[controller].ID] if we want to get the joyinfo for a certain joystick.
////////////////////////*/ ////////////////////////*/
@ -86,7 +86,7 @@ FILE *pFile;
HINSTANCE nJoy_hInst = NULL; HINSTANCE nJoy_hInst = NULL;
CONTROLLER_INFO *joyinfo = 0; CONTROLLER_INFO *joyinfo = 0;
CONTROLLER_STATE joystate[4]; CONTROLLER_STATE joystate[4];
CONTROLLER_MAPPING joysticks[4]; CONTROLLER_MAPPING PadMapping[4];
bool emulator_running = FALSE; bool emulator_running = FALSE;
HWND m_hWnd; // Handle to window HWND m_hWnd; // Handle to window
@ -264,15 +264,15 @@ void Initialize(void *init)
#endif #endif
Search_Devices(); // Populate joyinfo for all attached devices Search_Devices(); // Populate joyinfo for all attached devices
g_Config.Load(); // Load joystick mapping, joysticks[].ID etc g_Config.Load(); // Load joystick mapping, PadMapping[].ID etc
if (joysticks[0].enabled) if (PadMapping[0].enabled)
joystate[0].joy = SDL_JoystickOpen(joysticks[0].ID); joystate[0].joy = SDL_JoystickOpen(PadMapping[0].ID);
if (joysticks[1].enabled) if (PadMapping[1].enabled)
joystate[1].joy = SDL_JoystickOpen(joysticks[1].ID); joystate[1].joy = SDL_JoystickOpen(PadMapping[1].ID);
if (joysticks[2].enabled) if (PadMapping[2].enabled)
joystate[2].joy = SDL_JoystickOpen(joysticks[2].ID); joystate[2].joy = SDL_JoystickOpen(PadMapping[2].ID);
if (joysticks[3].enabled) if (PadMapping[3].enabled)
joystate[3].joy = SDL_JoystickOpen(joysticks[3].ID); joystate[3].joy = SDL_JoystickOpen(PadMapping[3].ID);
} }
@ -297,7 +297,7 @@ int Search_Devices()
joyinfo = new CONTROLLER_INFO [numjoy]; joyinfo = new CONTROLLER_INFO [numjoy];
} }
// Warn the user if no joysticks are detected // Warn the user if no PadMapping are detected
if (numjoy == 0) if (numjoy == 0)
{ {
#ifdef _WIN32 #ifdef _WIN32
@ -348,13 +348,13 @@ int Search_Devices()
Called from: The Dolphin Core, ConfigBox::OnClose() */ Called from: The Dolphin Core, ConfigBox::OnClose() */
void Shutdown() void Shutdown()
{ {
if (joysticks[0].enabled && SDL_JoystickOpened(joysticks[0].ID)) if (PadMapping[0].enabled && SDL_JoystickOpened(PadMapping[0].ID))
SDL_JoystickClose(joystate[0].joy); SDL_JoystickClose(joystate[0].joy);
if (joysticks[1].enabled && SDL_JoystickOpened(joysticks[1].ID)) if (PadMapping[1].enabled && SDL_JoystickOpened(PadMapping[1].ID))
SDL_JoystickClose(joystate[1].joy); SDL_JoystickClose(joystate[1].joy);
if (joysticks[2].enabled && SDL_JoystickOpened(joysticks[2].ID)) if (PadMapping[2].enabled && SDL_JoystickOpened(PadMapping[2].ID))
SDL_JoystickClose(joystate[2].joy); SDL_JoystickClose(joystate[2].joy);
if (joysticks[3].enabled && SDL_JoystickOpened(joysticks[3].ID)) if (PadMapping[3].enabled && SDL_JoystickOpened(PadMapping[3].ID))
SDL_JoystickClose(joystate[3].joy); SDL_JoystickClose(joystate[3].joy);
SDL_Quit(); SDL_Quit();
@ -386,13 +386,13 @@ void PAD_Input(u16 _Key, u8 _UpDown)
{ {
for(int j = CTL_L_SHOULDER; j <= CTL_START; j++) for(int j = CTL_L_SHOULDER; j <= CTL_START; j++)
{ {
if (joysticks[i].buttons[j] == _Key) if (PadMapping[i].buttons[j] == _Key)
{ joystate[i].buttons[j] = _UpDown; break; } { joystate[i].buttons[j] = _UpDown; break; }
} }
for(int j = CTL_D_PAD_UP; j <= CTL_D_PAD_RIGHT; j++) for(int j = CTL_D_PAD_UP; j <= CTL_D_PAD_RIGHT; j++)
{ {
if (joysticks[i].dpad2[j] == _Key) if (PadMapping[i].dpad2[j] == _Key)
{ joystate[i].dpad2[j] = _UpDown; break; } { joystate[i].dpad2[j] = _UpDown; break; }
} }
} }
@ -413,7 +413,7 @@ void DoState(unsigned char **ptr, int mode) {}
// Function: Gives the current pad status to the Core // Function: Gives the current pad status to the Core
void PAD_GetStatus(u8 _numPAD, SPADStatus* _pPADStatus) void PAD_GetStatus(u8 _numPAD, SPADStatus* _pPADStatus)
{ {
if (!joysticks[_numPAD].enabled) if (!PadMapping[_numPAD].enabled)
return; return;
// Clear pad status // Clear pad status
@ -423,7 +423,7 @@ void PAD_GetStatus(u8 _numPAD, SPADStatus* _pPADStatus)
GetJoyState(_numPAD); GetJoyState(_numPAD);
// Get type // Get type
int TriggerType = joysticks[_numPAD].triggertype; int TriggerType = PadMapping[_numPAD].triggertype;
/////////////////////////////////////////////////// ///////////////////////////////////////////////////
// The analog controls // The analog controls
@ -438,7 +438,7 @@ void PAD_GetStatus(u8 _numPAD, SPADStatus* _pPADStatus)
int TriggerRight = joystate[_numPAD].axis[CTL_R_SHOULDER]; int TriggerRight = joystate[_numPAD].axis[CTL_R_SHOULDER];
// Check if we should make adjustments // Check if we should make adjustments
if(g_Config.bSquareToCircle.at(_numPAD)) if(PadMapping[_numPAD].bSquareToCircle)
{ {
std::vector<int> main_xy = Pad_Square_to_Circle(i_main_stick_x, i_main_stick_y, _numPAD); std::vector<int> main_xy = Pad_Square_to_Circle(i_main_stick_x, i_main_stick_y, _numPAD);
i_main_stick_x = main_xy.at(0); i_main_stick_x = main_xy.at(0);
@ -452,15 +452,15 @@ void PAD_GetStatus(u8 _numPAD, SPADStatus* _pPADStatus)
u8 sub_stick_y = Pad_Convert(i_sub_stick_y); u8 sub_stick_y = Pad_Convert(i_sub_stick_y);
// Convert the triggers values // Convert the triggers values
if(joysticks[_numPAD].triggertype == CTL_TRIGGER_SDL) if(PadMapping[_numPAD].triggertype == CTL_TRIGGER_SDL)
{ {
TriggerLeft = Pad_Convert(TriggerLeft); TriggerLeft = Pad_Convert(TriggerLeft);
TriggerRight = Pad_Convert(TriggerRight); TriggerRight = Pad_Convert(TriggerRight);
} }
// Set Deadzones (perhaps out of function?) // Set Deadzones (perhaps out of function?)
int deadzone = (int)(((float)(128.00/100.00)) * (float)(joysticks[_numPAD].deadzone + 1)); int deadzone = (int)(((float)(128.00/100.00)) * (float)(PadMapping[_numPAD].deadzone + 1));
int deadzone2 = (int)(((float)(-128.00/100.00)) * (float)(joysticks[_numPAD].deadzone + 1)); int deadzone2 = (int)(((float)(-128.00/100.00)) * (float)(PadMapping[_numPAD].deadzone + 1));
// Send values to Dolpin if they are outside the deadzone // Send values to Dolpin if they are outside the deadzone
if ((main_stick_x < deadzone2) || (main_stick_x > deadzone)) _pPADStatus->stickX = main_stick_x; if ((main_stick_x < deadzone2) || (main_stick_x > deadzone)) _pPADStatus->stickX = main_stick_x;
@ -519,7 +519,7 @@ void PAD_GetStatus(u8 _numPAD, SPADStatus* _pPADStatus)
/////////////////////////////////////////////////// ///////////////////////////////////////////////////
// The D-pad // The D-pad
// ----------- // -----------
if (joysticks[_numPAD].controllertype == CTL_DPAD_HAT) if (PadMapping[_numPAD].controllertype == CTL_DPAD_HAT)
{ {
if (joystate[_numPAD].dpad == SDL_HAT_LEFTUP || joystate[_numPAD].dpad == SDL_HAT_UP || joystate[_numPAD].dpad == SDL_HAT_RIGHTUP ) _pPADStatus->button|=PAD_BUTTON_UP; if (joystate[_numPAD].dpad == SDL_HAT_LEFTUP || joystate[_numPAD].dpad == SDL_HAT_UP || joystate[_numPAD].dpad == SDL_HAT_RIGHTUP ) _pPADStatus->button|=PAD_BUTTON_UP;
if (joystate[_numPAD].dpad == SDL_HAT_LEFTUP || joystate[_numPAD].dpad == SDL_HAT_LEFT || joystate[_numPAD].dpad == SDL_HAT_LEFTDOWN ) _pPADStatus->button|=PAD_BUTTON_LEFT; if (joystate[_numPAD].dpad == SDL_HAT_LEFTUP || joystate[_numPAD].dpad == SDL_HAT_LEFT || joystate[_numPAD].dpad == SDL_HAT_LEFTDOWN ) _pPADStatus->button|=PAD_BUTTON_LEFT;
@ -549,9 +549,9 @@ void PAD_GetStatus(u8 _numPAD, SPADStatus* _pPADStatus)
Console::Print( Console::Print(
"Trigger type: %s Left:%04x Right:%04x Value:%i\n" "Trigger type: %s Left:%04x Right:%04x Value:%i\n"
"D-Pad type: %s L:%i R:%i U:%i D:%i", "D-Pad type: %s L:%i R:%i U:%i D:%i",
(joysticks[_numPAD].triggertype ? "CTL_TRIGGER_XINPUT" : "CTL_TRIGGER_SDL"), (PadMapping[_numPAD].triggertype ? "CTL_TRIGGER_XINPUT" : "CTL_TRIGGER_SDL"),
TriggerLeft, TriggerRight, TriggerValue, TriggerLeft, TriggerRight, TriggerValue,
(joysticks[_numPAD].controllertype ? "CTL_DPAD_CUSTOM" : "CTL_DPAD_HAT"), (PadMapping[_numPAD].controllertype ? "CTL_DPAD_CUSTOM" : "CTL_DPAD_HAT"),
0, 0, 0, 0 0, 0, 0, 0
);*/ );*/
} }
@ -565,10 +565,10 @@ unsigned int PAD_GetAttachedPads()
g_Config.Load(); g_Config.Load();
if (joysticks[0].enabled) connected |= 1; if (PadMapping[0].enabled) connected |= 1;
if (joysticks[1].enabled) connected |= 2; if (PadMapping[1].enabled) connected |= 2;
if (joysticks[2].enabled) connected |= 4; if (PadMapping[2].enabled) connected |= 4;
if (joysticks[3].enabled) connected |= 8; if (PadMapping[3].enabled) connected |= 8;
return connected; return connected;
} }
@ -648,7 +648,7 @@ std::vector<int> Pad_Square_to_Circle(int _x, int _y, int _pad)
// ==================================== // ====================================
// Convert to circle // Convert to circle
// ----------- // -----------
int Tmp = atoi (g_Config.SDiagonal.at(_pad).substr(0, g_Config.SDiagonal.at(_pad).length() - 1).c_str()); int Tmp = atoi (PadMapping[_pad].SDiagonal.substr(0, PadMapping[_pad].SDiagonal.length() - 1).c_str());
float Diagonal = Tmp / 100.0; float Diagonal = Tmp / 100.0;
// First make a perfect square in case we don't have one already // First make a perfect square in case we don't have one already
@ -695,7 +695,7 @@ std::vector<int> Pad_Square_to_Circle(int _x, int _y, int _pad)
// Read current joystick status // Read current joystick status
/* ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ /* ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
The value joysticks[].buttons[] is the number of the assigned joypad button, The value PadMapping[].buttons[] is the number of the assigned joypad button,
joystate[].buttons[] is the status of the button, it becomes 0 (no pressed) or 1 (pressed) */ joystate[].buttons[] is the status of the button, it becomes 0 (no pressed) or 1 (pressed) */
@ -703,8 +703,8 @@ std::vector<int> Pad_Square_to_Circle(int _x, int _y, int _pad)
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
void ReadButton(int controller, int button) void ReadButton(int controller, int button)
{ {
int ctl_button = joysticks[controller].buttons[button]; int ctl_button = PadMapping[controller].buttons[button];
if (ctl_button < joyinfo[joysticks[controller].ID].NumButtons) if (ctl_button < joyinfo[PadMapping[controller].ID].NumButtons)
{ {
joystate[controller].buttons[button] = SDL_JoystickGetButton(joystate[controller].joy, ctl_button); joystate[controller].buttons[button] = SDL_JoystickGetButton(joystate[controller].joy, ctl_button);
} }
@ -722,27 +722,27 @@ void GetJoyState(int controller)
SDL_JoystickUpdate(); SDL_JoystickUpdate();
// Save the number of buttons // Save the number of buttons
int Buttons = joyinfo[joysticks[controller].ID].NumButtons; int Buttons = joyinfo[PadMapping[controller].ID].NumButtons;
// Update axis states. It doesn't hurt much if we happen to ask for nonexisting axises here. // Update axis states. It doesn't hurt much if we happen to ask for nonexisting axises here.
joystate[controller].axis[CTL_MAIN_X] = SDL_JoystickGetAxis(joystate[controller].joy, joysticks[controller].axis[CTL_MAIN_X]); joystate[controller].axis[CTL_MAIN_X] = SDL_JoystickGetAxis(joystate[controller].joy, PadMapping[controller].axis[CTL_MAIN_X]);
joystate[controller].axis[CTL_MAIN_Y] = SDL_JoystickGetAxis(joystate[controller].joy, joysticks[controller].axis[CTL_MAIN_Y]); joystate[controller].axis[CTL_MAIN_Y] = SDL_JoystickGetAxis(joystate[controller].joy, PadMapping[controller].axis[CTL_MAIN_Y]);
joystate[controller].axis[CTL_SUB_X] = SDL_JoystickGetAxis(joystate[controller].joy, joysticks[controller].axis[CTL_SUB_X]); joystate[controller].axis[CTL_SUB_X] = SDL_JoystickGetAxis(joystate[controller].joy, PadMapping[controller].axis[CTL_SUB_X]);
joystate[controller].axis[CTL_SUB_Y] = SDL_JoystickGetAxis(joystate[controller].joy, joysticks[controller].axis[CTL_SUB_Y]); joystate[controller].axis[CTL_SUB_Y] = SDL_JoystickGetAxis(joystate[controller].joy, PadMapping[controller].axis[CTL_SUB_Y]);
// Update trigger axises // Update trigger axises
#ifdef _WIN32 #ifdef _WIN32
if (joysticks[controller].triggertype == CTL_TRIGGER_SDL) if (PadMapping[controller].triggertype == CTL_TRIGGER_SDL)
{ {
#endif #endif
joystate[controller].axis[CTL_L_SHOULDER] = SDL_JoystickGetAxis(joystate[controller].joy, joysticks[controller].buttons[CTL_L_SHOULDER] - 1000); joystate[controller].axis[CTL_L_SHOULDER] = SDL_JoystickGetAxis(joystate[controller].joy, PadMapping[controller].buttons[CTL_L_SHOULDER] - 1000);
joystate[controller].axis[CTL_R_SHOULDER] = SDL_JoystickGetAxis(joystate[controller].joy, joysticks[controller].buttons[CTL_R_SHOULDER] - 1000); joystate[controller].axis[CTL_R_SHOULDER] = SDL_JoystickGetAxis(joystate[controller].joy, PadMapping[controller].buttons[CTL_R_SHOULDER] - 1000);
#ifdef _WIN32 #ifdef _WIN32
} }
else else
{ {
joystate[controller].axis[CTL_L_SHOULDER] = XInput::GetXI(0, joysticks[controller].buttons[CTL_L_SHOULDER] - 1000); joystate[controller].axis[CTL_L_SHOULDER] = XInput::GetXI(0, PadMapping[controller].buttons[CTL_L_SHOULDER] - 1000);
joystate[controller].axis[CTL_R_SHOULDER] = XInput::GetXI(0, joysticks[controller].buttons[CTL_R_SHOULDER] - 1000); joystate[controller].axis[CTL_R_SHOULDER] = XInput::GetXI(0, PadMapping[controller].buttons[CTL_R_SHOULDER] - 1000);
} }
#endif #endif
@ -752,8 +752,8 @@ void GetJoyState(int controller)
"Controller and handle: %i %i\n" "Controller and handle: %i %i\n"
"Triggers:%i %i %i %i %i\n", "Triggers:%i %i %i %i %i\n",
controller, (int)joystate[controller].joy, controller, (int)joystate[controller].joy,
joysticks[controller].triggertype, PadMapping[controller].triggertype,
joysticks[controller].buttons[CTL_L_SHOULDER], joysticks[controller].buttons[CTL_R_SHOULDER], PadMapping[controller].buttons[CTL_L_SHOULDER], PadMapping[controller].buttons[CTL_R_SHOULDER],
joystate[controller].axis[CTL_L_SHOULDER], joystate[controller].axis[CTL_R_SHOULDER] joystate[controller].axis[CTL_L_SHOULDER], joystate[controller].axis[CTL_R_SHOULDER]
); */ ); */
@ -767,26 +767,26 @@ void GetJoyState(int controller)
ReadButton(controller, CTL_START); ReadButton(controller, CTL_START);
// //
if (joysticks[controller].halfpress < joyinfo[controller].NumButtons) if (PadMapping[controller].halfpress < joyinfo[controller].NumButtons)
joystate[controller].halfpress = SDL_JoystickGetButton(joystate[controller].joy, joysticks[controller].halfpress); joystate[controller].halfpress = SDL_JoystickGetButton(joystate[controller].joy, PadMapping[controller].halfpress);
// Check if we have an analog or digital joypad // Check if we have an analog or digital joypad
if (joysticks[controller].controllertype == CTL_DPAD_HAT) if (PadMapping[controller].controllertype == CTL_DPAD_HAT)
{ {
joystate[controller].dpad = SDL_JoystickGetHat(joystate[controller].joy, joysticks[controller].dpad); joystate[controller].dpad = SDL_JoystickGetHat(joystate[controller].joy, PadMapping[controller].dpad);
} }
else else
{ {
/* Only do this if the assigned button is in range (to allow for the current way of saving keyboard /* Only do this if the assigned button is in range (to allow for the current way of saving keyboard
keys in the same array) */ keys in the same array) */
if(joysticks[controller].dpad2[CTL_D_PAD_UP] <= Buttons) if(PadMapping[controller].dpad2[CTL_D_PAD_UP] <= Buttons)
joystate[controller].dpad2[CTL_D_PAD_UP] = SDL_JoystickGetButton(joystate[controller].joy, joysticks[controller].dpad2[CTL_D_PAD_UP]); joystate[controller].dpad2[CTL_D_PAD_UP] = SDL_JoystickGetButton(joystate[controller].joy, PadMapping[controller].dpad2[CTL_D_PAD_UP]);
if(joysticks[controller].dpad2[CTL_D_PAD_DOWN] <= Buttons) if(PadMapping[controller].dpad2[CTL_D_PAD_DOWN] <= Buttons)
joystate[controller].dpad2[CTL_D_PAD_DOWN] = SDL_JoystickGetButton(joystate[controller].joy, joysticks[controller].dpad2[CTL_D_PAD_DOWN]); joystate[controller].dpad2[CTL_D_PAD_DOWN] = SDL_JoystickGetButton(joystate[controller].joy, PadMapping[controller].dpad2[CTL_D_PAD_DOWN]);
if(joysticks[controller].dpad2[CTL_D_PAD_LEFT] <= Buttons) if(PadMapping[controller].dpad2[CTL_D_PAD_LEFT] <= Buttons)
joystate[controller].dpad2[CTL_D_PAD_LEFT] = SDL_JoystickGetButton(joystate[controller].joy, joysticks[controller].dpad2[CTL_D_PAD_LEFT]); joystate[controller].dpad2[CTL_D_PAD_LEFT] = SDL_JoystickGetButton(joystate[controller].joy, PadMapping[controller].dpad2[CTL_D_PAD_LEFT]);
if(joysticks[controller].dpad2[CTL_D_PAD_RIGHT] <= Buttons) if(PadMapping[controller].dpad2[CTL_D_PAD_RIGHT] <= Buttons)
joystate[controller].dpad2[CTL_D_PAD_RIGHT] = SDL_JoystickGetButton(joystate[controller].joy, joysticks[controller].dpad2[CTL_D_PAD_RIGHT]); joystate[controller].dpad2[CTL_D_PAD_RIGHT] = SDL_JoystickGetButton(joystate[controller].joy, PadMapping[controller].dpad2[CTL_D_PAD_RIGHT]);
} }
} }
////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////

7
Source/Plugins/Plugin_nJoy_SDL/Src/nJoy.h
View File

@ -51,6 +51,7 @@
#include "pluginspecs_pad.h" #include "pluginspecs_pad.h"
#include "IniFile.h" #include "IniFile.h"
//#include "ConsoleWindow.h" //#include "ConsoleWindow.h"
//#include "Timer.h"
#include "Config.h" // Local #include "Config.h" // Local
#include "XInput.h" #include "XInput.h"
@ -134,6 +135,8 @@ struct CONTROLLER_MAPPING // GC PAD MAPPING
int ID; // SDL joystick device ID int ID; // SDL joystick device ID
int controllertype; // Hat: Hat or custom buttons int controllertype; // Hat: Hat or custom buttons
int triggertype; // Triggers range int triggertype; // Triggers range
std::string SDiagonal;
bool bSquareToCircle;
int eventnum; // Linux Event Number, Can't be found dynamically yet int eventnum; // Linux Event Number, Can't be found dynamically yet
}; };
@ -143,7 +146,7 @@ struct CONTROLLER_INFO // CONNECTED WINDOWS DEVICES INFO
int NumButtons; // Amount of Buttons int NumButtons; // Amount of Buttons
int NumBalls; // Amount of Balls int NumBalls; // Amount of Balls
int NumHats; // Amount of Hats (POV) int NumHats; // Amount of Hats (POV)
const char *Name; // Joypad/stickname std::string Name; // Joypad/stickname
int ID; // SDL joystick device ID int ID; // SDL joystick device ID
SDL_Joystick *joy; // SDL joystick device SDL_Joystick *joy; // SDL joystick device
}; };
@ -226,7 +229,7 @@ extern std::vector<u8> Keys;
extern FILE *pFile; extern FILE *pFile;
extern CONTROLLER_INFO *joyinfo; extern CONTROLLER_INFO *joyinfo;
extern CONTROLLER_STATE joystate[4]; extern CONTROLLER_STATE joystate[4];
extern CONTROLLER_MAPPING joysticks[4]; extern CONTROLLER_MAPPING PadMapping[4];
extern HWND m_hWnd; // Handle to window extern HWND m_hWnd; // Handle to window
#endif #endif