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/ConsoleWindow.cpp

1696 lines
42 KiB
C++
Raw Blame History

// GameApp.cpp
//
#include <fstream>
#include <iostream>
#include <cstdlib>
#include <QFileDialog>
#include <QMessageBox>
#include <QInputDialog>
#include "../../fceu.h"
#include "../../fds.h"
#include "../../movie.h"
#ifdef _S9XLUA_H
#include "../../fceulua.h"
#endif
#include "Qt/main.h"
#include "Qt/dface.h"
#include "Qt/input.h"
#include "Qt/ConsoleWindow.h"
#include "Qt/GamePadConf.h"
#include "Qt/HotKeyConf.h"
#include "Qt/PaletteConf.h"
#include "Qt/GuiConf.h"
#include "Qt/LuaControl.h"
#include "Qt/CheatsConf.h"
#include "Qt/HexEditor.h"
#include "Qt/TraceLogger.h"
#include "Qt/CodeDataLogger.h"
#include "Qt/ConsoleDebugger.h"
#include "Qt/ConsoleUtilities.h"
#include "Qt/ConsoleSoundConf.h"
#include "Qt/ConsoleVideoConf.h"
#include "Qt/AboutWindow.h"
#include "Qt/fceuWrapper.h"
#include "Qt/ppuViewer.h"
#include "Qt/NameTableViewer.h"
#include "Qt/RamWatch.h"
#include "Qt/RamSearch.h"
#include "Qt/keyscan.h"
#include "Qt/nes_shm.h"
consoleWin_t::consoleWin_t(QWidget *parent)
: QMainWindow( parent )
{
int use_SDL_video = false;
createMainMenu();
g_config->getOption( "SDL.VideoDriver", &use_SDL_video );
errorMsgValid = false;
viewport_GL = NULL;
viewport_SDL = NULL;
if ( use_SDL_video )
{
viewport_SDL = new ConsoleViewSDL_t(this);
setCentralWidget(viewport_SDL);
}
else
{
viewport_GL = new ConsoleViewGL_t(this);
setCentralWidget(viewport_GL);
}
setWindowIcon(QIcon(":fceux1.png"));
gameTimer = new QTimer( this );
mutex = new QMutex( QMutex::Recursive );
emulatorThread = new emulatorThread_t();
connect(emulatorThread, &QThread::finished, emulatorThread, &QObject::deleteLater);
connect( gameTimer, &QTimer::timeout, this, &consoleWin_t::updatePeriodic );
gameTimer->setTimerType( Qt::PreciseTimer );
//gameTimer->start( 16 ); // 60hz
gameTimer->start( 8 ); // 120hz
emulatorThread->start();
}
consoleWin_t::~consoleWin_t(void)
{
nes_shm->runEmulator = 0;
gameTimer->stop();
closeGamePadConfWindow();
//printf("Thread Finished: %i \n", gameThread->isFinished() );
emulatorThread->quit();
emulatorThread->wait( 1000 );
fceuWrapperLock();
fceuWrapperClose();
fceuWrapperUnLock();
if ( viewport_GL != NULL )
{
delete viewport_GL; viewport_GL = NULL;
}
if ( viewport_SDL != NULL )
{
delete viewport_SDL; viewport_SDL = NULL;
}
delete mutex;
// LoadGame() checks for an IP and if it finds one begins a network session
// clear the NetworkIP field so this doesn't happen unintentionally
g_config->setOption ("SDL.NetworkIP", "");
g_config->save ();
if ( this == consoleWindow )
{
consoleWindow = NULL;
}
}
void consoleWin_t::setCyclePeriodms( int ms )
{
// If timer is already running, it will be restarted.
gameTimer->start( ms );
//printf("Period Set to: %i ms \n", ms );
}
void consoleWin_t::showErrorMsgWindow()
{
QMessageBox msgBox(this);
fceuWrapperLock();
msgBox.setIcon( QMessageBox::Critical );
msgBox.setText( tr(errorMsg.c_str()) );
errorMsg.clear();
fceuWrapperUnLock();
msgBox.show();
msgBox.exec();
}
void consoleWin_t::QueueErrorMsgWindow( const char *msg )
{
errorMsg.append( msg );
errorMsg.append("\n");
errorMsgValid = true;
}
void consoleWin_t::closeEvent(QCloseEvent *event)
{
//printf("Main Window Close Event\n");
closeGamePadConfWindow();
event->accept();
closeApp();
}
void consoleWin_t::keyPressEvent(QKeyEvent *event)
{
//printf("Key Press: 0x%x \n", event->key() );
pushKeyEvent( event, 1 );
}
void consoleWin_t::keyReleaseEvent(QKeyEvent *event)
{
//printf("Key Release: 0x%x \n", event->key() );
pushKeyEvent( event, 0 );
}
//---------------------------------------------------------------------------
void consoleWin_t::createMainMenu(void)
{
QAction *act;
QMenu *subMenu;
QActionGroup *group;
int useNativeMenuBar;
// This is needed for menu bar to show up on MacOS
g_config->getOption( "SDL.UseNativeMenuBar", &useNativeMenuBar );
menuBar()->setNativeMenuBar( useNativeMenuBar ? true : false );
//-----------------------------------------------------------------------
// File
fileMenu = menuBar()->addMenu(tr("File"));
// File -> Open ROM
openROM = new QAction(tr("Open ROM"), this);
openROM->setShortcuts(QKeySequence::Open);
openROM->setStatusTip(tr("Open ROM File"));
connect(openROM, SIGNAL(triggered()), this, SLOT(openROMFile(void)) );
fileMenu->addAction(openROM);
// File -> Close ROM
closeROM = new QAction(tr("Close ROM"), this);
closeROM->setShortcut( QKeySequence(tr("Ctrl+C")));
closeROM->setStatusTip(tr("Close Loaded ROM"));
connect(closeROM, SIGNAL(triggered()), this, SLOT(closeROMCB(void)) );
fileMenu->addAction(closeROM);
fileMenu->addSeparator();
// File -> Play NSF
playNSF = new QAction(tr("Play NSF"), this);
playNSF->setShortcut( QKeySequence(tr("Ctrl+N")));
playNSF->setStatusTip(tr("Play NSF"));
connect(playNSF, SIGNAL(triggered()), this, SLOT(loadNSF(void)) );
fileMenu->addAction(playNSF);
fileMenu->addSeparator();
// File -> Load State From
loadStateAct = new QAction(tr("Load State From"), this);
//loadStateAct->setShortcut( QKeySequence(tr("Ctrl+N")));
loadStateAct->setStatusTip(tr("Load State From"));
connect(loadStateAct, SIGNAL(triggered()), this, SLOT(loadStateFrom(void)) );
fileMenu->addAction(loadStateAct);
// File -> Save State As
saveStateAct = new QAction(tr("Save State As"), this);
//loadStateAct->setShortcut( QKeySequence(tr("Ctrl+N")));
saveStateAct->setStatusTip(tr("Save State As"));
connect(saveStateAct, SIGNAL(triggered()), this, SLOT(saveStateAs(void)) );
fileMenu->addAction(saveStateAct);
// File -> Quick Load
quickLoadAct = new QAction(tr("Quick Load"), this);
quickLoadAct->setShortcut( QKeySequence(tr("F7")));
quickLoadAct->setStatusTip(tr("Quick Load"));
connect(quickLoadAct, SIGNAL(triggered()), this, SLOT(quickLoad(void)) );
fileMenu->addAction(quickLoadAct);
// File -> Quick Save
quickSaveAct = new QAction(tr("Quick Save"), this);
quickSaveAct->setShortcut( QKeySequence(tr("F5")));
quickSaveAct->setStatusTip(tr("Quick Save"));
connect(quickSaveAct, SIGNAL(triggered()), this, SLOT(quickSave(void)) );
fileMenu->addAction(quickSaveAct);
// File -> Change State
subMenu = fileMenu->addMenu(tr("Change State"));
group = new QActionGroup(this);
group->setExclusive(true);
for (int i=0; i<10; i++)
{
char stmp[8];
sprintf( stmp, "%i", i );
state[i] = new QAction(tr(stmp), this);
state[i]->setCheckable(true);
group->addAction(state[i]);
subMenu->addAction(state[i]);
}
state[0]->setChecked(true);
connect(state[0], SIGNAL(triggered()), this, SLOT(changeState0(void)) );
connect(state[1], SIGNAL(triggered()), this, SLOT(changeState1(void)) );
connect(state[2], SIGNAL(triggered()), this, SLOT(changeState2(void)) );
connect(state[3], SIGNAL(triggered()), this, SLOT(changeState3(void)) );
connect(state[4], SIGNAL(triggered()), this, SLOT(changeState4(void)) );
connect(state[5], SIGNAL(triggered()), this, SLOT(changeState5(void)) );
connect(state[6], SIGNAL(triggered()), this, SLOT(changeState6(void)) );
connect(state[7], SIGNAL(triggered()), this, SLOT(changeState7(void)) );
connect(state[8], SIGNAL(triggered()), this, SLOT(changeState8(void)) );
connect(state[9], SIGNAL(triggered()), this, SLOT(changeState9(void)) );
fileMenu->addSeparator();
#ifdef _S9XLUA_H
// File -> Quick Save
loadLuaAct = new QAction(tr("Load Lua Script"), this);
//loadLuaAct->setShortcut( QKeySequence(tr("F5")));
loadLuaAct->setStatusTip(tr("Load Lua Script"));
connect(loadLuaAct, SIGNAL(triggered()), this, SLOT(loadLua(void)) );
fileMenu->addAction(loadLuaAct);
fileMenu->addSeparator();
#else
loadLuaAct = NULL;
#endif
// File -> Screenshort
scrShotAct = new QAction(tr("Screenshot"), this);
scrShotAct->setShortcut( QKeySequence(tr("F12")));
scrShotAct->setStatusTip(tr("Screenshot"));
connect(scrShotAct, SIGNAL(triggered()), this, SLOT(takeScreenShot()));
fileMenu->addAction(scrShotAct);
// File -> Quit
quitAct = new QAction(tr("Quit"), this);
quitAct->setShortcut( QKeySequence(tr("Ctrl+Q")));
quitAct->setStatusTip(tr("Quit the Application"));
connect(quitAct, SIGNAL(triggered()), this, SLOT(closeApp()));
fileMenu->addAction(quitAct);
//-----------------------------------------------------------------------
// Options
optMenu = menuBar()->addMenu(tr("Options"));
// Options -> GamePad Config
gamePadConfig = new QAction(tr("GamePad Config"), this);
//gamePadConfig->setShortcut( QKeySequence(tr("Ctrl+C")));
gamePadConfig->setStatusTip(tr("GamePad Configure"));
connect(gamePadConfig, SIGNAL(triggered()), this, SLOT(openGamePadConfWin(void)) );
optMenu->addAction(gamePadConfig);
// Options -> Sound Config
gameSoundConfig = new QAction(tr("Sound Config"), this);
//gameSoundConfig->setShortcut( QKeySequence(tr("Ctrl+C")));
gameSoundConfig->setStatusTip(tr("Sound Configure"));
connect(gameSoundConfig, SIGNAL(triggered()), this, SLOT(openGameSndConfWin(void)) );
optMenu->addAction(gameSoundConfig);
// Options -> Video Config
gameVideoConfig = new QAction(tr("Video Config"), this);
//gameVideoConfig->setShortcut( QKeySequence(tr("Ctrl+C")));
gameVideoConfig->setStatusTip(tr("Video Preferences"));
connect(gameVideoConfig, SIGNAL(triggered()), this, SLOT(openGameVideoConfWin(void)) );
optMenu->addAction(gameVideoConfig);
// Options -> HotKey Config
hotkeyConfig = new QAction(tr("Hotkey Config"), this);
//hotkeyConfig->setShortcut( QKeySequence(tr("Ctrl+C")));
hotkeyConfig->setStatusTip(tr("Hotkey Configure"));
connect(hotkeyConfig, SIGNAL(triggered()), this, SLOT(openHotkeyConfWin(void)) );
optMenu->addAction(hotkeyConfig);
// Options -> Palette Config
paletteConfig = new QAction(tr("Palette Config"), this);
//paletteConfig->setShortcut( QKeySequence(tr("Ctrl+C")));
paletteConfig->setStatusTip(tr("Palette Configure"));
connect(paletteConfig, SIGNAL(triggered()), this, SLOT(openPaletteConfWin(void)) );
optMenu->addAction(paletteConfig);
// Options -> GUI Config
guiConfig = new QAction(tr("GUI Config"), this);
//guiConfig->setShortcut( QKeySequence(tr("Ctrl+C")));
guiConfig->setStatusTip(tr("GUI Configure"));
connect(guiConfig, SIGNAL(triggered()), this, SLOT(openGuiConfWin(void)) );
optMenu->addAction(guiConfig);
// Options -> Auto-Resume
autoResume = new QAction(tr("Auto-Resume Play"), this);
//autoResume->setShortcut( QKeySequence(tr("Ctrl+C")));
autoResume->setCheckable(true);
autoResume->setStatusTip(tr("Auto-Resume Play"));
connect(autoResume, SIGNAL(triggered()), this, SLOT(toggleAutoResume(void)) );
optMenu->addAction(autoResume);
optMenu->addSeparator();
// Options -> Full Screen
fullscreen = new QAction(tr("Fullscreen"), this);
fullscreen->setShortcut( QKeySequence(tr("Alt+Return")));
//fullscreen->setCheckable(true);
fullscreen->setStatusTip(tr("Fullscreen"));
connect(fullscreen, SIGNAL(triggered()), this, SLOT(toggleFullscreen(void)) );
optMenu->addAction(fullscreen);
//-----------------------------------------------------------------------
// Emulation
emuMenu = menuBar()->addMenu(tr("Emulation"));
// Emulation -> Power
powerAct = new QAction(tr("Power"), this);
//powerAct->setShortcut( QKeySequence(tr("Ctrl+P")));
powerAct->setStatusTip(tr("Power On Console"));
connect(powerAct, SIGNAL(triggered()), this, SLOT(powerConsoleCB(void)) );
emuMenu->addAction(powerAct);
// Emulation -> Reset
resetAct = new QAction(tr("Reset"), this);
//resetAct->setShortcut( QKeySequence(tr("Ctrl+R")));
resetAct->setStatusTip(tr("Reset Console"));
connect(resetAct, SIGNAL(triggered()), this, SLOT(consoleHardReset(void)) );
emuMenu->addAction(resetAct);
// Emulation -> Soft Reset
sresetAct = new QAction(tr("Soft Reset"), this);
//sresetAct->setShortcut( QKeySequence(tr("Ctrl+R")));
sresetAct->setStatusTip(tr("Soft Reset of Console"));
connect(sresetAct, SIGNAL(triggered()), this, SLOT(consoleSoftReset(void)) );
emuMenu->addAction(sresetAct);
// Emulation -> Pause
pauseAct = new QAction(tr("Pause"), this);
pauseAct->setShortcut( QKeySequence(tr("Pause")));
pauseAct->setStatusTip(tr("Pause Console"));
connect(pauseAct, SIGNAL(triggered()), this, SLOT(consolePause(void)) );
emuMenu->addAction(pauseAct);
emuMenu->addSeparator();
// Emulation -> Enable Game Genie
gameGenieAct = new QAction(tr("Enable Game Genie"), this);
//gameGenieAct->setShortcut( QKeySequence(tr("Ctrl+G")));
gameGenieAct->setCheckable(true);
gameGenieAct->setStatusTip(tr("Enable Game Genie"));
connect(gameGenieAct, SIGNAL(triggered(bool)), this, SLOT(toggleGameGenie(bool)) );
syncActionConfig( gameGenieAct, "SDL.GameGenie" );
emuMenu->addAction(gameGenieAct);
// Emulation -> Load Game Genie ROM
loadGgROMAct = new QAction(tr("Load Game Genie ROM"), this);
//loadGgROMAct->setShortcut( QKeySequence(tr("Ctrl+G")));
loadGgROMAct->setStatusTip(tr("Load Game Genie ROM"));
connect(loadGgROMAct, SIGNAL(triggered()), this, SLOT(loadGameGenieROM(void)) );
emuMenu->addAction(loadGgROMAct);
emuMenu->addSeparator();
// Emulation -> Insert Coin
insCoinAct = new QAction(tr("Insert Coin"), this);
//insCoinAct->setShortcut( QKeySequence(tr("Ctrl+G")));
insCoinAct->setStatusTip(tr("Insert Coin"));
connect(insCoinAct, SIGNAL(triggered()), this, SLOT(insertCoin(void)) );
emuMenu->addAction(insCoinAct);
emuMenu->addSeparator();
// Emulation -> FDS
subMenu = emuMenu->addMenu(tr("FDS"));
// Emulation -> FDS -> Switch Disk
fdsSwitchAct = new QAction(tr("Switch Disk"), this);
//fdsSwitchAct->setShortcut( QKeySequence(tr("Ctrl+G")));
fdsSwitchAct->setStatusTip(tr("Switch Disk"));
connect(fdsSwitchAct, SIGNAL(triggered()), this, SLOT(fdsSwitchDisk(void)) );
subMenu->addAction(fdsSwitchAct);
// Emulation -> FDS -> Eject Disk
fdsEjectAct = new QAction(tr("Eject Disk"), this);
//fdsEjectAct->setShortcut( QKeySequence(tr("Ctrl+G")));
fdsEjectAct->setStatusTip(tr("Eject Disk"));
connect(fdsEjectAct, SIGNAL(triggered()), this, SLOT(fdsEjectDisk(void)) );
subMenu->addAction(fdsEjectAct);
// Emulation -> FDS -> Load BIOS
fdsLoadBiosAct = new QAction(tr("Load BIOS"), this);
//fdsLoadBiosAct->setShortcut( QKeySequence(tr("Ctrl+G")));
fdsLoadBiosAct->setStatusTip(tr("Load BIOS"));
connect(fdsLoadBiosAct, SIGNAL(triggered()), this, SLOT(fdsLoadBiosFile(void)) );
subMenu->addAction(fdsLoadBiosAct);
emuMenu->addSeparator();
// Emulation -> Speed
subMenu = emuMenu->addMenu(tr("Speed"));
// Emulation -> Speed -> Speed Up
act = new QAction(tr("Speed Up"), this);
act->setShortcut( QKeySequence(tr("=")));
act->setStatusTip(tr("Speed Up"));
connect(act, SIGNAL(triggered()), this, SLOT(emuSpeedUp(void)) );
subMenu->addAction(act);
// Emulation -> Speed -> Slow Down
act = new QAction(tr("Slow Down"), this);
act->setShortcut( QKeySequence(tr("-")));
act->setStatusTip(tr("Slow Down"));
connect(act, SIGNAL(triggered()), this, SLOT(emuSlowDown(void)) );
subMenu->addAction(act);
subMenu->addSeparator();
// Emulation -> Speed -> Slowest Speed
act = new QAction(tr("Slowest"), this);
//act->setShortcut( QKeySequence(tr("-")));
act->setStatusTip(tr("Slowest"));
connect(act, SIGNAL(triggered()), this, SLOT(emuSlowestSpd(void)) );
subMenu->addAction(act);
// Emulation -> Speed -> Normal Speed
act = new QAction(tr("Normal"), this);
//act->setShortcut( QKeySequence(tr("-")));
act->setStatusTip(tr("Normal"));
connect(act, SIGNAL(triggered()), this, SLOT(emuNormalSpd(void)) );
subMenu->addAction(act);
// Emulation -> Speed -> Fastest Speed
act = new QAction(tr("Turbo"), this);
//act->setShortcut( QKeySequence(tr("-")));
act->setStatusTip(tr("Turbo (Fastest)"));
connect(act, SIGNAL(triggered()), this, SLOT(emuFastestSpd(void)) );
subMenu->addAction(act);
// Emulation -> Speed -> Custom Speed
act = new QAction(tr("Custom"), this);
//act->setShortcut( QKeySequence(tr("-")));
act->setStatusTip(tr("Custom"));
connect(act, SIGNAL(triggered()), this, SLOT(emuCustomSpd(void)) );
subMenu->addAction(act);
subMenu->addSeparator();
// Emulation -> Speed -> Set Frame Advance Delay
act = new QAction(tr("Set Frame Advance Delay"), this);
//act->setShortcut( QKeySequence(tr("-")));
act->setStatusTip(tr("Set Frame Advance Delay"));
connect(act, SIGNAL(triggered()), this, SLOT(emuSetFrameAdvDelay(void)) );
subMenu->addAction(act);
//-----------------------------------------------------------------------
// Tools
toolsMenu = menuBar()->addMenu(tr("Tools"));
// Tools -> Cheats
cheatsAct = new QAction(tr("Cheats..."), this);
//cheatsAct->setShortcut( QKeySequence(tr("Shift+F7")));
cheatsAct->setStatusTip(tr("Open Cheat Window"));
connect(cheatsAct, SIGNAL(triggered()), this, SLOT(openCheats(void)) );
toolsMenu->addAction(cheatsAct);
// Tools -> RAM Search
ramSearchAct = new QAction(tr("RAM Search..."), this);
//ramSearchAct->setShortcut( QKeySequence(tr("Shift+F7")));
ramSearchAct->setStatusTip(tr("Open RAM Search Window"));
connect(ramSearchAct, SIGNAL(triggered()), this, SLOT(openRamSearch(void)) );
toolsMenu->addAction(ramSearchAct);
// Tools -> RAM Watch
ramWatchAct = new QAction(tr("RAM Watch..."), this);
//ramWatchAct->setShortcut( QKeySequence(tr("Shift+F7")));
ramWatchAct->setStatusTip(tr("Open RAM Watch Window"));
connect(ramWatchAct, SIGNAL(triggered()), this, SLOT(openRamWatch(void)) );
toolsMenu->addAction(ramWatchAct);
//-----------------------------------------------------------------------
// Debug
debugMenu = menuBar()->addMenu(tr("Debug"));
// Debug -> Debugger
debuggerAct = new QAction(tr("Debugger..."), this);
//debuggerAct->setShortcut( QKeySequence(tr("Shift+F7")));
debuggerAct->setStatusTip(tr("Open 6502 Debugger"));
connect(debuggerAct, SIGNAL(triggered()), this, SLOT(openDebugWindow(void)) );
debugMenu->addAction(debuggerAct);
// Debug -> Hex Editor
hexEditAct = new QAction(tr("Hex Editor..."), this);
//hexEditAct->setShortcut( QKeySequence(tr("Shift+F7")));
hexEditAct->setStatusTip(tr("Open Memory Hex Editor"));
connect(hexEditAct, SIGNAL(triggered()), this, SLOT(openHexEditor(void)) );
debugMenu->addAction(hexEditAct);
// Debug -> PPU Viewer
ppuViewAct = new QAction(tr("PPU Viewer..."), this);
//ppuViewAct->setShortcut( QKeySequence(tr("Shift+F7")));
ppuViewAct->setStatusTip(tr("Open PPU Viewer"));
connect(ppuViewAct, SIGNAL(triggered()), this, SLOT(openPPUViewer(void)) );
debugMenu->addAction(ppuViewAct);
// Debug -> Name Table Viewer
ntViewAct = new QAction(tr("Name Table Viewer..."), this);
//ntViewAct->setShortcut( QKeySequence(tr("Shift+F7")));
ntViewAct->setStatusTip(tr("Open Name Table Viewer"));
connect(ntViewAct, SIGNAL(triggered()), this, SLOT(openNTViewer(void)) );
debugMenu->addAction(ntViewAct);
// Debug -> Trace Logger
traceLogAct = new QAction(tr("Trace Logger..."), this);
//traceLogAct->setShortcut( QKeySequence(tr("Shift+F7")));
traceLogAct->setStatusTip(tr("Open Trace Logger"));
connect(traceLogAct, SIGNAL(triggered()), this, SLOT(openTraceLogger(void)) );
debugMenu->addAction(traceLogAct);
// Debug -> Code/Data Logger
codeDataLogAct = new QAction(tr("Code/Data Logger..."), this);
//codeDataLogAct->setShortcut( QKeySequence(tr("Shift+F7")));
codeDataLogAct->setStatusTip(tr("Open Code Data Logger"));
connect(codeDataLogAct, SIGNAL(triggered()), this, SLOT(openCodeDataLogger(void)) );
debugMenu->addAction(codeDataLogAct);
//-----------------------------------------------------------------------
// Movie
movieMenu = menuBar()->addMenu(tr("Movie"));
// Movie -> Open
openMovAct = new QAction(tr("Open"), this);
openMovAct->setShortcut( QKeySequence(tr("Shift+F7")));
openMovAct->setStatusTip(tr("Open Movie File"));
connect(openMovAct, SIGNAL(triggered()), this, SLOT(openMovie(void)) );
movieMenu->addAction(openMovAct);
// Movie -> Stop
stopMovAct = new QAction(tr("Stop"), this);
//stopMovAct->setShortcut( QKeySequence(tr("Shift+F7")));
stopMovAct->setStatusTip(tr("Stop Movie Recording"));
connect(stopMovAct, SIGNAL(triggered()), this, SLOT(stopMovie(void)) );
movieMenu->addAction(stopMovAct);
movieMenu->addSeparator();
// Movie -> Record
recMovAct = new QAction(tr("Record"), this);
recMovAct->setShortcut( QKeySequence(tr("Shift+F5")));
recMovAct->setStatusTip(tr("Record Movie"));
connect(recMovAct, SIGNAL(triggered()), this, SLOT(recordMovie(void)) );
movieMenu->addAction(recMovAct);
// Movie -> Record As
recAsMovAct = new QAction(tr("Record As"), this);
//recAsMovAct->setShortcut( QKeySequence(tr("Shift+F5")));
recAsMovAct->setStatusTip(tr("Record Movie"));
connect(recAsMovAct, SIGNAL(triggered()), this, SLOT(recordMovieAs(void)) );
movieMenu->addAction(recAsMovAct);
//-----------------------------------------------------------------------
// Help
helpMenu = menuBar()->addMenu(tr("Help"));
// Help -> About FCEUX
aboutAct = new QAction(tr("About FCEUX"), this);
aboutAct->setStatusTip(tr("About FCEUX"));
connect(aboutAct, SIGNAL(triggered()), this, SLOT(aboutFCEUX(void)) );
helpMenu->addAction(aboutAct);
// Help -> About Qt
aboutActQt = new QAction(tr("About Qt"), this);
aboutActQt->setStatusTip(tr("About Qt"));
connect(aboutActQt, SIGNAL(triggered()), this, SLOT(aboutQt(void)) );
helpMenu->addAction(aboutActQt);
};
//---------------------------------------------------------------------------
void consoleWin_t::closeApp(void)
{
nes_shm->runEmulator = 0;
emulatorThread->quit();
emulatorThread->wait( 1000 );
fceuWrapperLock();
fceuWrapperClose();
fceuWrapperUnLock();
// LoadGame() checks for an IP and if it finds one begins a network session
// clear the NetworkIP field so this doesn't happen unintentionally
g_config->setOption ("SDL.NetworkIP", "");
g_config->save ();
//qApp::quit();
qApp->quit();
}
//---------------------------------------------------------------------------
void consoleWin_t::openROMFile(void)
{
int ret, useNativeFileDialogVal;
QString filename;
std::string last;
char dir[512];
QFileDialog dialog(this, tr("Open ROM File") );
dialog.setFileMode(QFileDialog::ExistingFile);
dialog.setNameFilter(tr("NES files (*.nes *.NES) ;; All files (*)"));
dialog.setViewMode(QFileDialog::List);
dialog.setFilter( QDir::AllEntries | QDir::Hidden );
dialog.setLabelText( QFileDialog::Accept, tr("Open") );
g_config->getOption ("SDL.LastOpenFile", &last );
getDirFromFile( last.c_str(), dir );
dialog.setDirectory( tr(dir) );
// Check config option to use native file dialog or not
g_config->getOption ("SDL.UseNativeFileDialog", &useNativeFileDialogVal);
dialog.setOption(QFileDialog::DontUseNativeDialog, !useNativeFileDialogVal);
dialog.show();
ret = dialog.exec();
if ( ret )
{
QStringList fileList;
fileList = dialog.selectedFiles();
if ( fileList.size() > 0 )
{
filename = fileList[0];
}
}
if ( filename.isNull() )
{
return;
}
qDebug() << "selected file path : " << filename.toUtf8();
g_config->setOption ("SDL.LastOpenFile", filename.toStdString().c_str() );
fceuWrapperLock();
CloseGame ();
LoadGame ( filename.toStdString().c_str() );
fceuWrapperUnLock();
return;
}
void consoleWin_t::closeROMCB(void)
{
fceuWrapperLock();
CloseGame();
fceuWrapperUnLock();
}
void consoleWin_t::loadNSF(void)
{
int ret, useNativeFileDialogVal;
QString filename;
std::string last;
char dir[512];
QFileDialog dialog(this, tr("Load NSF File") );
dialog.setFileMode(QFileDialog::ExistingFile);
dialog.setNameFilter(tr("NSF Sound Files (*.nsf *.NSF) ;; Zip Files (*.zip *.ZIP) ;; All files (*)"));
dialog.setViewMode(QFileDialog::List);
dialog.setFilter( QDir::AllEntries | QDir::Hidden );
dialog.setLabelText( QFileDialog::Accept, tr("Load") );
g_config->getOption ("SDL.LastOpenNSF", &last );
getDirFromFile( last.c_str(), dir );
dialog.setDirectory( tr(dir) );
// Check config option to use native file dialog or not
g_config->getOption ("SDL.UseNativeFileDialog", &useNativeFileDialogVal);
dialog.setOption(QFileDialog::DontUseNativeDialog, !useNativeFileDialogVal);
dialog.show();
ret = dialog.exec();
if ( ret )
{
QStringList fileList;
fileList = dialog.selectedFiles();
if ( fileList.size() > 0 )
{
filename = fileList[0];
}
}
if ( filename.isNull() )
{
return;
}
qDebug() << "selected file path : " << filename.toUtf8();
g_config->setOption ("SDL.LastOpenNSF", filename.toStdString().c_str() );
fceuWrapperLock();
LoadGame( filename.toStdString().c_str() );
fceuWrapperUnLock();
}
void consoleWin_t::loadStateFrom(void)
{
int ret, useNativeFileDialogVal;
QString filename;
std::string last;
char dir[512];
QFileDialog dialog(this, tr("Load State From File") );
dialog.setFileMode(QFileDialog::ExistingFile);
dialog.setNameFilter(tr("FCS & SAV Files (*.sav *.SAV *.fc? *.FC?) ;; All files (*)"));
dialog.setViewMode(QFileDialog::List);
dialog.setFilter( QDir::AllEntries | QDir::Hidden );
dialog.setLabelText( QFileDialog::Accept, tr("Load") );
g_config->getOption ("SDL.LastLoadStateFrom", &last );
getDirFromFile( last.c_str(), dir );
dialog.setDirectory( tr(dir) );
// Check config option to use native file dialog or not
g_config->getOption ("SDL.UseNativeFileDialog", &useNativeFileDialogVal);
dialog.setOption(QFileDialog::DontUseNativeDialog, !useNativeFileDialogVal);
dialog.show();
ret = dialog.exec();
if ( ret )
{
QStringList fileList;
fileList = dialog.selectedFiles();
if ( fileList.size() > 0 )
{
filename = fileList[0];
}
}
if ( filename.isNull() )
{
return;
}
qDebug() << "selected file path : " << filename.toUtf8();
g_config->setOption ("SDL.LastLoadStateFrom", filename.toStdString().c_str() );
fceuWrapperLock();
FCEUI_LoadState( filename.toStdString().c_str() );
fceuWrapperUnLock();
}
void consoleWin_t::saveStateAs(void)
{
int ret, useNativeFileDialogVal;
QString filename;
std::string last;
char dir[512];
QFileDialog dialog(this, tr("Save State To File") );
dialog.setFileMode(QFileDialog::AnyFile);
dialog.setNameFilter(tr("SAV Files (*.sav *.SAV) ;; All files (*)"));
dialog.setViewMode(QFileDialog::List);
dialog.setFilter( QDir::AllEntries | QDir::Hidden );
dialog.setLabelText( QFileDialog::Accept, tr("Save") );
dialog.setDefaultSuffix( tr(".sav") );
g_config->getOption ("SDL.LastSaveStateAs", &last );
getDirFromFile( last.c_str(), dir );
dialog.setDirectory( tr(dir) );
// Check config option to use native file dialog or not
g_config->getOption ("SDL.UseNativeFileDialog", &useNativeFileDialogVal);
dialog.setOption(QFileDialog::DontUseNativeDialog, !useNativeFileDialogVal);
dialog.show();
ret = dialog.exec();
if ( ret )
{
QStringList fileList;
fileList = dialog.selectedFiles();
if ( fileList.size() > 0 )
{
filename = fileList[0];
}
}
if ( filename.isNull() )
{
return;
}
qDebug() << "selected file path : " << filename.toUtf8();
g_config->setOption ("SDL.LastSaveStateAs", filename.toStdString().c_str() );
fceuWrapperLock();
FCEUI_SaveState( filename.toStdString().c_str() );
fceuWrapperUnLock();
}
void consoleWin_t::quickLoad(void)
{
fceuWrapperLock();
FCEUI_LoadState( NULL );
fceuWrapperUnLock();
}
void consoleWin_t::quickSave(void)
{
fceuWrapperLock();
FCEUI_SaveState( NULL );
fceuWrapperUnLock();
}
void consoleWin_t::changeState0(void)
{
fceuWrapperLock();
FCEUI_SelectState( 0, 1 );
fceuWrapperUnLock();
}
void consoleWin_t::changeState1(void)
{
fceuWrapperLock();
FCEUI_SelectState( 1, 1 );
fceuWrapperUnLock();
}
void consoleWin_t::changeState2(void)
{
fceuWrapperLock();
FCEUI_SelectState( 2, 1 );
fceuWrapperUnLock();
}
void consoleWin_t::changeState3(void)
{
fceuWrapperLock();
FCEUI_SelectState( 3, 1 );
fceuWrapperUnLock();
}
void consoleWin_t::changeState4(void)
{
fceuWrapperLock();
FCEUI_SelectState( 4, 1 );
fceuWrapperUnLock();
}
void consoleWin_t::changeState5(void)
{
fceuWrapperLock();
FCEUI_SelectState( 5, 1 );
fceuWrapperUnLock();
}
void consoleWin_t::changeState6(void)
{
fceuWrapperLock();
FCEUI_SelectState( 6, 1 );
fceuWrapperUnLock();
}
void consoleWin_t::changeState7(void)
{
fceuWrapperLock();
FCEUI_SelectState( 7, 1 );
fceuWrapperUnLock();
}
void consoleWin_t::changeState8(void)
{
fceuWrapperLock();
FCEUI_SelectState( 8, 1 );
fceuWrapperUnLock();
}
void consoleWin_t::changeState9(void)
{
fceuWrapperLock();
FCEUI_SelectState( 9, 1 );
fceuWrapperUnLock();
}
void consoleWin_t::takeScreenShot(void)
{
fceuWrapperLock();
FCEUI_SaveSnapshot();
fceuWrapperUnLock();
}
void consoleWin_t::loadLua(void)
{
#ifdef _S9XLUA_H
LuaControlDialog_t *luaCtrlWin;
//printf("Open Lua Control Window\n");
luaCtrlWin = new LuaControlDialog_t(this);
luaCtrlWin->show();
#endif
}
void consoleWin_t::openGamePadConfWin(void)
{
//printf("Open GamePad Config Window\n");
openGamePadConfWindow(this);
}
void consoleWin_t::openGameSndConfWin(void)
{
ConsoleSndConfDialog_t *sndConfWin;
//printf("Open Sound Config Window\n");
sndConfWin = new ConsoleSndConfDialog_t(this);
sndConfWin->show();
}
void consoleWin_t::openGameVideoConfWin(void)
{
ConsoleVideoConfDialog_t *vidConfWin;
//printf("Open Video Config Window\n");
vidConfWin = new ConsoleVideoConfDialog_t(this);
vidConfWin->show();
}
void consoleWin_t::openHotkeyConfWin(void)
{
HotKeyConfDialog_t *hkConfWin;
//printf("Open Hot Key Config Window\n");
hkConfWin = new HotKeyConfDialog_t(this);
hkConfWin->show();
}
void consoleWin_t::openPaletteConfWin(void)
{
PaletteConfDialog_t *paletteConfWin;
//printf("Open Palette Config Window\n");
paletteConfWin = new PaletteConfDialog_t(this);
paletteConfWin->show();
}
void consoleWin_t::openGuiConfWin(void)
{
GuiConfDialog_t *guiConfWin;
//printf("Open GUI Config Window\n");
guiConfWin = new GuiConfDialog_t(this);
guiConfWin->show();
}
void consoleWin_t::openCheats(void)
{
//printf("Open GUI Cheat Window\n");
openCheatDialog(this);
}
void consoleWin_t::openRamWatch(void)
{
RamWatchDialog_t *ramWatchWin;
//printf("Open GUI RAM Watch Window\n");
ramWatchWin = new RamWatchDialog_t(this);
ramWatchWin->show();
}
void consoleWin_t::openRamSearch(void)
{
//printf("Open GUI RAM Search Window\n");
openRamSearchWindow(this);
}
void consoleWin_t::openDebugWindow(void)
{
ConsoleDebugger *debugWin;
//printf("Open GUI 6502 Debugger Window\n");
debugWin = new ConsoleDebugger(this);
debugWin->show();
}
void consoleWin_t::openHexEditor(void)
{
HexEditorDialog_t *hexEditWin;
//printf("Open GUI Hex Editor Window\n");
hexEditWin = new HexEditorDialog_t(this);
hexEditWin->show();
}
void consoleWin_t::openPPUViewer(void)
{
//printf("Open GUI PPU Viewer Window\n");
openPPUViewWindow(this);
}
void consoleWin_t::openNTViewer(void)
{
//printf("Open GUI Name Table Viewer Window\n");
openNameTableViewWindow(this);
}
void consoleWin_t::openCodeDataLogger(void)
{
CodeDataLoggerDialog_t *cdlWin;
//printf("Open Code Data Logger Window\n");
cdlWin = new CodeDataLoggerDialog_t(this);
cdlWin->show();
}
void consoleWin_t::openTraceLogger(void)
{
openTraceLoggerWindow(this);
}
void consoleWin_t::toggleAutoResume(void)
{
//printf("Auto Resume: %i\n", autoResume->isChecked() );
g_config->setOption ("SDL.AutoResume", (int) autoResume->isChecked() );
AutoResumePlay = autoResume->isChecked();
}
void consoleWin_t::toggleFullscreen(void)
{
if ( isFullScreen() )
{
showNormal();
}
else
{
showFullScreen();
}
}
void consoleWin_t::powerConsoleCB(void)
{
fceuWrapperLock();
FCEUI_PowerNES();
fceuWrapperUnLock();
return;
}
void consoleWin_t::consoleHardReset(void)
{
fceuWrapperLock();
fceuWrapperHardReset();
fceuWrapperUnLock();
return;
}
void consoleWin_t::consoleSoftReset(void)
{
fceuWrapperLock();
fceuWrapperSoftReset();
fceuWrapperUnLock();
return;
}
void consoleWin_t::consolePause(void)
{
fceuWrapperLock();
fceuWrapperTogglePause();
fceuWrapperUnLock();
return;
}
void consoleWin_t::toggleGameGenie(bool checked)
{
int gg_enabled;
fceuWrapperLock();
g_config->getOption ("SDL.GameGenie", &gg_enabled);
g_config->setOption ("SDL.GameGenie", !gg_enabled);
g_config->save ();
FCEUI_SetGameGenie (gg_enabled);
fceuWrapperUnLock();
return;
}
void consoleWin_t::loadGameGenieROM(void)
{
int ret, useNativeFileDialogVal;
QString filename;
std::string last;
char dir[512];
QFileDialog dialog(this, tr("Open Game Genie ROM") );
dialog.setFileMode(QFileDialog::ExistingFile);
dialog.setNameFilter(tr("GG ROM File (gg.rom *Genie*.nes) ;; All files (*)"));
dialog.setViewMode(QFileDialog::List);
dialog.setFilter( QDir::AllEntries | QDir::Hidden );
dialog.setLabelText( QFileDialog::Accept, tr("Load") );
g_config->getOption ("SDL.LastOpenFile", &last );
getDirFromFile( last.c_str(), dir );
dialog.setDirectory( tr(dir) );
// Check config option to use native file dialog or not
g_config->getOption ("SDL.UseNativeFileDialog", &useNativeFileDialogVal);
dialog.setOption(QFileDialog::DontUseNativeDialog, !useNativeFileDialogVal);
dialog.show();
ret = dialog.exec();
if ( ret )
{
QStringList fileList;
fileList = dialog.selectedFiles();
if ( fileList.size() > 0 )
{
filename = fileList[0];
}
}
if ( filename.isNull() )
{
return;
}
qDebug() << "selected file path : " << filename.toUtf8();
g_config->setOption ("SDL.LastOpenFile", filename.toStdString().c_str() );
// copy file to proper place (~/.fceux/gg.rom)
std::ifstream f1 ( filename.toStdString().c_str(), std::fstream::binary);
std::string fn_out = FCEU_MakeFName (FCEUMKF_GGROM, 0, "");
std::ofstream f2 (fn_out.c_str (),
std::fstream::trunc | std::fstream::binary);
f2 << f1.rdbuf ();
return;
}
void consoleWin_t::insertCoin(void)
{
fceuWrapperLock();
FCEUI_VSUniCoin();
fceuWrapperUnLock();
return;
}
void consoleWin_t::fdsSwitchDisk(void)
{
fceuWrapperLock();
FCEU_FDSSelect();
fceuWrapperUnLock();
return;
}
void consoleWin_t::fdsEjectDisk(void)
{
fceuWrapperLock();
FCEU_FDSInsert();
fceuWrapperUnLock();
return;
}
void consoleWin_t::fdsLoadBiosFile(void)
{
int ret, useNativeFileDialogVal;
QString filename;
std::string last;
char dir[512];
QFileDialog dialog(this, tr("Load FDS BIOS (disksys.rom)") );
dialog.setFileMode(QFileDialog::ExistingFile);
dialog.setNameFilter(tr("ROM files (*.rom *.ROM) ;; All files (*)"));
dialog.setViewMode(QFileDialog::List);
dialog.setFilter( QDir::AllEntries | QDir::Hidden );
dialog.setLabelText( QFileDialog::Accept, tr("Load") );
g_config->getOption ("SDL.LastOpenFile", &last );
getDirFromFile( last.c_str(), dir );
dialog.setDirectory( tr(dir) );
// Check config option to use native file dialog or not
g_config->getOption ("SDL.UseNativeFileDialog", &useNativeFileDialogVal);
dialog.setOption(QFileDialog::DontUseNativeDialog, !useNativeFileDialogVal);
dialog.show();
ret = dialog.exec();
if ( ret )
{
QStringList fileList;
fileList = dialog.selectedFiles();
if ( fileList.size() > 0 )
{
filename = fileList[0];
}
}
if ( filename.isNull() )
{
return;
}
qDebug() << "selected file path : " << filename.toUtf8();
// copy BIOS file to proper place (~/.fceux/disksys.rom)
std::ifstream fdsBios (filename.toStdString().c_str(), std::fstream::binary);
std::string output_filename =
FCEU_MakeFName (FCEUMKF_FDSROM, 0, "");
std::ofstream outFile (output_filename.c_str (),
std::fstream::trunc | std::fstream::
binary);
outFile << fdsBios.rdbuf ();
if (outFile.fail ())
{
FCEUD_PrintError ("Error copying the FDS BIOS file.");
}
else
{
printf("Famicom Disk System BIOS loaded. If you are you having issues, make sure your BIOS file is 8KB in size.\n");
}
return;
}
void consoleWin_t::emuSpeedUp(void)
{
IncreaseEmulationSpeed();
}
void consoleWin_t::emuSlowDown(void)
{
DecreaseEmulationSpeed();
}
void consoleWin_t::emuSlowestSpd(void)
{
FCEUD_SetEmulationSpeed( EMUSPEED_SLOWEST );
}
void consoleWin_t::emuNormalSpd(void)
{
FCEUD_SetEmulationSpeed( EMUSPEED_NORMAL );
}
void consoleWin_t::emuFastestSpd(void)
{
FCEUD_SetEmulationSpeed( EMUSPEED_FASTEST );
}
void consoleWin_t::emuCustomSpd(void)
{
int ret;
QInputDialog dialog(this);
dialog.setWindowTitle( tr("Emulation Speed") );
dialog.setLabelText( tr("Enter a percentage from 1 to 1000.") );
dialog.setOkButtonText( tr("Ok") );
dialog.setInputMode( QInputDialog::IntInput );
dialog.setIntRange( 1, 1000 );
dialog.setIntValue( 100 );
dialog.show();
ret = dialog.exec();
if ( QDialog::Accepted == ret )
{
int spdPercent;
spdPercent = dialog.intValue();
CustomEmulationSpeed( spdPercent );
}
}
void consoleWin_t::emuSetFrameAdvDelay(void)
{
int ret;
QInputDialog dialog(this);
dialog.setWindowTitle( tr("Frame Advance Delay") );
dialog.setLabelText( tr("How much time should elapse before holding the frame advance unpauses the simulation?") );
dialog.setOkButtonText( tr("Ok") );
dialog.setInputMode( QInputDialog::IntInput );
dialog.setIntRange( 0, 1000 );
dialog.setIntValue( frameAdvance_Delay );
dialog.show();
ret = dialog.exec();
if ( QDialog::Accepted == ret )
{
frameAdvance_Delay = dialog.intValue();
}
}
void consoleWin_t::openMovie(void)
{
int ret, useNativeFileDialogVal;
QString filename;
std::string last;
char dir[512];
QFileDialog dialog(this, tr("Open FM2 Movie") );
dialog.setFileMode(QFileDialog::ExistingFile);
dialog.setNameFilter(tr("FM2 Movies (*.fm2) ;; All files (*)"));
dialog.setViewMode(QFileDialog::List);
dialog.setFilter( QDir::AllEntries | QDir::Hidden );
dialog.setLabelText( QFileDialog::Accept, tr("Open") );
g_config->getOption ("SDL.LastOpenFile", &last );
getDirFromFile( last.c_str(), dir );
dialog.setDirectory( tr(dir) );
// Check config option to use native file dialog or not
g_config->getOption ("SDL.UseNativeFileDialog", &useNativeFileDialogVal);
dialog.setOption(QFileDialog::DontUseNativeDialog, !useNativeFileDialogVal);
dialog.show();
ret = dialog.exec();
if ( ret )
{
QStringList fileList;
fileList = dialog.selectedFiles();
if ( fileList.size() > 0 )
{
filename = fileList[0];
}
}
if ( filename.isNull() )
{
return;
}
qDebug() << "selected file path : " << filename.toUtf8();
int pauseframe;
g_config->getOption ("SDL.PauseFrame", &pauseframe);
g_config->setOption ("SDL.PauseFrame", 0);
FCEUI_printf ("Playing back movie located at %s\n", filename.toStdString().c_str() );
fceuWrapperLock();
if (FCEUI_LoadMovie( filename.toStdString().c_str(),
false, pauseframe ? pauseframe : false) == false)
{
printf("Error: Could not open movie file: %s \n", filename.toStdString().c_str() );
}
fceuWrapperUnLock();
return;
}
void consoleWin_t::stopMovie(void)
{
fceuWrapperLock();
FCEUI_StopMovie();
fceuWrapperUnLock();
return;
}
void consoleWin_t::recordMovie(void)
{
fceuWrapperLock();
if (fceuWrapperGameLoaded())
{
std::string name = FCEU_MakeFName (FCEUMKF_MOVIE, 0, 0);
FCEUI_printf ("Recording movie to %s\n", name.c_str ());
FCEUI_SaveMovie (name.c_str (), MOVIE_FLAG_NONE, L"");
}
fceuWrapperUnLock();
return;
}
void consoleWin_t::recordMovieAs(void)
{
int ret, useNativeFileDialogVal;
QString filename;
std::string last;
char dir[512];
QFileDialog dialog(this, tr("Save FM2 Movie for Recording") );
dialog.setFileMode(QFileDialog::AnyFile);
dialog.setNameFilter(tr("FM2 Movies (*.fm2) ;; All files (*)"));
dialog.setViewMode(QFileDialog::List);
dialog.setFilter( QDir::AllEntries | QDir::Hidden );
dialog.setLabelText( QFileDialog::Accept, tr("Save") );
g_config->getOption ("SDL.LastOpenFile", &last );
getDirFromFile( last.c_str(), dir );
dialog.setDirectory( tr(dir) );
// Check config option to use native file dialog or not
g_config->getOption ("SDL.UseNativeFileDialog", &useNativeFileDialogVal);
dialog.setOption(QFileDialog::DontUseNativeDialog, !useNativeFileDialogVal);
dialog.show();
ret = dialog.exec();
if ( ret )
{
QStringList fileList;
fileList = dialog.selectedFiles();
if ( fileList.size() > 0 )
{
filename = fileList[0];
}
}
if ( filename.isNull() )
{
return;
}
qDebug() << "selected file path : " << filename.toUtf8();
int pauseframe;
g_config->getOption ("SDL.PauseFrame", &pauseframe);
g_config->setOption ("SDL.PauseFrame", 0);
FCEUI_printf ("Recording movie to %s\n", filename.toStdString().c_str() );
fceuWrapperLock();
std::string s = GetUserText ("Author name");
std::wstring author (s.begin (), s.end ());
FCEUI_SaveMovie ( filename.toStdString().c_str(), MOVIE_FLAG_NONE, author);
fceuWrapperUnLock();
return;
}
void consoleWin_t::aboutFCEUX(void)
{
AboutWindow *aboutWin;
//printf("About FCEUX Window\n");
aboutWin = new AboutWindow(this);
aboutWin->show();
return;
}
void consoleWin_t::aboutQt(void)
{
//printf("About Qt Window\n");
QMessageBox::aboutQt(this);
//printf("About Qt Destroyed\n");
return;
}
void consoleWin_t::syncActionConfig( QAction *act, const char *property )
{
if ( act->isCheckable() )
{
int enable;
g_config->getOption ( property, &enable);
act->setChecked( enable ? true : false );
}
}
void consoleWin_t::updatePeriodic(void)
{
//struct timespec ts;
//double t;
//clock_gettime( CLOCK_REALTIME, &ts );
//t = (double)ts.tv_sec + (double)(ts.tv_nsec * 1.0e-9);
//printf("Run Frame %f\n", t);
// Update Input Devices
FCEUD_UpdateInput();
// RePaint Game Viewport
if ( nes_shm->blitUpdated )
{
nes_shm->blitUpdated = 0;
if ( viewport_SDL )
{
viewport_SDL->transfer2LocalBuffer();
viewport_SDL->render();
}
else
{
viewport_GL->transfer2LocalBuffer();
//viewport_GL->repaint();
viewport_GL->update();
}
}
if ( errorMsgValid )
{
showErrorMsgWindow();
errorMsgValid = false;
}
return;
}
void emulatorThread_t::run(void)
{
printf("Emulator Start\n");
nes_shm->runEmulator = 1;
while ( nes_shm->runEmulator )
{
fceuWrapperUpdate();
}
printf("Emulator Exit\n");
emit finished();
}
Reference in New Issue View Git Blame Copy Permalink