static void update_minmax_state(win_window_info *window)
{
assert(GetCurrentThreadId() == window_threadid);
if (!window->fullscreen)
{
RECT bounds, minbounds, maxbounds;
// compare the maximum bounds versus the current bounds
get_min_bounds(window, &minbounds, video_config.keepaspect);
get_max_bounds(window, &maxbounds, video_config.keepaspect);
GetWindowRect(window->hwnd, &bounds);
// if either the width or height matches, we were maximized
window->isminimized = (rect_width(&bounds) == rect_width(&minbounds) ||
rect_height(&bounds) == rect_height(&minbounds));
window->ismaximized = (rect_width(&bounds) == rect_width(&maxbounds) ||
rect_height(&bounds) == rect_height(&maxbounds));
}
else
{
window->isminimized = FALSE;
window->ismaximized = TRUE;
}
}
static OSDWORK_CALLBACK( complete_create_wt )
{
worker_param * wp = (worker_param *) param;
sdl_window_info * window = wp->window;
int tempwidth, tempheight;
static int result[2] = {0,1};
ASSERT_WINDOW_THREAD();
osd_free(wp);
if (window->fullscreen)
{
// default to the current mode exactly
tempwidth = window->monitor->monitor_width;
tempheight = window->monitor->monitor_height;
// if we're allowed to switch resolutions, override with something better
if (video_config.switchres)
pick_best_mode(window, &tempwidth, &tempheight);
}
else if (window->windowed_width)
{
// if we have a remembered size force the new window size to it
tempwidth = window->windowed_width;
tempheight = window->windowed_height;
}
else
{
if (window->startmaximized)
{
tempwidth = tempheight = 0;
get_max_bounds(window, &tempwidth, &tempheight, video_config.keepaspect );
}
else
{
/* Create the window directly with the correct aspect
instead of letting sdlwindow_blit_surface_size() resize it
this stops the window from "flashing" from the wrong aspect
size to the right one at startup. */
tempwidth = (window->maxwidth != 0) ? window->maxwidth : 640;
tempheight = (window->maxheight != 0) ? window->maxheight : 480;
get_min_bounds(window, &tempwidth, &tempheight, video_config.keepaspect );
}
}
// initialize the drawing backend
if (window->create(window, tempwidth, tempheight))
return (void *) &result[1];
// Make sure we have a consistent state
SDL_ShowCursor(0);
SDL_ShowCursor(1);
return (void *) &result[0];
}
static void maximize_window(win_window_info *window)
{
RECT newsize;
assert(GetCurrentThreadId() == window_threadid);
get_max_bounds(window, &newsize, video_config.keepaspect);
SetWindowPos(window->hwnd, NULL, newsize.left, newsize.top, rect_width(&newsize), rect_height(&newsize), SWP_NOZORDER);
}
int sdl_window_info::complete_create()
{
osd_dim temp(0,0);
// clear out original mode. Needed on OSX
if (fullscreen())
{
// default to the current mode exactly
temp = monitor()->position_size().dim();
// if we're allowed to switch resolutions, override with something better
if (video_config.switchres)
temp = pick_best_mode();
}
else if (m_windowed_dim.width() > 0)
{
// if we have a remembered size force the new window size to it
temp = m_windowed_dim;
}
else if (m_startmaximized)
temp = get_max_bounds(video_config.keepaspect );
else
temp = get_min_bounds(video_config.keepaspect );
// create the window .....
/* FIXME: On Ubuntu and potentially other Linux OS you should use
* to disable panning. This has to be done before every invocation of mame.
*
* xrandr --output HDMI-0 --panning 0x0+0+0 --fb 0x0
*
*/
osd_printf_verbose("Enter sdl_info::create\n");
if (renderer().has_flags(osd_renderer::FLAG_NEEDS_OPENGL) && !video_config.novideo)
{
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
/* FIXME: A reminder that gamma is wrong throughout MAME. Currently, SDL2.0 doesn't seem to
* support the following attribute although my hardware lists GL_ARB_framebuffer_sRGB as an extension.
*
* SDL_GL_SetAttribute( SDL_GL_FRAMEBUFFER_SRGB_CAPABLE, 1 );
*
*/
m_extra_flags = SDL_WINDOW_OPENGL;
}
else
m_extra_flags = 0;
#ifdef SDLMAME_MACOSX
/* FIMXE: On OSX, SDL_WINDOW_FULLSCREEN_DESKTOP seems to be more reliable.
* It however creates issues with white borders, i.e. the screen clear
* does not work. This happens both with opengl and accel.
*/
#endif
// We need to workaround an issue in SDL 2.0.4 for OS X where setting the
// relative mode on the mouse in fullscreen mode makes mouse events stop
// It is fixed in the latest revisions so we'll assume it'll be fixed
// in the next public SDL release as well
#if defined(SDLMAME_MACOSX) && SDL_VERSION_ATLEAST(2, 0, 2) // SDL_HINT_MOUSE_RELATIVE_MODE_WARP is introduced in 2.0.2
SDL_version linked;
SDL_GetVersion(&linked);
int revision = SDL_GetRevisionNumber();
// If we're running the exact version of SDL 2.0.4 (revision 10001) from the
// SDL web site, we need to work around this issue and send the warp mode hint
if (SDL_VERSION_EQUALS(linked, SDL_VERSIONNUM(2, 0, 4)) && revision == 10001)
{
osd_printf_verbose("Using warp mode for relative mouse in OS X SDL 2.0.4\n");
SDL_SetHint(SDL_HINT_MOUSE_RELATIVE_MODE_WARP, "1");
}
#endif
// create the SDL window
// soft driver also used | SDL_WINDOW_INPUT_GRABBED | SDL_WINDOW_MOUSE_FOCUS
m_extra_flags |= (fullscreen() ?
SDL_WINDOW_BORDERLESS | SDL_WINDOW_INPUT_FOCUS | SDL_WINDOW_FULLSCREEN : SDL_WINDOW_RESIZABLE);
#if defined(SDLMAME_WIN32)
SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "0");
#endif
// get monitor work area for centering
osd_rect work = monitor()->usuable_position_size();
// create the SDL window
auto sdlwindow = SDL_CreateWindow(m_title,
work.left() + (work.width() - temp.width()) / 2,
work.top() + (work.height() - temp.height()) / 2,
temp.width(), temp.height(), m_extra_flags);
//window().sdl_window() = SDL_CreateWindow(window().m_title, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
// width, height, m_extra_flags);
if (sdlwindow == nullptr )
{
if (renderer().has_flags(osd_renderer::FLAG_NEEDS_OPENGL))
osd_printf_error("OpenGL not supported on this driver: %s\n", SDL_GetError());
else
osd_printf_error("Window creation failed: %s\n", SDL_GetError());
return 1;
}
set_platform_window(sdlwindow);
if (fullscreen() && video_config.switchres)
{
SDL_DisplayMode mode;
//SDL_GetCurrentDisplayMode(window().monitor()->handle, &mode);
SDL_GetWindowDisplayMode(platform_window(), &mode);
m_original_mode->mode = mode;
mode.w = temp.width();
mode.h = temp.height();
if (m_win_config.refresh)
mode.refresh_rate = m_win_config.refresh;
SDL_SetWindowDisplayMode(platform_window(), &mode); // Try to set mode
#ifndef SDLMAME_WIN32
/* FIXME: Warp the mouse to 0,0 in case a virtual desktop resolution
* is in place after the mode switch - which will most likely be the case
* This is a hack to work around a deficiency in SDL2
*/
SDL_WarpMouseInWindow(platform_window(), 1, 1);
#endif
}
else
{
//SDL_SetWindowDisplayMode(window().sdl_window(), nullptr); // Use desktop
}
// show window
SDL_ShowWindow(platform_window());
//SDL_SetWindowFullscreen(window->sdl_window(), 0);
//SDL_SetWindowFullscreen(window->sdl_window(), window->fullscreen());
SDL_RaiseWindow(platform_window());
#ifdef SDLMAME_WIN32
if (fullscreen())
SDL_SetWindowGrab(platform_window(), SDL_TRUE);
#endif
// set main window
if (m_index > 0)
{
for (auto w : osd_common_t::s_window_list)
{
if (w->m_index == 0)
{
set_main_window(std::dynamic_pointer_cast<osd_window>(w));
break;
}
}
}
else
{
// We must be the main window
set_main_window(shared_from_this());
}
// update monitor resolution after mode change to ensure proper pixel aspect
monitor()->refresh();
if (fullscreen() && video_config.switchres)
monitor()->update_resolution(temp.width(), temp.height());
// initialize the drawing backend
if (renderer().create())
return 1;
// Make sure we have a consistent state
SDL_ShowCursor(0);
SDL_ShowCursor(1);
return 0;
}
