summaryrefslogtreecommitdiffstatshomepage
path: root/src/osd
diff options
context:
space:
mode:
author couriersud <couriersud@arcor.de>2015-02-26 19:38:42 +0100
committer couriersud <couriersud@arcor.de>2015-02-26 19:38:42 +0100
commit4001dfe147078e0b98e881fdff2762291f5f5a25 (patch)
tree8a4619ba7b0c61c45b40607f4248aa40ea48e2ce /src/osd
parent5fc8d523eca2ee983df074d57e12f0894b1e14d7 (diff)
C++'d more of window.c (nw)
Diffstat (limited to 'src/osd')
-rw-r--r--src/osd/windows/video.c2
-rw-r--r--src/osd/windows/window.c302
-rw-r--r--src/osd/windows/window.h22
3 files changed, 164 insertions, 162 deletions
diff --git a/src/osd/windows/video.c b/src/osd/windows/video.c
index 41fa7534e87..44574699caa 100644
--- a/src/osd/windows/video.c
+++ b/src/osd/windows/video.c
@@ -83,7 +83,7 @@ bool windows_osd_interface::video_init()
// create the windows
windows_options &options = downcast<windows_options &>(machine().options());
for (index = 0; index < video_config.numscreens; index++)
- winwindow_video_window_create(machine(), index, pick_monitor(options, index), &windows[index]);
+ win_window_info::create(machine(), index, pick_monitor(options, index), &windows[index]);
if (video_config.mode != VIDEO_MODE_NONE)
SetForegroundWindow(win_window_list->m_hwnd);
diff --git a/src/osd/windows/window.c b/src/osd/windows/window.c
index 301b885b4d0..16a22069191 100644
--- a/src/osd/windows/window.c
+++ b/src/osd/windows/window.c
@@ -120,23 +120,8 @@ static HANDLE window_thread_ready_event;
// PROTOTYPES
//============================================================
-static void winwindow_video_window_destroy(win_window_info *window);
-static unsigned __stdcall thread_entry(void *param);
-static int complete_create(win_window_info *window);
static void create_window_class(void);
-static void set_starting_view(int index, win_window_info *window, const char *view);
-
-static void constrain_to_aspect_ratio(win_window_info *window, RECT *rect, int adjustment);
-static void get_min_bounds(win_window_info *window, RECT *bounds, int constrain);
-static void get_max_bounds(win_window_info *window, RECT *bounds, int constrain);
-static void update_minmax_state(win_window_info *window);
-static void minimize_window(win_window_info *window);
-static void maximize_window(win_window_info *window);
-
-static void adjust_window_position_after_major_change(win_window_info *window);
-static void set_fullscreen(win_window_info *window, int fullscreen);
-
// temporary hacks
#if LOG_THREADS
@@ -213,7 +198,7 @@ bool windows_osd_interface::window_init()
fatalerror("Failed to create window thread ready event\n");
// create a thread to run the windows from
- temp = _beginthreadex(NULL, 0, thread_entry, NULL, 0, (unsigned *)&window_threadid);
+ temp = _beginthreadex(NULL, 0, win_window_info::thread_entry, NULL, 0, (unsigned *)&window_threadid);
window_thread = (HANDLE)temp;
if (window_thread == NULL)
fatalerror("Failed to create window thread\n");
@@ -272,7 +257,9 @@ void windows_osd_interface::window_exit()
{
win_window_info *temp = win_window_list;
win_window_list = temp->m_next;
- winwindow_video_window_destroy(temp);
+ temp->destroy();
+ global_free(temp);
+
}
// kill the drawers
@@ -659,7 +646,7 @@ void winwindow_update_cursor_state(running_machine &machine)
// (main thread)
//============================================================
-void winwindow_video_window_create(running_machine &machine, int index, win_monitor_info *monitor, const osd_window_config *config)
+void win_window_info::create(running_machine &machine, int index, win_monitor_info *monitor, const osd_window_config *config)
{
win_window_info *window, *win;
@@ -690,7 +677,7 @@ void winwindow_video_window_create(running_machine &machine, int index, win_moni
// set the specific view
windows_options &options = downcast<windows_options &>(machine.options());
- set_starting_view(index, window, options.view(index));
+ window->set_starting_view(index, options.view(index));
// remember the current values in case they change
window->m_targetview = window->m_target->view();
@@ -720,7 +707,7 @@ void winwindow_video_window_create(running_machine &machine, int index, win_moni
}
}
else
- window->m_init_state = complete_create(window) ? -1 : 1;
+ window->m_init_state = window->complete_create() ? -1 : 1;
// handle error conditions
if (window->m_init_state == -1)
@@ -734,7 +721,7 @@ void winwindow_video_window_create(running_machine &machine, int index, win_moni
// (main thread)
//============================================================
-static void winwindow_video_window_destroy(win_window_info *window)
+void win_window_info::destroy()
{
win_window_info **prevptr;
@@ -742,24 +729,23 @@ static void winwindow_video_window_destroy(win_window_info *window)
// remove us from the list
for (prevptr = &win_window_list; *prevptr != NULL; prevptr = &(*prevptr)->m_next)
- if (*prevptr == window)
+ if (*prevptr == this)
{
- *prevptr = window->m_next;
+ *prevptr = this->m_next;
break;
}
// destroy the window
- if (window->m_hwnd != NULL)
- SendMessage(window->m_hwnd, WM_USER_SELF_TERMINATE, 0, 0);
+ if (m_hwnd != NULL)
+ SendMessage(m_hwnd, WM_USER_SELF_TERMINATE, 0, 0);
// free the render target
- window->machine().render().target_free(window->m_target);
+ machine().render().target_free(m_target);
+ // FIXME: move to destructor
// free the lock
- osd_lock_free(window->m_render_lock);
+ osd_lock_free(m_render_lock);
- // free the window itself
- global_free(window);
}
@@ -905,9 +891,9 @@ static void create_window_class(void)
// (main thread)
//============================================================
-static void set_starting_view(int index, win_window_info *window, const char *view)
+void win_window_info::set_starting_view(int index, const char *view)
{
- const char *defview = downcast<windows_options &>(window->machine().options()).view();
+ const char *defview = downcast<windows_options &>(machine().options()).view();
int viewindex;
assert(GetCurrentThreadId() == main_threadid);
@@ -917,10 +903,10 @@ static void set_starting_view(int index, win_window_info *window, const char *vi
view = defview;
// query the video system to help us pick a view
- viewindex = window->m_target->configured_view(view, index, video_config.numscreens);
+ viewindex = m_target->configured_view(view, index, video_config.numscreens);
// set the view
- window->m_target->set_view(viewindex);
+ m_target->set_view(viewindex);
}
@@ -1037,12 +1023,12 @@ int winwindow_ui_is_paused(running_machine &machine)
// (window thread)
//============================================================
-INLINE int wnd_extra_width(win_window_info *window)
+int win_window_info::wnd_extra_width()
{
RECT temprect = { 100, 100, 200, 200 };
- if (window->m_fullscreen)
+ if (m_fullscreen)
return 0;
- AdjustWindowRectEx(&temprect, WINDOW_STYLE, window->win_has_menu(), WINDOW_STYLE_EX);
+ AdjustWindowRectEx(&temprect, WINDOW_STYLE, win_has_menu(), WINDOW_STYLE_EX);
return rect_width(&temprect) - 100;
}
@@ -1053,12 +1039,12 @@ INLINE int wnd_extra_width(win_window_info *window)
// (window thread)
//============================================================
-INLINE int wnd_extra_height(win_window_info *window)
+int win_window_info::wnd_extra_height()
{
RECT temprect = { 100, 100, 200, 200 };
- if (window->m_fullscreen)
+ if (m_fullscreen)
return 0;
- AdjustWindowRectEx(&temprect, WINDOW_STYLE, window->win_has_menu(), WINDOW_STYLE_EX);
+ AdjustWindowRectEx(&temprect, WINDOW_STYLE, win_has_menu(), WINDOW_STYLE_EX);
return rect_height(&temprect) - 100;
}
@@ -1069,7 +1055,7 @@ INLINE int wnd_extra_height(win_window_info *window)
// (window thread)
//============================================================
-static unsigned __stdcall thread_entry(void *param)
+unsigned __stdcall win_window_info::thread_entry(void *param)
{
MSG message;
@@ -1141,7 +1127,7 @@ static unsigned __stdcall thread_entry(void *param)
case WM_USER_FINISH_CREATE_WINDOW:
{
win_window_info *window = (win_window_info *)message.lParam;
- window->m_init_state = complete_create(window) ? -1 : 1;
+ window->m_init_state = window->complete_create() ? -1 : 1;
dispatch = FALSE;
break;
}
@@ -1165,7 +1151,7 @@ static unsigned __stdcall thread_entry(void *param)
// (window thread)
//============================================================
-static int complete_create(win_window_info *window)
+int win_window_info::complete_create()
{
RECT monitorbounds, client;
int tempwidth, tempheight;
@@ -1175,70 +1161,70 @@ static int complete_create(win_window_info *window)
assert(GetCurrentThreadId() == window_threadid);
// get the monitor bounds
- monitorbounds = window->m_monitor->position_size();
+ monitorbounds = m_monitor->position_size();
// create the window menu if needed
- if (downcast<windows_options &>(window->machine().options()).menu())
+ if (downcast<windows_options &>(machine().options()).menu())
{
- if (win_create_menu(window->machine(), &menu))
+ if (win_create_menu(machine(), &menu))
return 1;
}
// create the window, but don't show it yet
- window->m_hwnd = win_create_window_ex_utf8(
- window->m_fullscreen ? FULLSCREEN_STYLE_EX : WINDOW_STYLE_EX,
+ m_hwnd = win_create_window_ex_utf8(
+ m_fullscreen ? FULLSCREEN_STYLE_EX : WINDOW_STYLE_EX,
"MAME",
- window->m_title,
- window->m_fullscreen ? FULLSCREEN_STYLE : WINDOW_STYLE,
+ m_title,
+ m_fullscreen ? FULLSCREEN_STYLE : WINDOW_STYLE,
monitorbounds.left + 20, monitorbounds.top + 20,
monitorbounds.left + 100, monitorbounds.top + 100,
NULL,//(win_window_list != NULL) ? win_window_list->m_hwnd : NULL,
menu,
GetModuleHandle(NULL),
NULL);
- if (window->m_hwnd == NULL)
+ if (m_hwnd == NULL)
return 1;
// set window #0 as the focus window for all windows, required for D3D & multimonitor
- window->m_focus_hwnd = win_window_list->m_hwnd;
+ m_focus_hwnd = win_window_list->m_hwnd;
// set a pointer back to us
- SetWindowLongPtr(window->m_hwnd, GWLP_USERDATA, (LONG_PTR)window);
+ SetWindowLongPtr(m_hwnd, GWLP_USERDATA, (LONG_PTR)this);
// skip the positioning stuff for -video none */
if (video_config.mode == VIDEO_MODE_NONE)
return 0;
// adjust the window position to the initial width/height
- tempwidth = (window->m_win_config.width != 0) ? window->m_win_config.width : 640;
- tempheight = (window->m_win_config.height != 0) ? window->m_win_config.height : 480;
- SetWindowPos(window->m_hwnd, NULL, monitorbounds.left + 20, monitorbounds.top + 20,
- monitorbounds.left + tempwidth + wnd_extra_width(window),
- monitorbounds.top + tempheight + wnd_extra_height(window),
+ tempwidth = (m_win_config.width != 0) ? m_win_config.width : 640;
+ tempheight = (m_win_config.height != 0) ? m_win_config.height : 480;
+ SetWindowPos(m_hwnd, NULL, monitorbounds.left + 20, monitorbounds.top + 20,
+ monitorbounds.left + tempwidth + wnd_extra_width(),
+ monitorbounds.top + tempheight + wnd_extra_height(),
SWP_NOZORDER);
// maximum or minimize as appropriate
- if (window->m_startmaximized)
- maximize_window(window);
+ if (m_startmaximized)
+ maximize_window();
else
- minimize_window(window);
- adjust_window_position_after_major_change(window);
+ minimize_window();
+ adjust_window_position_after_major_change();
// show the window
- if (!window->m_fullscreen || window->m_fullscreen_safe)
+ if (!m_fullscreen || m_fullscreen_safe)
{
// finish off by trying to initialize DirectX; if we fail, ignore it
- window->m_renderer = draw.create(window);
- if (window->m_renderer->create())
+ m_renderer = draw.create(this);
+ if (m_renderer->create())
return 1;
- ShowWindow(window->m_hwnd, SW_SHOW);
+ ShowWindow(m_hwnd, SW_SHOW);
}
// clear the window
- dc = GetDC(window->m_hwnd);
- GetClientRect(window->m_hwnd, &client);
+ dc = GetDC(m_hwnd);
+ GetClientRect(m_hwnd, &client);
FillRect(dc, &client, (HBRUSH)GetStockObject(BLACK_BRUSH));
- ReleaseDC(window->m_hwnd, dc);
+ ReleaseDC(m_hwnd, dc);
return 0;
}
@@ -1258,7 +1244,7 @@ LRESULT CALLBACK win_window_info::video_window_proc(HWND wnd, UINT message, WPAR
if (window != NULL)
{
assert(GetCurrentThreadId() == window_threadid);
- update_minmax_state(window);
+ window->update_minmax_state();
}
// handle a few messages
@@ -1360,7 +1346,7 @@ LRESULT CALLBACK win_window_info::video_window_proc(HWND wnd, UINT message, WPAR
{
RECT *rect = (RECT *)lparam;
if (video_config.keepaspect && !(GetAsyncKeyState(VK_CONTROL) & 0x8000))
- constrain_to_aspect_ratio(window, rect, wparam);
+ window->constrain_to_aspect_ratio(rect, wparam);
InvalidateRect(wnd, NULL, FALSE);
break;
}
@@ -1380,11 +1366,11 @@ LRESULT CALLBACK win_window_info::video_window_proc(HWND wnd, UINT message, WPAR
// handle maximize
if (cmd == SC_MAXIMIZE)
{
- update_minmax_state(window);
+ window->update_minmax_state();
if (window->m_ismaximized)
- minimize_window(window);
+ window->minimize_window();
else
- maximize_window(window);
+ window->maximize_window();
break;
}
return DefWindowProc(wnd, message, wparam, lparam);
@@ -1435,17 +1421,17 @@ LRESULT CALLBACK win_window_info::video_window_proc(HWND wnd, UINT message, WPAR
// fullscreen set
case WM_USER_SET_FULLSCREEN:
- set_fullscreen(window, wparam);
+ window->set_fullscreen(wparam);
break;
// minimum size set
case WM_USER_SET_MINSIZE:
- minimize_window(window);
+ window->minimize_window();
break;
// maximum size set
case WM_USER_SET_MAXSIZE:
- maximize_window(window);
+ window->maximize_window();
break;
// set focus: if we're not the primary window, switch back
@@ -1514,11 +1500,11 @@ void win_window_info::draw_video_contents(HDC dc, int update)
// (window thread)
//============================================================
-static void constrain_to_aspect_ratio(win_window_info *window, RECT *rect, int adjustment)
+void win_window_info::constrain_to_aspect_ratio(RECT *rect, int adjustment)
{
- win_monitor_info *monitor = window->winwindow_video_window_monitor(rect);
- INT32 extrawidth = wnd_extra_width(window);
- INT32 extraheight = wnd_extra_height(window);
+ win_monitor_info *monitor = winwindow_video_window_monitor(rect);
+ INT32 extrawidth = wnd_extra_width();
+ INT32 extraheight = wnd_extra_height();
INT32 propwidth, propheight;
INT32 minwidth, minheight;
INT32 maxwidth, maxheight;
@@ -1541,21 +1527,21 @@ static void constrain_to_aspect_ratio(win_window_info *window, RECT *rect, int a
{
case WMSZ_BOTTOM:
case WMSZ_TOP:
- window->m_target->compute_visible_area(10000, propheight, pixel_aspect, window->m_target->orientation(), propwidth, propheight);
+ m_target->compute_visible_area(10000, propheight, pixel_aspect, m_target->orientation(), propwidth, propheight);
break;
case WMSZ_LEFT:
case WMSZ_RIGHT:
- window->m_target->compute_visible_area(propwidth, 10000, pixel_aspect, window->m_target->orientation(), propwidth, propheight);
+ m_target->compute_visible_area(propwidth, 10000, pixel_aspect, m_target->orientation(), propwidth, propheight);
break;
default:
- window->m_target->compute_visible_area(propwidth, propheight, pixel_aspect, window->m_target->orientation(), propwidth, propheight);
+ m_target->compute_visible_area(propwidth, propheight, pixel_aspect, m_target->orientation(), propwidth, propheight);
break;
}
// get the minimum width/height for the current layout
- window->m_target->compute_minimum_size(minwidth, minheight);
+ m_target->compute_minimum_size(minwidth, minheight);
// clamp against the absolute minimum
propwidth = MAX(propwidth, MIN_WINDOW_DIM);
@@ -1566,7 +1552,7 @@ static void constrain_to_aspect_ratio(win_window_info *window, RECT *rect, int a
propheight = MAX(propheight, minheight);
// clamp against the maximum (fit on one screen for full screen mode)
- if (window->m_fullscreen)
+ if (m_fullscreen)
{
maxwidth = rect_width(&monitor->position_size()) - extrawidth;
maxheight = rect_height(&monitor->position_size()) - extraheight;
@@ -1577,10 +1563,10 @@ static void constrain_to_aspect_ratio(win_window_info *window, RECT *rect, int a
maxheight = rect_height(&monitor->usuable_position_size()) - extraheight;
// further clamp to the maximum width/height in the window
- if (window->m_win_config.width != 0)
- maxwidth = MIN(maxwidth, window->m_win_config.width + extrawidth);
- if (window->m_win_config.height != 0)
- maxheight = MIN(maxheight, window->m_win_config.height + extraheight);
+ if (m_win_config.width != 0)
+ maxwidth = MIN(maxwidth, m_win_config.width + extrawidth);
+ if (m_win_config.height != 0)
+ maxheight = MIN(maxheight, m_win_config.height + extraheight);
}
// clamp to the maximum
@@ -1588,7 +1574,7 @@ static void constrain_to_aspect_ratio(win_window_info *window, RECT *rect, int a
propheight = MIN(propheight, maxheight);
// compute the visible area based on the proposed rectangle
- window->m_target->compute_visible_area(propwidth, propheight, pixel_aspect, window->m_target->orientation(), viswidth, visheight);
+ 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(rect);
@@ -1630,14 +1616,14 @@ static void constrain_to_aspect_ratio(win_window_info *window, RECT *rect, int a
// (window thread)
//============================================================
-static void get_min_bounds(win_window_info *window, RECT *bounds, int constrain)
+void win_window_info::get_min_bounds(RECT *bounds, int constrain)
{
INT32 minwidth, minheight;
assert(GetCurrentThreadId() == window_threadid);
// get the minimum target size
- window->m_target->compute_minimum_size(minwidth, minheight);
+ m_target->compute_minimum_size(minwidth, minheight);
// expand to our minimum dimensions
if (minwidth < MIN_WINDOW_DIM)
@@ -1646,8 +1632,8 @@ static void get_min_bounds(win_window_info *window, RECT *bounds, int constrain)
minheight = MIN_WINDOW_DIM;
// account for extra window stuff
- minwidth += wnd_extra_width(window);
- minheight += wnd_extra_height(window);
+ minwidth += wnd_extra_width();
+ minheight += wnd_extra_height();
// if we want it constrained, figure out which one is larger
if (constrain)
@@ -1658,13 +1644,13 @@ static void get_min_bounds(win_window_info *window, RECT *bounds, int constrain)
test1.top = test1.left = 0;
test1.right = minwidth;
test1.bottom = 10000;
- constrain_to_aspect_ratio(window, &test1, WMSZ_BOTTOMRIGHT);
+ constrain_to_aspect_ratio(&test1, WMSZ_BOTTOMRIGHT);
// then constrain with no width limit
test2.top = test2.left = 0;
test2.right = 10000;
test2.bottom = minheight;
- constrain_to_aspect_ratio(window, &test2, WMSZ_BOTTOMRIGHT);
+ constrain_to_aspect_ratio(&test2, WMSZ_BOTTOMRIGHT);
// pick the larger
if (rect_width(&test1) > rect_width(&test2))
@@ -1680,7 +1666,7 @@ static void get_min_bounds(win_window_info *window, RECT *bounds, int constrain)
}
// get the window rect
- GetWindowRect(window->m_hwnd, bounds);
+ GetWindowRect(m_hwnd, bounds);
// now adjust
bounds->right = bounds->left + minwidth;
@@ -1694,41 +1680,41 @@ static void get_min_bounds(win_window_info *window, RECT *bounds, int constrain)
// (window thread)
//============================================================
-static void get_max_bounds(win_window_info *window, RECT *bounds, int constrain)
+void win_window_info::get_max_bounds(RECT *bounds, int constrain)
{
RECT maximum;
assert(GetCurrentThreadId() == window_threadid);
// compute the maximum client area
- window->m_monitor->refresh();
- maximum = window->m_monitor->usuable_position_size();
+ m_monitor->refresh();
+ maximum = m_monitor->usuable_position_size();
// clamp to the window's max
- if (window->m_win_config.width != 0)
+ if (m_win_config.width != 0)
{
- int temp = window->m_win_config.width + wnd_extra_width(window);
+ int temp = m_win_config.width + wnd_extra_width();
if (temp < rect_width(&maximum))
maximum.right = maximum.left + temp;
}
- if (window->m_win_config.height != 0)
+ if (m_win_config.height != 0)
{
- int temp = window->m_win_config.height + wnd_extra_height(window);
+ int temp = m_win_config.height + wnd_extra_height();
if (temp < rect_height(&maximum))
maximum.bottom = maximum.top + temp;
}
// constrain to fit
if (constrain)
- constrain_to_aspect_ratio(window, &maximum, WMSZ_BOTTOMRIGHT);
+ constrain_to_aspect_ratio(&maximum, WMSZ_BOTTOMRIGHT);
else
{
- maximum.right -= wnd_extra_width(window);
- maximum.bottom -= wnd_extra_height(window);
+ maximum.right -= wnd_extra_width();
+ maximum.bottom -= wnd_extra_height();
}
// center within the work area
- RECT work = window->m_monitor->usuable_position_size();
+ RECT work = m_monitor->usuable_position_size();
bounds->left = work.left + (rect_width(&work) - rect_width(&maximum)) / 2;
bounds->top = work.top + (rect_height(&work) - rect_height(&maximum)) / 2;
bounds->right = bounds->left + rect_width(&maximum);
@@ -1742,29 +1728,29 @@ static void get_max_bounds(win_window_info *window, RECT *bounds, int constrain)
// (window thread)
//============================================================
-static void update_minmax_state(win_window_info *window)
+void win_window_info::update_minmax_state()
{
assert(GetCurrentThreadId() == window_threadid);
- if (!window->m_fullscreen)
+ if (!m_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->m_hwnd, &bounds);
+ get_min_bounds(&minbounds, video_config.keepaspect);
+ get_max_bounds(&maxbounds, video_config.keepaspect);
+ GetWindowRect(m_hwnd, &bounds);
// if either the width or height matches, we were maximized
- window->m_isminimized = (rect_width(&bounds) == rect_width(&minbounds) ||
+ m_isminimized = (rect_width(&bounds) == rect_width(&minbounds) ||
rect_height(&bounds) == rect_height(&minbounds));
- window->m_ismaximized = (rect_width(&bounds) == rect_width(&maxbounds) ||
+ m_ismaximized = (rect_width(&bounds) == rect_width(&maxbounds) ||
rect_height(&bounds) == rect_height(&maxbounds));
}
else
{
- window->m_isminimized = FALSE;
- window->m_ismaximized = TRUE;
+ m_isminimized = FALSE;
+ m_ismaximized = TRUE;
}
}
@@ -1775,14 +1761,14 @@ static void update_minmax_state(win_window_info *window)
// (window thread)
//============================================================
-static void minimize_window(win_window_info *window)
+void win_window_info::minimize_window()
{
RECT newsize;
assert(GetCurrentThreadId() == window_threadid);
- get_min_bounds(window, &newsize, video_config.keepaspect);
- SetWindowPos(window->m_hwnd, NULL, newsize.left, newsize.top, rect_width(&newsize), rect_height(&newsize), SWP_NOZORDER);
+ get_min_bounds(&newsize, video_config.keepaspect);
+ SetWindowPos(m_hwnd, NULL, newsize.left, newsize.top, rect_width(&newsize), rect_height(&newsize), SWP_NOZORDER);
}
@@ -1792,14 +1778,14 @@ static void minimize_window(win_window_info *window)
// (window thread)
//============================================================
-static void maximize_window(win_window_info *window)
+void win_window_info::maximize_window()
{
RECT newsize;
assert(GetCurrentThreadId() == window_threadid);
- get_max_bounds(window, &newsize, video_config.keepaspect);
- SetWindowPos(window->m_hwnd, NULL, newsize.left, newsize.top, rect_width(&newsize), rect_height(&newsize), SWP_NOZORDER);
+ get_max_bounds(&newsize, video_config.keepaspect);
+ SetWindowPos(m_hwnd, NULL, newsize.left, newsize.top, rect_width(&newsize), rect_height(&newsize), SWP_NOZORDER);
}
@@ -1809,40 +1795,40 @@ static void maximize_window(win_window_info *window)
// (window thread)
//============================================================
-static void adjust_window_position_after_major_change(win_window_info *window)
+void win_window_info::adjust_window_position_after_major_change()
{
RECT oldrect, newrect;
assert(GetCurrentThreadId() == window_threadid);
// get the current size
- GetWindowRect(window->m_hwnd, &oldrect);
+ GetWindowRect(m_hwnd, &oldrect);
// adjust the window size so the client area is what we want
- if (!window->m_fullscreen)
+ if (!m_fullscreen)
{
// constrain the existing size to the aspect ratio
newrect = oldrect;
if (video_config.keepaspect)
- constrain_to_aspect_ratio(window, &newrect, WMSZ_BOTTOMRIGHT);
+ constrain_to_aspect_ratio(&newrect, WMSZ_BOTTOMRIGHT);
}
// in full screen, make sure it covers the primary display
else
{
- win_monitor_info *monitor = window->winwindow_video_window_monitor(NULL);
+ win_monitor_info *monitor = winwindow_video_window_monitor(NULL);
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(window->m_hwnd, window->m_fullscreen ? HWND_TOPMOST : HWND_TOP,
+ SetWindowPos(m_hwnd, m_fullscreen ? HWND_TOPMOST : HWND_TOP,
newrect.left, newrect.top,
rect_width(&newrect), rect_height(&newrect), 0);
// take note of physical window size (used for lightgun coordinate calculation)
- if (window == win_window_list)
+ if (this == win_window_list)
{
win_physical_width = rect_width(&newrect);
win_physical_height = rect_height(&newrect);
@@ -1856,48 +1842,48 @@ static void adjust_window_position_after_major_change(win_window_info *window)
// (window thread)
//============================================================
-static void set_fullscreen(win_window_info *window, int fullscreen)
+void win_window_info::set_fullscreen(int fullscreen)
{
assert(GetCurrentThreadId() == window_threadid);
// if we're in the right state, punt
- if (window->m_fullscreen == fullscreen)
+ if (m_fullscreen == fullscreen)
return;
- window->m_fullscreen = fullscreen;
+ m_fullscreen = fullscreen;
// kill off the drawers
- window->m_renderer->destroy();
- global_free(window->m_renderer);
- window->m_renderer = NULL;
+ m_renderer->destroy();
+ global_free(m_renderer);
+ m_renderer = NULL;
// hide ourself
- ShowWindow(window->m_hwnd, SW_HIDE);
+ ShowWindow(m_hwnd, SW_HIDE);
// configure the window if non-fullscreen
if (!fullscreen)
{
// adjust the style
- SetWindowLong(window->m_hwnd, GWL_STYLE, WINDOW_STYLE);
- SetWindowLong(window->m_hwnd, GWL_EXSTYLE, WINDOW_STYLE_EX);
- SetWindowPos(window->m_hwnd, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
+ SetWindowLong(m_hwnd, GWL_STYLE, WINDOW_STYLE);
+ SetWindowLong(m_hwnd, GWL_EXSTYLE, WINDOW_STYLE_EX);
+ SetWindowPos(m_hwnd, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
// force to the bottom, then back on top
- SetWindowPos(window->m_hwnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
- SetWindowPos(window->m_hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+ SetWindowPos(m_hwnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+ SetWindowPos(m_hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
// if we have previous non-fullscreen bounds, use those
- if (window->m_non_fullscreen_bounds.right != window->m_non_fullscreen_bounds.left)
+ if (m_non_fullscreen_bounds.right != m_non_fullscreen_bounds.left)
{
- SetWindowPos(window->m_hwnd, HWND_TOP, window->m_non_fullscreen_bounds.left, window->m_non_fullscreen_bounds.top,
- rect_width(&window->m_non_fullscreen_bounds), rect_height(&window->m_non_fullscreen_bounds),
+ SetWindowPos(m_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(window->m_hwnd, HWND_TOP, 0, 0, MIN_WINDOW_DIM, MIN_WINDOW_DIM, SWP_NOZORDER);
- maximize_window(window);
+ SetWindowPos(m_hwnd, HWND_TOP, 0, 0, MIN_WINDOW_DIM, MIN_WINDOW_DIM, SWP_NOZORDER);
+ maximize_window();
}
}
@@ -1905,32 +1891,32 @@ static void set_fullscreen(win_window_info *window, int fullscreen)
else
{
// save the bounds
- GetWindowRect(window->m_hwnd, &window->m_non_fullscreen_bounds);
+ GetWindowRect(m_hwnd, &m_non_fullscreen_bounds);
// adjust the style
- SetWindowLong(window->m_hwnd, GWL_STYLE, FULLSCREEN_STYLE);
- SetWindowLong(window->m_hwnd, GWL_EXSTYLE, FULLSCREEN_STYLE_EX);
- SetWindowPos(window->m_hwnd, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
+ SetWindowLong(m_hwnd, GWL_STYLE, FULLSCREEN_STYLE);
+ SetWindowLong(m_hwnd, GWL_EXSTYLE, FULLSCREEN_STYLE_EX);
+ SetWindowPos(m_hwnd, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
// set topmost
- SetWindowPos(window->m_hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+ SetWindowPos(m_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(window);
+ adjust_window_position_after_major_change();
// show ourself
- if (!window->m_fullscreen || window->m_fullscreen_safe)
+ if (!m_fullscreen || m_fullscreen_safe)
{
if (video_config.mode != VIDEO_MODE_NONE)
- ShowWindow(window->m_hwnd, SW_SHOW);
- window->m_renderer = draw.create(window);
- if (window->m_renderer->create())
+ ShowWindow(m_hwnd, SW_SHOW);
+ m_renderer = draw.create(this);
+ if (m_renderer->create())
exit(1);
}
// ensure we're still adjusted correctly
- adjust_window_position_after_major_change(window);
+ adjust_window_position_after_major_change();
}
#if (USE_QTDEBUG)
diff --git a/src/osd/windows/window.h b/src/osd/windows/window.h
index d1486f755c5..6a32a8e4167 100644
--- a/src/osd/windows/window.h
+++ b/src/osd/windows/window.h
@@ -63,9 +63,16 @@ public:
win_monitor_info *monitor() const { return m_monitor; }
+ void destroy();
+
+ // static
+
+ static void create(running_machine &machine, int index, win_monitor_info *monitor, const osd_window_config *config);
+
// static callbacks
static LRESULT CALLBACK video_window_proc(HWND wnd, UINT message, WPARAM wparam, LPARAM lparam);
+ static unsigned __stdcall thread_entry(void *param);
// member variables
@@ -102,6 +109,18 @@ public:
private:
void draw_video_contents(HDC dc, int update);
+ void set_starting_view(int index, const char *view);
+ int wnd_extra_width();
+ int wnd_extra_height();
+ int complete_create();
+ void constrain_to_aspect_ratio(RECT *rect, int adjustment);
+ void get_min_bounds(RECT *bounds, int constrain);
+ void get_max_bounds(RECT *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);
running_machine & m_machine;
};
@@ -125,9 +144,6 @@ extern win_window_info *win_window_list;
// PROTOTYPES
//============================================================
-// creation/deletion of windows
-void winwindow_video_window_create(running_machine &machine, int index, win_monitor_info *monitor, const osd_window_config *config);
-
BOOL winwindow_has_focus(void);
void winwindow_update_cursor_state(running_machine &machine);