670 lines
No EOL
18 KiB
C++
670 lines
No EOL
18 KiB
C++
#include "stdafx.h"
|
|
#include "Resource.h"
|
|
#include "MainWindow.h"
|
|
#include "../Core/Console.h"
|
|
#include "../Utilities/ConfigManager.h"
|
|
#include "../Utilities/FolderUtilities.h"
|
|
#include "InputManager.h"
|
|
|
|
using namespace DirectX;
|
|
|
|
namespace NES {
|
|
MainWindow* MainWindow::Instance = nullptr;
|
|
|
|
bool MainWindow::Initialize()
|
|
{
|
|
if(FAILED(InitWindow())) {
|
|
return false;
|
|
}
|
|
|
|
_renderer.reset(new Renderer(_hWnd));
|
|
_soundManager.reset(new SoundManager(_hWnd));
|
|
|
|
return true;
|
|
}
|
|
|
|
void CreateConsole()
|
|
{
|
|
CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
|
|
int consoleHandleR, consoleHandleW;
|
|
long stdioHandle;
|
|
FILE *fptr;
|
|
|
|
AllocConsole();
|
|
std::wstring strW = L"Dev Console";
|
|
SetConsoleTitle(strW.c_str());
|
|
|
|
EnableMenuItem(GetSystemMenu(GetConsoleWindow(), FALSE), SC_CLOSE, MF_GRAYED);
|
|
DrawMenuBar(GetConsoleWindow());
|
|
|
|
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &consoleInfo);
|
|
|
|
stdioHandle = (long)GetStdHandle(STD_INPUT_HANDLE);
|
|
consoleHandleR = _open_osfhandle(stdioHandle, _O_TEXT);
|
|
fptr = _fdopen(consoleHandleR, "r");
|
|
*stdin = *fptr;
|
|
setvbuf(stdin, NULL, _IONBF, 0);
|
|
|
|
stdioHandle = (long)GetStdHandle(STD_OUTPUT_HANDLE);
|
|
consoleHandleW = _open_osfhandle(stdioHandle, _O_TEXT);
|
|
fptr = _fdopen(consoleHandleW, "w");
|
|
*stdout = *fptr;
|
|
setvbuf(stdout, NULL, _IONBF, 0);
|
|
|
|
stdioHandle = (long)GetStdHandle(STD_ERROR_HANDLE);
|
|
*stderr = *fptr;
|
|
setvbuf(stderr, NULL, _IONBF, 0);
|
|
}
|
|
|
|
int MainWindow::Run()
|
|
{
|
|
#if _DEBUG
|
|
CreateConsole();
|
|
#endif
|
|
|
|
Initialize();
|
|
|
|
InitializeOptions();
|
|
InputManager inputManager;
|
|
ControlManager::RegisterControlDevice(&inputManager, 0);
|
|
|
|
HACCEL hAccel = LoadAccelerators(_hInstance, MAKEINTRESOURCE(IDC_Accelerator));
|
|
if(hAccel == nullptr) {
|
|
//error
|
|
std::cout << "error";
|
|
}
|
|
|
|
MSG msg = { 0 };
|
|
while(WM_QUIT != msg.message) {
|
|
if(PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE)) {
|
|
if(!TranslateAccelerator(_hWnd, hAccel, &msg)) {
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
} else {
|
|
_renderer->Render();
|
|
}
|
|
std::this_thread::sleep_for(std::chrono::duration<int, std::milli>(1));
|
|
|
|
if(_playingMovie) {
|
|
if(!Movie::Playing()) {
|
|
_playingMovie = false;
|
|
_renderer->DisplayMessage(L"Movie ended.", 3000);
|
|
|
|
//Pause game
|
|
Stop(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
return (int)msg.wParam;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
// Register class and create window
|
|
//--------------------------------------------------------------------------------------
|
|
HRESULT MainWindow::InitWindow()
|
|
{
|
|
// Register class
|
|
WNDCLASSEX wcex;
|
|
wcex.cbSize = sizeof(WNDCLASSEX);
|
|
wcex.style = CS_HREDRAW | CS_VREDRAW;
|
|
wcex.lpfnWndProc = WndProc;
|
|
wcex.cbClsExtra = 0;
|
|
wcex.cbWndExtra = 0;
|
|
wcex.hInstance = _hInstance;
|
|
wcex.hIcon = LoadIcon(_hInstance, (LPCTSTR)IDI_GUI);
|
|
wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
|
|
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
|
|
wcex.lpszMenuName = MAKEINTRESOURCE(IDC_GUI);
|
|
wcex.lpszClassName = L"NESEmu";
|
|
wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);
|
|
if(!RegisterClassEx(&wcex))
|
|
return E_FAIL;
|
|
|
|
// Create window
|
|
RECT rc = { 0, 0, 800, 700 };
|
|
AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, FALSE);
|
|
_hWnd = CreateWindow(L"NESEmu", _windowName,
|
|
WS_OVERLAPPEDWINDOW,
|
|
CW_USEDEFAULT, CW_USEDEFAULT, rc.right - rc.left, rc.bottom - rc.top, nullptr, nullptr, _hInstance,
|
|
nullptr);
|
|
if(!_hWnd) {
|
|
return E_FAIL;
|
|
}
|
|
|
|
ShowWindow(_hWnd, _nCmdShow);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
INT_PTR CALLBACK MainWindow::About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
UNREFERENCED_PARAMETER(lParam);
|
|
switch(message) {
|
|
case WM_INITDIALOG:
|
|
return (INT_PTR)TRUE;
|
|
|
|
case WM_COMMAND:
|
|
if(LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) {
|
|
EndDialog(hDlg, LOWORD(wParam));
|
|
return (INT_PTR)TRUE;
|
|
}
|
|
break;
|
|
}
|
|
return (INT_PTR)FALSE;
|
|
}
|
|
|
|
INT_PTR CALLBACK MainWindow::ControllerSetup(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
UNREFERENCED_PARAMETER(lParam);
|
|
static HWND _focusedControl;
|
|
switch(message) {
|
|
case WM_INITDIALOG:
|
|
HWND cboPort1;
|
|
cboPort1 = GetDlgItem(hDlg, IDC_CBOPORT1);
|
|
SendMessage(cboPort1, CB_ADDSTRING, 0, (LPARAM)_T("<none>"));
|
|
SendMessage(cboPort1, CB_ADDSTRING, 0, (LPARAM)_T("Gamepad"));
|
|
SendMessage(cboPort1, CB_SETCURSEL, 0, 0);
|
|
return (INT_PTR)TRUE;
|
|
|
|
case WM_SETFOCUS:
|
|
case WM_SETCURSOR:
|
|
_focusedControl = GetFocus();
|
|
break;
|
|
|
|
case WM_KEYDOWN:
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
if(LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) {
|
|
if(LOWORD(wParam) == IDOK) {
|
|
//Save settings
|
|
ConfigManager::SetValue(Config::Player1_ButtonA, "V");
|
|
}
|
|
|
|
EndDialog(hDlg, LOWORD(wParam));
|
|
return (INT_PTR)TRUE;
|
|
}
|
|
break;
|
|
}
|
|
return (INT_PTR)FALSE;
|
|
}
|
|
|
|
INT_PTR CALLBACK MainWindow::InputConfig(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
UNREFERENCED_PARAMETER(lParam);
|
|
switch(message) {
|
|
case WM_INITDIALOG:
|
|
HWND cboPort1;
|
|
cboPort1 = GetDlgItem(hDlg, IDC_CBOPORT1);
|
|
SendMessage(cboPort1, CB_ADDSTRING, 0, (LPARAM)_T("<none>"));
|
|
SendMessage(cboPort1, CB_ADDSTRING, 0, (LPARAM)_T("Gamepad"));
|
|
SendMessage(cboPort1, CB_SETCURSEL, 0, 0);
|
|
return (INT_PTR)TRUE;
|
|
|
|
case WM_COMMAND:
|
|
if(LOWORD(wParam) == IDC_BTNPORT1KEYS) {
|
|
DialogBox(nullptr, MAKEINTRESOURCE(IDD_CONTROLLERSETUP), hDlg, ControllerSetup);
|
|
} else if(LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) {
|
|
if(LOWORD(wParam) == IDOK) {
|
|
//Save settings
|
|
ConfigManager::SetValue(Config::Player1_ButtonA, "V");
|
|
}
|
|
|
|
EndDialog(hDlg, LOWORD(wParam));
|
|
return (INT_PTR)TRUE;
|
|
}
|
|
break;
|
|
}
|
|
return (INT_PTR)FALSE;
|
|
}
|
|
|
|
void MainWindow::InitializeOptions()
|
|
{
|
|
if(ConfigManager::GetValue<bool>(Config::LimitFPS)) {
|
|
Console::SetFlags(EmulationFlags::LimitFPS);
|
|
SetMenuCheck(ID_OPTIONS_LIMITFPS, true);
|
|
}
|
|
|
|
if(ConfigManager::GetValue<bool>(Config::ShowFPS)) {
|
|
_renderer->SetFlags(UIFlags::ShowFPS);
|
|
SetMenuCheck(ID_OPTIONS_SHOWFPS, true);
|
|
}
|
|
|
|
UpdateMRUMenu();
|
|
}
|
|
|
|
void MainWindow::UpdateMRUMenu()
|
|
{
|
|
wstring MRU0 = ConfigManager::GetValue<wstring>(Config::MRU0);
|
|
wstring MRU1 = ConfigManager::GetValue<wstring>(Config::MRU1);
|
|
wstring MRU2 = ConfigManager::GetValue<wstring>(Config::MRU2);
|
|
wstring MRU3 = ConfigManager::GetValue<wstring>(Config::MRU3);
|
|
wstring MRU4 = ConfigManager::GetValue<wstring>(Config::MRU4);
|
|
|
|
HMENU hMenu = GetMenu(_hWnd);
|
|
|
|
MENUITEMINFOW info;
|
|
//Initialize MENUITEMINFO structure:
|
|
memset(&info, 0, sizeof(info));
|
|
info.cbSize = sizeof(info);
|
|
info.fMask = MIIM_TYPE;
|
|
info.fType = MFT_STRING;
|
|
info.cch = 256;
|
|
|
|
if(!MRU0.empty()) {
|
|
info.dwTypeData = (LPWSTR)MRU0.c_str();
|
|
SetMenuItemInfo(hMenu, ID_RECENTFILES_MRU1, false, &info);
|
|
}
|
|
|
|
if(!MRU1.empty()) {
|
|
info.dwTypeData = (LPWSTR)MRU1.c_str();
|
|
SetMenuItemInfo(hMenu, ID_RECENTFILES_MRU2, false, &info);
|
|
}
|
|
|
|
if(!MRU2.empty()) {
|
|
info.dwTypeData = (LPWSTR)MRU2.c_str();
|
|
SetMenuItemInfo(hMenu, ID_RECENTFILES_MRU3, false, &info);
|
|
}
|
|
|
|
if(!MRU3.empty()) {
|
|
info.dwTypeData = (LPWSTR)MRU3.c_str();
|
|
SetMenuItemInfo(hMenu, ID_RECENTFILES_MRU4, false, &info);
|
|
}
|
|
|
|
if(!MRU4.empty()) {
|
|
info.dwTypeData = (LPWSTR)MRU4.c_str();
|
|
SetMenuItemInfo(hMenu, ID_RECENTFILES_MRU5, false, &info);
|
|
}
|
|
}
|
|
|
|
wstring MainWindow::SelectROM(wstring filepath)
|
|
{
|
|
if(filepath.empty()) {
|
|
filepath = FolderUtilities::OpenFile(L"NES Roms (*.nes)\0*.NES\0All (*.*)\0*.*", ConfigManager::GetValue<wstring>(Config::LastGameFolder), false);
|
|
if(!filepath.empty()) {
|
|
ConfigManager::SetValue(Config::LastGameFolder, FolderUtilities::GetFolderName(filepath));
|
|
}
|
|
}
|
|
|
|
if(!filepath.empty()) {
|
|
ConfigManager::AddToMRU(filepath);
|
|
UpdateMRUMenu();
|
|
Start(filepath);
|
|
}
|
|
|
|
return filepath;
|
|
}
|
|
|
|
void MainWindow::Start(wstring romFilepath)
|
|
{
|
|
if(_emuThread) {
|
|
Stop(false);
|
|
}
|
|
|
|
if(romFilepath.length() > 0) {
|
|
_currentROM = romFilepath;
|
|
_currentROMName = FolderUtilities::GetFilename(romFilepath, false);
|
|
SetWindowText(_hWnd, (wstring(_windowName) + L": " + _currentROMName).c_str());
|
|
_console.reset(new Console(_currentROM));
|
|
}
|
|
|
|
if(!_console && _currentROM.length() > 0) {
|
|
_console.reset(new Console(_currentROM));
|
|
}
|
|
|
|
if(_console) {
|
|
_emuThread.reset(new thread(&Console::Run, _console.get()));
|
|
|
|
SetMenuEnabled(ID_NES_PAUSE, true);
|
|
SetMenuEnabled(ID_NES_RESET, true);
|
|
SetMenuEnabled(ID_NES_STOP, true);
|
|
SetMenuEnabled(ID_NES_RESUME, false);
|
|
|
|
SetMenuEnabled(ID_FILE_QUICKLOAD, true);
|
|
SetMenuEnabled(ID_FILE_QUICKSAVE, true);
|
|
|
|
SetMenuEnabled(ID_MOVIES_PLAY, true);
|
|
SetMenuEnabled(ID_RECORDFROM_START, true);
|
|
SetMenuEnabled(ID_RECORDFROM_NOW, true);
|
|
SetMenuEnabled(ID_MOVIES_STOP, true);
|
|
|
|
_renderer->ClearFlags(UIFlags::ShowPauseScreen);
|
|
if(IsMenuChecked(ID_OPTIONS_SHOWFPS)) {
|
|
_renderer->SetFlags(UIFlags::ShowFPS);
|
|
}
|
|
}
|
|
}
|
|
|
|
void MainWindow::Stop(bool powerOff)
|
|
{
|
|
_renderer->ClearFlags(UIFlags::ShowFPS | UIFlags::ShowPauseScreen);
|
|
|
|
_soundManager->Reset();
|
|
if(_console) {
|
|
_console->Stop();
|
|
}
|
|
if(_emuThread) {
|
|
_emuThread->join();
|
|
|
|
if(powerOff) {
|
|
_console.reset(nullptr);
|
|
} else {
|
|
_renderer->SetFlags(UIFlags::ShowPauseScreen);
|
|
}
|
|
|
|
_emuThread.reset(nullptr);
|
|
}
|
|
|
|
SetMenuEnabled(ID_NES_PAUSE, false);
|
|
SetMenuEnabled(ID_NES_RESET, !powerOff);
|
|
SetMenuEnabled(ID_NES_STOP, !powerOff);
|
|
SetMenuEnabled(ID_FILE_QUICKLOAD, !powerOff);
|
|
SetMenuEnabled(ID_FILE_QUICKSAVE, !powerOff);
|
|
|
|
SetMenuEnabled(ID_MOVIES_PLAY, !powerOff);
|
|
SetMenuEnabled(ID_RECORDFROM_START, !powerOff);
|
|
SetMenuEnabled(ID_RECORDFROM_NOW, !powerOff);
|
|
SetMenuEnabled(ID_MOVIES_STOP, !powerOff);
|
|
|
|
SetMenuEnabled(ID_NES_RESUME, true);
|
|
}
|
|
|
|
void MainWindow::Reset()
|
|
{
|
|
if(_console) {
|
|
_soundManager->Reset();
|
|
Console::Pause();
|
|
Console::Reset();
|
|
Console::Resume();
|
|
}
|
|
}
|
|
|
|
void MainWindow::SetMenuEnabled(int resourceID, bool enabled)
|
|
{
|
|
HMENU hMenu = GetMenu(_hWnd);
|
|
EnableMenuItem(hMenu, resourceID, enabled ? MF_ENABLED : MF_GRAYED);
|
|
}
|
|
|
|
bool MainWindow::IsMenuChecked(int resourceID)
|
|
{
|
|
HMENU hMenu = GetMenu(_hWnd);
|
|
return (GetMenuState(hMenu, resourceID, MF_BYCOMMAND) & MF_CHECKED) == MF_CHECKED;
|
|
}
|
|
|
|
bool MainWindow::SetMenuCheck(int resourceID, bool checked)
|
|
{
|
|
HMENU hMenu = GetMenu(_hWnd);
|
|
CheckMenuItem(hMenu, resourceID, MF_BYCOMMAND | (checked ? MF_CHECKED : MF_UNCHECKED));
|
|
return checked;
|
|
}
|
|
|
|
bool MainWindow::ToggleMenuCheck(int resourceID)
|
|
{
|
|
return SetMenuCheck(resourceID, !IsMenuChecked(resourceID));
|
|
}
|
|
|
|
void MainWindow::LimitFPS_Click()
|
|
{
|
|
if(ToggleMenuCheck(ID_OPTIONS_LIMITFPS)) {
|
|
Console::SetFlags(EmulationFlags::LimitFPS);
|
|
ConfigManager::SetValue(Config::LimitFPS, true);
|
|
} else {
|
|
Console::ClearFlags(EmulationFlags::LimitFPS);
|
|
ConfigManager::SetValue(Config::LimitFPS, false);
|
|
}
|
|
}
|
|
|
|
void MainWindow::ShowFPS_Click()
|
|
{
|
|
if(ToggleMenuCheck(ID_OPTIONS_SHOWFPS)) {
|
|
_renderer->SetFlags(UIFlags::ShowFPS);
|
|
ConfigManager::SetValue(Config::ShowFPS, true);
|
|
} else {
|
|
_renderer->ClearFlags(UIFlags::ShowFPS);
|
|
ConfigManager::SetValue(Config::ShowFPS, false);
|
|
}
|
|
}
|
|
|
|
void MainWindow::SaveTestResult()
|
|
{
|
|
if(_console) {
|
|
_console->SaveTestResult();
|
|
}
|
|
}
|
|
|
|
void MainWindow::RunTests()
|
|
{
|
|
Stop(true);
|
|
int passCount = 0;
|
|
int failCount = 0;
|
|
int totalCount = 0;
|
|
for(wstring testROM : FolderUtilities::GetFilesInFolder(L"..\\TestSuite\\", L"*.nes", true)) {
|
|
ifstream testResult(testROM + L".trt", ios::in | ios::binary);
|
|
|
|
if(testResult) {
|
|
std::wcout << testROM.substr(13) << ": ";
|
|
uint8_t* expectedResult = new uint8_t[256 * 240 * 4];
|
|
testResult.read((char*)expectedResult, 256 * 240 * 4);
|
|
|
|
Console *console = new Console(testROM);
|
|
if(console->RunTest(expectedResult)) {
|
|
std::cout << "Passed";
|
|
passCount++;
|
|
} else {
|
|
std::cout << "FAILED";
|
|
failCount++;
|
|
}
|
|
std::cout << std::endl;
|
|
|
|
testResult.close();
|
|
|
|
delete[] expectedResult;
|
|
} else {
|
|
//std::wcout << "[No result]" << std::endl;
|
|
}
|
|
totalCount++;
|
|
}
|
|
Stop(true);
|
|
|
|
std::cout << "------------------------" << std::endl;
|
|
std::cout << passCount << " / " << totalCount << " + " << failCount << " FAILED" << std::endl;
|
|
std::cout << "------------------------" << std::endl;
|
|
}
|
|
|
|
void MainWindow::SelectSaveSlot(int slot)
|
|
{
|
|
_currentSaveSlot = slot % 5;
|
|
_renderer->DisplayMessage(L"Savestate slot: " + std::to_wstring(_currentSaveSlot + 1), 3000);
|
|
|
|
SetMenuCheck(ID_SAVESTATESLOT_1, _currentSaveSlot == 0);
|
|
SetMenuCheck(ID_SAVESTATESLOT_2, _currentSaveSlot == 1);
|
|
SetMenuCheck(ID_SAVESTATESLOT_3, _currentSaveSlot == 2);
|
|
SetMenuCheck(ID_SAVESTATESLOT_4, _currentSaveSlot == 3);
|
|
SetMenuCheck(ID_SAVESTATESLOT_5, _currentSaveSlot == 4);
|
|
}
|
|
|
|
LRESULT CALLBACK MainWindow::WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
static MainWindow *mainWindow = MainWindow::GetInstance();
|
|
wstring filename;
|
|
PAINTSTRUCT ps;
|
|
int wmId, wmEvent;
|
|
HDC hdc;
|
|
|
|
switch(message) {
|
|
case WM_COMMAND:
|
|
wmId = LOWORD(wParam);
|
|
wmEvent = HIWORD(wParam);
|
|
// Parse the menu selections:
|
|
switch(wmId) {
|
|
case ID_FILE_OPEN:
|
|
mainWindow->SelectROM();
|
|
break;
|
|
|
|
case ID_SAVESTATESLOT_1:
|
|
mainWindow->SelectSaveSlot(0);
|
|
break;
|
|
case ID_SAVESTATESLOT_2:
|
|
mainWindow->SelectSaveSlot(1);
|
|
break;
|
|
case ID_SAVESTATESLOT_3:
|
|
mainWindow->SelectSaveSlot(2);
|
|
break;
|
|
case ID_SAVESTATESLOT_4:
|
|
mainWindow->SelectSaveSlot(3);
|
|
break;
|
|
case ID_SAVESTATESLOT_5:
|
|
mainWindow->SelectSaveSlot(4);
|
|
break;
|
|
|
|
case ID_RECENTFILES_MRU1:
|
|
mainWindow->SelectROM(ConfigManager::GetValue<wstring>(Config::MRU0));
|
|
break;
|
|
case ID_RECENTFILES_MRU2:
|
|
mainWindow->SelectROM(ConfigManager::GetValue<wstring>(Config::MRU1));
|
|
break;
|
|
case ID_RECENTFILES_MRU3:
|
|
mainWindow->SelectROM(ConfigManager::GetValue<wstring>(Config::MRU2));
|
|
break;
|
|
case ID_RECENTFILES_MRU4:
|
|
mainWindow->SelectROM(ConfigManager::GetValue<wstring>(Config::MRU3));
|
|
break;
|
|
case ID_RECENTFILES_MRU5:
|
|
mainWindow->SelectROM(ConfigManager::GetValue<wstring>(Config::MRU4));
|
|
break;
|
|
|
|
case ID_FILE_QUICKLOAD:
|
|
if(mainWindow->_console->LoadState(FolderUtilities::GetSaveStateFolder() + mainWindow->_currentROMName + L".ss" + std::to_wstring(mainWindow->_currentSaveSlot + 1))) {
|
|
mainWindow->_renderer->DisplayMessage(L"State loaded.", 3000);
|
|
} else {
|
|
mainWindow->_renderer->DisplayMessage(L"Slot is empty.", 3000);
|
|
}
|
|
break;
|
|
case ID_FILE_QUICKSAVE:
|
|
mainWindow->_console->SaveState(FolderUtilities::GetSaveStateFolder() + mainWindow->_currentROMName + L".ss" + std::to_wstring(mainWindow->_currentSaveSlot + 1));
|
|
mainWindow->_renderer->DisplayMessage(L"State saved.", 3000);
|
|
break;
|
|
case ID_CHANGESLOT:
|
|
mainWindow->SelectSaveSlot(mainWindow->_currentSaveSlot + 1);
|
|
break;
|
|
case ID_FILE_EXIT:
|
|
DestroyWindow(hWnd);
|
|
break;
|
|
|
|
case ID_NES_RESUME:
|
|
mainWindow->Start();
|
|
break;
|
|
case ID_NES_PAUSE:
|
|
mainWindow->Stop(false);
|
|
break;
|
|
case ID_NES_STOP:
|
|
mainWindow->Stop(true);
|
|
break;
|
|
case ID_NES_RESET:
|
|
mainWindow->Reset();
|
|
break;
|
|
|
|
case ID_OPTIONS_LIMITFPS:
|
|
mainWindow->LimitFPS_Click();
|
|
break;
|
|
case ID_OPTIONS_SHOWFPS:
|
|
mainWindow->ShowFPS_Click();
|
|
break;
|
|
case ID_OPTIONS_INPUT:
|
|
DialogBox(nullptr, MAKEINTRESOURCE(IDD_INPUTCONFIG), hWnd, InputConfig);
|
|
break;
|
|
|
|
case ID_MOVIES_PLAY:
|
|
filename = FolderUtilities::OpenFile(L"Movie Files (*.nmo)\0*.nmo\0All (*.*)\0*.*", FolderUtilities::GetMovieFolder(), false);
|
|
if(!filename.empty()) {
|
|
mainWindow->_renderer->DisplayMessage(L"Playing movie: " + FolderUtilities::GetFilename(filename, true), 3000);
|
|
mainWindow->_playingMovie = true;
|
|
Movie::Play(filename);
|
|
}
|
|
mainWindow->SetMenuEnabled(ID_MOVIES_STOP, true);
|
|
break;
|
|
case ID_RECORDFROM_START:
|
|
case ID_RECORDFROM_NOW:
|
|
filename = FolderUtilities::OpenFile(L"Movie Files (*.nmo)\0*.nmo\0All (*.*)\0*.*", FolderUtilities::GetMovieFolder(), true, L"nmo");
|
|
if(!filename.empty()) {
|
|
mainWindow->_renderer->DisplayMessage(L"Recording...", 3000);
|
|
Movie::Record(filename, wmId == ID_RECORDFROM_START);
|
|
}
|
|
mainWindow->SetMenuEnabled(ID_MOVIES_STOP, true);
|
|
break;
|
|
|
|
case ID_MOVIES_STOP:
|
|
Movie::Stop();
|
|
mainWindow->_playingMovie = false;
|
|
mainWindow->SetMenuEnabled(ID_MOVIES_STOP, false);
|
|
break;
|
|
|
|
case ID_TESTS_RUNTESTS:
|
|
mainWindow->RunTests();
|
|
break;
|
|
case ID_TESTS_SAVETESTRESULT:
|
|
mainWindow->SaveTestResult();
|
|
break;
|
|
|
|
case ID_HELP_ABOUT:
|
|
DialogBox(nullptr, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
|
|
break;
|
|
|
|
default:
|
|
return DefWindowProc(hWnd, message, wParam, lParam);
|
|
}
|
|
break;
|
|
case WM_PAINT:
|
|
hdc = BeginPaint(hWnd, &ps);
|
|
EndPaint(hWnd, &ps);
|
|
break;
|
|
|
|
case WM_SIZE:
|
|
if(wParam == SIZE_RESTORED) {
|
|
RECT clientRect;
|
|
RECT windowRect;
|
|
LONG xGap;
|
|
LONG yGap;
|
|
GetWindowRect(hWnd, &windowRect);
|
|
GetClientRect(hWnd, &clientRect);
|
|
|
|
xGap = (windowRect.right - windowRect.left) - (clientRect.right - clientRect.left);
|
|
yGap = (windowRect.bottom - windowRect.top) - (clientRect.bottom - clientRect.top);
|
|
|
|
SetWindowPos(mainWindow->_hWnd, nullptr, windowRect.left, windowRect.top, windowRect.right - windowRect.left, (windowRect.bottom - windowRect.top - xGap) * 224 / 256 + yGap, 0);
|
|
}
|
|
break;
|
|
|
|
case WM_WINDOWPOSCHANGING:
|
|
WINDOWPOS* windowPos;
|
|
windowPos = (WINDOWPOS*)lParam;
|
|
|
|
if(!(windowPos->flags & SWP_NOSIZE)) {
|
|
RECT clientRect;
|
|
RECT windowRect;
|
|
LONG xGap;
|
|
LONG yGap;
|
|
GetWindowRect(hWnd, &windowRect);
|
|
GetClientRect(hWnd, &clientRect);
|
|
|
|
xGap = (windowRect.right - windowRect.left) - (clientRect.right - clientRect.left);
|
|
yGap = (windowRect.bottom - windowRect.top) - (clientRect.bottom - clientRect.top);
|
|
|
|
windowPos->cy = (windowPos->cx - xGap) * 224 / 256 + yGap;
|
|
}
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
mainWindow->Stop(true);
|
|
PostQuitMessage(0);
|
|
break;
|
|
|
|
default:
|
|
return DefWindowProc(hWnd, message, wParam, lParam);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
} |