ShuriZma
/
fceux
mirror of https://github.com/TASEmulators/fceux.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
fceux/src/drivers/Qt/GamePadConf.cpp

1029 lines
27 KiB
C++
Raw Blame History

/* FCE Ultra - NES/Famicom Emulator
*
* Copyright notice for this file:
* Copyright (C) 2020 mjbudd77
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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 for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
// GamePadConf.cpp
//
#include <QDir>
#include <QInputDialog>
#include <QMessageBox>
#include <QScrollArea>
#include "Qt/GamePadConf.h"
#include "Qt/main.h"
#include "Qt/dface.h"
#include "Qt/input.h"
#include "Qt/config.h"
#include "Qt/keyscan.h"
#include "Qt/sdl-joystick.h"
#include "Qt/fceuWrapper.h"
struct GamePadConfigLocalData_t
{
std::string guid;
std::string profile;
struct {
char needsSave;
} btn[GAMEPAD_NUM_BUTTONS];
GamePadConfigLocalData_t(void)
{
for (int i=0; i<GAMEPAD_NUM_BUTTONS; i++)
{
btn[i].needsSave = 0;
}
}
};
static GamePadConfigLocalData_t lcl[GAMEPAD_NUM_DEVICES];
static GamePadConfDialog_t *gamePadConfWin = NULL;
//----------------------------------------------------
int openGamePadConfWindow( QWidget *parent )
{
if ( gamePadConfWin != NULL )
{
return -1;
}
gamePadConfWin = new GamePadConfDialog_t(parent);
gamePadConfWin->show();
return 0;
}
//----------------------------------------------------
int closeGamePadConfWindow(void)
{
if ( gamePadConfWin != NULL )
{
gamePadConfWin->closeWindow();
}
return 0;
}
//----------------------------------------------------
GamePadConfDialog_t::GamePadConfDialog_t(QWidget *parent)
: QDialog( parent )
, changeSeqStatus(0)
{
QWidget *mainWidget;
QVBoxLayout *mainLayout;
QHBoxLayout *hbox, *hbox1, *hbox2, *hbox3, *hbox4, *hbox5;
QVBoxLayout *vbox, *vbox1, *vbox2;
QGridLayout *grid;
QCheckBox *udlr_chkbox;
QGroupBox *frame1, *frame2;
QLabel *label;
QPushButton *newProfileButton;
QPushButton *saveProfileButton;
QPushButton *applyProfileButton;
QPushButton *removeProfileButton;
QPushButton *clearAllButton;
QPushButton *closebutton;
QPushButton *changeSeqButton = nullptr;
QPushButton *clearButton[GAMEPAD_NUM_BUTTONS];
QScrollArea *scroll;
QStyle *style;
std::string prefix;
char stmp[256];
style = this->style();
gamePadConfWin = this;
// Ensure that joysticks are enabled, no harm calling init again.
InitJoysticks();
scroll = new QScrollArea(this);
mainWidget = new QWidget();
portNum = 0;
buttonConfigStatus = 1;
inputTimer = new QTimer( this );
connect( inputTimer, &QTimer::timeout, this, &GamePadConfDialog_t::updatePeriodic );
setWindowTitle( tr("GamePad Config") );
hbox1 = new QHBoxLayout();
hbox2 = new QHBoxLayout();
hbox3 = new QHBoxLayout();
hbox4 = new QHBoxLayout();
hbox5 = new QHBoxLayout();
label = new QLabel(tr("Console Port:"));
portSel = new QComboBox();
hbox1->addWidget( label );
hbox1->addWidget( portSel );
portSel->addItem( tr("1"), 0 );
portSel->addItem( tr("2"), 1 );
portSel->addItem( tr("3"), 2 );
portSel->addItem( tr("4"), 3 );
label = new QLabel(tr("Device:"));
devSel = new QComboBox();
hbox2->addWidget( label );
hbox2->addWidget( devSel );
devSel->addItem( tr("Keyboard"), -1 );
for (int i=0; i<MAX_JOYSTICKS; i++)
{
jsDev_t *js = getJoystickDevice( i );
if ( js != NULL )
{
if ( js->isConnected() )
{
sprintf( stmp, "%i: %s", i, js->getName() );
devSel->addItem( tr(stmp), i );
}
}
}
for (int i=0; i<devSel->count(); i++)
{
if ( devSel->itemData(i).toInt() == GamePad[portNum].getDeviceIndex() )
{
devSel->setCurrentIndex( i );
}
}
label = new QLabel(tr("GUID:"));
guidLbl = new QLabel();
hbox3->addWidget( label );
hbox3->addWidget( guidLbl );
guidLbl->setText( GamePad[portNum].getGUID() );
frame1 = new QGroupBox(tr("Mapping Profile:"));
//grid = new QGridLayout();
vbox = new QVBoxLayout();
//frame1->setLayout( grid );
frame1->setLayout( vbox );
hbox = new QHBoxLayout();
vbox->addLayout( hbox );
mapSel = new QComboBox();
hbox->addWidget( mapSel );
mapSel->setWhatsThis( tr("Combo box for selection of a saved button mapping profile for the selected device"));
mapSel->addItem( tr("default"), 0 );
hbox = new QHBoxLayout();
vbox->addLayout( hbox );
applyProfileButton = new QPushButton( tr("Load") );
applyProfileButton->setWhatsThis(tr("Sets Current Active Map to the Selected Profile"));
applyProfileButton->setIcon( style->standardIcon( QStyle::SP_DialogApplyButton ) );
hbox->addWidget( applyProfileButton );
saveProfileButton = new QPushButton( tr("Save") );
saveProfileButton->setWhatsThis(tr("Stores Current Active Map to the Selected Profile"));
saveProfileButton->setIcon( style->standardIcon( QStyle::SP_DialogSaveButton ) );
hbox->addWidget( saveProfileButton );
hbox = new QHBoxLayout();
vbox->addLayout( hbox );
newProfileButton = new QPushButton( tr("New") );
newProfileButton->setWhatsThis(tr("Create a New Map Profile"));
newProfileButton->setIcon( style->standardIcon( QStyle::SP_FileIcon ) );
hbox->addWidget( newProfileButton );
removeProfileButton = new QPushButton( tr("Delete") );
removeProfileButton->setWhatsThis(tr("Deletes the Selected Map Profile"));
removeProfileButton->setIcon( style->standardIcon( QStyle::SP_TrashIcon ) );
hbox->addWidget( removeProfileButton );
mapMsg = new QLabel();
vbox->addWidget(mapMsg);
efs_chkbox = new QCheckBox( tr("Enable Four Score") );
udlr_chkbox = new QCheckBox( tr("Allow Up+Down/Left+Right") );
int fourScore;
g_config->getOption("SDL.FourScore", &fourScore);
efs_chkbox->setChecked( fourScore );
int opposite_dirs;
g_config->getOption("SDL.Input.EnableOppositeDirectionals", &opposite_dirs);
udlr_chkbox->setChecked( opposite_dirs );
frame2 = new QGroupBox(tr("Current Active Button Mappings:"));
grid = new QGridLayout();
grid-> setHorizontalSpacing(50);
frame2->setLayout( grid );
for (int i=0; i<GAMEPAD_NUM_BUTTONS; i++)
{
char text[64];
QLabel *buttonName;
sprintf( text, "%s:", GamePadNames[i] );
//hbox2 = new QHBoxLayout();
//hbox2->setAlignment(Qt::AlignCenter);
buttonName = new QLabel(tr(text));
keyName[i] = new QLabel();
keyState[i] = new QLabel( tr("F") );
label = new QLabel( tr("State:") );
button[i] = new GamePadConfigButton_t(i);
clearButton[i] = new QPushButton( tr("Clear") );
grid->addWidget( buttonName , i, 0, Qt::AlignCenter );
grid->addWidget( keyName[i] , i, 1, Qt::AlignCenter );
grid->addWidget( label , i, 2, Qt::AlignCenter );
grid->addWidget( keyState[i] , i, 3, Qt::AlignCenter );
grid->addWidget( button[i] , i, 4, Qt::AlignCenter );
grid->addWidget( clearButton[i], i, 5, Qt::AlignCenter );
}
updateCntrlrDpy();
clearAllButton = new QPushButton(tr("Clear All"));
closebutton = new QPushButton(tr("Close"));
changeSeqButton = new QPushButton(tr("Change Sequentially"));
clearAllButton->setIcon( style->standardIcon( QStyle::SP_LineEditClearButton ) );
closebutton->setIcon( style->standardIcon( QStyle::SP_DialogCloseButton ) );
changeSeqButton->setIcon( style->standardIcon( QStyle::QStyle::SP_ArrowDown ) );
hbox4->addWidget( clearAllButton );
hbox4->addWidget( changeSeqButton );
hbox4->addWidget( closebutton );
connect(button[0], SIGNAL(clicked()), this, SLOT(changeButton0(void)) );
connect(button[1], SIGNAL(clicked()), this, SLOT(changeButton1(void)) );
connect(button[2], SIGNAL(clicked()), this, SLOT(changeButton2(void)) );
connect(button[3], SIGNAL(clicked()), this, SLOT(changeButton3(void)) );
connect(button[4], SIGNAL(clicked()), this, SLOT(changeButton4(void)) );
connect(button[5], SIGNAL(clicked()), this, SLOT(changeButton5(void)) );
connect(button[6], SIGNAL(clicked()), this, SLOT(changeButton6(void)) );
connect(button[7], SIGNAL(clicked()), this, SLOT(changeButton7(void)) );
connect(button[8], SIGNAL(clicked()), this, SLOT(changeButton8(void)) );
connect(button[9], SIGNAL(clicked()), this, SLOT(changeButton9(void)) );
connect(clearButton[0], SIGNAL(clicked()), this, SLOT(clearButton0(void)) );
connect(clearButton[1], SIGNAL(clicked()), this, SLOT(clearButton1(void)) );
connect(clearButton[2], SIGNAL(clicked()), this, SLOT(clearButton2(void)) );
connect(clearButton[3], SIGNAL(clicked()), this, SLOT(clearButton3(void)) );
connect(clearButton[4], SIGNAL(clicked()), this, SLOT(clearButton4(void)) );
connect(clearButton[5], SIGNAL(clicked()), this, SLOT(clearButton5(void)) );
connect(clearButton[6], SIGNAL(clicked()), this, SLOT(clearButton6(void)) );
connect(clearButton[7], SIGNAL(clicked()), this, SLOT(clearButton7(void)) );
connect(clearButton[8], SIGNAL(clicked()), this, SLOT(clearButton8(void)) );
connect(clearButton[9], SIGNAL(clicked()), this, SLOT(clearButton9(void)) );
connect(newProfileButton , SIGNAL(clicked()), this, SLOT(newProfileCallback(void)) );
connect(applyProfileButton , SIGNAL(clicked()), this, SLOT(loadProfileCallback(void)) );
connect(saveProfileButton , SIGNAL(clicked()), this, SLOT(saveProfileCallback(void)) );
connect(removeProfileButton, SIGNAL(clicked()), this, SLOT(deleteProfileCallback(void)) );
connect(clearAllButton , SIGNAL(clicked()), this, SLOT(clearAllCallback(void)) );
connect(closebutton , SIGNAL(clicked()), this, SLOT(closeWindow(void)) );
connect(changeSeqButton , SIGNAL(clicked()), this, SLOT(changeSequentallyCallback(void)) );
connect(portSel , SIGNAL(activated(int)), this, SLOT(portSelect(int)) );
connect(devSel , SIGNAL(activated(int)), this, SLOT(deviceSelect(int)) );
connect(efs_chkbox , SIGNAL(stateChanged(int)), this, SLOT(ena4score(int)) );
connect(udlr_chkbox, SIGNAL(stateChanged(int)), this, SLOT(oppDirEna(int)) );
mainLayout = new QVBoxLayout();
vbox1 = new QVBoxLayout();
vbox2 = new QVBoxLayout();
hbox5->addWidget( efs_chkbox );
hbox5->addWidget( udlr_chkbox );
vbox1->addLayout( hbox1 );
vbox1->addLayout( hbox2 );
vbox1->addLayout( hbox3 );
vbox1->addWidget( frame1);
vbox1->addLayout( hbox5 );
vbox2->addWidget( frame2 );
vbox2->addLayout( hbox4 );
mainLayout->addLayout( vbox1 );
mainLayout->addLayout( vbox2 );
mainWidget->setLayout( mainLayout );
mainWidget->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
scroll->setWidget( mainWidget );
scroll->setWidgetResizable(true);
scroll->setSizeAdjustPolicy( QAbstractScrollArea::AdjustToContents );
scroll->setHorizontalScrollBarPolicy( Qt::ScrollBarAsNeeded );
scroll->setVerticalScrollBarPolicy( Qt::ScrollBarAsNeeded );
QHBoxLayout *dialogLayout = new QHBoxLayout();
dialogLayout->addWidget( scroll );
setLayout( dialogLayout );
inputTimer->start( 33 ); // 30hz
for (int i=0; i<GAMEPAD_NUM_DEVICES; i++)
{
sprintf( stmp, "SDL.Input.GamePad.%i.", i );
prefix = stmp;
g_config->getOption(prefix + "Profile", &lcl[i].profile );
lcl[i].guid.assign( GamePad[i].getGUID() );
}
loadMapList();
}
//----------------------------------------------------
GamePadConfDialog_t::~GamePadConfDialog_t(void)
{
inputTimer->stop();
buttonConfigStatus = 0;
gamePadConfWin = NULL;
printf("GamePad Window Deleted\n");
}
void GamePadConfDialog_t::keyPressEvent(QKeyEvent *event)
{
//printf("GamePad Window Key Press: 0x%x \n", event->key() );
pushKeyEvent( event, 1 );
}
void GamePadConfDialog_t::keyReleaseEvent(QKeyEvent *event)
{
//printf("GamePad Window Key Release: 0x%x \n", event->key() );
pushKeyEvent( event, 0 );
}
//----------------------------------------------------
void GamePadConfDialog_t::loadMapList(void)
{
QDir dir;
QStringList filters, fileList;
const char *baseDir = FCEUI_GetBaseDirectory();
const char *guid;
std::string path;
std::string prefix, mapName;
int index, devIdx;
jsDev_t *js;
size_t n=0;
char stmp[256];
index = devSel->currentIndex();
devIdx = devSel->itemData(index).toInt();
if ( devIdx < 0 )
{
guid = "keyboard";
}
else
{
js = getJoystickDevice( devIdx );
guid = js->getGUID();
}
if ( guid == NULL )
{
return;
}
path = std::string(baseDir) + "/input/" + std::string(guid);
dir.setPath( QString::fromStdString(path) );
filters << "*.txt";
dir.setNameFilters(filters);
fileList = dir.entryList( filters, QDir::Files, QDir::NoSort );
sprintf( stmp, "SDL.Input.GamePad.%u.", portNum );
prefix = stmp;
g_config->getOption(prefix + "Profile", &mapName );
mapSel->clear();
mapSel->addItem( tr("default"), 0 ); n=1;
for (size_t i=0; i < fileList.size(); i++)
{
size_t suffixIdx;
std::string fileName = fileList[i].toStdString();
suffixIdx = fileName.find_last_of('.');
fileName.erase( suffixIdx );
//printf("File: %s \n", fileName.c_str() );
//
if ( fileName.compare("default") == 0 ) continue;
mapSel->addItem( tr(fileName.c_str()), (int)i+1 );
if ( mapName.compare( fileName ) == 0 )
{
mapSel->setCurrentIndex(n);
}
n++;
}
}
//----------------------------------------------------
void GamePadConfDialog_t::updateCntrlrDpy(void)
{
char keyNameStr[128];
for (int i=0; i<GAMEPAD_NUM_BUTTONS; i++)
{
if (GamePad[portNum].bmap[i].ButtType == BUTTC_KEYBOARD)
{
snprintf( keyNameStr, sizeof (keyNameStr), "%s",
SDL_GetKeyName (GamePad[portNum].bmap[i].ButtonNum));
}
else
{
strcpy( keyNameStr, ButtonName( &GamePad[portNum].bmap[i] ) );
}
keyName[i]->setText( tr(keyNameStr) );
//if ( lcl[portNum].btn[i].needsSave )
//{
// keyName[i]->setStyleSheet("color: red;");
//}
//else
//{
// keyName[i]->setStyleSheet("color: black;");
//}
}
}
//----------------------------------------------------
void GamePadConfDialog_t::portSelect(int index)
{
//printf("Port Number:%i \n", index);
portNum = index;
updateCntrlrDpy();
for (int i=0; i<devSel->count(); i++)
{
if ( devSel->itemData(i).toInt() == GamePad[portNum].getDeviceIndex() )
{
devSel->setCurrentIndex( i );
}
}
guidLbl->setText( GamePad[portNum].getGUID() );
loadMapList();
}
//----------------------------------------------------
void GamePadConfDialog_t::deviceSelect(int index)
{
jsDev_t *js;
int devIdx = devSel->itemData(index).toInt();
js = getJoystickDevice( devIdx );
if ( js != NULL )
{
if ( js->isConnected() )
{
guidLbl->setText( js->getGUID() );
}
}
else
{
guidLbl->setText("");
}
GamePad[portNum].setDeviceIndex( devIdx );
lcl[portNum].guid.assign( GamePad[portNum].getGUID() );
lcl[portNum].profile.assign("default");
loadMapList();
updateCntrlrDpy();
}
//----------------------------------------------------
void GamePadConfDialog_t::ena4score(int state)
{
int value = (state == Qt::Unchecked) ? 0 : 1;
//printf("Set 'SDL.FourScore' = %i\n", value);
g_config->setOption("SDL.FourScore", value);
}
//----------------------------------------------------
void GamePadConfDialog_t::oppDirEna(int state)
{
int value = (state == Qt::Unchecked) ? 0 : 1;
//printf("Set 'SDL.Input.EnableOppositeDirectionals' = %i\n", value);
g_config->setOption("SDL.Input.EnableOppositeDirectionals", value);
}
//----------------------------------------------------
void GamePadConfDialog_t::changeButton(int padNo, int x)
{
//char buf[256];
//std::string prefix;
const char *keyNameStr;
if ( buttonConfigStatus == 2 )
{
buttonConfigStatus = 0;
return;
}
buttonConfigStatus = 2;
ButtonConfigBegin ();
button[x]->setText("Waiting" );
button[x]->setStyleSheet("background-color: green; color: white;");
DWaitButton (NULL, &GamePad[padNo].bmap[x], &buttonConfigStatus );
button[x]->setText("Change");
button[x]->setStyleSheet("");
if (buttonConfigStatus != 0)
{
keyNameStr = ButtonName( &GamePad[padNo].bmap[x] );
keyName[x]->setText( keyNameStr );
lcl[padNo].btn[x].needsSave = 1;
}
ButtonConfigEnd ();
buttonConfigStatus = 1;
}
//----------------------------------------------------
void GamePadConfDialog_t::clearButton( int padNo, int x )
{
GamePad[padNo].bmap[x].ButtonNum = -1;
keyName[x]->setText("");
lcl[padNo].btn[x].needsSave = 1;
}
//----------------------------------------------------
void GamePadConfDialog_t::closeEvent(QCloseEvent *event)
{
if (changeSeqStatus != 0)
{
// change sequentially still in progress
// now try to abort its progress
changeSeqStatus = -1;
// ... out from waiting gamepad button event loop
buttonConfigStatus = 0;
// and ignore this event
event->ignore();
return;
}
promptToSave();
printf("GamePad Close Window Event\n");
buttonConfigStatus = 0;
done(0);
deleteLater();
event->accept();
}
//----------------------------------------------------
void GamePadConfDialog_t::closeWindow(void)
{
if (changeSeqStatus != 0)
{
// change sequentially still in progress
// now try to abort its progress
changeSeqStatus = -1;
// ... out from waiting gamepad button event loop
buttonConfigStatus = 0;
return;
}
promptToSave();
printf("Close Window\n");
buttonConfigStatus = 0;
done(0);
deleteLater();
}
//----------------------------------------------------
void GamePadConfDialog_t::changeButton0(void)
{
changeButton( portNum, 0 );
}
//----------------------------------------------------
void GamePadConfDialog_t::changeButton1(void)
{
changeButton( portNum, 1 );
}
//----------------------------------------------------
void GamePadConfDialog_t::changeButton2(void)
{
changeButton( portNum, 2 );
}
//----------------------------------------------------
void GamePadConfDialog_t::changeButton3(void)
{
changeButton( portNum, 3 );
}
//----------------------------------------------------
void GamePadConfDialog_t::changeButton4(void)
{
changeButton( portNum, 4 );
}
//----------------------------------------------------
void GamePadConfDialog_t::changeButton5(void)
{
changeButton( portNum, 5 );
}
//----------------------------------------------------
void GamePadConfDialog_t::changeButton6(void)
{
changeButton( portNum, 6 );
}
//----------------------------------------------------
void GamePadConfDialog_t::changeButton7(void)
{
changeButton( portNum, 7 );
}
//----------------------------------------------------
void GamePadConfDialog_t::changeButton8(void)
{
changeButton( portNum, 8 );
}
//----------------------------------------------------
void GamePadConfDialog_t::changeButton9(void)
{
changeButton( portNum, 9 );
}
//----------------------------------------------------
void GamePadConfDialog_t::clearButton0(void)
{
clearButton( portNum, 0 );
}
//----------------------------------------------------
void GamePadConfDialog_t::clearButton1(void)
{
clearButton( portNum, 1 );
}
//----------------------------------------------------
void GamePadConfDialog_t::clearButton2(void)
{
clearButton( portNum, 2 );
}
//----------------------------------------------------
void GamePadConfDialog_t::clearButton3(void)
{
clearButton( portNum, 3 );
}
//----------------------------------------------------
void GamePadConfDialog_t::clearButton4(void)
{
clearButton( portNum, 4 );
}
//----------------------------------------------------
void GamePadConfDialog_t::clearButton5(void)
{
clearButton( portNum, 5 );
}
//----------------------------------------------------
void GamePadConfDialog_t::clearButton6(void)
{
clearButton( portNum, 6 );
}
//----------------------------------------------------
void GamePadConfDialog_t::clearButton7(void)
{
clearButton( portNum, 7 );
}
//----------------------------------------------------
void GamePadConfDialog_t::clearButton8(void)
{
clearButton( portNum, 8 );
}
//----------------------------------------------------
void GamePadConfDialog_t::clearButton9(void)
{
clearButton( portNum, 9 );
}
//----------------------------------------------------
void GamePadConfDialog_t::clearAllCallback(void)
{
for (int i=0; i<GAMEPAD_NUM_BUTTONS; i++)
{
clearButton( portNum, i );
}
}
//----------------------------------------------------
void GamePadConfDialog_t::saveConfig(void)
{
int i;
char stmp[256];
std::string prefix, mapName;
sprintf( stmp, "SDL.Input.GamePad.%u.", portNum );
prefix = stmp;
mapName = mapSel->currentText().toStdString();
g_config->setOption(prefix + "DeviceGUID", GamePad[portNum].getGUID() );
g_config->setOption(prefix + "Profile" , mapName.c_str() );
for (i=0; i<GAMEPAD_NUM_BUTTONS; i++)
{
lcl[portNum].btn[i].needsSave = 0;
}
g_config->save();
}
//----------------------------------------------------
void GamePadConfDialog_t::createNewProfile( const char *name )
{
char stmp[256];
//printf("Creating: %s \n", name );
GamePad[portNum].createProfile(name);
mapSel->addItem( tr(name) );
mapSel->setCurrentIndex( mapSel->count() - 1 );
saveConfig();
sprintf( stmp, "Mapping Created: %s/%s \n", GamePad[portNum].getGUID(), name );
mapMsg->setText( tr(stmp) );
}
//----------------------------------------------------
void GamePadConfDialog_t::newProfileCallback(void)
{
int ret;
QInputDialog dialog(this);
dialog.setWindowTitle( tr("New Profile") );
dialog.setLabelText( tr("Specify New Profile Name") );
dialog.setOkButtonText( tr("Create") );
dialog.show();
ret = dialog.exec();
if ( QDialog::Accepted == ret )
{
createNewProfile( dialog.textValue().toStdString().c_str() );
}
}
//----------------------------------------------------
void GamePadConfDialog_t::loadProfileCallback(void)
{
char stmp[256];
int index, devIdx, ret;
std::string mapName;
index = devSel->currentIndex();
devIdx = devSel->itemData(index).toInt();
mapName = mapSel->currentText().toStdString();
GamePad[portNum].setDeviceIndex( devIdx );
if ( mapName.compare("default") == 0 )
{
ret =GamePad[portNum].loadDefaults();
}
else
{
ret = GamePad[portNum].loadProfile( mapName.c_str() );
}
if ( ret == 0 )
{
saveConfig();
sprintf( stmp, "Mapping Loaded: %s/%s \n", GamePad[portNum].getGUID(), mapName.c_str() );
}
else
{
sprintf( stmp, "Error: Failed to Load Mapping: %s/%s \n", GamePad[portNum].getGUID(), mapName.c_str() );
}
mapMsg->setText( tr(stmp) );
updateCntrlrDpy();
}
//----------------------------------------------------
void GamePadConfDialog_t::saveProfileCallback(void)
{
int ret;
std::string mapName;
char stmp[256];
mapName = mapSel->currentText().toStdString();
ret = GamePad[portNum].saveCurrentMapToFile( mapName.c_str() );
if ( ret == 0 )
{
saveConfig();
sprintf( stmp, "Mapping Saved: %s/%s \n", GamePad[portNum].getGUID(), mapName.c_str() );
}
else
{
sprintf( stmp, "Error: Failed to Save Mapping: %s \n", mapName.c_str() );
}
mapMsg->setText( tr(stmp) );
}
//----------------------------------------------------
void GamePadConfDialog_t::deleteProfileCallback(void)
{
int ret;
std::string mapName;
char stmp[256];
mapName = mapSel->currentText().toStdString();
ret = GamePad[portNum].deleteMapping( mapName.c_str() );
if ( ret == 0 )
{
sprintf( stmp, "Mapping Deleted: %s/%s \n", GamePad[portNum].getGUID(), mapName.c_str() );
}
else
{
sprintf( stmp, "Error: Failed to Delete Mapping: %s \n", mapName.c_str() );
}
mapMsg->setText( tr(stmp) );
loadMapList();
}
//----------------------------------------------------
void GamePadConfDialog_t::promptToSave(void)
{
int i,j,n;
std::string msg;
QMessageBox msgBox(this);
char saveRequired = 0;
char padNeedsSave[GAMEPAD_NUM_DEVICES];
char stmp[256];
n=0;
for (i=0; i<GAMEPAD_NUM_DEVICES; i++)
{
padNeedsSave[i] = 0;
for (j=0; j<GAMEPAD_NUM_BUTTONS; j++)
{
if ( lcl[i].btn[j].needsSave )
{
padNeedsSave[i] = 1;
saveRequired = 1;
n++;
break;
}
}
}
if ( !saveRequired )
{
return;
}
sprintf( stmp, "Warning: Gamepad mappings have not been saved for port%c ", (n > 1) ? 's':' ');
msg.assign( stmp );
j=n;
for (i=0; i<GAMEPAD_NUM_DEVICES; i++)
{
if ( padNeedsSave[i] )
{
sprintf( stmp, "%i", i+1 );
msg.append(stmp);
j--;
if ( j > 1 )
{
msg.append(", ");
}
else if ( j == 1 )
{
msg.append(" and ");
}
}
}
msg.append(".");
msgBox.setIcon( QMessageBox::Warning );
msgBox.setText( tr(msg.c_str()) );
msgBox.show();
//msgBox.resize( 512, 128 );
msgBox.exec();
}
//----------------------------------------------------
void GamePadConfDialog_t::updatePeriodic(void)
{
for (int i=0; i<GAMEPAD_NUM_BUTTONS; i++)
{
const char *txt, *style;
if ( GamePad[portNum].bmap[i].state )
{
txt = " T ";
style = "background-color: green; color: white;";
}
else
{
txt = " F ";
style = "background-color: red; color: white;";
}
keyState[i]->setText( tr(txt) );
keyState[i]->setStyleSheet( style );
if ( lcl[portNum].btn[i].needsSave )
{
keyName[i]->setStyleSheet("color: red;");
}
else
{
keyName[i]->setStyleSheet("color: black;");
}
}
int fourScore;
g_config->getOption("SDL.FourScore", &fourScore);
if ( fourScore != efs_chkbox->isChecked() )
{
efs_chkbox->setChecked( fourScore );
}
}
//----------------------------------------------------
void GamePadConfDialog_t::changeSequentallyCallback(void)
{
// get pointer to button
QPushButton* changeSeqButton = qobject_cast<QPushButton*>(sender());
if (!changeSeqButton)
return;
// disable it for user input
changeSeqButton->setEnabled(false);
// change button for every button on gamepad
for (int i = 0; i < GAMEPAD_NUM_BUTTONS; ++i)
{
changeSeqStatus += 1;
if (this->isHidden()) break;
changeButton(portNum, i);
if (this->isHidden()) break;
// abort?
if (changeSeqStatus == -1) break;
}
// return all back
changeSeqStatus = 0;
changeSeqButton->setEnabled(true);
}
//----------------------------------------------------
GamePadConfigButton_t::GamePadConfigButton_t(int i)
{
idx = i;
setText("Change");
}
//----------------------------------------------------
void GamePadConfigButton_t::keyPressEvent(QKeyEvent *event)
{
//printf("GamePad Button Key Press: 0x%x \n", event->key() );
pushKeyEvent( event, 1 );
}
void GamePadConfigButton_t::keyReleaseEvent(QKeyEvent *event)
{
//printf("GamePad Button Key Release: 0x%x \n", event->key() );
pushKeyEvent( event, 0 );
}
//----------------------------------------------------
Reference in New Issue View Git Blame Copy Permalink