summaryrefslogtreecommitdiffstatshomepage
path: root/src/osd/uwp/window.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/osd/uwp/window.cpp')
-rw-r--r--src/osd/uwp/window.cpp1146
1 files changed, 0 insertions, 1146 deletions
diff --git a/src/osd/uwp/window.cpp b/src/osd/uwp/window.cpp
deleted file mode 100644
index 12c67308f22..00000000000
--- a/src/osd/uwp/window.cpp
+++ /dev/null
@@ -1,1146 +0,0 @@
-// 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())
-
-//============================================================
-// 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 std::chrono::time_point<std::chrono::high_resolution_clock> 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);
-}
-
-uwp_window_info::uwp_window_info(
- running_machine &machine,
- int index,
- std::shared_ptr<osd_monitor_info> monitor,
- const osd_window_config *config) : osd_window_t(*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 uwp_window_info::s_saved_cursor_pos = { -1, -1 };
-
-CoreCursor^ uwp_window_info::s_cursor = nullptr;
-
-void uwp_window_info::capture_pointer()
-{
- platform_window()->SetPointerCapture();
-}
-
-void uwp_window_info::release_pointer()
-{
- platform_window()->ReleasePointerCapture();
-}
-
-void uwp_window_info::hide_pointer()
-{
- auto window = platform_window();
- uwp_window_info::s_cursor = window->PointerCursor;
- window->PointerCursor = nullptr;
-}
-
-void uwp_window_info::show_pointer()
-{
- auto window = platform_window();
- window->PointerCursor = uwp_window_info::s_cursor;
-}
-
-//============================================================
-// 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);
-}
-
-//============================================================
-// winwindow_has_focus
-// (main or window thread)
-//============================================================
-
-bool winwindow_has_focus(void)
-{
- // For now always act like we have focus
- return true;
-}
-
-//============================================================
-// winwindow_process_events
-// (main thread)
-//============================================================
-
-void winwindow_process_events(running_machine &machine, bool ingame, bool nodispatch)
-{
-// MSG message;
-
- assert(GetCurrentThreadId() == main_threadid);
-
- // remember the last time we did this
- last_event_check = std::chrono::system_clock::now();
-
- try
- {
- CoreWindow^ window = CoreWindow::GetForCurrentThread();
- window->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);
- }
- catch (Platform::DisconnectedException^)
- {
- // This can get thrown when the window is being destroyed
- }
-}
-
-
-//============================================================
-// winwindow_video_window_create
-// (main thread)
-//============================================================
-
-void uwp_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<uwp_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().type.fullname(), machine.system().name);
- else
- sprintf(window->m_title, "%s: %s [%s] - Screen %d", emulator_info::get_appname(), machine.system().type.fullname(), 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> uwp_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 uwp_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 uwp_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() != nullptr && m_target != nullptr && has_renderer())
- {
- bool got_lock = true;
- auto clock = std::chrono::high_resolution_clock();
-
- // only block if we're throttled
- if (machine().video().throttled() || clock.now() - last_update_time > std::chrono::milliseconds(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 = clock.now();
-
- // Actually perform the redraw
- m_primlist = primlist;
- draw_video_contents(false);
- }
- }
-}
-
-//============================================================
-// draw_video_contents
-// (window thread)
-//============================================================
-
-void uwp_window_info::draw_video_contents(bool update)
-{
- assert(GetCurrentThreadId() == window_threadid);
-
- std::lock_guard<std::mutex> lock(m_render_lock);
-
- // if we're iconic, don't bother
- if (platform_window() != nullptr)
- {
- // if no bitmap, just fill
- if (m_primlist == nullptr)
- {
- // For now do nothing, eventually we need to clear the window
- }
-
- // otherwise, render with our drawing system
- else
- {
- renderer().draw(update);
- }
- }
-}
-
-
-//============================================================
-// set_starting_view
-// (main thread)
-//============================================================
-
-void uwp_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 uwp_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 uwp_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 uwp_window_info::complete_create()
-{
- int tempwidth, tempheight;
-
- assert(GetCurrentThreadId() == window_threadid);
-
- // get the monitor bounds
- osd_rect monitorbounds = m_monitor->position_size();
-
- auto coreWindow = Platform::Agile<CoreWindow>(CoreWindow::GetForCurrentThread());
- set_platform_window(coreWindow);
-
- // 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 uwp_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 uwp_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 uwp_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 uwp_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 uwp_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 uwp_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 uwp_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 uwp_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();
-}
-