summaryrefslogtreecommitdiffstatshomepage
diff options
context:
space:
mode:
-rw-r--r--scripts/src/osd/uwp.lua6
-rw-r--r--src/osd/uwp/video.cpp200
-rw-r--r--src/osd/uwp/video.h19
-rw-r--r--src/osd/uwp/window.cpp1181
-rw-r--r--src/osd/uwp/window.h177
5 files changed, 1583 insertions, 0 deletions
diff --git a/scripts/src/osd/uwp.lua b/scripts/src/osd/uwp.lua
index fdaec08a3c7..2cf4eb8c573 100644
--- a/scripts/src/osd/uwp.lua
+++ b/scripts/src/osd/uwp.lua
@@ -64,8 +64,14 @@ project ("osd_" .. _OPTIONS["osd"])
}
files {
+ MAME_DIR .. "src/osd/uwp/video.cpp",
+ MAME_DIR .. "src/osd/uwp/video.h",
+ MAME_DIR .. "src/osd/uwp/window.cpp",
+ MAME_DIR .. "src/osd/uwp/window.h",
MAME_DIR .. "src/osd/modules/osdwindow.cpp",
MAME_DIR .. "src/osd/modules/osdwindow.h",
+ MAME_DIR .. "src/osd/windows/winmain.cpp",
+ MAME_DIR .. "src/osd/windows/winmain.h",
MAME_DIR .. "src/osd/modules/render/drawnone.cpp",
MAME_DIR .. "src/osd/modules/render/drawnone.h",
MAME_DIR .. "src/osd/uwp/uwpcompat.cpp",
diff --git a/src/osd/uwp/video.cpp b/src/osd/uwp/video.cpp
new file mode 100644
index 00000000000..989d074f3a5
--- /dev/null
+++ b/src/osd/uwp/video.cpp
@@ -0,0 +1,200 @@
+// license:BSD-3-Clause
+// copyright-holders:Brad Hughes, Aaron Giles
+//============================================================
+//
+// video.c - UWP video handling
+//
+//============================================================
+
+// standard windows headers
+#include <exception>
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <dxgi1_2.h>
+#include <wrl\client.h>
+#undef interface
+
+// MAME headers
+#include "emu.h"
+#include "emuopts.h"
+#include "render.h"
+#include "uiinput.h"
+
+// MAMEOS headers
+#include "winmain.h"
+#include "video.h"
+#include "window.h"
+#include "strconv.h"
+
+#include "modules/osdwindow.h"
+
+using namespace Platform;
+using namespace Microsoft::WRL;
+using namespace Windows::UI::Core;
+
+//============================================================
+// GLOBAL VARIABLES
+//============================================================
+
+osd_video_config video_config;
+
+
+//============================================================
+// PROTOTYPES
+//============================================================
+
+static void get_resolution(const char *defdata, const char *data, osd_window_config *config, int report_error);
+
+
+//============================================================
+// video_init
+//============================================================
+
+// FIXME: Temporary workaround
+static osd_window_config windows[MAX_VIDEO_WINDOWS]; // configuration data per-window
+
+bool windows_osd_interface::video_init()
+{
+ // extract data from the options
+ extract_video_config();
+
+ // initialize the window system so we can make windows
+ window_init();
+
+ // create the windows
+ windows_options &options = downcast<windows_options &>(machine().options());
+ for (int index = 0; index < video_config.numscreens; index++)
+ {
+ win_window_info::create(machine(), index, m_monitor_module->pick_monitor(options, index), &windows[index]);
+ }
+
+ if (video_config.mode != VIDEO_MODE_NONE)
+ osd_common_t::s_window_list.front()->platform_window<Platform::Agile<CoreWindow^>>()->Activate();
+
+ return true;
+}
+
+//============================================================
+// video_exit
+//============================================================
+
+void windows_osd_interface::video_exit()
+{
+ window_exit();
+}
+
+//============================================================
+// update
+//============================================================
+
+void windows_osd_interface::update(bool skip_redraw)
+{
+ osd_common_t::update(skip_redraw);
+
+ // if we're not skipping this redraw, update all windows
+ if (!skip_redraw)
+ {
+// profiler_mark(PROFILER_BLIT);
+ for (auto window : osd_common_t::s_window_list)
+ window->update();
+// profiler_mark(PROFILER_END);
+ }
+
+ // poll the joystick values here
+ winwindow_process_events(machine(), TRUE, FALSE);
+ poll_input(machine());
+ check_osd_inputs();
+ // if we're running, disable some parts of the debugger
+ if ((machine().debug_flags & DEBUG_FLAG_OSD_ENABLED) != 0)
+ debugger_update();
+}
+
+
+//============================================================
+// check_osd_inputs
+//============================================================
+
+void windows_osd_interface::check_osd_inputs()
+{
+}
+
+
+
+//============================================================
+// extract_video_config
+//============================================================
+
+void windows_osd_interface::extract_video_config()
+{
+ const char *stemp;
+
+ // global options: extract the data
+ video_config.windowed = options().window();
+ video_config.prescale = options().prescale();
+ video_config.filter = options().filter();
+ video_config.keepaspect = options().keep_aspect();
+ video_config.numscreens = options().numscreens();
+
+ // if we are in debug mode, never go full screen
+ if (machine().debug_flags & DEBUG_FLAG_OSD_ENABLED)
+ video_config.windowed = TRUE;
+
+ // per-window options: extract the data
+ const char *default_resolution = options().resolution();
+ get_resolution(default_resolution, options().resolution(0), &windows[0], TRUE);
+ get_resolution(default_resolution, options().resolution(1), &windows[1], TRUE);
+ get_resolution(default_resolution, options().resolution(2), &windows[2], TRUE);
+ get_resolution(default_resolution, options().resolution(3), &windows[3], TRUE);
+
+ // video options: extract the data
+ stemp = options().video();
+ if (strcmp(stemp, "auto") == 0)
+ video_config.mode = VIDEO_MODE_BGFX;
+ else if (strcmp(stemp, "bgfx") == 0)
+ video_config.mode = VIDEO_MODE_BGFX;
+ else if (strcmp(stemp, "none") == 0)
+ {
+ video_config.mode = VIDEO_MODE_NONE;
+ if (!emulator_info::standalone() && options().seconds_to_run() == 0)
+ osd_printf_warning("Warning: -video none doesn't make much sense without -seconds_to_run\n");
+ }
+ else
+ {
+ osd_printf_warning("Invalid video value %s; reverting to gdi\n", stemp);
+ video_config.mode = VIDEO_MODE_GDI;
+ }
+ video_config.waitvsync = options().wait_vsync();
+ video_config.syncrefresh = options().sync_refresh();
+ video_config.triplebuf = options().triple_buffer();
+ video_config.switchres = options().switch_res();
+
+ if (video_config.prescale < 1 || video_config.prescale > 3)
+ {
+ osd_printf_warning("Invalid prescale option, reverting to '1'\n");
+ video_config.prescale = 1;
+ }
+}
+
+
+//============================================================
+// get_resolution
+//============================================================
+
+static void get_resolution(const char *defdata, const char *data, osd_window_config *config, int report_error)
+{
+ config->width = config->height = config->depth = config->refresh = 0;
+ if (strcmp(data, OSDOPTVAL_AUTO) == 0)
+ {
+ if (strcmp(defdata, OSDOPTVAL_AUTO) == 0)
+ return;
+ data = defdata;
+ }
+
+ if (sscanf(data, "%dx%dx%d", &config->width, &config->height, &config->depth) < 2 && report_error)
+ osd_printf_error("Illegal resolution value = %s\n", data);
+
+ const char * at_pos = strchr(data, '@');
+ if (at_pos)
+ if (sscanf(at_pos + 1, "%d", &config->refresh) < 1 && report_error)
+ osd_printf_error("Illegal refresh rate in resolution value = %s\n", data);
+}
diff --git a/src/osd/uwp/video.h b/src/osd/uwp/video.h
new file mode 100644
index 00000000000..3f4b49efbe4
--- /dev/null
+++ b/src/osd/uwp/video.h
@@ -0,0 +1,19 @@
+// license:BSD-3-Clause
+// copyright-holders:Aaron Giles
+//============================================================
+//
+// video.h - Win32 implementation of MAME video routines
+//
+//============================================================
+
+#ifndef __WIN_VIDEO__
+#define __WIN_VIDEO__
+
+#include "modules/osdhelper.h"
+
+inline osd_rect RECT_to_osd_rect(const RECT &r)
+{
+ return osd_rect(r.left, r.top, r.right - r.left, r.bottom - r.top);
+}
+
+#endif
diff --git a/src/osd/uwp/window.cpp b/src/osd/uwp/window.cpp
new file mode 100644
index 00000000000..282d29972f8
--- /dev/null
+++ b/src/osd/uwp/window.cpp
@@ -0,0 +1,1181 @@
+// license:BSD-3-Clause
+// copyright-holders:Aaron Giles
+//============================================================
+//
+// window.c - Win32 window handling
+//
+//============================================================
+
+#define LOG_TEMP_PAUSE 0
+
+// Needed for RAW Input
+#define WM_INPUT 0x00FF
+
+// standard C headers
+#include <process.h>
+
+#include <atomic>
+#include <chrono>
+#include <list>
+#include <memory>
+
+// MAME headers
+#include "emu.h"
+#include "uiinput.h"
+#include "ui/uimain.h"
+
+// MAMEOS headers
+#include "winmain.h"
+#include "window.h"
+#include "video.h"
+#include "winutf8.h"
+
+#include "winutil.h"
+
+#include "modules/monitor/monitor_common.h"
+
+#include <agile.h>
+using namespace Windows::UI::Core;
+
+#include "modules/render/drawbgfx.h"
+#include "modules/render/drawnone.h"
+
+#define NOT_ALREADY_DOWN(x) (x & 0x40000000) == 0
+#define SCAN_CODE(x) ((x >> 16) & 0xff)
+#define IS_EXTENDED(x) (0x01000000 & x)
+#define MAKE_DI_SCAN(scan, isextended) (scan & 0x7f) | (isextended ? 0x80 : 0x00)
+#define WINOSD(machine) downcast<windows_osd_interface*>(&machine.osd())
+
+#undef min
+#undef max
+
+//============================================================
+// PARAMETERS
+//============================================================
+
+// window styles
+#define WINDOW_STYLE WS_OVERLAPPEDWINDOW
+#define WINDOW_STYLE_EX 0
+
+// debugger window styles
+#define DEBUG_WINDOW_STYLE WS_OVERLAPPED
+#define DEBUG_WINDOW_STYLE_EX 0
+
+// full screen window styles
+#define FULLSCREEN_STYLE WS_POPUP
+#define FULLSCREEN_STYLE_EX WS_EX_TOPMOST
+
+// minimum window dimension
+#define MIN_WINDOW_DIM 200
+
+// custom window messages
+#define WM_USER_REDRAW (WM_USER + 2)
+#define WM_USER_SET_FULLSCREEN (WM_USER + 3)
+#define WM_USER_SET_MAXSIZE (WM_USER + 4)
+#define WM_USER_SET_MINSIZE (WM_USER + 5)
+
+
+
+//============================================================
+// GLOBAL VARIABLES
+//============================================================
+
+static DWORD main_threadid;
+
+// actual physical resolution
+static int win_physical_width;
+static int win_physical_height;
+
+
+
+//============================================================
+// LOCAL VARIABLES
+//============================================================
+
+// event handling
+static std::chrono::system_clock::time_point last_event_check;
+
+// debugger
+static int in_background;
+
+static int ui_temp_pause;
+static int ui_temp_was_paused;
+
+static HANDLE window_thread;
+static DWORD window_threadid;
+
+static DWORD last_update_time;
+
+static HANDLE ui_pause_event;
+
+//============================================================
+// window_init
+// (main thread)
+//============================================================
+
+bool windows_osd_interface::window_init()
+{
+ // get the main thread ID before anything else
+ main_threadid = GetCurrentThreadId();
+
+ // create an event to signal UI pausing
+ ui_pause_event = CreateEvent(nullptr, TRUE, FALSE, nullptr);
+ if (!ui_pause_event)
+ fatalerror("Failed to create pause event\n");
+
+ window_thread = GetCurrentThread();
+ window_threadid = main_threadid;
+
+ const int fallbacks[VIDEO_MODE_COUNT] = {
+ -1, // NONE -> no fallback
+ VIDEO_MODE_NONE, // GDI -> NONE
+ -1 // No SOFT on Windows OSD
+ };
+
+ int current_mode = video_config.mode;
+ while (current_mode != VIDEO_MODE_NONE)
+ {
+ bool error = false;
+ switch(current_mode)
+ {
+ case VIDEO_MODE_NONE:
+ error = renderer_none::init(machine());
+ break;
+ case VIDEO_MODE_BGFX:
+ error = renderer_bgfx::init(machine());
+ break;
+ default:
+ fatalerror("Unknown video mode.");
+ break;
+ }
+ if (error)
+ {
+ current_mode = fallbacks[current_mode];
+ }
+ else
+ {
+ break;
+ }
+ }
+ video_config.mode = current_mode;
+
+ return true;
+}
+
+void windows_osd_interface::update_slider_list()
+{
+ for (auto window : osd_common_t::s_window_list)
+ {
+ // check if any window has dirty sliders
+ if (window->has_renderer() && window->renderer().sliders_dirty())
+ {
+ build_slider_list();
+ return;
+ }
+ }
+}
+
+int windows_osd_interface::window_count()
+{
+ return osd_common_t::s_window_list.size();
+}
+
+void windows_osd_interface::build_slider_list()
+{
+ m_sliders.clear();
+
+ for (auto window : osd_common_t::s_window_list)
+ {
+ if (window->has_renderer())
+ {
+ // take the sliders of the first window
+ std::vector<ui::menu_item> window_sliders = window->renderer().get_slider_list();
+ m_sliders.insert(m_sliders.end(), window_sliders.begin(), window_sliders.end());
+ }
+ }
+}
+
+void windows_osd_interface::add_audio_to_recording(const int16_t *buffer, int samples_this_frame)
+{
+ auto window = osd_common_t::s_window_list.front(); // We only record on the first window
+ if (window != nullptr)
+ {
+ window->renderer().add_audio_to_recording(buffer, samples_this_frame);
+ }
+}
+
+//============================================================
+// winwindow_exit
+// (main thread)
+//============================================================
+
+void windows_osd_interface::window_exit()
+{
+ assert(GetCurrentThreadId() == main_threadid);
+
+ // if we hid the cursor during the emulation, show it
+ if (!osd_common_t::s_window_list.empty())
+ osd_common_t::s_window_list.front()->show_pointer();
+
+ // free all the windows
+ while (!osd_common_t::s_window_list.empty())
+ {
+ auto window = osd_common_t::s_window_list.front();
+
+ // Destroy removes it from the list also
+ window->destroy();
+ }
+
+ switch(video_config.mode)
+ {
+ case VIDEO_MODE_NONE:
+ renderer_none::exit();
+ break;
+ case VIDEO_MODE_BGFX:
+ renderer_bgfx::exit();
+ break;
+ default:
+ break;
+ }
+
+ // kill the UI pause event
+ if (ui_pause_event)
+ CloseHandle(ui_pause_event);
+}
+
+win_window_info::win_window_info(
+ running_machine &machine,
+ int index,
+ std::shared_ptr<osd_monitor_info> monitor,
+ const osd_window_config *config) : osd_window(*config),
+ m_next(nullptr),
+ m_init_state(0),
+ m_startmaximized(0),
+ m_isminimized(0),
+ m_ismaximized(0),
+ m_monitor(monitor),
+ m_fullscreen(!video_config.windowed),
+ m_fullscreen_safe(0),
+ m_aspect(0),
+ m_target(nullptr),
+ m_targetview(0),
+ m_targetorient(0),
+ m_lastclicktime(std::chrono::system_clock::time_point::min()),
+ m_lastclickx(0),
+ m_lastclicky(0),
+ m_machine(machine)
+{
+ memset(m_title,0,sizeof(m_title));
+ m_non_fullscreen_bounds.left = 0;
+ m_non_fullscreen_bounds.top = 0;
+ m_non_fullscreen_bounds.right = 0;
+ m_non_fullscreen_bounds.bottom = 0;
+ m_prescale = video_config.prescale;
+}
+
+POINT win_window_info::s_saved_cursor_pos = { -1, -1 };
+
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+
+void win_window_info::capture_pointer()
+{
+ RECT bounds;
+ GetClientRect(platform_window<HWND>(), &bounds);
+ ClientToScreen(platform_window<HWND>(), &reinterpret_cast<POINT *>(&bounds)[0]);
+ ClientToScreen(platform_window<HWND>(), &reinterpret_cast<POINT *>(&bounds)[1]);
+ ClipCursor(&bounds);
+}
+
+void win_window_info::release_pointer()
+{
+ ClipCursor(nullptr);
+}
+
+void win_window_info::hide_pointer()
+{
+ GetCursorPos(&s_saved_cursor_pos);
+
+ while (ShowCursor(FALSE) >= -1) {};
+ ShowCursor(TRUE);
+}
+
+void win_window_info::show_pointer()
+{
+ if (s_saved_cursor_pos.x != -1 || s_saved_cursor_pos.y != -1)
+ {
+ SetCursorPos(s_saved_cursor_pos.x, s_saved_cursor_pos.y);
+ s_saved_cursor_pos.x = s_saved_cursor_pos.y = -1;
+ }
+
+ while (ShowCursor(TRUE) < 1) {};
+ ShowCursor(FALSE);
+}
+
+#else
+
+CoreCursor^ win_window_info::s_cursor = nullptr;
+
+void win_window_info::capture_pointer()
+{
+ platform_window<Platform::Agile<CoreWindow^>>()->SetPointerCapture();
+}
+
+void win_window_info::release_pointer()
+{
+ platform_window<Platform::Agile<CoreWindow^>>()->ReleasePointerCapture();
+}
+
+void win_window_info::hide_pointer()
+{
+ auto window = platform_window<Platform::Agile<CoreWindow^>>();
+ win_window_info::s_cursor = window->PointerCursor;
+ window->PointerCursor = nullptr;
+}
+
+void win_window_info::show_pointer()
+{
+ auto window = platform_window<Platform::Agile<CoreWindow^>>();
+ window->PointerCursor = win_window_info::s_cursor;
+}
+
+#endif
+
+//============================================================
+// winwindow_process_events_periodic
+// (main thread)
+//============================================================
+
+void winwindow_process_events_periodic(running_machine &machine)
+{
+ auto currticks = std::chrono::system_clock::now();
+
+ assert(GetCurrentThreadId() == main_threadid);
+
+ // update once every 1/8th of a second
+ if (currticks - last_event_check < std::chrono::milliseconds(1000 / 8))
+ return;
+ winwindow_process_events(machine, TRUE, false);
+}
+
+
+
+//============================================================
+// is_mame_window
+//============================================================
+
+static bool is_mame_window(HWND hwnd)
+{
+ //for (auto window : osd_common_t::s_window_list)
+ //if (window->platform_window<HWND>() == hwnd)
+ //return true;
+
+ return false;
+}
+
+inline static BOOL handle_mouse_button(windows_osd_interface *osd, int button, int down, int x, int y)
+{
+ MouseButtonEventArgs args;
+ args.button = button;
+ args.keydown = down;
+ args.xpos = x;
+ args.ypos = y;
+
+ bool handled = osd->handle_input_event(INPUT_EVENT_MOUSE_BUTTON, &args);
+
+ // When in lightgun mode or mouse mode, the mouse click may be routed to the input system
+ // because the mouse interactions in the UI are routed from the video_window_proc below
+ // we need to make sure they aren't suppressed in these cases.
+ return handled && !osd->options().lightgun() && !osd->options().mouse();
+}
+
+inline static BOOL handle_keypress(windows_osd_interface *osd, int vkey, int down, int scancode, BOOL extended_key)
+{
+ KeyPressEventArgs args;
+ args.event_id = down ? INPUT_EVENT_KEYDOWN : INPUT_EVENT_KEYUP;
+ args.scancode = MAKE_DI_SCAN(scancode, extended_key);
+ args.vkey = vkey;
+
+ return osd->handle_input_event(args.event_id, &args);
+}
+
+//============================================================
+// winwindow_process_events
+// (main thread)
+//============================================================
+
+void winwindow_process_events(running_machine &machine, int ingame, bool nodispatch)
+{
+// MSG message;
+
+ assert(GetCurrentThreadId() == main_threadid);
+
+ // remember the last time we did this
+ last_event_check = std::chrono::system_clock::now();
+
+ CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);
+}
+
+
+//============================================================
+// winwindow_video_window_create
+// (main thread)
+//============================================================
+
+void win_window_info::create(running_machine &machine, int index, std::shared_ptr<osd_monitor_info> monitor, const osd_window_config *config)
+{
+ assert(GetCurrentThreadId() == main_threadid);
+
+ // allocate a new window object
+ auto window = std::make_shared<win_window_info>(machine, index, monitor, config);
+
+ // set main window
+ if (window->m_index > 0)
+ {
+ for (auto w : osd_common_t::s_window_list)
+ {
+ if (w->m_index == 0)
+ {
+ window->set_main_window(std::static_pointer_cast<osd_window>(w));
+ break;
+ }
+ }
+ }
+ else
+ {
+ // We must be the main window
+ window->set_main_window(window);
+ }
+
+ // see if we are safe for fullscreen
+ window->m_fullscreen_safe = TRUE;
+ for (auto win : osd_common_t::s_window_list)
+ if (win->monitor() == monitor.get())
+ window->m_fullscreen_safe = FALSE;
+
+ // add us to the list
+ osd_common_t::s_window_list.push_back(window);
+
+ // load the layout
+ window->m_target = machine.render().target_alloc();
+
+ // set the specific view
+ windows_options &options = downcast<windows_options &>(machine.options());
+
+ const char *defview = options.view();
+ window->set_starting_view(index, defview, options.view(index));
+
+ // remember the current values in case they change
+ window->m_targetview = window->m_target->view();
+ window->m_targetorient = window->m_target->orientation();
+ window->m_targetlayerconfig = window->m_target->layer_config();
+
+ // make the window title
+ if (video_config.numscreens == 1)
+ sprintf(window->m_title, "%s: %s [%s]", emulator_info::get_appname(), machine.system().description, machine.system().name);
+ else
+ sprintf(window->m_title, "%s: %s [%s] - Screen %d", emulator_info::get_appname(), machine.system().description, machine.system().name, index);
+
+ // set the initial maximized state
+ window->m_startmaximized = options.maximize();
+
+ window->m_init_state = window->complete_create() ? -1 : 1;
+
+ // handle error conditions
+ if (window->m_init_state == -1)
+ fatalerror("Unable to complete window creation\n");
+}
+
+std::shared_ptr<osd_monitor_info> win_window_info::monitor_from_rect(const osd_rect* proposed) const
+{
+ std::shared_ptr<osd_monitor_info> monitor;
+
+ // in window mode, find the nearest
+ if (!fullscreen())
+ {
+ if (proposed != nullptr)
+ {
+ monitor = m_monitor->module().monitor_from_rect(*proposed);
+ }
+ else
+ monitor = m_monitor->module().monitor_from_window(*this);
+ }
+ else
+ {
+ // in full screen, just use the configured monitor
+ monitor = m_monitor;
+ }
+
+ return monitor;
+}
+
+//============================================================
+// winwindow_video_window_destroy
+// (main thread)
+//============================================================
+
+void win_window_info::destroy()
+{
+ assert(GetCurrentThreadId() == main_threadid);
+
+ // remove us from the list
+ osd_common_t::s_window_list.remove(shared_from_this());
+
+ // destroy the window
+// if (platform_window<HWND>() != nullptr)
+ // DestroyWindow(platform_window<HWND>());
+
+ // free the render target
+ machine().render().target_free(m_target);
+}
+
+
+
+//============================================================
+// winwindow_video_window_update
+// (main thread)
+//============================================================
+
+void win_window_info::update()
+{
+ int targetview, targetorient;
+ render_layer_config targetlayerconfig;
+
+ assert(GetCurrentThreadId() == main_threadid);
+
+ // see if the target has changed significantly in window mode
+ targetview = m_target->view();
+ targetorient = m_target->orientation();
+ targetlayerconfig = m_target->layer_config();
+ if (targetview != m_targetview || targetorient != m_targetorient || targetlayerconfig != m_targetlayerconfig)
+ {
+ m_targetview = targetview;
+ m_targetorient = targetorient;
+ m_targetlayerconfig = targetlayerconfig;
+
+ // in window mode, reminimize/maximize
+ if (!fullscreen())
+ {
+ //if (m_isminimized)
+ //SendMessage(platform_window<HWND>(), WM_USER_SET_MINSIZE, 0, 0);
+ //if (m_ismaximized)
+// SendMessage(platform_window<HWND>(), WM_USER_SET_MAXSIZE, 0, 0);
+ }
+ }
+
+ // if we're visible and running and not in the middle of a resize, draw
+// if (platform_window<HWND>() != nullptr && m_target != nullptr && has_renderer())
+// {
+// bool got_lock = true;
+//
+// // only block if we're throttled
+// //if (machine().video().throttled() || timeGetTime() - last_update_time > 250)
+//// m_render_lock.lock();
+// // else
+// got_lock = m_render_lock.try_lock();
+//
+// // only render if we were able to get the lock
+// if (got_lock)
+// {
+// render_primitive_list *primlist;
+//
+// // don't hold the lock; we just used it to see if rendering was still happening
+// m_render_lock.unlock();
+//
+// // ensure the target bounds are up-to-date, and then get the primitives
+// primlist = renderer().get_primitives();
+//
+// // post a redraw request with the primitive list as a parameter
+// // last_update_time = timeGetTime();
+//
+// //SendMessage(platform_window<HWND>(), WM_USER_REDRAW, 0, (LPARAM)primlist);
+// }
+// }
+}
+
+
+//============================================================
+// set_starting_view
+// (main thread)
+//============================================================
+
+void win_window_info::set_starting_view(int index, const char *defview, const char *view)
+{
+ int viewindex;
+
+ assert(GetCurrentThreadId() == main_threadid);
+
+ // choose non-auto over auto
+ if (strcmp(view, "auto") == 0 && strcmp(defview, "auto") != 0)
+ view = defview;
+
+ // query the video system to help us pick a view
+ viewindex = target()->configured_view(view, index, video_config.numscreens);
+
+ // set the view
+ target()->set_view(viewindex);
+}
+
+
+//============================================================
+// winwindow_ui_pause
+// (main thread)
+//============================================================
+
+void winwindow_ui_pause(running_machine &machine, int pause)
+{
+ int old_temp_pause = ui_temp_pause;
+
+ assert(GetCurrentThreadId() == main_threadid);
+
+ // if we're pausing, increment the pause counter
+ if (pause)
+ {
+ // if we're the first to pause, we have to actually initiate it
+ if (ui_temp_pause++ == 0)
+ {
+ // only call mame_pause if we weren't already paused due to some external reason
+ ui_temp_was_paused = machine.paused();
+ if (!ui_temp_was_paused)
+ machine.pause();
+
+ SetEvent(ui_pause_event);
+ }
+ }
+
+ // if we're resuming, decrement the pause counter
+ else
+ {
+ // if we're the last to resume, unpause MAME
+ if (--ui_temp_pause == 0)
+ {
+ // but only do it if we were the ones who initiated it
+ if (!ui_temp_was_paused)
+ machine.resume();
+
+ ResetEvent(ui_pause_event);
+ }
+ }
+
+ if (LOG_TEMP_PAUSE)
+ osd_printf_verbose("winwindow_ui_pause(): %d --> %d\n", old_temp_pause, ui_temp_pause);
+}
+
+
+
+//============================================================
+// winwindow_ui_is_paused
+//============================================================
+
+int winwindow_ui_is_paused(running_machine &machine)
+{
+ return machine.paused() && ui_temp_was_paused;
+}
+
+
+
+//============================================================
+// wnd_extra_width
+// (window thread)
+//============================================================
+
+int win_window_info::wnd_extra_width()
+{
+ RECT temprect = { 100, 100, 200, 200 };
+ if (fullscreen())
+ return 0;
+ //AdjustWindowRectEx(&temprect, WINDOW_STYLE, win_has_menu(), WINDOW_STYLE_EX);
+ return rect_width(&temprect) - 100;
+}
+
+
+
+//============================================================
+// wnd_extra_height
+// (window thread)
+//============================================================
+
+int win_window_info::wnd_extra_height()
+{
+ RECT temprect = { 100, 100, 200, 200 };
+ if (fullscreen())
+ return 0;
+ //AdjustWindowRectEx(&temprect, WINDOW_STYLE, win_has_menu(), WINDOW_STYLE_EX);
+ return rect_height(&temprect) - 100;
+}
+
+
+//============================================================
+// complete_create
+// (window thread)
+//============================================================
+
+int win_window_info::complete_create()
+{
+ int tempwidth, tempheight;
+
+ assert(GetCurrentThreadId() == window_threadid);
+
+ // get the monitor bounds
+ osd_rect monitorbounds = m_monitor->position_size();
+
+ m_window = Windows::UI::Core::CoreWindow::GetForCurrentThread();
+
+ // skip the positioning stuff for -video none */
+ if (video_config.mode == VIDEO_MODE_NONE)
+ {
+ set_renderer(osd_renderer::make_for_type(video_config.mode, shared_from_this()));
+ renderer().create();
+ return 0;
+ }
+
+ // adjust the window position to the initial width/height
+ tempwidth = (m_win_config.width != 0) ? m_win_config.width : 640;
+ tempheight = (m_win_config.height != 0) ? m_win_config.height : 480;
+
+ // maximum or minimize as appropriate
+ if (m_startmaximized)
+ maximize_window();
+ else
+ minimize_window();
+ adjust_window_position_after_major_change();
+
+ // show the window
+ if (!fullscreen() || m_fullscreen_safe)
+ {
+ set_renderer(osd_renderer::make_for_type(video_config.mode, shared_from_this()));
+ if (renderer().create())
+ return 1;
+
+ }
+
+ return 0;
+}
+
+
+//============================================================
+// constrain_to_aspect_ratio
+// (window thread)
+//============================================================
+
+osd_rect win_window_info::constrain_to_aspect_ratio(const osd_rect &rect, int adjustment)
+{
+ assert(GetCurrentThreadId() == window_threadid);
+
+ int32_t extrawidth = wnd_extra_width();
+ int32_t extraheight = wnd_extra_height();
+ int32_t propwidth, propheight;
+ int32_t minwidth, minheight;
+ int32_t maxwidth, maxheight;
+ int32_t viswidth, visheight;
+ int32_t adjwidth, adjheight;
+ float pixel_aspect;
+
+ auto monitor = monitor_from_rect(&rect);
+
+ // Sometimes this gets called when monitors have already been torn down
+ // In that the case, just return the unmodified rect
+ if (monitor == nullptr)
+ return rect;
+
+ // do not constrain aspect ratio for integer scaled views
+ if (m_target->scale_mode() != SCALE_FRACTIONAL)
+ return rect;
+
+ // get the pixel aspect ratio for the target monitor
+ pixel_aspect = monitor->pixel_aspect();
+
+ // determine the proposed width/height
+ propwidth = rect.width() - extrawidth;
+ propheight = rect.height() - extraheight;
+
+ // based on which edge we are adjusting, take either the width, height, or both as gospel
+ // and scale to fit using that as our parameter
+ switch (adjustment)
+ {
+ case WMSZ_BOTTOM:
+ case WMSZ_TOP:
+ m_target->compute_visible_area(10000, propheight, pixel_aspect, m_target->orientation(), propwidth, propheight);
+ break;
+
+ case WMSZ_LEFT:
+ case WMSZ_RIGHT:
+ m_target->compute_visible_area(propwidth, 10000, pixel_aspect, m_target->orientation(), propwidth, propheight);
+ break;
+
+ default:
+ m_target->compute_visible_area(propwidth, propheight, pixel_aspect, m_target->orientation(), propwidth, propheight);
+ break;
+ }
+
+ // get the minimum width/height for the current layout
+ m_target->compute_minimum_size(minwidth, minheight);
+
+ // clamp against the absolute minimum
+ propwidth = std::max(propwidth, MIN_WINDOW_DIM);
+ propheight = std::max(propheight, MIN_WINDOW_DIM);
+
+ // clamp against the minimum width and height
+ propwidth = std::max(propwidth, minwidth);
+ propheight = std::max(propheight, minheight);
+
+ // clamp against the maximum (fit on one screen for full screen mode)
+ if (fullscreen())
+ {
+ maxwidth = monitor->position_size().width() - extrawidth;
+ maxheight = monitor->position_size().height() - extraheight;
+ }
+ else
+ {
+ maxwidth = monitor->usuable_position_size().width() - extrawidth;
+ maxheight = monitor->usuable_position_size().height() - extraheight;
+
+ // further clamp to the maximum width/height in the window
+ if (m_win_config.width != 0)
+ maxwidth = std::min(maxwidth, m_win_config.width + extrawidth);
+ if (m_win_config.height != 0)
+ maxheight = std::min(maxheight, m_win_config.height + extraheight);
+ }
+
+ // clamp to the maximum
+ propwidth = std::min(propwidth, maxwidth);
+ propheight = std::min(propheight, maxheight);
+
+ // compute the visible area based on the proposed rectangle
+ m_target->compute_visible_area(propwidth, propheight, pixel_aspect, m_target->orientation(), viswidth, visheight);
+
+ // compute the adjustments we need to make
+ adjwidth = (viswidth + extrawidth) - rect.width();
+ adjheight = (visheight + extraheight) - rect.height();
+
+ // based on which corner we're adjusting, constrain in different ways
+ osd_rect ret(rect);
+
+ switch (adjustment)
+ {
+ case WMSZ_BOTTOM:
+ case WMSZ_BOTTOMRIGHT:
+ case WMSZ_RIGHT:
+ ret = rect.resize(rect.width() + adjwidth, rect.height() + adjheight);
+ break;
+
+ case WMSZ_BOTTOMLEFT:
+ ret = rect.move_by(-adjwidth, 0).resize(rect.width() + adjwidth, rect.height() + adjheight);
+ break;
+
+ case WMSZ_LEFT:
+ case WMSZ_TOPLEFT:
+ case WMSZ_TOP:
+ ret = rect.move_by(-adjwidth, -adjheight).resize(rect.width() + adjwidth, rect.height() + adjheight);
+ break;
+
+ case WMSZ_TOPRIGHT:
+ ret = rect.move_by(0, -adjheight).resize(rect.width() + adjwidth, rect.height() + adjheight);
+ break;
+ }
+ return ret;
+}
+
+
+
+//============================================================
+// get_min_bounds
+// (window thread)
+//============================================================
+
+osd_dim win_window_info::get_min_bounds(int constrain)
+{
+ int32_t minwidth, minheight;
+
+ //assert(GetCurrentThreadId() == window_threadid);
+
+ // get the minimum target size
+ m_target->compute_minimum_size(minwidth, minheight);
+
+ // expand to our minimum dimensions
+ if (minwidth < MIN_WINDOW_DIM)
+ minwidth = MIN_WINDOW_DIM;
+ if (minheight < MIN_WINDOW_DIM)
+ minheight = MIN_WINDOW_DIM;
+
+ // account for extra window stuff
+ minwidth += wnd_extra_width();
+ minheight += wnd_extra_height();
+
+ // if we want it constrained, figure out which one is larger
+ if (constrain && m_target->scale_mode() == SCALE_FRACTIONAL)
+ {
+ // first constrain with no height limit
+ osd_rect test1(0,0,minwidth,10000);
+ test1 = constrain_to_aspect_ratio(test1, WMSZ_BOTTOMRIGHT);
+
+ // then constrain with no width limit
+ osd_rect test2(0,0,10000,minheight);
+ test2 = constrain_to_aspect_ratio(test2, WMSZ_BOTTOMRIGHT);
+
+ // pick the larger
+ if (test1.width() > test2.width())
+ {
+ minwidth = test1.width();
+ minheight = test1.height();
+ }
+ else
+ {
+ minwidth = test2.width();
+ minheight = test2.height();
+ }
+ }
+
+ return osd_dim(minwidth, minheight);
+}
+
+
+
+//============================================================
+// get_max_bounds
+// (window thread)
+//============================================================
+
+osd_dim win_window_info::get_max_bounds(int constrain)
+{
+ //assert(GetCurrentThreadId() == window_threadid);
+
+ // compute the maximum client area
+ //m_monitor->refresh();
+ osd_rect maximum = m_monitor->usuable_position_size();
+
+ // clamp to the window's max
+ int tempw = maximum.width();
+ int temph = maximum.height();
+ if (m_win_config.width != 0)
+ {
+ int temp = m_win_config.width + wnd_extra_width();
+ if (temp < maximum.width())
+ tempw = temp;
+ }
+ if (m_win_config.height != 0)
+ {
+ int temp = m_win_config.height + wnd_extra_height();
+ if (temp < maximum.height())
+ temph = temp;
+ }
+
+ maximum = maximum.resize(tempw, temph);
+
+ // constrain to fit
+ if (constrain && m_target->scale_mode() == SCALE_FRACTIONAL)
+ maximum = constrain_to_aspect_ratio(maximum, WMSZ_BOTTOMRIGHT);
+
+ return maximum.dim();
+}
+
+
+
+//============================================================
+// update_minmax_state
+// (window thread)
+//============================================================
+
+void win_window_info::update_minmax_state()
+{
+ assert(GetCurrentThreadId() == window_threadid);
+
+ if (!fullscreen())
+ {
+ RECT bounds;
+
+ // compare the maximum bounds versus the current bounds
+ osd_dim minbounds = get_min_bounds(video_config.keepaspect);
+ osd_dim maxbounds = get_max_bounds(video_config.keepaspect);
+ //GetWindowRect(platform_window<HWND>(), &bounds);
+
+ // if either the width or height matches, we were maximized
+ m_isminimized = (rect_width(&bounds) == minbounds.width()) ||
+ (rect_height(&bounds) == minbounds.height());
+ m_ismaximized = (rect_width(&bounds) == maxbounds.width()) ||
+ (rect_height(&bounds) == maxbounds.height());
+ }
+ else
+ {
+ m_isminimized = FALSE;
+ m_ismaximized = TRUE;
+ }
+}
+
+
+
+//============================================================
+// minimize_window
+// (window thread)
+//============================================================
+
+void win_window_info::minimize_window()
+{
+ assert(GetCurrentThreadId() == window_threadid);
+
+ osd_dim newsize = get_min_bounds(video_config.keepaspect);
+
+ // get the window rect
+ RECT bounds;
+ //GetWindowRect(platform_window<HWND>(), &bounds);
+
+ osd_rect newrect(bounds.left, bounds.top, newsize );
+
+
+ //SetWindowPos(platform_window<HWND>(), nullptr, newrect.left(), newrect.top(), newrect.width(), newrect.height(), SWP_NOZORDER);
+}
+
+
+
+//============================================================
+// maximize_window
+// (window thread)
+//============================================================
+
+void win_window_info::maximize_window()
+{
+ assert(GetCurrentThreadId() == window_threadid);
+
+ osd_dim newsize = get_max_bounds(video_config.keepaspect);
+
+ // center within the work area
+ osd_rect work = m_monitor->usuable_position_size();
+ osd_rect newrect = osd_rect(work.left() + (work.width() - newsize.width()) / 2,
+ work.top() + (work.height() - newsize.height()) / 2,
+ newsize);
+
+ //SetWindowPos(platform_window<HWND>(), nullptr, newrect.left(), newrect.top(), newrect.width(), newrect.height(), SWP_NOZORDER);
+}
+
+
+
+//============================================================
+// adjust_window_position_after_major_change
+// (window thread)
+//============================================================
+
+void win_window_info::adjust_window_position_after_major_change()
+{
+ RECT oldrect;
+
+ assert(GetCurrentThreadId() == window_threadid);
+
+ // get the current size
+ //GetWindowRect(platform_window<HWND>(), &oldrect);
+ osd_rect newrect = RECT_to_osd_rect(oldrect);
+
+ // adjust the window size so the client area is what we want
+ if (!fullscreen())
+ {
+ // constrain the existing size to the aspect ratio
+ if (video_config.keepaspect)
+ newrect = constrain_to_aspect_ratio(newrect, WMSZ_BOTTOMRIGHT);
+ }
+
+ // in full screen, make sure it covers the primary display
+ else
+ {
+ std::shared_ptr<osd_monitor_info> monitor = monitor_from_rect(nullptr);
+ newrect = monitor->position_size();
+ }
+
+ // adjust the position if different
+ if (oldrect.left != newrect.left() || oldrect.top != newrect.top() ||
+ oldrect.right != newrect.right() || oldrect.bottom != newrect.bottom())
+ //SetWindowPos(platform_window<HWND>(), fullscreen() ? HWND_TOPMOST : HWND_TOP,
+ // newrect.left(), newrect.top(),
+ //newrect.width(), newrect.height(), 0);
+
+ // take note of physical window size (used for lightgun coordinate calculation)
+ if (m_index == 0)
+ {
+ win_physical_width = newrect.width();
+ win_physical_height = newrect.height();
+ osd_printf_verbose("Physical width %d, height %d\n",win_physical_width,win_physical_height);
+ }
+}
+
+
+//============================================================
+// set_fullscreen
+// (window thread)
+//============================================================
+
+void win_window_info::set_fullscreen(int fullscreen)
+{
+ assert(GetCurrentThreadId() == window_threadid);
+
+ // if we're in the right state, punt
+ if (this->fullscreen() == fullscreen)
+ return;
+ m_fullscreen = fullscreen;
+
+ // reset UI to main menu
+ machine().ui().menu_reset();
+
+ // kill off the drawers
+ renderer_reset();
+
+ // hide ourself
+ //ShowWindow(platform_window<HWND>(), SW_HIDE);
+
+ // configure the window if non-fullscreen
+ if (!fullscreen)
+ {
+ // adjust the style
+ //SetWindowLong(platform_window<HWND>(), GWL_STYLE, WINDOW_STYLE);
+ //SetWindowLong(platform_window<HWND>(), GWL_EXSTYLE, WINDOW_STYLE_EX);
+ //SetWindowPos(platform_window<HWND>(), nullptr, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
+
+ // force to the bottom, then back on top
+ //SetWindowPos(platform_window<HWND>(), HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+ //SetWindowPos(platform_window<HWND>(), HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+
+ //// if we have previous non-fullscreen bounds, use those
+ //if (m_non_fullscreen_bounds.right != m_non_fullscreen_bounds.left)
+ //{
+ // SetWindowPos(platform_window<HWND>(), HWND_TOP, m_non_fullscreen_bounds.left, m_non_fullscreen_bounds.top,
+ // rect_width(&m_non_fullscreen_bounds), rect_height(&m_non_fullscreen_bounds),
+ // SWP_NOZORDER);
+ //}
+ //
+ //// otherwise, set a small size and maximize from there
+ //else
+ //{
+ // SetWindowPos(platform_window<HWND>(), HWND_TOP, 0, 0, MIN_WINDOW_DIM, MIN_WINDOW_DIM, SWP_NOZORDER);
+ // maximize_window();
+ //}
+ }
+
+ // configure the window if fullscreen
+ else
+ {
+ // save the bounds
+ //GetWindowRect(platform_window<HWND>(), &m_non_fullscreen_bounds);
+ //
+ //// adjust the style
+ //SetWindowLong(platform_window<HWND>(), GWL_STYLE, FULLSCREEN_STYLE);
+ //SetWindowLong(platform_window<HWND>(), GWL_EXSTYLE, FULLSCREEN_STYLE_EX);
+ //SetWindowPos(platform_window<HWND>(), nullptr, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
+ //
+ //// set topmost
+ //SetWindowPos(platform_window<HWND>(), HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+ }
+
+ // adjust the window to compensate for the change
+ adjust_window_position_after_major_change();
+
+ // show ourself
+ if (!this->fullscreen() || m_fullscreen_safe)
+ {
+ //if (video_config.mode != VIDEO_MODE_NONE)
+ //ShowWindow(platform_window<HWND>(), SW_SHOW);
+
+ set_renderer(osd_renderer::make_for_type(video_config.mode, shared_from_this()));
+ if (renderer().create())
+ exit(1);
+ }
+
+ // ensure we're still adjusted correctly
+ adjust_window_position_after_major_change();
+}
+
diff --git a/src/osd/uwp/window.h b/src/osd/uwp/window.h
new file mode 100644
index 00000000000..a6c6960b226
--- /dev/null
+++ b/src/osd/uwp/window.h
@@ -0,0 +1,177 @@
+// license:BSD-3-Clause
+// copyright-holders:Aaron Giles
+//============================================================
+//
+// window.h - Win32 window handling
+//
+//============================================================
+
+#ifndef __WIN_WINDOW__
+#define __WIN_WINDOW__
+
+// standard windows headers
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <windowsx.h>
+#include <mmsystem.h>
+
+#include <chrono>
+#include <mutex>
+#include <memory>
+#include <list>
+
+#include "render.h"
+
+#include "modules/osdwindow.h"
+
+//============================================================
+// PARAMETERS
+//============================================================
+
+
+//============================================================
+// CONSTANTS
+//============================================================
+
+#define RESIZE_STATE_NORMAL 0
+#define RESIZE_STATE_RESIZING 1
+#define RESIZE_STATE_PENDING 2
+
+
+
+//============================================================
+// TYPE DEFINITIONS
+//============================================================
+
+class win_window_info : public osd_window
+{
+public:
+ win_window_info(running_machine &machine, int index, std::shared_ptr<osd_monitor_info> monitor, const osd_window_config *config);
+
+ running_machine &machine() const override { return m_machine; }
+
+ virtual render_target *target() override { return m_target; }
+ int fullscreen() const override { return m_fullscreen; }
+
+ void update() override;
+
+ virtual bool win_has_menu() override
+ {
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+ return GetMenu(platform_window<HWND>()) ? true : false;
+#else
+ return false;
+#endif
+ }
+
+ virtual osd_dim get_size() override
+ {
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+ RECT client;
+ GetClientRect(platform_window<HWND>(), &client);
+ return osd_dim(client.right - client.left, client.bottom - client.top);
+#else
+ throw ref new Platform::NotImplementedException();
+#endif
+ }
+
+ void capture_pointer() override;
+ void release_pointer() override;
+ void show_pointer() override;
+ void hide_pointer() override;
+
+ virtual osd_monitor_info *monitor() const override { return m_monitor.get(); }
+
+ void destroy() override;
+
+ // static
+
+ static void create(running_machine &machine, int index, std::shared_ptr<osd_monitor_info> monitor, const osd_window_config *config);
+
+ // static callbacks
+
+ static LRESULT CALLBACK video_window_proc(HWND wnd, UINT message, WPARAM wparam, LPARAM lparam);
+
+ // member variables
+
+ win_window_info * m_next;
+ volatile int m_init_state;
+
+ // window handle and info
+ char m_title[256];
+ RECT m_non_fullscreen_bounds;
+ int m_startmaximized;
+ int m_isminimized;
+ int m_ismaximized;
+
+ // monitor info
+ std::shared_ptr<osd_monitor_info> m_monitor;
+ int m_fullscreen;
+ int m_fullscreen_safe;
+ float m_aspect;
+
+ // rendering info
+ std::mutex m_render_lock;
+ render_target * m_target;
+ int m_targetview;
+ int m_targetorient;
+ render_layer_config m_targetlayerconfig;
+
+ // input info
+ std::chrono::system_clock::time_point m_lastclicktime;
+ int m_lastclickx;
+ int m_lastclicky;
+
+private:
+ int complete_create();
+ void set_starting_view(int index, const char *defview, const char *view);
+ int wnd_extra_width();
+ int wnd_extra_height();
+ osd_rect constrain_to_aspect_ratio(const osd_rect &rect, int adjustment);
+ osd_dim get_min_bounds(int constrain);
+ osd_dim get_max_bounds(int constrain);
+ void update_minmax_state();
+ void minimize_window();
+ void maximize_window();
+ void adjust_window_position_after_major_change();
+ void set_fullscreen(int fullscreen);
+ std::shared_ptr<osd_monitor_info> monitor_from_rect(const osd_rect* proposed) const;
+
+ static POINT s_saved_cursor_pos;
+
+#if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+ static Windows::UI::Core::CoreCursor^ s_cursor;
+#endif
+
+ running_machine & m_machine;
+};
+
+struct osd_draw_callbacks
+{
+ osd_renderer *(*create)(osd_window *window);
+ void (*exit)(void);
+};
+
+
+//============================================================
+// PROTOTYPES
+//============================================================
+
+void winwindow_process_events(running_machine &machine, int ingame, bool nodispatch);
+
+//============================================================
+// rect_width / rect_height
+//============================================================
+
+static inline int rect_width(const RECT *rect)
+{
+ return rect->right - rect->left;
+}
+
+
+static inline int rect_height(const RECT *rect)
+{
+ return rect->bottom - rect->top;
+}
+
+#endif