diff options
-rw-r--r-- | scripts/src/osd/uwp.lua | 6 | ||||
-rw-r--r-- | src/osd/uwp/video.cpp | 200 | ||||
-rw-r--r-- | src/osd/uwp/video.h | 19 | ||||
-rw-r--r-- | src/osd/uwp/window.cpp | 1181 | ||||
-rw-r--r-- | src/osd/uwp/window.h | 177 |
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 |