2020-11-05 16:44:34 +01:00
|
|
|
#include "pch.h"
|
|
|
|
#include "winmain.h"
|
2020-11-06 14:56:32 +01:00
|
|
|
|
|
|
|
#include "fullscrn.h"
|
2020-11-05 16:44:34 +01:00
|
|
|
#include "memory.h"
|
2020-12-02 18:12:34 +01:00
|
|
|
#include "midi.h"
|
2020-11-05 16:44:34 +01:00
|
|
|
#include "pinball.h"
|
|
|
|
#include "options.h"
|
2020-11-06 14:56:32 +01:00
|
|
|
#include "pb.h"
|
2020-11-29 16:50:49 +01:00
|
|
|
#include "Sound.h"
|
2020-12-04 16:35:47 +01:00
|
|
|
#include "resource.h"
|
2021-01-29 12:24:49 +01:00
|
|
|
#include "splash.h"
|
2020-11-05 16:44:34 +01:00
|
|
|
|
2021-08-27 12:29:41 +02:00
|
|
|
const double TargetFps = 60, TargetFrameTime = 1000 / TargetFps;
|
|
|
|
|
2020-12-03 15:47:36 +01:00
|
|
|
HINSTANCE winmain::hinst = nullptr;
|
|
|
|
HWND winmain::hwnd_frame = nullptr;
|
|
|
|
HCURSOR winmain::mouse_hsave;
|
2021-08-27 12:29:41 +02:00
|
|
|
SDL_Window* winmain::MainWindow = nullptr;
|
2020-12-03 15:47:36 +01:00
|
|
|
|
|
|
|
int winmain::return_value = 0;
|
|
|
|
int winmain::bQuit = 0;
|
|
|
|
int winmain::activated;
|
2021-01-16 15:45:29 +01:00
|
|
|
int winmain::DispFrameRate = 0;
|
2020-12-03 15:47:36 +01:00
|
|
|
int winmain::DispGRhistory = 0;
|
|
|
|
int winmain::single_step = 0;
|
|
|
|
int winmain::has_focus = 1;
|
|
|
|
int winmain::last_mouse_x;
|
|
|
|
int winmain::last_mouse_y;
|
|
|
|
int winmain::mouse_down;
|
|
|
|
int winmain::no_time_loss;
|
|
|
|
|
|
|
|
DWORD winmain::then;
|
|
|
|
DWORD winmain::now;
|
2020-12-02 18:12:34 +01:00
|
|
|
UINT winmain::iFrostUniqueMsg;
|
2021-02-06 14:53:47 +01:00
|
|
|
bool winmain::restart = false;
|
2020-12-03 15:47:36 +01:00
|
|
|
|
2020-11-29 16:50:49 +01:00
|
|
|
gdrv_bitmap8 winmain::gfr_display{};
|
2020-12-02 18:12:34 +01:00
|
|
|
char winmain::DatFileName[300]{};
|
2020-12-03 15:47:36 +01:00
|
|
|
|
2020-11-05 16:44:34 +01:00
|
|
|
|
2021-08-27 12:29:41 +02:00
|
|
|
uint32_t timeGetTimeAlt()
|
|
|
|
{
|
|
|
|
auto now = std::chrono::high_resolution_clock::now();
|
|
|
|
auto duration = now.time_since_epoch();
|
|
|
|
auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
|
|
|
|
return static_cast<uint32_t>(millis);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-11-07 16:41:14 +01:00
|
|
|
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
|
2020-11-05 16:44:34 +01:00
|
|
|
{
|
2020-11-07 16:41:14 +01:00
|
|
|
return winmain::WinMain(hInstance, hPrevInstance, lpCmdLine, nShowCmd);
|
2020-11-05 16:44:34 +01:00
|
|
|
}
|
|
|
|
|
2020-11-07 16:41:14 +01:00
|
|
|
int winmain::WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
|
2020-11-05 16:44:34 +01:00
|
|
|
{
|
2020-11-07 16:41:14 +01:00
|
|
|
memory::init(memalloc_failure);
|
2020-11-05 16:44:34 +01:00
|
|
|
++memory::critical_allocation;
|
|
|
|
auto optionsRegPath = pinball::get_rc_string(165, 0);
|
2021-08-27 12:29:41 +02:00
|
|
|
options::path_init(optionsRegPath);
|
|
|
|
--memory::critical_allocation;
|
2020-11-05 16:44:34 +01:00
|
|
|
|
2021-08-27 12:29:41 +02:00
|
|
|
// SDL init
|
|
|
|
SDL_SetMainReady();
|
|
|
|
if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
|
2020-11-05 16:44:34 +01:00
|
|
|
{
|
2021-08-27 12:29:41 +02:00
|
|
|
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Could not initialize SDL2", SDL_GetError(), nullptr);
|
|
|
|
return 1;
|
|
|
|
}
|
2020-11-05 16:44:34 +01:00
|
|
|
|
2020-11-06 14:56:32 +01:00
|
|
|
pinball::quickFlag = strstr(lpCmdLine, "-quick") != nullptr;
|
2020-12-03 15:47:36 +01:00
|
|
|
hinst = hInstance;
|
2021-08-27 12:29:41 +02:00
|
|
|
auto regSpaceCadet = pinball::get_rc_string(166, 0);
|
2020-12-02 18:12:34 +01:00
|
|
|
options::get_string(regSpaceCadet, "Pinball Data", DatFileName, pinball::get_rc_string(168, 0), 300);
|
2020-11-05 16:44:34 +01:00
|
|
|
|
2021-02-06 14:53:47 +01:00
|
|
|
/*Check for full tilt .dat file and switch to it automatically*/
|
|
|
|
char cadetFilePath[300]{};
|
|
|
|
pinball::make_path_name(cadetFilePath, "CADET.DAT", 300);
|
|
|
|
FILE* cadetDat;
|
|
|
|
fopen_s(&cadetDat, cadetFilePath, "r");
|
|
|
|
if (cadetDat)
|
|
|
|
{
|
|
|
|
fclose(cadetDat);
|
|
|
|
strcpy_s(DatFileName, "CADET.DAT");
|
|
|
|
pb::FullTiltMode = true;
|
|
|
|
}
|
|
|
|
|
2020-11-05 16:44:34 +01:00
|
|
|
iFrostUniqueMsg = RegisterWindowMessageA("PinballThemeSwitcherUniqueMsgString");
|
2020-12-04 16:35:47 +01:00
|
|
|
auto windowClass = pinball::get_rc_string(167, 0);
|
|
|
|
auto windowHandle = FindWindowA(windowClass, nullptr);
|
2020-11-05 16:44:34 +01:00
|
|
|
if (windowHandle)
|
|
|
|
{
|
|
|
|
SendMessageA(windowHandle, iFrostUniqueMsg, 0, 0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (check_expiration_date())
|
|
|
|
return 0;
|
|
|
|
|
2021-01-29 12:24:49 +01:00
|
|
|
auto splash = splash::splash_screen(hInstance, "splash_bitmap", "splash_bitmap");
|
2020-11-06 14:56:32 +01:00
|
|
|
pinball::FindShiftKeys();
|
2021-02-06 14:53:47 +01:00
|
|
|
options::init_resolution();
|
2020-11-06 14:56:32 +01:00
|
|
|
|
2021-08-27 12:29:41 +02:00
|
|
|
// SDL window
|
|
|
|
SDL_Window* window = SDL_CreateWindow
|
|
|
|
(
|
|
|
|
pinball::get_rc_string(38, 0),
|
|
|
|
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
|
|
|
|
800, 600,
|
|
|
|
SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE
|
|
|
|
);
|
|
|
|
MainWindow = window;
|
|
|
|
if (!window)
|
2020-11-06 14:56:32 +01:00
|
|
|
{
|
2021-08-27 12:29:41 +02:00
|
|
|
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Could not create window", SDL_GetError(), nullptr);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
SDL_Renderer* renderer = SDL_CreateRenderer
|
|
|
|
(
|
|
|
|
window,
|
|
|
|
-1,
|
|
|
|
SDL_RENDERER_ACCELERATED
|
|
|
|
);
|
|
|
|
if (!renderer)
|
|
|
|
{
|
|
|
|
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Could not create renderer", SDL_GetError(), window);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// PB init from message handler
|
|
|
|
{
|
|
|
|
RECT rect{};
|
|
|
|
++memory::critical_allocation;
|
|
|
|
|
|
|
|
auto prevCursor = SetCursor(LoadCursorA(nullptr, IDC_WAIT));
|
|
|
|
|
|
|
|
auto voiceCount = options::get_int(nullptr, "Voices", 8);
|
|
|
|
if (!Sound::Init(voiceCount))
|
|
|
|
options::menu_set(Menu1_Sounds, 0);
|
|
|
|
Sound::Activate();
|
|
|
|
|
|
|
|
if (!pinball::quickFlag && !midi::music_init((HWND)window))
|
|
|
|
options::menu_set(Menu1_Music, 0);
|
|
|
|
|
|
|
|
if (pb::init(renderer))
|
|
|
|
_exit(0);
|
|
|
|
SetCursor(prevCursor);
|
|
|
|
auto changeDisplayFg = options::get_int(nullptr, "Change Display", 1);
|
|
|
|
auto menuHandle = GetMenu((HWND)window);
|
|
|
|
|
|
|
|
GetWindowRect(GetDesktopWindow(), &rect);
|
|
|
|
int width = rect.right - rect.left;
|
|
|
|
int height = rect.bottom - rect.top;
|
|
|
|
pb::window_size(&width, &height);
|
|
|
|
fullscrn::init(width, height, options::Options.FullScreen, (HWND)window, menuHandle,
|
|
|
|
changeDisplayFg);
|
|
|
|
|
|
|
|
--memory::critical_allocation;
|
2020-11-06 14:56:32 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
auto menuHandle = GetMenu(windowHandle);
|
|
|
|
options::init(menuHandle);
|
|
|
|
pb::reset_table();
|
|
|
|
pb::firsttime_setup();
|
|
|
|
|
|
|
|
if (strstr(lpCmdLine, "-fullscreen"))
|
|
|
|
{
|
|
|
|
options::Options.FullScreen = 1;
|
2020-12-06 14:21:56 +01:00
|
|
|
options::menu_check(Menu1_Full_Screen, 1);
|
2020-11-06 14:56:32 +01:00
|
|
|
}
|
|
|
|
|
2021-08-27 12:29:41 +02:00
|
|
|
SDL_ShowWindow(window);
|
2020-11-06 14:56:32 +01:00
|
|
|
fullscrn::set_screen_mode(options::Options.FullScreen);
|
|
|
|
|
2021-01-29 12:24:49 +01:00
|
|
|
if (splash)
|
2020-11-06 14:56:32 +01:00
|
|
|
{
|
2021-01-29 12:24:49 +01:00
|
|
|
splash::splash_hide(splash);
|
|
|
|
splash::splash_destroy(splash);
|
|
|
|
}
|
2020-11-06 14:56:32 +01:00
|
|
|
|
|
|
|
pinball::adjust_priority(options::Options.PriorityAdj);
|
2021-08-27 12:29:41 +02:00
|
|
|
const auto startTime = timeGetTimeAlt();
|
2020-11-06 14:56:32 +01:00
|
|
|
MSG wndMessage{};
|
2021-08-27 12:29:41 +02:00
|
|
|
while (timeGetTimeAlt() >= startTime && timeGetTimeAlt() - startTime < 0) // Don't wait for now, was 2000
|
2020-12-03 15:47:36 +01:00
|
|
|
PeekMessageA(&wndMessage, hwnd_frame, 0, 0, 1u);
|
2020-11-07 16:41:14 +01:00
|
|
|
|
2020-11-29 16:50:49 +01:00
|
|
|
if (strstr(lpCmdLine, "-demo"))
|
|
|
|
pb::toggle_demo();
|
|
|
|
else
|
|
|
|
pb::replay_level(0);
|
|
|
|
|
2021-08-27 12:29:41 +02:00
|
|
|
DWORD updateCounter = 300u, frameCounter = 0, prevTime = 0u;
|
|
|
|
then = timeGetTimeAlt();
|
|
|
|
|
|
|
|
double sdlTimerResMs = 1000.0 / static_cast<double>(SDL_GetPerformanceFrequency());
|
|
|
|
auto frameStart = static_cast<double>(SDL_GetPerformanceCounter());
|
2020-11-06 14:56:32 +01:00
|
|
|
while (true)
|
2021-08-27 12:29:41 +02:00
|
|
|
{
|
|
|
|
if (!updateCounter)
|
2020-11-13 17:04:58 +01:00
|
|
|
{
|
2021-08-27 12:29:41 +02:00
|
|
|
updateCounter = 300;
|
2020-11-29 16:50:49 +01:00
|
|
|
if (DispFrameRate)
|
2020-11-13 17:04:58 +01:00
|
|
|
{
|
2021-08-27 12:29:41 +02:00
|
|
|
auto curTime = timeGetTimeAlt();
|
2020-11-29 16:50:49 +01:00
|
|
|
if (prevTime)
|
2020-11-13 17:04:58 +01:00
|
|
|
{
|
2020-11-29 16:50:49 +01:00
|
|
|
char buf[60];
|
2021-08-27 12:29:41 +02:00
|
|
|
auto elapsedSec = static_cast<float>(curTime - prevTime) * 0.001f;
|
|
|
|
sprintf_s(buf, "Updates/sec = %02.02f Frames/sec = %02.02f ",
|
|
|
|
300.0f / elapsedSec, frameCounter / elapsedSec);
|
|
|
|
SDL_SetWindowTitle(window, buf);
|
|
|
|
frameCounter = 0;
|
2020-11-29 16:50:49 +01:00
|
|
|
|
|
|
|
if (DispGRhistory)
|
|
|
|
{
|
|
|
|
if (!gfr_display.BmpBufPtr1)
|
|
|
|
{
|
|
|
|
auto plt = static_cast<PALETTEENTRY*>(malloc(1024u));
|
|
|
|
auto pltPtr = &plt[10];
|
|
|
|
for (int i1 = 0, i2 = 0; i1 < 256 - 10; ++i1, i2 += 8)
|
|
|
|
{
|
|
|
|
unsigned char blue = i2, redGreen = i2;
|
|
|
|
if (i2 > 255)
|
|
|
|
{
|
|
|
|
blue = 255;
|
|
|
|
redGreen = i1;
|
|
|
|
}
|
2020-11-13 17:04:58 +01:00
|
|
|
|
2020-11-29 16:50:49 +01:00
|
|
|
*pltPtr++ = {redGreen, redGreen, blue};
|
|
|
|
}
|
|
|
|
gdrv::display_palette(plt);
|
|
|
|
free(plt);
|
|
|
|
gdrv::create_bitmap(&gfr_display, 400, 15);
|
|
|
|
}
|
|
|
|
|
|
|
|
gdrv::blit(&gfr_display, 0, 0, 0, 0, 300, 10);
|
|
|
|
gdrv::fill_bitmap(&gfr_display, 300, 10, 0, 0, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
prevTime = curTime;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
prevTime = 0;
|
2020-11-13 17:04:58 +01:00
|
|
|
}
|
|
|
|
}
|
2021-08-27 12:29:41 +02:00
|
|
|
|
2020-11-06 14:56:32 +01:00
|
|
|
if (!ProcessWindowMessages() || bQuit)
|
|
|
|
break;
|
2020-11-29 16:50:49 +01:00
|
|
|
|
|
|
|
if (has_focus)
|
|
|
|
{
|
|
|
|
if (mouse_down)
|
|
|
|
{
|
2021-08-27 12:29:41 +02:00
|
|
|
now = timeGetTimeAlt();
|
2020-11-29 16:50:49 +01:00
|
|
|
if (now - then >= 2)
|
|
|
|
{
|
2021-08-27 12:29:41 +02:00
|
|
|
int x, y;
|
|
|
|
SDL_GetMouseState(&x, &y);
|
|
|
|
pb::ballset(last_mouse_x - x, y - last_mouse_y);
|
|
|
|
SDL_WarpMouseInWindow(window, last_mouse_x, last_mouse_y);
|
2020-11-29 16:50:49 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!single_step)
|
|
|
|
{
|
2021-08-27 12:29:41 +02:00
|
|
|
auto curTime = timeGetTimeAlt();
|
2020-11-29 16:50:49 +01:00
|
|
|
now = curTime;
|
|
|
|
if (no_time_loss)
|
|
|
|
{
|
|
|
|
then = curTime;
|
|
|
|
no_time_loss = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (curTime == then)
|
|
|
|
{
|
|
|
|
Sleep(8u);
|
|
|
|
}
|
|
|
|
else if (pb::frame(curTime - then))
|
|
|
|
{
|
|
|
|
if (gfr_display.BmpBufPtr1)
|
|
|
|
{
|
|
|
|
auto deltaT = now - then + 10;
|
|
|
|
auto fillChar = static_cast<char>(deltaT);
|
|
|
|
if (deltaT > 236)
|
|
|
|
{
|
|
|
|
fillChar = -7;
|
|
|
|
}
|
2021-08-27 12:29:41 +02:00
|
|
|
gdrv::fill_bitmap(&gfr_display, 1, 10, 299 - updateCounter, 0, fillChar);
|
2020-11-29 16:50:49 +01:00
|
|
|
}
|
2021-08-27 12:29:41 +02:00
|
|
|
--updateCounter;
|
2020-11-29 16:50:49 +01:00
|
|
|
then = now;
|
2021-08-27 12:29:41 +02:00
|
|
|
|
|
|
|
auto frameEnd = static_cast<double>(SDL_GetPerformanceCounter());
|
|
|
|
auto elapsedMs = (frameEnd - frameStart) * sdlTimerResMs;
|
|
|
|
if (elapsedMs >= TargetFrameTime)
|
|
|
|
{
|
|
|
|
// Keep track of remainder, limited to one frame time.
|
|
|
|
frameStart = frameEnd - min(elapsedMs - TargetFrameTime, TargetFrameTime) / sdlTimerResMs;
|
|
|
|
SDL_RenderPresent(renderer);
|
|
|
|
frameCounter++;
|
|
|
|
}
|
2020-11-29 16:50:49 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-11-06 14:56:32 +01:00
|
|
|
}
|
|
|
|
|
2020-12-04 16:35:47 +01:00
|
|
|
gdrv::destroy_bitmap(&gfr_display);
|
|
|
|
options::uninit();
|
|
|
|
midi::music_shutdown();
|
|
|
|
pb::uninit();
|
|
|
|
Sound::Close();
|
|
|
|
gdrv::uninit();
|
|
|
|
DestroyWindow(hwnd_frame);
|
|
|
|
options::path_uninit();
|
|
|
|
UnregisterClassA(windowClass, hinst);
|
2021-02-06 14:53:47 +01:00
|
|
|
|
|
|
|
if (restart)
|
|
|
|
{
|
|
|
|
char restartPath[300]{};
|
|
|
|
if (GetModuleFileNameA(nullptr, restartPath, 300))
|
|
|
|
{
|
|
|
|
STARTUPINFO si{};
|
|
|
|
PROCESS_INFORMATION pi{};
|
|
|
|
si.cb = sizeof si;
|
|
|
|
if (CreateProcess(restartPath, nullptr, nullptr, nullptr,
|
|
|
|
FALSE, 0, nullptr, nullptr, &si, &pi))
|
|
|
|
{
|
|
|
|
CloseHandle(pi.hProcess);
|
|
|
|
CloseHandle(pi.hThread);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-06 14:56:32 +01:00
|
|
|
return return_value;
|
|
|
|
}
|
|
|
|
|
2020-11-07 16:41:14 +01:00
|
|
|
LRESULT CALLBACK winmain::message_handler(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
|
2020-11-06 14:56:32 +01:00
|
|
|
{
|
2021-02-16 17:03:45 +01:00
|
|
|
int wParamI = static_cast<int>(wParam);
|
|
|
|
|
2020-12-02 18:12:34 +01:00
|
|
|
if (Msg == iFrostUniqueMsg)
|
|
|
|
{
|
|
|
|
if (IsIconic(hWnd))
|
|
|
|
ShowWindow(hWnd, 9);
|
|
|
|
SetForegroundWindow(hWnd);
|
|
|
|
return 0;
|
|
|
|
}
|
2021-01-29 14:42:05 +01:00
|
|
|
|
2020-12-02 18:12:34 +01:00
|
|
|
if (Msg <= WM_ACTIVATEAPP)
|
|
|
|
{
|
|
|
|
switch (Msg)
|
|
|
|
{
|
|
|
|
case WM_ACTIVATEAPP:
|
|
|
|
if (wParam)
|
|
|
|
{
|
|
|
|
activated = 1;
|
|
|
|
Sound::Activate();
|
|
|
|
if (options::Options.Music && !single_step)
|
|
|
|
midi::play_pb_theme(0);
|
|
|
|
no_time_loss = 1;
|
|
|
|
pinball::adjust_priority(options::Options.PriorityAdj);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
activated = 0;
|
|
|
|
fullscrn::activate(0);
|
2020-12-06 14:21:56 +01:00
|
|
|
options::menu_check(Menu1_Full_Screen, 0);
|
2020-12-02 18:12:34 +01:00
|
|
|
options::Options.FullScreen = 0;
|
|
|
|
SetThreadPriority(GetCurrentThread(), 0);
|
|
|
|
Sound::Deactivate();
|
|
|
|
midi::music_stop();
|
|
|
|
}
|
|
|
|
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
case WM_KILLFOCUS:
|
|
|
|
has_focus = 0;
|
|
|
|
gdrv::get_focus();
|
|
|
|
pb::loose_focus();
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
case WM_CREATE:
|
|
|
|
{
|
|
|
|
RECT rect{};
|
|
|
|
++memory::critical_allocation;
|
|
|
|
|
2020-12-11 17:03:13 +01:00
|
|
|
auto prevCursor = SetCursor(LoadCursorA(nullptr, IDC_WAIT));
|
2021-08-27 12:29:41 +02:00
|
|
|
gdrv::init(nullptr,0,0);
|
2020-12-02 18:12:34 +01:00
|
|
|
|
|
|
|
auto voiceCount = options::get_int(nullptr, "Voices", 8);
|
2021-08-27 12:29:41 +02:00
|
|
|
if (!Sound::Init(voiceCount))
|
2020-12-06 14:21:56 +01:00
|
|
|
options::menu_set(Menu1_Sounds, 0);
|
2020-12-02 18:12:34 +01:00
|
|
|
Sound::Activate();
|
|
|
|
|
|
|
|
if (!pinball::quickFlag && !midi::music_init(hWnd))
|
2020-12-06 14:21:56 +01:00
|
|
|
options::menu_set(Menu1_Music, 0);
|
2020-12-02 18:12:34 +01:00
|
|
|
|
2021-08-27 12:29:41 +02:00
|
|
|
if (pb::init(nullptr))
|
2020-12-02 18:12:34 +01:00
|
|
|
_exit(0);
|
|
|
|
SetCursor(prevCursor);
|
|
|
|
auto changeDisplayFg = options::get_int(nullptr, "Change Display", 1);
|
|
|
|
auto menuHandle = GetMenu(hWnd);
|
2021-02-06 14:53:47 +01:00
|
|
|
|
|
|
|
GetWindowRect(GetDesktopWindow(), &rect);
|
|
|
|
int width = rect.right - rect.left;
|
|
|
|
int height = rect.bottom - rect.top;
|
|
|
|
pb::window_size(&width, &height);
|
2020-12-27 16:19:36 +01:00
|
|
|
fullscrn::init(width, height, options::Options.FullScreen, hWnd, menuHandle,
|
2020-12-02 18:12:34 +01:00
|
|
|
changeDisplayFg);
|
|
|
|
|
|
|
|
--memory::critical_allocation;
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
}
|
|
|
|
case WM_MOVE:
|
|
|
|
no_time_loss = 1;
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
case WM_SETFOCUS:
|
|
|
|
has_focus = 1;
|
|
|
|
no_time_loss = 1;
|
|
|
|
gdrv::get_focus();
|
|
|
|
fullscrn::force_redraw();
|
|
|
|
pb::paint();
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
case WM_PAINT:
|
|
|
|
{
|
|
|
|
PAINTSTRUCT paint{};
|
|
|
|
_BeginPaint(hWnd, &paint);
|
|
|
|
fullscrn::paint();
|
|
|
|
EndPaint(hWnd, &paint);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case WM_CLOSE:
|
|
|
|
case WM_QUIT:
|
|
|
|
case WM_DESTROY:
|
|
|
|
end_pause();
|
|
|
|
bQuit = 1;
|
|
|
|
PostQuitMessage(0);
|
|
|
|
fullscrn::shutdown();
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
case WM_ERASEBKGND:
|
|
|
|
break;
|
2021-02-09 16:09:44 +01:00
|
|
|
case WM_SIZE:
|
|
|
|
fullscrn::window_size_changed();
|
|
|
|
fullscrn::force_redraw();
|
|
|
|
pb::paint();
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
2020-12-02 18:12:34 +01:00
|
|
|
default:
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-01-06 15:06:13 +01:00
|
|
|
switch (Msg)
|
2020-12-02 18:12:34 +01:00
|
|
|
{
|
2021-01-06 15:06:13 +01:00
|
|
|
case WM_MENUSELECT:
|
|
|
|
if (lParam)
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
if (fullscrn::screen_mode)
|
|
|
|
fullscrn::set_menu_mode(0);
|
|
|
|
return 0;
|
|
|
|
case WM_SYSKEYDOWN:
|
|
|
|
no_time_loss = 1;
|
|
|
|
if (fullscrn::screen_mode)
|
|
|
|
fullscrn::set_menu_mode(1);
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
case WM_GETMINMAXINFO:
|
|
|
|
fullscrn::getminmaxinfo((MINMAXINFO*)lParam);
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
case WM_DISPLAYCHANGE:
|
2021-02-06 14:53:47 +01:00
|
|
|
options::update_resolution_menu();
|
2021-01-06 15:06:13 +01:00
|
|
|
if (fullscrn::displaychange())
|
2020-12-02 18:12:34 +01:00
|
|
|
{
|
2021-01-06 15:06:13 +01:00
|
|
|
options::Options.FullScreen = 0;
|
|
|
|
options::menu_check(Menu1_Full_Screen, 0);
|
|
|
|
}
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
case WM_KEYUP:
|
2021-02-16 17:03:45 +01:00
|
|
|
pb::keyup(wParamI);
|
2021-01-06 15:06:13 +01:00
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
case WM_KEYDOWN:
|
|
|
|
if (!(lParam & 0x40000000))
|
2021-02-16 17:03:45 +01:00
|
|
|
pb::keydown(wParamI);
|
2021-01-06 15:06:13 +01:00
|
|
|
switch (wParam)
|
|
|
|
{
|
|
|
|
case VK_ESCAPE:
|
|
|
|
if (options::Options.FullScreen)
|
|
|
|
options::toggle(0x193u);
|
|
|
|
SendMessageA(hwnd_frame, 0x112u, 0xF020u, 0);
|
|
|
|
break;
|
|
|
|
case VK_F1:
|
|
|
|
help_introduction(hinst, hWnd);
|
|
|
|
break;
|
|
|
|
case VK_F2:
|
|
|
|
new_game();
|
|
|
|
break;
|
|
|
|
case VK_F3:
|
|
|
|
pause();
|
|
|
|
break;
|
|
|
|
case VK_F4:
|
|
|
|
options::toggle(0x193u);
|
|
|
|
break;
|
|
|
|
case VK_F8:
|
|
|
|
if (!single_step)
|
|
|
|
pause();
|
|
|
|
options::keyboard();
|
|
|
|
break;
|
2021-02-16 17:03:45 +01:00
|
|
|
default:
|
|
|
|
break;
|
2021-01-06 15:06:13 +01:00
|
|
|
}
|
|
|
|
if (!pb::cheat_mode)
|
2020-12-02 18:12:34 +01:00
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
2021-01-06 15:06:13 +01:00
|
|
|
switch (wParam)
|
|
|
|
{
|
|
|
|
case 'H':
|
|
|
|
DispGRhistory = 1;
|
2020-12-02 18:12:34 +01:00
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
2021-01-06 15:06:13 +01:00
|
|
|
case 'Y':
|
|
|
|
SetWindowTextA(hWnd, "Pinball");
|
|
|
|
DispFrameRate = DispFrameRate == 0;
|
2020-12-02 18:12:34 +01:00
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
2021-01-06 15:06:13 +01:00
|
|
|
case VK_F1:
|
|
|
|
pb::frame(10);
|
2020-12-02 18:12:34 +01:00
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
2021-01-06 15:06:13 +01:00
|
|
|
case VK_F15:
|
|
|
|
single_step = single_step == 0;
|
|
|
|
if (single_step == 0)
|
|
|
|
no_time_loss = 1;
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
default:
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
}
|
|
|
|
case WM_SYSCOMMAND:
|
|
|
|
switch (wParam & 0xFFF0)
|
|
|
|
{
|
|
|
|
case SC_MOVE:
|
|
|
|
if (fullscrn::screen_mode)
|
|
|
|
return 0;
|
|
|
|
break;
|
|
|
|
case SC_MINIMIZE:
|
|
|
|
if (!single_step)
|
2020-12-02 18:12:34 +01:00
|
|
|
pause();
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
2021-01-06 15:06:13 +01:00
|
|
|
case SC_SCREENSAVE:
|
|
|
|
fullscrn::activate(0);
|
2020-12-02 18:12:34 +01:00
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
2021-01-06 15:06:13 +01:00
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
end_pause();
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
case WM_INITMENU:
|
|
|
|
no_time_loss = 1;
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
case WM_COMMAND:
|
|
|
|
no_time_loss = 1;
|
|
|
|
switch (wParam)
|
|
|
|
{
|
|
|
|
case Menu1_Launch_Ball:
|
|
|
|
end_pause();
|
|
|
|
pb::launch_ball();
|
|
|
|
break;
|
|
|
|
case Menu1_Pause_Resume_Game:
|
|
|
|
pause();
|
|
|
|
break;
|
|
|
|
case Menu1_Demo:
|
|
|
|
end_pause();
|
|
|
|
pb::toggle_demo();
|
|
|
|
break;
|
|
|
|
case Menu1_Select_Table:
|
2020-12-02 18:12:34 +01:00
|
|
|
{
|
2021-01-06 15:06:13 +01:00
|
|
|
if (!single_step)
|
|
|
|
pause();
|
|
|
|
auto tmpBuf = memory::allocate(0x1F4u);
|
|
|
|
if (tmpBuf)
|
2020-12-02 18:12:34 +01:00
|
|
|
{
|
2021-01-06 15:06:13 +01:00
|
|
|
char cmdLine[0x1F4u];
|
2021-02-18 10:53:25 +01:00
|
|
|
options::get_string(nullptr, "Shell Exe", tmpBuf, "", 500);
|
2021-01-29 14:42:05 +01:00
|
|
|
auto iHwnd = reinterpret_cast<size_t>(hwnd_frame);
|
2021-01-06 15:06:13 +01:00
|
|
|
sprintf_s(
|
|
|
|
cmdLine,
|
2021-02-16 17:03:45 +01:00
|
|
|
"%s %s%zX %s%zX",
|
2021-01-06 15:06:13 +01:00
|
|
|
tmpBuf,
|
|
|
|
"select=",
|
2021-01-29 14:42:05 +01:00
|
|
|
iHwnd,
|
2021-01-06 15:06:13 +01:00
|
|
|
"confirm=",
|
2021-01-29 14:42:05 +01:00
|
|
|
iHwnd * iHwnd * iHwnd * iHwnd * iHwnd * iHwnd * iHwnd);
|
2021-01-06 15:06:13 +01:00
|
|
|
if (static_cast<int>(WinExec(cmdLine, 5u)) < 32)
|
2020-12-02 18:12:34 +01:00
|
|
|
{
|
2021-01-06 15:06:13 +01:00
|
|
|
auto caption = pinball::get_rc_string(170, 0);
|
|
|
|
auto text = pinball::get_rc_string(171, 0);
|
|
|
|
MessageBoxA(hwnd_frame, text, caption, 0x2010u);
|
2020-12-02 18:12:34 +01:00
|
|
|
}
|
2021-01-06 15:06:13 +01:00
|
|
|
memory::free(tmpBuf);
|
2020-12-02 18:12:34 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2021-01-06 15:06:13 +01:00
|
|
|
case Menu1_1Player:
|
|
|
|
case Menu1_2Players:
|
|
|
|
case Menu1_3Players:
|
|
|
|
case Menu1_4Players:
|
2021-02-16 17:03:45 +01:00
|
|
|
options::toggle(wParamI);
|
2021-01-06 15:06:13 +01:00
|
|
|
new_game();
|
2020-12-02 18:12:34 +01:00
|
|
|
break;
|
2021-02-06 14:53:47 +01:00
|
|
|
case Menu1_MaximumResolution:
|
|
|
|
case Menu1_640x480:
|
|
|
|
case Menu1_800x600:
|
|
|
|
case Menu1_1024x768:
|
2021-02-09 16:09:44 +01:00
|
|
|
case Menu1_WindowUniformScale:
|
2021-02-16 17:03:45 +01:00
|
|
|
options::toggle(wParamI);
|
2021-02-06 14:53:47 +01:00
|
|
|
break;
|
2021-01-06 15:06:13 +01:00
|
|
|
case Menu1_Help_Topics:
|
|
|
|
if (!single_step)
|
|
|
|
pause();
|
|
|
|
help_introduction(hinst, hWnd);
|
|
|
|
break;
|
|
|
|
case 106: // End game button?
|
|
|
|
pb::end_game();
|
|
|
|
break;
|
|
|
|
case Menu1_Full_Screen:
|
|
|
|
case Menu1_Sounds:
|
|
|
|
case Menu1_Music:
|
|
|
|
if (!single_step)
|
|
|
|
pause();
|
2021-02-16 17:03:45 +01:00
|
|
|
options::toggle(wParamI);
|
2021-01-06 15:06:13 +01:00
|
|
|
break;
|
|
|
|
case Menu1_Player_Controls:
|
|
|
|
case 204: // Second controls button?
|
|
|
|
if (!single_step)
|
|
|
|
pause();
|
|
|
|
options::keyboard();
|
|
|
|
break;
|
|
|
|
case Menu1_Exit:
|
|
|
|
PostMessageA(hWnd, WM_QUIT, 0, 0);
|
|
|
|
break;
|
|
|
|
case Menu1_New_Game:
|
|
|
|
new_game();
|
|
|
|
break;
|
|
|
|
case Menu1_About_Pinball:
|
|
|
|
if (!single_step)
|
|
|
|
pause();
|
|
|
|
a_dialog(hinst, hWnd);
|
2020-12-02 18:12:34 +01:00
|
|
|
break;
|
2021-01-06 15:06:13 +01:00
|
|
|
case Menu1_High_Scores:
|
|
|
|
if (!single_step)
|
|
|
|
pause();
|
|
|
|
pb::high_scores();
|
|
|
|
break;
|
|
|
|
case 1: // Unknown button
|
|
|
|
midi::restart_midi_seq(lParam);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
case WM_LBUTTONDOWN:
|
|
|
|
if (pb::game_mode)
|
|
|
|
{
|
|
|
|
if (pb::cheat_mode)
|
2020-12-02 18:12:34 +01:00
|
|
|
{
|
2021-01-06 15:06:13 +01:00
|
|
|
mouse_down = 1;
|
|
|
|
mouse_hsave = SetCursor(nullptr);
|
2021-02-16 17:03:45 +01:00
|
|
|
auto mouseXY = fullscrn::convert_mouse_pos(static_cast<unsigned>(lParam));
|
2021-01-06 15:06:13 +01:00
|
|
|
last_mouse_x = mouseXY & 0xffFFu;
|
|
|
|
last_mouse_y = mouseXY >> 16;
|
|
|
|
SetCapture(hWnd);
|
2020-12-02 18:12:34 +01:00
|
|
|
}
|
2021-02-09 16:09:44 +01:00
|
|
|
else
|
|
|
|
pb::keydown(options::Options.LeftFlipperKey);
|
|
|
|
|
2020-12-02 18:12:34 +01:00
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
2021-01-06 15:06:13 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_LBUTTONUP:
|
|
|
|
if (mouse_down)
|
|
|
|
{
|
|
|
|
mouse_down = 0;
|
|
|
|
SetCursor(mouse_hsave);
|
|
|
|
ReleaseCapture();
|
|
|
|
}
|
2021-02-09 16:09:44 +01:00
|
|
|
if (!pb::cheat_mode)
|
|
|
|
pb::keyup(options::Options.LeftFlipperKey);
|
2021-01-06 15:06:13 +01:00
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
case WM_RBUTTONDOWN:
|
2021-02-09 16:09:44 +01:00
|
|
|
if (!pb::cheat_mode)
|
|
|
|
pb::keydown(options::Options.RightFlipperKey);
|
|
|
|
if (pb::game_mode)
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
break;
|
|
|
|
case WM_RBUTTONUP:
|
|
|
|
if (!pb::cheat_mode)
|
|
|
|
pb::keyup(options::Options.RightFlipperKey);
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
2021-01-06 15:06:13 +01:00
|
|
|
case WM_MBUTTONDOWN:
|
2021-02-09 16:09:44 +01:00
|
|
|
pb::keydown(options::Options.PlungerKey);
|
2021-01-06 15:06:13 +01:00
|
|
|
if (pb::game_mode)
|
2020-12-02 18:12:34 +01:00
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
2021-01-06 15:06:13 +01:00
|
|
|
break;
|
2021-02-09 16:09:44 +01:00
|
|
|
case WM_MBUTTONUP:
|
|
|
|
pb::keyup(options::Options.PlungerKey);
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
2021-01-06 15:06:13 +01:00
|
|
|
case WM_POWERBROADCAST:
|
|
|
|
if (wParam == 4 && options::Options.FullScreen)
|
|
|
|
{
|
|
|
|
options::Options.FullScreen = 0;
|
|
|
|
options::menu_check(Menu1_Full_Screen, 0);
|
|
|
|
fullscrn::set_screen_mode(options::Options.FullScreen);
|
2020-12-02 18:12:34 +01:00
|
|
|
}
|
2021-01-06 15:06:13 +01:00
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
case WM_PALETTECHANGED:
|
|
|
|
InvalidateRect(hWnd, nullptr, 0);
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
2021-02-15 16:55:54 +01:00
|
|
|
case MM_MCINOTIFY:
|
2021-01-06 15:06:13 +01:00
|
|
|
if (wParam == 1)
|
|
|
|
midi::restart_midi_seq(lParam);
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
default:
|
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
2020-12-02 18:12:34 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
pb::mode_countdown(-1);
|
2020-11-06 14:56:32 +01:00
|
|
|
return DefWindowProcA(hWnd, Msg, wParam, lParam);
|
|
|
|
}
|
|
|
|
|
2021-08-27 12:29:41 +02:00
|
|
|
int winmain::event_handler(const SDL_Event* event)
|
2020-11-06 14:56:32 +01:00
|
|
|
{
|
2021-08-27 12:29:41 +02:00
|
|
|
switch (event->type)
|
2020-11-06 14:56:32 +01:00
|
|
|
{
|
2021-08-27 12:29:41 +02:00
|
|
|
case SDL_QUIT:
|
|
|
|
end_pause();
|
|
|
|
bQuit = 1;
|
|
|
|
PostQuitMessage(0);
|
|
|
|
fullscrn::shutdown();
|
|
|
|
return_value = 0;
|
|
|
|
return 0;
|
|
|
|
case SDL_KEYUP:
|
|
|
|
pb::keyup(event->key.keysym.sym);
|
|
|
|
break;
|
|
|
|
case SDL_KEYDOWN:
|
|
|
|
if (!event->key.repeat)
|
|
|
|
pb::keydown(event->key.keysym.sym);
|
|
|
|
switch (event->key.keysym.sym)
|
|
|
|
{
|
|
|
|
case SDLK_ESCAPE:
|
|
|
|
if (options::Options.FullScreen)
|
|
|
|
options::toggle(Menu1_Full_Screen);
|
|
|
|
SDL_MinimizeWindow(MainWindow);
|
|
|
|
break;
|
|
|
|
case SDLK_F1:
|
|
|
|
help_introduction(hinst, (HWND)MainWindow);
|
|
|
|
break;
|
|
|
|
case SDLK_F2:
|
|
|
|
new_game();
|
|
|
|
break;
|
|
|
|
case SDLK_F3:
|
|
|
|
pause();
|
|
|
|
break;
|
|
|
|
case SDLK_F4:
|
|
|
|
options::toggle(Menu1_Full_Screen);
|
|
|
|
break;
|
|
|
|
case SDLK_F5:
|
|
|
|
options::toggle(Menu1_Sounds);
|
|
|
|
break;
|
|
|
|
case SDLK_F6:
|
|
|
|
options::toggle(Menu1_Music);
|
|
|
|
break;
|
|
|
|
case SDLK_F8:
|
|
|
|
if (!single_step)
|
|
|
|
pause();
|
|
|
|
options::keyboard();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!pb::cheat_mode)
|
|
|
|
break;
|
|
|
|
|
|
|
|
switch (event->key.keysym.sym)
|
|
|
|
{
|
|
|
|
case SDLK_h:
|
|
|
|
DispGRhistory = 1;
|
|
|
|
break;
|
|
|
|
case SDLK_y:
|
|
|
|
SDL_SetWindowTitle(MainWindow, "Pinball");
|
|
|
|
DispFrameRate = DispFrameRate == 0;
|
|
|
|
break;
|
|
|
|
case SDLK_F1:
|
|
|
|
pb::frame(10);
|
|
|
|
break;
|
|
|
|
case SDLK_F10:
|
|
|
|
single_step = single_step == 0;
|
|
|
|
if (single_step == 0)
|
|
|
|
no_time_loss = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SDL_MOUSEBUTTONDOWN:
|
|
|
|
switch (event->button.button)
|
2020-11-06 14:56:32 +01:00
|
|
|
{
|
2021-08-27 12:29:41 +02:00
|
|
|
case SDL_BUTTON_LEFT:
|
|
|
|
if (pb::cheat_mode)
|
2020-11-06 14:56:32 +01:00
|
|
|
{
|
2021-08-27 12:29:41 +02:00
|
|
|
mouse_down = 1;
|
|
|
|
last_mouse_x = event->button.x;
|
|
|
|
last_mouse_y = event->button.y;
|
|
|
|
SDL_ShowCursor(SDL_DISABLE);
|
|
|
|
SDL_SetWindowGrab(MainWindow, SDL_TRUE);
|
2020-11-06 14:56:32 +01:00
|
|
|
}
|
2021-08-27 12:29:41 +02:00
|
|
|
else
|
|
|
|
pb::keydown(options::Options.LeftFlipperKey);
|
|
|
|
break;
|
|
|
|
case SDL_BUTTON_RIGHT:
|
|
|
|
if (!pb::cheat_mode)
|
|
|
|
pb::keydown(options::Options.RightFlipperKey);
|
|
|
|
break;
|
|
|
|
case SDL_BUTTON_MIDDLE:
|
|
|
|
pb::keydown(options::Options.PlungerKey);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2020-11-06 14:56:32 +01:00
|
|
|
}
|
2021-08-27 12:29:41 +02:00
|
|
|
break;
|
|
|
|
case SDL_MOUSEBUTTONUP:
|
|
|
|
switch (event->button.button)
|
|
|
|
{
|
|
|
|
case SDL_BUTTON_LEFT:
|
|
|
|
if (mouse_down)
|
|
|
|
{
|
|
|
|
mouse_down = 0;
|
|
|
|
SDL_ShowCursor(SDL_ENABLE);
|
|
|
|
SDL_SetWindowGrab(MainWindow, SDL_FALSE);
|
|
|
|
}
|
|
|
|
if (!pb::cheat_mode)
|
|
|
|
pb::keyup(options::Options.LeftFlipperKey);
|
|
|
|
break;
|
|
|
|
case SDL_BUTTON_RIGHT:
|
|
|
|
if (!pb::cheat_mode)
|
|
|
|
pb::keyup(options::Options.RightFlipperKey);
|
|
|
|
break;
|
|
|
|
case SDL_BUTTON_MIDDLE:
|
|
|
|
pb::keyup(options::Options.PlungerKey);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SDL_WINDOWEVENT:
|
|
|
|
switch (event->window.event)
|
|
|
|
{
|
|
|
|
case SDL_WINDOWEVENT_FOCUS_GAINED:
|
|
|
|
case SDL_WINDOWEVENT_TAKE_FOCUS:
|
|
|
|
case SDL_WINDOWEVENT_EXPOSED:
|
|
|
|
case SDL_WINDOWEVENT_SHOWN:
|
|
|
|
activated = 1;
|
|
|
|
Sound::Activate();
|
|
|
|
if (options::Options.Music && !single_step)
|
|
|
|
midi::play_pb_theme(0);
|
|
|
|
no_time_loss = 1;
|
|
|
|
pinball::adjust_priority(options::Options.PriorityAdj);
|
|
|
|
has_focus = 1;
|
|
|
|
gdrv::get_focus();
|
|
|
|
fullscrn::force_redraw();
|
|
|
|
pb::paint();
|
|
|
|
break;
|
|
|
|
case SDL_WINDOWEVENT_FOCUS_LOST:
|
|
|
|
case SDL_WINDOWEVENT_HIDDEN:
|
|
|
|
activated = 0;
|
|
|
|
fullscrn::activate(0);
|
|
|
|
options::menu_check(Menu1_Full_Screen, 0);
|
|
|
|
options::Options.FullScreen = 0;
|
|
|
|
SetThreadPriority(GetCurrentThread(), 0);
|
|
|
|
Sound::Deactivate();
|
|
|
|
midi::music_stop();
|
|
|
|
has_focus = 0;
|
|
|
|
gdrv::get_focus();
|
|
|
|
pb::loose_focus();
|
|
|
|
break;
|
|
|
|
default: ;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default: ;
|
2020-11-06 14:56:32 +01:00
|
|
|
}
|
2021-08-27 12:29:41 +02:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int winmain::ProcessWindowMessages()
|
|
|
|
{
|
|
|
|
SDL_Event event;
|
|
|
|
if (has_focus && !single_step)
|
2020-11-06 14:56:32 +01:00
|
|
|
{
|
2021-08-27 12:29:41 +02:00
|
|
|
while (SDL_PollEvent(&event))
|
|
|
|
{
|
|
|
|
if (!event_handler(&event))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
2020-11-06 14:56:32 +01:00
|
|
|
}
|
2021-08-27 12:29:41 +02:00
|
|
|
|
|
|
|
SDL_WaitEvent(&event);
|
|
|
|
return event_handler(&event);
|
2020-11-05 16:44:34 +01:00
|
|
|
}
|
|
|
|
|
2020-11-07 16:41:14 +01:00
|
|
|
void winmain::memalloc_failure()
|
2020-11-05 16:44:34 +01:00
|
|
|
{
|
2020-12-02 18:12:34 +01:00
|
|
|
midi::music_stop();
|
|
|
|
Sound::Close();
|
2020-11-13 17:04:58 +01:00
|
|
|
gdrv::uninit();
|
2020-11-05 16:44:34 +01:00
|
|
|
char* caption = pinball::get_rc_string(170, 0);
|
|
|
|
char* text = pinball::get_rc_string(179, 0);
|
|
|
|
MessageBoxA(nullptr, text, caption, 0x2030u);
|
|
|
|
_exit(1);
|
|
|
|
}
|
2020-11-07 16:41:14 +01:00
|
|
|
|
|
|
|
int winmain::check_expiration_date()
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HDC winmain::_BeginPaint(HWND hWnd, LPPAINTSTRUCT lpPaint)
|
|
|
|
{
|
|
|
|
HDC context = BeginPaint(hWnd, lpPaint);
|
|
|
|
if (hWnd && GetLayout(context) & 1)
|
|
|
|
SetLayout(context, 0);
|
|
|
|
return context;
|
|
|
|
}
|
|
|
|
|
|
|
|
HDC winmain::_GetDC(HWND hWnd)
|
|
|
|
{
|
|
|
|
HDC context = GetDC(hWnd);
|
|
|
|
if (hWnd && GetLayout(context) & 1)
|
|
|
|
SetLayout(context, 0);
|
|
|
|
return context;
|
|
|
|
}
|
|
|
|
|
|
|
|
int winmain::a_dialog(HINSTANCE hInstance, HWND hWnd)
|
|
|
|
{
|
|
|
|
char appName[100];
|
|
|
|
char szOtherStuff[100];
|
|
|
|
|
|
|
|
lstrcpyA(appName, pinball::get_rc_string(38, 0));
|
|
|
|
lstrcpyA(szOtherStuff, pinball::get_rc_string(102, 0));
|
|
|
|
auto icon = LoadIconA(hInstance, "ICON_1");
|
|
|
|
return ShellAboutA(hWnd, appName, szOtherStuff, icon);
|
|
|
|
}
|
2020-12-02 18:12:34 +01:00
|
|
|
|
|
|
|
void winmain::end_pause()
|
|
|
|
{
|
|
|
|
if (single_step)
|
|
|
|
{
|
|
|
|
if (fullscrn::screen_mode)
|
|
|
|
fullscrn::set_menu_mode(0);
|
|
|
|
pb::pause_continue();
|
|
|
|
no_time_loss = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void winmain::new_game()
|
|
|
|
{
|
|
|
|
end_pause();
|
2020-12-11 17:03:13 +01:00
|
|
|
HCURSOR prevCursor = SetCursor(LoadCursorA(nullptr, IDC_WAIT));
|
2020-12-02 18:12:34 +01:00
|
|
|
pb::replay_level(0);
|
|
|
|
SetCursor(prevCursor);
|
|
|
|
}
|
|
|
|
|
|
|
|
void winmain::pause()
|
|
|
|
{
|
|
|
|
if (fullscrn::screen_mode)
|
|
|
|
{
|
|
|
|
if (single_step)
|
|
|
|
fullscrn::set_menu_mode(0);
|
|
|
|
else
|
|
|
|
fullscrn::set_menu_mode(1);
|
|
|
|
}
|
|
|
|
pb::pause_continue();
|
|
|
|
no_time_loss = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void winmain::help_introduction(HINSTANCE a1, HWND a2)
|
|
|
|
{
|
|
|
|
char* buf1 = memory::allocate(0x1F4u);
|
|
|
|
if (buf1)
|
|
|
|
{
|
|
|
|
char* buf2 = memory::allocate(0x1F4u);
|
|
|
|
if (buf2)
|
|
|
|
{
|
|
|
|
options::get_string(nullptr, "HelpFile", buf1, pinball::get_rc_string(178, 0), 500);
|
|
|
|
options::get_string(pinball::get_rc_string(166, 0), "HelpFile", buf1, buf1, 500);
|
|
|
|
lstrcpyA(buf2, buf1);
|
|
|
|
memory::free(buf1);
|
2021-08-27 12:29:41 +02:00
|
|
|
//HtmlHelpA(GetDesktopWindow(), buf2, 0, 0);
|
2020-12-02 18:12:34 +01:00
|
|
|
memory::free(buf2);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
memory::free(buf1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-02-06 14:53:47 +01:00
|
|
|
|
|
|
|
void winmain::Restart()
|
|
|
|
{
|
|
|
|
restart = true;
|
|
|
|
PostMessageA(hwnd_frame, WM_QUIT, 0, 0);
|
|
|
|
}
|