Introduced osd_rect and osd_dim to allow for more code alignment. (nw)

src/osd/modules/osdwindow.h

@@ -51,7 +51,7 @@ public:
 
 	float aspect() const { return monitor()->aspect(); }
 
-	virtual void get_size(int &w, int &h) = 0;
+	virtual osd_dim get_size() = 0;
 
 #ifdef OSD_SDL
 	virtual void blit_surface_size(int &blitwidth, int &blitheight) = 0;
@@ -65,7 +65,7 @@ public:
 	virtual win_monitor_info *monitor() const = 0;
 	virtual bool win_has_menu() = 0;
 	// FIXME: cann we replace winwindow_video_window_monitor(NULL) with monitor() ?
-	virtual win_monitor_info *winwindow_video_window_monitor(const RECT *proposed) = 0;
+	virtual win_monitor_info *winwindow_video_window_monitor(const osd_rect *proposed) = 0;
 
 	// window handle and info
 	HWND                    m_hwnd;

src/osd/sdl/draw13.c

@@ -688,14 +688,13 @@ int sdl_info13::draw(int update)
 		return 0;
 	}
 
-	int width = 0; int height = 0;
+	osd_dim wdim = window().get_size();
-	window().get_size(width,height);
 
-	if (has_flags(FI_CHANGED) || (width != m_width) || (height != m_height))
+	if (has_flags(FI_CHANGED) || (wdim.width() != m_width) || (wdim.height() != m_height))
 	{
 		destroy_all_textures();
-		m_width = width;
+		m_width = wdim.width();
-		m_height = height;
+		m_height = wdim.height();
 		SDL_RenderSetViewport(m_sdl_renderer, NULL);
 		m_blittimer = 3;
 		clear_flags(FI_CHANGED);
@@ -720,8 +719,8 @@ int sdl_info13::draw(int update)
 	{
 		int ch, cw;
 
-		ch = height;
+		ch = wdim.height();
-		cw = width;
+		cw = wdim.width();
 
 		if (video_config.centerv)
 		{

src/osd/sdl/drawogl.c

@@ -1479,7 +1479,6 @@ int sdl_info_ogl::draw(const int update)
 	texture_info *texture=NULL;
 	float vofs, hofs;
 	int  pendingPrimitive=GL_NO_PRIMITIVE, curPrimitive=GL_NO_PRIMITIVE;
-	int width = 0; int height = 0;
 
 #ifdef TOBEMIGRATED
 	if (video_config.novideo)
@@ -1488,13 +1487,13 @@ int sdl_info_ogl::draw(const int update)
 	}
 #endif
 
-	window().get_size(width, height);
+	osd_dim wdim = window().get_size();
 
-	if (has_flags(FI_CHANGED) || (width != m_width) || (height != m_height))
+	if (has_flags(FI_CHANGED) || (wdim.width() != m_width) || (wdim.height() != m_height))
 	{
 		destroy_all_textures();
-		m_width = width;
+		m_width = wdim.width();
-		m_height = height;
+		m_height = wdim.height();
 		m_blittimer = 3;
 		m_init_context = 1;
 		clear_flags(FI_CHANGED);

src/osd/sdl/drawsdl.c

@@ -559,7 +559,6 @@ int sdl_info::draw(int update)
 	UINT8 *surfptr;
 	INT32 pitch;
 	Uint32 rmask, gmask, bmask;
-	int width = 0; int height = 0;
 #if (SDLMAME_SDL2)
 	Uint32 amask;
 #endif
@@ -571,14 +570,14 @@ int sdl_info::draw(int update)
 		return 0;
 	}
 
-	window().get_size(width, height);
+	osd_dim wdim = window().get_size();
-	if (has_flags(FI_CHANGED) || (width != m_last_width) || (height != m_last_height))
+	if (has_flags(FI_CHANGED) || (wdim.width() != m_last_width) || (wdim.height() != m_last_height))
 	{
 		destroy_all_textures();
 		clear_flags(FI_CHANGED);
 		m_blittimer = 3;
-		m_last_width = width;
+		m_last_width = wdim.width();
-		m_last_height = height;
+		m_last_height = wdim.height();
 #if (SDLMAME_SDL2)
 		SDL_RenderSetViewport(m_sdl_renderer, NULL);
 		if (m_texture_id != NULL)
@@ -619,7 +618,7 @@ int sdl_info::draw(int update)
 	// Clear if necessary
 	if (m_blittimer > 0)
 	{
-		memset(window().sdl_surface()->pixels, 0, height * window().sdl_surface()->pitch);
+		memset(window().sdl_surface()->pixels, 0, wdim.height() * window().sdl_surface()->pitch);
 		m_blittimer--;
 	}
 
@@ -669,8 +668,8 @@ int sdl_info::draw(int update)
 	blitwidth = m_blitwidth;
 	blitheight = m_blitheight;
 
-	ch = height;
+	ch = wdim.height();
-	cw = width;
+	cw = wdim.width();
 
 	// do not crash if the window's smaller than the blit area
 	if (blitheight > ch)

src/osd/sdl/video.h

@@ -59,6 +59,56 @@ struct sdl_mode
 	int                 height;
 };
 
+class osd_dim
+{
+public:
+	osd_dim(const int &w, const int &h)
+	: m_w(w), m_h(h)
+	{
+	}
+	int width() const { return m_w; }
+	int height() const { return m_h; }
+
+private:
+	int m_w;
+	int m_h;
+};
+
+class osd_rect
+{
+public:
+	osd_rect(const int x, const int y, const int &w, const int &h)
+	: m_x(x), m_y(y), m_d(w,h)
+	{
+	}
+	osd_rect(const int x, const int y, const osd_dim &d)
+	: m_x(x), m_y(y), m_d(d)
+	{
+	}
+	int top() const { return m_y; }
+	int left() const { return m_x; }
+	int width() const { return m_d.width(); }
+	int height() const { return m_d.height(); }
+
+	osd_dim dim() const { return m_d; }
+
+	int bottom() const { return m_y + m_d.height(); }
+	int right() const { return m_x + m_d.width(); }
+
+	osd_rect move_by(int dx, int dy) const { return osd_rect(m_x + dx, m_y + dy, m_d); }
+	osd_rect resize(int w, int h) const { return osd_rect(m_x, m_y, w, h); }
+
+private:
+	int m_x;
+	int m_y;
+	osd_dim m_d;
+};
+
+inline osd_rect SDL_Rect_to_osd_rect(const SDL_Rect &r)
+{
+	return osd_rect(r.x, r.y, r.w, r.h);
+}
+
 // FIXME: This is sort of ugly ... and should be a real interface only
 class sdl_monitor_info
 {
@@ -75,7 +125,7 @@ public:
 	}
 
 	const UINT64 handle() { return m_handle; }
-	const SDL_Rect &position_size() { refresh(); return m_dimensions; }
+	const osd_rect position_size() { refresh(); return SDL_Rect_to_osd_rect(m_dimensions); }
 
 	const char *devicename() { refresh(); return m_name[0] ? m_name : "UNKNOWN"; }
 

src/osd/sdl/window.c

@@ -384,14 +384,13 @@ INLINE int better_mode(int width0, int height0, int width1, int height1, float d
 
 void sdl_window_info::blit_surface_size(int &blitwidth, int &blitheight)
 {
-	int window_width, window_height;
+	osd_dim window_dim = get_size();
-	get_size(window_width, window_height);
 
-	INT32 newwidth, newheight;
+	int newwidth, newheight;
 	int xscale = 1, yscale = 1;
 	float desired_aspect = 1.0f;
-	INT32 target_width = window_width;
+	INT32 target_width = window_dim.width();
-	INT32 target_height = window_height;
+	INT32 target_height = window_dim.height();
 
 	// start with the minimum size
 	m_target->compute_minimum_size(newwidth, newheight);
@@ -415,17 +414,17 @@ void sdl_window_info::blit_surface_size(int &blitwidth, int &blitheight)
 		if (video_config.keepaspect)
 		{
 			// if we could stretch more in the X direction, and that makes a better fit, bump the xscale
-			while (newwidth * (xscale + 1) <= window_width &&
+			while (newwidth * (xscale + 1) <= window_dim.width() &&
 				better_mode(newwidth * xscale, newheight * yscale, newwidth * (xscale + 1), newheight * yscale, desired_aspect))
 				xscale++;
 
 			// if we could stretch more in the Y direction, and that makes a better fit, bump the yscale
-			while (newheight * (yscale + 1) <= window_height &&
+			while (newheight * (yscale + 1) <= window_dim.height() &&
 				better_mode(newwidth * xscale, newheight * yscale, newwidth * xscale, newheight * (yscale + 1), desired_aspect))
 				yscale++;
 
 			// now that we've maxed out, see if backing off the maximally stretched one makes a better fit
-			if (window_width - newwidth * xscale < window_height - newheight * yscale)
+			if (window_dim.width() - newwidth * xscale < window_dim.height() - newheight * yscale)
 			{
 				while (better_mode(newwidth * xscale, newheight * yscale, newwidth * (xscale - 1), newheight * yscale, desired_aspect) && (xscale >= 0))
 					xscale--;
@@ -454,13 +453,8 @@ void sdl_window_info::blit_surface_size(int &blitwidth, int &blitheight)
 	//FIXME: really necessary to distinguish for yuv_modes ?
 	if (m_target->zoom_to_screen()
 		&& (video_config.scale_mode == VIDEO_SCALE_MODE_NONE ))
-		newwidth = window_width;
+		newwidth = window_dim.width();
 
-#if 0
-	// Fixme: notify_changed really necessary ?
-	if ((blitwidth != newwidth) || (blitheight != newheight))
-		notify_changed();
-#endif
 	blitwidth = newwidth;
 	blitheight = newheight;
 }
@@ -498,10 +492,9 @@ void sdl_window_info::resize(INT32 width, INT32 height)
 {
 	ASSERT_MAIN_THREAD();
 
-	int cw=0; int ch=0;
+	osd_dim cd = get_size();
-	get_size(cw, ch);
 
-	if (width != cw || height != ch)
+	if (width != cd.width() || height != cd.height())
 		execute_async_wait(&sdlwindow_resize_wt, worker_param(this, width, height));
 }
 
@@ -555,7 +548,7 @@ OSDWORK_CALLBACK( sdl_window_info::sdlwindow_toggle_full_screen_wt )
 	// If we are going fullscreen (leaving windowed) remember our windowed size
 	if (!window->fullscreen())
 	{
-		window->get_size(window->m_windowed_width, window->m_windowed_height);
+		window->m_windowed_dim = window->get_size();
 	}
 
 	window->renderer().destroy();
@@ -853,7 +846,7 @@ void sdl_window_info::destroy()
 //============================================================
 
 #if SDLMAME_SDL2
-void sdl_window_info::pick_best_mode(int *fswidth, int *fsheight)
+osd_dim sdl_window_info::pick_best_mode()
 {
 	int minimum_width, minimum_height, target_width, target_height;
 	int i;
@@ -912,15 +905,15 @@ void sdl_window_info::pick_best_mode(int *fswidth, int *fsheight)
 			if (size_score > best_score)
 			{
 				best_score = size_score;
-				*fswidth = mode.w;
+				return osd_dim(mode.w, mode.h);
-				*fsheight = mode.h;
 			}
 
 		}
 	}
+	return osd_dim(0,0); // please compiler
 }
 #else
-void sdl_window_info::pick_best_mode(int *fswidth, int *fsheight)
+osd_dim sdl_window_info::pick_best_mode()
 {
 	int minimum_width, minimum_height, target_width, target_height;
 	int i;
@@ -958,8 +951,7 @@ void sdl_window_info::pick_best_mode(int *fswidth, int *fsheight)
 	}
 	else if (modes == (SDL_Rect **)-1)  // all modes are possible
 	{
-		*fswidth = m_win_config.width;
+		return osd_dim(m_win_config.width, m_win_config.height);
-		*fsheight = m_win_config.height;
 	}
 	else
 	{
@@ -986,12 +978,12 @@ void sdl_window_info::pick_best_mode(int *fswidth, int *fsheight)
 			if (size_score > best_score)
 			{
 				best_score = size_score;
-				*fswidth = modes[i]->w;
+				return osd_dim(modes[i]->w, modes[i]->h);
-				*fsheight = modes[i]->h;
 			}
 
 		}
 	}
+	return osd_dim(0,0);
 }
 #endif
 
@@ -1029,8 +1021,8 @@ void sdl_window_info::update()
 			}
 			else if (video_config.switchres)
 			{
-				this->pick_best_mode(&tempwidth, &tempheight);
+				osd_dim tmp = this->pick_best_mode();
-				resize(tempwidth, tempheight);
+				resize(tmp.width(), tmp.height());
 			}
 		}
 
@@ -1086,7 +1078,7 @@ OSDWORK_CALLBACK( sdl_window_info::complete_create_wt )
 	worker_param *      wp = (worker_param *) param;
 	sdl_window_info *   window = wp->window();
 
-	int tempwidth, tempheight;
+	osd_dim temp(0,0);
 	static int result[2] = {0,1};
 
 	ASSERT_WINDOW_THREAD();
@@ -1095,36 +1087,35 @@ OSDWORK_CALLBACK( sdl_window_info::complete_create_wt )
 	if (window->fullscreen())
 	{
 		// default to the current mode exactly
-		tempwidth = window->monitor()->position_size().w;
+		temp = window->monitor()->position_size().dim();
-		tempheight = window->monitor()->position_size().h;
 
 		// if we're allowed to switch resolutions, override with something better
 		if (video_config.switchres)
-			window->pick_best_mode(&tempwidth, &tempheight);
+			temp = window->pick_best_mode();
 	}
-	else if (window->m_windowed_width)
+	else if (window->m_windowed_dim.width() > 0)
 	{
 		// if we have a remembered size force the new window size to it
-		tempwidth = window->m_windowed_width;
+		temp = window->m_windowed_dim;
-		tempheight = window->m_windowed_height;
 	}
 	else
 	{
 		if (window->m_startmaximized)
 		{
-			tempwidth = tempheight = 0;
+			temp = window->get_max_bounds(video_config.keepaspect );
-			window->get_max_bounds(&tempwidth, &tempheight, video_config.keepaspect );
 		}
 		else
 		{
+#if 0
+			// Couriersud: This code never has worked with the last version of get_min_bounds
 			/* 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->m_win_config.width != 0) ? window->m_win_config.width : 640;
 			tempheight = (window->m_win_config.height != 0) ? window->m_win_config.height : 480;
-
+#endif
-			window->get_min_bounds(&tempwidth, &tempheight, video_config.keepaspect );
+			temp = window->get_min_bounds(video_config.keepaspect );
 		}
 	}
 
@@ -1166,8 +1157,8 @@ OSDWORK_CALLBACK( sdl_window_info::complete_create_wt )
 #endif
 	// create the SDL window
 	window->m_sdl_window = SDL_CreateWindow(window->m_title,
-			window->monitor()->position_size().x, window->monitor()->position_size().y,
+			window->monitor()->position_size().left(), window->monitor()->position_size().top(),
-			tempwidth, tempheight, window->m_extra_flags);
+			temp.width(), temp.height(), window->m_extra_flags);
 	//window().sdl_window() = SDL_CreateWindow(window().m_title, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
 	//      width, height, m_extra_flags);
 
@@ -1186,8 +1177,8 @@ OSDWORK_CALLBACK( sdl_window_info::complete_create_wt )
 		//SDL_GetCurrentDisplayMode(window().monitor()->handle, &mode);
 		SDL_GetWindowDisplayMode(window->sdl_window(), &mode);
 		window->m_original_mode = mode;
-		mode.w = tempwidth;
+		mode.w = temp.width();
-		mode.h = tempheight;
+		mode.h = temp.height();
 		if (window->m_win_config.refresh)
 			mode.refresh_rate = window->m_win_config.refresh;
 
@@ -1241,7 +1232,7 @@ OSDWORK_CALLBACK( sdl_window_info::complete_create_wt )
 	if (!window->m_sdlsurf)
 		printf("completely failed\n");
 #endif
-	window->m_sdlsurf = SDL_SetVideoMode(tempwidth, tempheight,
+	window->m_sdlsurf = SDL_SetVideoMode(temp.width(), temp.height(),
 							0, SDL_SWSURFACE  | SDL_ANYFORMAT | window->m_extra_flags);
 
 	if (!window->m_sdlsurf)
@@ -1377,28 +1368,39 @@ OSDWORK_CALLBACK( sdl_window_info::draw_video_contents_wt )
 	return NULL;
 }
 
+int sdl_window_info::wnd_extra_width()
+{
+	return m_fullscreen ? 0 : WINDOW_DECORATION_WIDTH;
+}
+
+int sdl_window_info::wnd_extra_height()
+{
+	return m_fullscreen ? 0 : WINDOW_DECORATION_HEIGHT;
+}
+
 
 //============================================================
 //  constrain_to_aspect_ratio
 //  (window thread)
 //============================================================
 
-void sdl_window_info::constrain_to_aspect_ratio(int *window_width, int *window_height, int adjustment)
+osd_rect sdl_window_info::constrain_to_aspect_ratio(const osd_rect &rect, int adjustment)
 {
-	INT32 extrawidth = 0;
+	INT32 extrawidth = wnd_extra_width();
-	INT32 extraheight = 0;
+	INT32 extraheight = wnd_extra_height();
 	INT32 propwidth, propheight;
 	INT32 minwidth, minheight;
 	INT32 maxwidth, maxheight;
 	INT32 viswidth, visheight;
+	INT32 adjwidth, adjheight;
 	float pixel_aspect;
 
 	// get the pixel aspect ratio for the target monitor
 	pixel_aspect = m_monitor->aspect();
 
 	// determine the proposed width/height
-	propwidth = *window_width - extrawidth;
+	propwidth = rect.width() - extrawidth;
-	propheight = *window_height - extraheight;
+	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
@@ -1431,19 +1433,21 @@ void sdl_window_info::constrain_to_aspect_ratio(int *window_width, int *window_h
 	propheight = MAX(propheight, minheight);
 
 	// clamp against the maximum (fit on one screen for full screen mode)
-	maxwidth = m_monitor->position_size().w - extrawidth;
+	if (m_fullscreen)
-	maxheight = m_monitor->position_size().h - extraheight;
-	if (this->m_fullscreen)
 	{
-		// nothing
+		maxwidth = m_monitor->position_size().width() - extrawidth;
+		maxheight = m_monitor->position_size().height() - extraheight;
 	}
 	else
 	{
+		maxwidth = m_monitor->position_size().width() - extrawidth;
+		maxheight = m_monitor->position_size().height() - extraheight;
+
 		// further clamp to the maximum width/height in the window
-		if (this->m_win_config.width != 0)
+		if (m_win_config.width != 0)
-			maxwidth = MIN(maxwidth, this->m_win_config.width + extrawidth);
+			maxwidth = MIN(maxwidth, m_win_config.width + extrawidth);
-		if (this->m_win_config.height != 0)
+		if (m_win_config.height != 0)
-			maxheight = MIN(maxheight, this->m_win_config.height + extraheight);
+			maxheight = MIN(maxheight, m_win_config.height + extraheight);
 	}
 
 	// clamp to the maximum
@@ -1453,9 +1457,38 @@ void sdl_window_info::constrain_to_aspect_ratio(int *window_width, int *window_h
 	// compute the visible area based on the proposed rectangle
 	m_target->compute_visible_area(propwidth, propheight, pixel_aspect, m_target->orientation(), viswidth, visheight);
 
-	*window_width = viswidth;
+	// compute the adjustments we need to make
-	*window_height = visheight;
+	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(), rect.height() + adjheight);
+			break;
+
+		case WMSZ_LEFT:
+		case WMSZ_TOPLEFT:
+		case WMSZ_TOP:
+			ret = rect.move_by(-adjwidth, -adjheight);
+			break;
+
+		case WMSZ_TOPRIGHT:
+			ret = rect.move_by(0, -adjheight).resize(rect.width() + adjwidth, rect.height());
+			break;
 }
+	return ret;
+}
+
 
 
 //============================================================
@@ -1463,12 +1496,12 @@ void sdl_window_info::constrain_to_aspect_ratio(int *window_width, int *window_h
 //  (window thread)
 //============================================================
 
-void sdl_window_info::get_min_bounds(int *window_width, int *window_height, int constrain)
+osd_dim sdl_window_info::get_min_bounds(int constrain)
 {
 	INT32 minwidth, minheight;
 
 	// get the minimum target size
-	this->m_target->compute_minimum_size(minwidth, minheight);
+	m_target->compute_minimum_size(minwidth, minheight);
 
 	// expand to our minimum dimensions
 	if (minwidth < MIN_WINDOW_DIM)
@@ -1476,73 +1509,74 @@ void sdl_window_info::get_min_bounds(int *window_width, int *window_height, int
 	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)
 	{
-		int test1w, test1h;
-		int test2w, test2h;
-
 		// first constrain with no height limit
-		test1w = minwidth; test1h = 10000;
+		osd_rect test1(0,0,minwidth,10000);
-		this->constrain_to_aspect_ratio(&test1w, &test1h, WMSZ_BOTTOMRIGHT);
+		test1 = constrain_to_aspect_ratio(test1, WMSZ_BOTTOMRIGHT);
 
 		// then constrain with no width limit
-		test2w = 10000; test2h = minheight;
+		osd_rect test2(0,0,10000,minheight);
-		this->constrain_to_aspect_ratio(&test2w, &test2h, WMSZ_BOTTOMRIGHT);
+		test2 = constrain_to_aspect_ratio(test2, WMSZ_BOTTOMRIGHT);
 
 		// pick the larger
-		if ( test1w > test2w )
+		if (test1.width() > test2.width())
 		{
-			minwidth = test1w;
+			minwidth = test1.width();
-			minheight = test1h;
+			minheight = test1.height();
 		}
 		else
 		{
-			minwidth = test2w;
+			minwidth = test2.width();
-			minheight = test2h;
+			minheight = test2.height();
 		}
 	}
 
-	*window_width = minwidth;
+	return osd_dim(minwidth, minheight);
-	*window_height = minheight;
 }
 
 
+
 //============================================================
 //  get_max_bounds
 //  (window thread)
 //============================================================
 
-void sdl_window_info::get_max_bounds(int *window_width, int *window_height, int constrain)
+osd_dim sdl_window_info::get_max_bounds(int constrain)
 {
-	INT32 maxwidth, maxheight;
-
 	// compute the maximum client area
-	maxwidth = m_monitor->position_size().w;
+
-	maxheight = m_monitor->position_size().h;
+	osd_rect maximum = m_monitor->position_size();
 
 	// clamp to the window's max
-	if (this->m_win_config.width != 0)
+	int tempw = maximum.width();
+	int temph = maximum.height();
+	if (m_win_config.width != 0)
 	{
-		int temp = this->m_win_config.width + WINDOW_DECORATION_WIDTH;
+		int temp = m_win_config.width + wnd_extra_width();
-		if (temp < maxwidth)
+		if (temp < maximum.width())
-			maxwidth = temp;
+			tempw = temp;
 	}
-	if (this->m_win_config.height != 0)
+	if (m_win_config.height != 0)
 	{
-		int temp = this->m_win_config.height + WINDOW_DECORATION_HEIGHT;
+		int temp = m_win_config.height + wnd_extra_height();
-		if (temp < maxheight)
+		if (temp < maximum.height())
-			maxheight = temp;
+			temph = temp;
 	}
 
+	maximum = maximum.resize(tempw, temph);
+
 	// constrain to fit
 	if (constrain)
-		this->constrain_to_aspect_ratio(&maxwidth, &maxheight, WMSZ_BOTTOMRIGHT);
+		maximum = constrain_to_aspect_ratio(maximum, WMSZ_BOTTOMRIGHT);
-	//else
+	else
 	{
-		maxwidth -= WINDOW_DECORATION_WIDTH;
+		maximum = maximum.resize(maximum.width() - wnd_extra_width(), maximum.height() - wnd_extra_height());
-		maxheight -= WINDOW_DECORATION_HEIGHT;
-		*window_width = maxwidth;
-		*window_height = maxheight;
 	}
+	return maximum.dim();
 }

src/osd/sdl/window.h

@@ -44,7 +44,8 @@ public:
 		m_resize_height(0),
 		m_last_resize(0),
 #endif
-			m_minwidth(0), m_minheight(0),
+		m_minwidth(0), m_minheight(0),
+		m_windowed_dim(0,0),
 		m_rendered_event(0), m_target(0),
 #if (SDLMAME_SDL2)
 		m_sdl_window(NULL),
@@ -61,8 +62,7 @@ public:
 		m_fullscreen = !video_config.windowed;
 		m_prescale = video_config.prescale;
 
-		m_windowed_width = config->width;
+		m_windowed_dim = osd_dim(config->width, config->height);
-		m_windowed_height = config->height;
 	}
 
 	~sdl_window_info()
@@ -80,12 +80,14 @@ public:
 
 	void notify_changed();
 
-	void get_size(int &w, int &h)
+	osd_dim get_size()
 	{
 #if (SDLMAME_SDL2)
+		int w=0; int h=0;
 		SDL_GetWindowSize(m_sdl_window, &w, &h);
+		return osd_dim(w,h);
 #else
-		w = m_sdlsurf->w; h = m_sdlsurf->h;
+		return osd_dim(m_sdlsurf->w, m_sdlsurf->h);
 #endif
 	}
 
@@ -122,8 +124,7 @@ private:
 
 	// diverse flags
 	int                 m_minwidth, m_minheight;
-	int                 m_windowed_width;
+	osd_dim             m_windowed_dim;
-	int                 m_windowed_height;
 
 	// rendering info
 	osd_event *         m_rendered_event;
@@ -150,12 +151,14 @@ private:
 protected:
 	osd_renderer &renderer() { return *m_renderer; }
 private:
-	void constrain_to_aspect_ratio(int *window_width, int *window_height, int adjustment);
+	int wnd_extra_width();
-	void update_cursor_state();
+	int wnd_extra_height();
-	void pick_best_mode(int *fswidth, int *fsheight);
 	void set_starting_view(running_machine &machine, int index, const char *defview, const char *view);
-	void get_min_bounds(int *window_width, int *window_height, int constrain);
+	osd_rect constrain_to_aspect_ratio(const osd_rect &rect, int adjustment);
-	void get_max_bounds(int *window_width, int *window_height, int constrain);
+	osd_dim get_min_bounds(int constrain);
+	osd_dim get_max_bounds(int constrain);
+	void update_cursor_state();
+	osd_dim pick_best_mode();
 	void set_fullscreen(int afullscreen) { m_fullscreen = afullscreen; }
 
 	// Pointer to machine

src/osd/windows/drawdd.c

@@ -964,11 +964,11 @@ void renderer_dd::blit_to_primary(int srcwidth, int srcheight)
 		ClientToScreen(window().m_hwnd, &((LPPOINT)&outer)[1]);
 
 		// adjust to be relative to the monitor
-		RECT pos = monitor->position_size();
+		osd_rect pos = monitor->position_size();
-		outer.left -= pos.left;
+		outer.left -= pos.left();
-		outer.right -= pos.left;
+		outer.right -= pos.left();
-		outer.top -= pos.top;
+		outer.top -= pos.top();
-		outer.bottom -= pos.top;
+		outer.bottom -= pos.top();
 	}
 
 	// compute outer rect -- full screen version

src/osd/windows/video.h

@@ -35,6 +35,56 @@ enum {
 //  TYPE DEFINITIONS
 //============================================================
 
+class osd_dim
+{
+public:
+	osd_dim(const int &w, const int &h)
+	: m_w(w), m_h(h)
+	{
+	}
+	int width() const { return m_w; }
+	int height() const { return m_h; }
+
+private:
+	int m_w;
+	int m_h;
+};
+
+class osd_rect
+{
+public:
+	osd_rect(const int x, const int y, const int &w, const int &h)
+	: m_x(x), m_y(y), m_d(w,h)
+	{
+	}
+	osd_rect(const int x, const int y, const osd_dim &d)
+	: m_x(x), m_y(y), m_d(d)
+	{
+	}
+	int top() const { return m_y; }
+	int left() const { return m_x; }
+	int width() const { return m_d.width(); }
+	int height() const { return m_d.height(); }
+
+	osd_dim dim() const { return m_d; }
+
+	int bottom() const { return m_y + m_d.height(); }
+	int right() const { return m_x + m_d.width(); }
+
+	osd_rect move_by(int dx, int dy) const { return osd_rect(m_x + dx, m_y + dy, m_d); }
+	osd_rect resize(int w, int h) const { return osd_rect(m_x, m_y, w, h); }
+
+private:
+	int m_x;
+	int m_y;
+	osd_dim m_d;
+};
+
+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);
+}
+
 class win_monitor_info
 {
 public:
@@ -44,8 +94,9 @@ public:
 	void refresh();
 
 	const HMONITOR handle() { return m_handle; }
-	const RECT &position_size() { refresh(); return m_info.rcMonitor; }
+	// position_size is used only by draw_dd renderer
-	const RECT &usuable_position_size() { refresh(); return m_info.rcWork; }
+	const osd_rect position_size() { refresh(); return RECT_to_osd_rect(m_info.rcMonitor); }
+	const osd_rect usuable_position_size() { refresh(); return RECT_to_osd_rect(m_info.rcWork); }
 	bool is_primary() { return (m_info.dwFlags & MONITORINFOF_PRIMARY) != 0; }
 	const char *devicename() { refresh(); return (m_name != NULL) ? m_name : "UNKNOWN"; }
 

src/osd/windows/window.c

@@ -831,7 +831,7 @@ void win_window_info::update()
 //  (window thread)
 //============================================================
 
-win_monitor_info *win_window_info::winwindow_video_window_monitor(const RECT *proposed)
+win_monitor_info *win_window_info::winwindow_video_window_monitor(const osd_rect *proposed)
 {
 	win_monitor_info *monitor;
 
@@ -839,7 +839,14 @@ win_monitor_info *win_window_info::winwindow_video_window_monitor(const RECT *pr
 	if (!m_fullscreen)
 	{
 		if (proposed != NULL)
-			monitor = winvideo_monitor_from_handle(MonitorFromRect(proposed, MONITOR_DEFAULTTONEAREST));
+		{
+			RECT p;
+			p.top = proposed->top();
+			p.left = proposed->left();
+			p.bottom = proposed->bottom();
+			p.right = proposed->right();
+			monitor = winvideo_monitor_from_handle(MonitorFromRect(&p, MONITOR_DEFAULTTONEAREST));
+		}
 		else
 			monitor = winvideo_monitor_from_handle(MonitorFromWindow(m_hwnd, MONITOR_DEFAULTTONEAREST));
 	}
@@ -1153,7 +1160,7 @@ unsigned __stdcall win_window_info::thread_entry(void *param)
 
 int win_window_info::complete_create()
 {
-	RECT monitorbounds, client;
+	RECT client;
 	int tempwidth, tempheight;
 	HMENU menu = NULL;
 	HDC dc;
@@ -1161,7 +1168,7 @@ int win_window_info::complete_create()
 	assert(GetCurrentThreadId() == window_threadid);
 
 	// get the monitor bounds
-	monitorbounds = m_monitor->position_size();
+	osd_rect monitorbounds = m_monitor->position_size();
 
 	// create the window menu if needed
 	if (downcast<windows_options &>(machine().options()).menu())
@@ -1176,8 +1183,8 @@ int win_window_info::complete_create()
 						"MAME",
 						m_title,
 						m_fullscreen ? FULLSCREEN_STYLE : WINDOW_STYLE,
-						monitorbounds.left + 20, monitorbounds.top + 20,
+						monitorbounds.left() + 20, monitorbounds.top() + 20,
-						monitorbounds.left + 100, monitorbounds.top + 100,
+						monitorbounds.left() + 100, monitorbounds.top() + 100,
 						NULL,//(win_window_list != NULL) ? win_window_list->m_hwnd : NULL,
 						menu,
 						GetModuleHandle(NULL),
@@ -1198,9 +1205,9 @@ int win_window_info::complete_create()
 	// 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;
-	SetWindowPos(m_hwnd, NULL, monitorbounds.left + 20, monitorbounds.top + 20,
+	SetWindowPos(m_hwnd, NULL, monitorbounds.left() + 20, monitorbounds.top() + 20,
-			monitorbounds.left + tempwidth + wnd_extra_width(),
+			monitorbounds.left() + tempwidth + wnd_extra_width(),
-			monitorbounds.top + tempheight + wnd_extra_height(),
+			monitorbounds.top() + tempheight + wnd_extra_height(),
 			SWP_NOZORDER);
 
 	// maximum or minimize as appropriate
@@ -1346,7 +1353,13 @@ 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))
-				window->constrain_to_aspect_ratio(rect, wparam);
+			{
+				osd_rect r = window->constrain_to_aspect_ratio(RECT_to_osd_rect(*rect), wparam);
+				rect->top = r.top();
+				rect->left = r.left();
+				rect->bottom = r.bottom();
+				rect->right = r.right();
+			}
 			InvalidateRect(wnd, NULL, FALSE);
 			break;
 		}
@@ -1500,9 +1513,9 @@ void win_window_info::draw_video_contents(HDC dc, int update)
 //  (window thread)
 //============================================================
 
-void win_window_info::constrain_to_aspect_ratio(RECT *rect, int adjustment)
+osd_rect win_window_info::constrain_to_aspect_ratio(const osd_rect &rect, int adjustment)
 {
-	win_monitor_info *monitor = winwindow_video_window_monitor(rect);
+	win_monitor_info *monitor = winwindow_video_window_monitor(&rect);
 	INT32 extrawidth = wnd_extra_width();
 	INT32 extraheight = wnd_extra_height();
 	INT32 propwidth, propheight;
@@ -1518,8 +1531,8 @@ void win_window_info::constrain_to_aspect_ratio(RECT *rect, int adjustment)
 	pixel_aspect = monitor->aspect();
 
 	// determine the proposed width/height
-	propwidth = rect_width(rect) - extrawidth;
+	propwidth = rect.width() - extrawidth;
-	propheight = rect_height(rect) - extraheight;
+	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
@@ -1554,13 +1567,13 @@ void win_window_info::constrain_to_aspect_ratio(RECT *rect, int adjustment)
 	// clamp against the maximum (fit on one screen for full screen mode)
 	if (m_fullscreen)
 	{
-		maxwidth = rect_width(&monitor->position_size()) - extrawidth;
+		maxwidth = monitor->position_size().width() - extrawidth;
-		maxheight = rect_height(&monitor->position_size()) - extraheight;
+		maxheight = monitor->position_size().height() - extraheight;
 	}
 	else
 	{
-		maxwidth = rect_width(&monitor->usuable_position_size()) - extrawidth;
+		maxwidth = monitor->usuable_position_size().width() - extrawidth;
-		maxheight = rect_height(&monitor->usuable_position_size()) - extraheight;
+		maxheight = monitor->usuable_position_size().height() - extraheight;
 
 		// further clamp to the maximum width/height in the window
 		if (m_win_config.width != 0)
@@ -1577,36 +1590,35 @@ void win_window_info::constrain_to_aspect_ratio(RECT *rect, int adjustment)
 	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);
+	adjwidth = (viswidth + extrawidth) - rect.width();
-	adjheight = (visheight + extraheight) - rect_height(rect);
+	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:
-			rect->right += adjwidth;
+			ret = rect.resize(rect.width() + adjwidth, rect.height() + adjheight);
-			rect->bottom += adjheight;
 			break;
 
 		case WMSZ_BOTTOMLEFT:
-			rect->left -= adjwidth;
+			ret = rect.move_by(-adjwidth, 0).resize(rect.width(), rect.height() + adjheight);
-			rect->bottom += adjheight;
 			break;
 
 		case WMSZ_LEFT:
 		case WMSZ_TOPLEFT:
 		case WMSZ_TOP:
-			rect->left -= adjwidth;
+			ret = rect.move_by(-adjwidth, -adjheight);
-			rect->top -= adjheight;
 			break;
 
 		case WMSZ_TOPRIGHT:
-			rect->right += adjwidth;
+			ret = rect.move_by(0, -adjheight).resize(rect.width() + adjwidth, rect.height());
-			rect->top -= adjheight;
 			break;
 	}
+	return ret;
 }
 
 
@@ -1616,7 +1628,7 @@ void win_window_info::constrain_to_aspect_ratio(RECT *rect, int adjustment)
 //  (window thread)
 //============================================================
 
-void win_window_info::get_min_bounds(RECT *bounds, int constrain)
+osd_dim win_window_info::get_min_bounds(int constrain)
 {
 	INT32 minwidth, minheight;
 
@@ -1638,39 +1650,28 @@ void win_window_info::get_min_bounds(RECT *bounds, int constrain)
 	// if we want it constrained, figure out which one is larger
 	if (constrain)
 	{
-		RECT test1, test2;
-
 		// first constrain with no height limit
-		test1.top = test1.left = 0;
+		osd_rect test1(0,0,minwidth,10000);
-		test1.right = minwidth;
+		test1 = constrain_to_aspect_ratio(test1, WMSZ_BOTTOMRIGHT);
-		test1.bottom = 10000;
-		constrain_to_aspect_ratio(&test1, WMSZ_BOTTOMRIGHT);
 
 		// then constrain with no width limit
-		test2.top = test2.left = 0;
+		osd_rect test2(0,0,10000,minheight);
-		test2.right = 10000;
+		test2 = constrain_to_aspect_ratio(test2, WMSZ_BOTTOMRIGHT);
-		test2.bottom = minheight;
-		constrain_to_aspect_ratio(&test2, WMSZ_BOTTOMRIGHT);
 
 		// pick the larger
-		if (rect_width(&test1) > rect_width(&test2))
+		if (test1.width() > test2.width())
 		{
-			minwidth = rect_width(&test1);
+			minwidth = test1.width();
-			minheight = rect_height(&test1);
+			minheight = test1.height();
 		}
 		else
 		{
-			minwidth = rect_width(&test2);
+			minwidth = test2.width();
-			minheight = rect_height(&test2);
+			minheight = test2.height();
 		}
 	}
 
-	// get the window rect
+	return osd_dim(minwidth, minheight);
-	GetWindowRect(m_hwnd, bounds);
-
-	// now adjust
-	bounds->right = bounds->left + minwidth;
-	bounds->bottom = bounds->top + minheight;
 }
 
 
@@ -1680,45 +1681,40 @@ void win_window_info::get_min_bounds(RECT *bounds, int constrain)
 //  (window thread)
 //============================================================
 
-void win_window_info::get_max_bounds(RECT *bounds, int constrain)
+osd_dim win_window_info::get_max_bounds(int constrain)
 {
-	RECT maximum;
-
 	assert(GetCurrentThreadId() == window_threadid);
 
 	// compute the maximum client area
 	m_monitor->refresh();
-	maximum = m_monitor->usuable_position_size();
+	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 < rect_width(&maximum))
+		if (temp < maximum.width())
-			maximum.right = maximum.left + temp;
+			tempw = temp;
 	}
 	if (m_win_config.height != 0)
 	{
 		int temp = m_win_config.height + wnd_extra_height();
-		if (temp < rect_height(&maximum))
+		if (temp < maximum.height())
-			maximum.bottom = maximum.top + temp;
+			temph = temp;
 	}
 
+	maximum = maximum.resize(tempw, temph);
+
 	// constrain to fit
 	if (constrain)
-		constrain_to_aspect_ratio(&maximum, WMSZ_BOTTOMRIGHT);
+		maximum = constrain_to_aspect_ratio(maximum, WMSZ_BOTTOMRIGHT);
 	else
 	{
-		maximum.right -= wnd_extra_width();
+		maximum = maximum.resize(maximum.width() - wnd_extra_width(), maximum.height() - wnd_extra_height());
-		maximum.bottom -= wnd_extra_height();
 	}
-
+	return maximum.dim();
-	// center within the work area
-	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);
-	bounds->bottom = bounds->top + rect_height(&maximum);
 }
 
 
@@ -1734,18 +1730,18 @@ void win_window_info::update_minmax_state()
 
 	if (!m_fullscreen)
 	{
-		RECT bounds, minbounds, maxbounds;
+		RECT bounds;
 
 		// compare the maximum bounds versus the current bounds
-		get_min_bounds(&minbounds, video_config.keepaspect);
+		osd_dim minbounds = get_min_bounds(video_config.keepaspect);
-		get_max_bounds(&maxbounds, video_config.keepaspect);
+		osd_dim maxbounds = get_max_bounds(video_config.keepaspect);
 		GetWindowRect(m_hwnd, &bounds);
 
 		// if either the width or height matches, we were maximized
-		m_isminimized = (rect_width(&bounds) == rect_width(&minbounds) ||
+		m_isminimized = (rect_width(&bounds) == minbounds.width()) ||
-								rect_height(&bounds) == rect_height(&minbounds));
+								(rect_height(&bounds) == minbounds.height());
-		m_ismaximized = (rect_width(&bounds) == rect_width(&maxbounds) ||
+		m_ismaximized = (rect_width(&bounds) == maxbounds.width()) ||
-								rect_height(&bounds) == rect_height(&maxbounds));
+								(rect_height(&bounds) == maxbounds.height());
 	}
 	else
 	{
@@ -1763,12 +1759,18 @@ void win_window_info::update_minmax_state()
 
 void win_window_info::minimize_window()
 {
-	RECT newsize;
-
 	assert(GetCurrentThreadId() == window_threadid);
 
-	get_min_bounds(&newsize, video_config.keepaspect);
+	osd_dim newsize = get_min_bounds(video_config.keepaspect);
-	SetWindowPos(m_hwnd, NULL, newsize.left, newsize.top, rect_width(&newsize), rect_height(&newsize), SWP_NOZORDER);
+
+	// get the window rect
+	RECT bounds;
+	GetWindowRect(m_hwnd, &bounds);
+
+	osd_rect newrect(bounds.left, bounds.top, newsize );
+
+
+	SetWindowPos(m_hwnd, NULL, newrect.left(), newrect.top(), newrect.width(), newrect.height(), SWP_NOZORDER);
 }
 
 
@@ -1780,12 +1782,17 @@ void win_window_info::minimize_window()
 
 void win_window_info::maximize_window()
 {
-	RECT newsize;
-
 	assert(GetCurrentThreadId() == window_threadid);
 
-	get_max_bounds(&newsize, video_config.keepaspect);
+	osd_dim newsize = get_max_bounds(video_config.keepaspect);
-	SetWindowPos(m_hwnd, NULL, newsize.left, newsize.top, rect_width(&newsize), rect_height(&newsize), SWP_NOZORDER);
+
+	// 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(m_hwnd, NULL, newrect.left(), newrect.top(), newrect.width(), newrect.height(), SWP_NOZORDER);
 }
 
 
@@ -1797,20 +1804,20 @@ void win_window_info::maximize_window()
 
 void win_window_info::adjust_window_position_after_major_change()
 {
-	RECT oldrect, newrect;
+	RECT oldrect;
 
 	assert(GetCurrentThreadId() == window_threadid);
 
 	// get the current size
 	GetWindowRect(m_hwnd, &oldrect);
+	osd_rect newrect = RECT_to_osd_rect(oldrect);
 
 	// adjust the window size so the client area is what we want
 	if (!m_fullscreen)
 	{
 		// constrain the existing size to the aspect ratio
-		newrect = oldrect;
 		if (video_config.keepaspect)
-			constrain_to_aspect_ratio(&newrect, WMSZ_BOTTOMRIGHT);
+			newrect = constrain_to_aspect_ratio(newrect, WMSZ_BOTTOMRIGHT);
 	}
 
 	// in full screen, make sure it covers the primary display
@@ -1821,17 +1828,17 @@ void win_window_info::adjust_window_position_after_major_change()
 	}
 
 	// adjust the position if different
-	if (oldrect.left != newrect.left || oldrect.top != newrect.top ||
+	if (oldrect.left != newrect.left() || oldrect.top != newrect.top() ||
-		oldrect.right != newrect.right || oldrect.bottom != newrect.bottom)
+		oldrect.right != newrect.right() || oldrect.bottom != newrect.bottom())
 		SetWindowPos(m_hwnd, m_fullscreen ? HWND_TOPMOST : HWND_TOP,
-				newrect.left, newrect.top,
+				newrect.left(), newrect.top(),
-				rect_width(&newrect), rect_height(&newrect), 0);
+				newrect.width(), newrect.height(), 0);
 
 	// take note of physical window size (used for lightgun coordinate calculation)
 	if (this == win_window_list)
 	{
-		win_physical_width = rect_width(&newrect);
+		win_physical_width = newrect.width();
-		win_physical_height = rect_height(&newrect);
+		win_physical_height = newrect.height();
 		logerror("Physical width %d, height %d\n",win_physical_width,win_physical_height);
 	}
 }

src/osd/windows/window.h

@@ -46,7 +46,7 @@ public:
 
 	void update();
 
-	win_monitor_info *winwindow_video_window_monitor(const RECT *proposed);
+	win_monitor_info *winwindow_video_window_monitor(const osd_rect *proposed);
 
 	bool win_has_menu()
 	{
@@ -109,13 +109,13 @@ public:
 
 private:
 	void draw_video_contents(HDC dc, int update);
+	int complete_create();
 	void set_starting_view(int index, const char *view);
 	int wnd_extra_width();
 	int wnd_extra_height();
-	int complete_create();
+	osd_rect constrain_to_aspect_ratio(const osd_rect &rect, int adjustment);
-	void constrain_to_aspect_ratio(RECT *rect, int adjustment);
+	osd_dim get_min_bounds(int constrain);
-	void get_min_bounds(RECT *bounds, int constrain);
+	osd_dim get_max_bounds(int constrain);
-	void get_max_bounds(RECT *bounds, int constrain);
 	void update_minmax_state();
 	void minimize_window();
 	void maximize_window();