[PATCH 1/5] ddraw/tests: Rename modes and rectangles in test_coop_level_mode_set (v2).
Stefan Dösinger
stefan at codeweavers.com
Tue Nov 11 17:18:03 CST 2014
Version 2: Move the recreation of the ddraw object into patch 2.
I split this out of the next patch to make it easier to review. It
introduces the mode selection from test_mode_change in d3d8/9 but does
not introduce the additional tests yet. Other than selecting a variable
mode this is a no-op.
---
dlls/ddraw/tests/ddraw1.c | 278 ++++++++++++++++++++++------------------
dlls/ddraw/tests/ddraw2.c | 320 ++++++++++++++++++++++++++--------------------
dlls/ddraw/tests/ddraw4.c | 320 ++++++++++++++++++++++++++--------------------
dlls/ddraw/tests/ddraw7.c | 320 ++++++++++++++++++++++++++--------------------
4 files changed, 690 insertions(+), 548 deletions(-)
diff --git a/dlls/ddraw/tests/ddraw1.c b/dlls/ddraw/tests/ddraw1.c
index fe8a36e..ed18b47 100644
--- a/dlls/ddraw/tests/ddraw1.c
+++ b/dlls/ddraw/tests/ddraw1.c
@@ -2102,10 +2102,30 @@ static LRESULT CALLBACK mode_set_proc(HWND hwnd, UINT message, WPARAM wparam, LP
return test_proc(hwnd, message, wparam, lparam);
}
+struct test_coop_level_mode_set_enum_param
+{
+ DWORD ddraw_width, ddraw_height;
+};
+
+static HRESULT CALLBACK test_coop_level_mode_set_enum_cb(DDSURFACEDESC *surface_desc, void *context)
+{
+ struct test_coop_level_mode_set_enum_param *param = context;
+
+ if (U1(surface_desc->ddpfPixelFormat).dwRGBBitCount != registry_mode.dmBitsPerPel)
+ return DDENUMRET_OK;
+ if (surface_desc->dwWidth == registry_mode.dmPelsWidth
+ && surface_desc->dwHeight == registry_mode.dmPelsHeight)
+ return DDENUMRET_OK;
+
+ param->ddraw_width = surface_desc->dwWidth;
+ param->ddraw_height = surface_desc->dwHeight;
+ return DDENUMRET_CANCEL;
+}
+
static void test_coop_level_mode_set(void)
{
IDirectDrawSurface *primary;
- RECT fullscreen_rect, r, s;
+ RECT registry_rect, ddraw_rect, r;
IDirectDraw *ddraw;
DDSURFACEDESC ddsd;
WNDCLASSA wc = {0};
@@ -2113,6 +2133,7 @@ static void test_coop_level_mode_set(void)
HRESULT hr;
ULONG ref;
MSG msg;
+ struct test_coop_level_mode_set_enum_param param;
static const UINT exclusive_messages[] =
{
@@ -2132,6 +2153,21 @@ static void test_coop_level_mode_set(void)
ddraw = create_ddraw();
ok(!!ddraw, "Failed to create a ddraw object.\n");
+ memset(¶m, 0, sizeof(param));
+ hr = IDirectDraw_EnumDisplayModes(ddraw, 0, NULL, ¶m, test_coop_level_mode_set_enum_cb);
+ ok(SUCCEEDED(hr), "Failed to enumerate display mode, hr %#x.\n", hr);
+
+ if (!param.ddraw_width)
+ {
+ skip("Fewer than 2 different modes supported, skipping mode restore test.\n");
+ ref = IDirectDraw_Release(ddraw);
+ ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
+ return;
+ }
+
+ SetRect(®istry_rect, 0, 0, registry_mode.dmPelsWidth, registry_mode.dmPelsHeight);
+ SetRect(&ddraw_rect, 0, 0, param.ddraw_width, param.ddraw_height);
+
wc.lpfnWndProc = mode_set_proc;
wc.lpszClassName = "ddraw_test_wndproc_wc";
ok(RegisterClassA(&wc), "Failed to register window class.\n");
@@ -2139,15 +2175,12 @@ static void test_coop_level_mode_set(void)
window = CreateWindowA("ddraw_test_wndproc_wc", "ddraw_test", WS_OVERLAPPEDWINDOW,
0, 0, 100, 100, 0, 0, 0, 0);
- SetRect(&fullscreen_rect, 0, 0, registry_mode.dmPelsWidth, registry_mode.dmPelsHeight);
- SetRect(&s, 0, 0, 640, 480);
-
hr = IDirectDraw_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2159,14 +2192,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2174,26 +2207,26 @@ static void test_coop_level_mode_set(void)
screen_size.cx = 0;
screen_size.cy = 0;
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
expect_messages = NULL;
- ok(screen_size.cx == s.right && screen_size.cy == s.bottom,
+ ok(screen_size.cx == param.ddraw_width && screen_size.cy == param.ddraw_height,
"Expected screen size %ux%u, got %ux%u.\n",
- s.right, s.bottom, screen_size.cx, screen_size.cy);
+ param.ddraw_width, param.ddraw_height, screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- s.left, s.top, s.right, s.bottom,
+ ok(EqualRect(&r, &ddraw_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ ddraw_rect.left, ddraw_rect.top, ddraw_rect.right, ddraw_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2205,14 +2238,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- s.left, s.top, s.right, s.bottom,
+ ok(EqualRect(&r, &ddraw_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ ddraw_rect.left, ddraw_rect.top, ddraw_rect.right, ddraw_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2225,21 +2258,22 @@ static void test_coop_level_mode_set(void)
ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
expect_messages = NULL;
- ok(screen_size.cx == fullscreen_rect.right && screen_size.cy == fullscreen_rect.bottom,
+ ok(screen_size.cx == registry_mode.dmPelsWidth
+ && screen_size.cy == registry_mode.dmPelsHeight,
"Expected screen size %ux%u, got %ux%u.\n",
- fullscreen_rect.right, fullscreen_rect.bottom, screen_size.cx, screen_size.cy);
+ registry_mode.dmPelsWidth, registry_mode.dmPelsHeight, screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2251,30 +2285,30 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDraw_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2286,14 +2320,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2301,7 +2335,7 @@ static void test_coop_level_mode_set(void)
screen_size.cx = 0;
screen_size.cy = 0;
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
if (hr == DDERR_NOEXCLUSIVEMODE /* NT4 testbot */)
{
win_skip("Broken SetDisplayMode(), skipping remaining tests.\n");
@@ -2316,16 +2350,16 @@ static void test_coop_level_mode_set(void)
ok(!screen_size.cx && !screen_size.cy, "Got unexpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2337,14 +2371,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2360,16 +2394,16 @@ static void test_coop_level_mode_set(void)
ok(!screen_size.cx && !screen_size.cy, "Got unexpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2381,14 +2415,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
/* DDSCL_NORMAL | DDSCL_FULLSCREEN behaves the same as just DDSCL_NORMAL.
@@ -2398,16 +2432,16 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2419,14 +2453,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2434,7 +2468,7 @@ static void test_coop_level_mode_set(void)
screen_size.cx = 0;
screen_size.cy = 0;
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
@@ -2442,16 +2476,16 @@ static void test_coop_level_mode_set(void)
ok(!screen_size.cx && !screen_size.cy, "Got unexpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2463,14 +2497,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2486,16 +2520,16 @@ static void test_coop_level_mode_set(void)
ok(!screen_size.cx && !screen_size.cy, "Got unexpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2507,21 +2541,21 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
/* Unlike ddraw2-7, changing from EXCLUSIVE to NORMAL does not restore the resolution */
hr = IDirectDraw_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
hr = IDirectDraw_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
@@ -2536,10 +2570,10 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
hr = IDirectDraw_RestoreDisplayMode(ddraw);
ok(SUCCEEDED(hr), "RestoreDisplayMode failed, hr %#x.\n", hr);
@@ -2548,8 +2582,8 @@ static void test_coop_level_mode_set(void)
ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, &ddraw_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ ddraw_rect.left, ddraw_rect.top, ddraw_rect.right, ddraw_rect.bottom,
r.left, r.top, r.right, r.bottom);
done:
diff --git a/dlls/ddraw/tests/ddraw2.c b/dlls/ddraw/tests/ddraw2.c
index ad0d040..4e10d26 100644
--- a/dlls/ddraw/tests/ddraw2.c
+++ b/dlls/ddraw/tests/ddraw2.c
@@ -2301,10 +2301,30 @@ static LRESULT CALLBACK mode_set_proc2(HWND hwnd, UINT message, WPARAM wparam, L
return test_proc(hwnd, message, wparam, lparam);
}
+struct test_coop_level_mode_set_enum_param
+{
+ DWORD ddraw_width, ddraw_height;
+};
+
+static HRESULT CALLBACK test_coop_level_mode_set_enum_cb(DDSURFACEDESC *surface_desc, void *context)
+{
+ struct test_coop_level_mode_set_enum_param *param = context;
+
+ if (U1(surface_desc->ddpfPixelFormat).dwRGBBitCount != registry_mode.dmBitsPerPel)
+ return DDENUMRET_OK;
+ if (surface_desc->dwWidth == registry_mode.dmPelsWidth
+ && surface_desc->dwHeight == registry_mode.dmPelsHeight)
+ return DDENUMRET_OK;
+
+ param->ddraw_width = surface_desc->dwWidth;
+ param->ddraw_height = surface_desc->dwHeight;
+ return DDENUMRET_CANCEL;
+}
+
static void test_coop_level_mode_set(void)
{
IDirectDrawSurface *primary;
- RECT fullscreen_rect, r, s;
+ RECT registry_rect, ddraw_rect, r;
IDirectDraw2 *ddraw;
DDSURFACEDESC ddsd;
WNDCLASSA wc = {0};
@@ -2312,6 +2332,7 @@ static void test_coop_level_mode_set(void)
HRESULT hr;
ULONG ref;
MSG msg;
+ struct test_coop_level_mode_set_enum_param param;
static const UINT exclusive_messages[] =
{
@@ -2331,6 +2352,21 @@ static void test_coop_level_mode_set(void)
ddraw = create_ddraw();
ok(!!ddraw, "Failed to create a ddraw object.\n");
+ memset(¶m, 0, sizeof(param));
+ hr = IDirectDraw2_EnumDisplayModes(ddraw, 0, NULL, ¶m, test_coop_level_mode_set_enum_cb);
+ ok(SUCCEEDED(hr), "Failed to enumerate display mode, hr %#x.\n", hr);
+
+ if (!param.ddraw_width)
+ {
+ skip("Fewer than 2 different modes supported, skipping mode restore test.\n");
+ ref = IDirectDraw2_Release(ddraw);
+ ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
+ return;
+ }
+
+ SetRect(®istry_rect, 0, 0, registry_mode.dmPelsWidth, registry_mode.dmPelsHeight);
+ SetRect(&ddraw_rect, 0, 0, param.ddraw_width, param.ddraw_height);
+
wc.lpfnWndProc = mode_set_proc;
wc.lpszClassName = "ddraw_test_wndproc_wc";
ok(RegisterClassA(&wc), "Failed to register window class.\n");
@@ -2343,15 +2379,12 @@ static void test_coop_level_mode_set(void)
window2 = CreateWindowA("ddraw_test_wndproc_wc2", "ddraw_test", WS_OVERLAPPEDWINDOW,
0, 0, 100, 100, 0, 0, 0, 0);
- SetRect(&fullscreen_rect, 0, 0, registry_mode.dmPelsWidth, registry_mode.dmPelsHeight);
- SetRect(&s, 0, 0, 640, 480);
-
hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2363,14 +2396,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2378,26 +2411,26 @@ static void test_coop_level_mode_set(void)
screen_size.cx = 0;
screen_size.cy = 0;
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
expect_messages = NULL;
- ok(screen_size.cx == s.right && screen_size.cy == s.bottom,
+ ok(screen_size.cx == param.ddraw_width && screen_size.cy == param.ddraw_height,
"Expected screen size %ux%u, got %ux%u.\n",
- s.right, s.bottom, screen_size.cx, screen_size.cy);
+ param.ddraw_width, param.ddraw_height, screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- s.left, s.top, s.right, s.bottom,
+ ok(EqualRect(&r, &ddraw_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ ddraw_rect.left, ddraw_rect.top, ddraw_rect.right, ddraw_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2409,14 +2442,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- s.left, s.top, s.right, s.bottom,
+ ok(EqualRect(&r, &ddraw_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ ddraw_rect.left, ddraw_rect.top, ddraw_rect.right, ddraw_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2429,21 +2462,22 @@ static void test_coop_level_mode_set(void)
ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
expect_messages = NULL;
- ok(screen_size.cx == fullscreen_rect.right && screen_size.cy == fullscreen_rect.bottom,
+ ok(screen_size.cx == registry_mode.dmPelsWidth
+ && screen_size.cy == registry_mode.dmPelsHeight,
"Expected screen size %ux%u, got %ux%u.\n",
- fullscreen_rect.right, fullscreen_rect.bottom, screen_size.cx, screen_size.cy);
+ registry_mode.dmPelsWidth, registry_mode.dmPelsHeight, screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2455,30 +2489,30 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2490,14 +2524,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2505,7 +2539,7 @@ static void test_coop_level_mode_set(void)
screen_size.cx = 0;
screen_size.cy = 0;
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
if (hr == DDERR_NOEXCLUSIVEMODE /* NT4 testbot */)
{
win_skip("Broken SetDisplayMode(), skipping remaining tests.\n");
@@ -2520,16 +2554,16 @@ static void test_coop_level_mode_set(void)
ok(!screen_size.cx && !screen_size.cy, "Got unexpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2541,14 +2575,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2564,16 +2598,16 @@ static void test_coop_level_mode_set(void)
ok(!screen_size.cx && !screen_size.cy, "Got unexpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2585,14 +2619,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
/* DDSCL_NORMAL | DDSCL_FULLSCREEN behaves the same as just DDSCL_NORMAL.
@@ -2602,16 +2636,16 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2623,14 +2657,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2638,7 +2672,7 @@ static void test_coop_level_mode_set(void)
screen_size.cx = 0;
screen_size.cy = 0;
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
@@ -2646,16 +2680,16 @@ static void test_coop_level_mode_set(void)
ok(!screen_size.cx && !screen_size.cy, "Got unexpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2667,14 +2701,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2690,16 +2724,16 @@ static void test_coop_level_mode_set(void)
ok(!screen_size.cx && !screen_size.cy, "Got unexpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2711,21 +2745,21 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
/* Changing the coop level from EXCLUSIVE to NORMAL restores the screen resolution */
hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2738,13 +2772,15 @@ static void test_coop_level_mode_set(void)
ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
expect_messages = NULL;
- ok(screen_size.cx == fullscreen_rect.right && screen_size.cy == fullscreen_rect.bottom,
+ ok(screen_size.cx == registry_mode.dmPelsWidth
+ && screen_size.cy == registry_mode.dmPelsHeight,
"Expected screen size %ux%u, got %ux%u.\n",
- fullscreen_rect.right, fullscreen_rect.bottom, screen_size.cx, screen_size.cy);
+ registry_mode.dmPelsWidth, registry_mode.dmPelsHeight,
+ screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2756,16 +2792,16 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
/* The screen restore is a property of DDSCL_EXCLUSIVE */
hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL | DDSCL_FULLSCREEN);
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
@@ -2780,10 +2816,10 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
hr = IDirectDraw2_RestoreDisplayMode(ddraw);
@@ -2792,7 +2828,7 @@ static void test_coop_level_mode_set(void)
/* If the window is changed at the same time, messages are sent to the new window. */
hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2809,17 +2845,17 @@ static void test_coop_level_mode_set(void)
expect_messages = NULL;
ok(!screen_size.cx && !screen_size.cy, "Got unexpected screen size %ux%u.\n",
screen_size.cx, screen_size.cy);
- ok(screen_size2.cx == fullscreen_rect.right && screen_size2.cy == fullscreen_rect.bottom,
+ ok(screen_size2.cx == registry_mode.dmPelsWidth && screen_size2.cy == registry_mode.dmPelsHeight,
"Expected screen size 2 %ux%u, got %ux%u.\n",
- fullscreen_rect.right, fullscreen_rect.bottom, screen_size2.cx, screen_size2.cy);
+ registry_mode.dmPelsWidth, registry_mode.dmPelsHeight, screen_size2.cx, screen_size2.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- s.left, s.top, s.right, s.bottom,
+ ok(EqualRect(&r, &ddraw_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ ddraw_rect.left, ddraw_rect.top, ddraw_rect.right, ddraw_rect.bottom,
r.left, r.top, r.right, r.bottom);
GetWindowRect(window2, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2831,18 +2867,18 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface_Release(primary);
ref = IDirectDraw2_Release(ddraw);
ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- s.left, s.top, s.right, s.bottom,
+ ok(EqualRect(&r, &ddraw_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ ddraw_rect.left, ddraw_rect.top, ddraw_rect.right, ddraw_rect.bottom,
r.left, r.top, r.right, r.bottom);
done:
diff --git a/dlls/ddraw/tests/ddraw4.c b/dlls/ddraw/tests/ddraw4.c
index 69f3ac7..5ebbc11 100644
--- a/dlls/ddraw/tests/ddraw4.c
+++ b/dlls/ddraw/tests/ddraw4.c
@@ -2488,10 +2488,30 @@ static LRESULT CALLBACK mode_set_proc2(HWND hwnd, UINT message, WPARAM wparam, L
return test_proc(hwnd, message, wparam, lparam);
}
+struct test_coop_level_mode_set_enum_param
+{
+ DWORD ddraw_width, ddraw_height;
+};
+
+static HRESULT CALLBACK test_coop_level_mode_set_enum_cb(DDSURFACEDESC2 *surface_desc, void *context)
+{
+ struct test_coop_level_mode_set_enum_param *param = context;
+
+ if (U1(U4(surface_desc)->ddpfPixelFormat).dwRGBBitCount != registry_mode.dmBitsPerPel)
+ return DDENUMRET_OK;
+ if (surface_desc->dwWidth == registry_mode.dmPelsWidth
+ && surface_desc->dwHeight == registry_mode.dmPelsHeight)
+ return DDENUMRET_OK;
+
+ param->ddraw_width = surface_desc->dwWidth;
+ param->ddraw_height = surface_desc->dwHeight;
+ return DDENUMRET_CANCEL;
+}
+
static void test_coop_level_mode_set(void)
{
IDirectDrawSurface4 *primary;
- RECT fullscreen_rect, r, s;
+ RECT registry_rect, ddraw_rect, r;
IDirectDraw4 *ddraw;
DDSURFACEDESC2 ddsd;
WNDCLASSA wc = {0};
@@ -2499,6 +2519,7 @@ static void test_coop_level_mode_set(void)
HRESULT hr;
ULONG ref;
MSG msg;
+ struct test_coop_level_mode_set_enum_param param;
static const UINT exclusive_messages[] =
{
@@ -2518,6 +2539,21 @@ static void test_coop_level_mode_set(void)
ddraw = create_ddraw();
ok(!!ddraw, "Failed to create a ddraw object.\n");
+ memset(¶m, 0, sizeof(param));
+ hr = IDirectDraw4_EnumDisplayModes(ddraw, 0, NULL, ¶m, test_coop_level_mode_set_enum_cb);
+ ok(SUCCEEDED(hr), "Failed to enumerate display mode, hr %#x.\n", hr);
+
+ if (!param.ddraw_width)
+ {
+ skip("Fewer than 2 different modes supported, skipping mode restore test.\n");
+ ref = IDirectDraw4_Release(ddraw);
+ ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
+ return;
+ }
+
+ SetRect(®istry_rect, 0, 0, registry_mode.dmPelsWidth, registry_mode.dmPelsHeight);
+ SetRect(&ddraw_rect, 0, 0, param.ddraw_width, param.ddraw_height);
+
wc.lpfnWndProc = mode_set_proc;
wc.lpszClassName = "ddraw_test_wndproc_wc";
ok(RegisterClassA(&wc), "Failed to register window class.\n");
@@ -2530,15 +2566,12 @@ static void test_coop_level_mode_set(void)
window2 = CreateWindowA("ddraw_test_wndproc_wc2", "ddraw_test", WS_OVERLAPPEDWINDOW,
0, 0, 100, 100, 0, 0, 0, 0);
- SetRect(&fullscreen_rect, 0, 0, registry_mode.dmPelsWidth, registry_mode.dmPelsHeight);
- SetRect(&s, 0, 0, 640, 480);
-
hr = IDirectDraw4_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2550,14 +2583,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2565,26 +2598,26 @@ static void test_coop_level_mode_set(void)
screen_size.cx = 0;
screen_size.cy = 0;
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
expect_messages = NULL;
- ok(screen_size.cx == s.right && screen_size.cy == s.bottom,
+ ok(screen_size.cx == param.ddraw_width && screen_size.cy == param.ddraw_height,
"Expected screen size %ux%u, got %ux%u.\n",
- s.right, s.bottom, screen_size.cx, screen_size.cy);
+ param.ddraw_width, param.ddraw_height, screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- s.left, s.top, s.right, s.bottom,
+ ok(EqualRect(&r, &ddraw_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ ddraw_rect.left, ddraw_rect.top, ddraw_rect.right, ddraw_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface4_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2596,14 +2629,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- s.left, s.top, s.right, s.bottom,
+ ok(EqualRect(&r, &ddraw_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ ddraw_rect.left, ddraw_rect.top, ddraw_rect.right, ddraw_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2616,21 +2649,22 @@ static void test_coop_level_mode_set(void)
ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
expect_messages = NULL;
- ok(screen_size.cx == fullscreen_rect.right && screen_size.cy == fullscreen_rect.bottom,
+ ok(screen_size.cx == registry_mode.dmPelsWidth
+ && screen_size.cy == registry_mode.dmPelsHeight,
"Expected screen size %ux%u, got %ux%u.\n",
- fullscreen_rect.right, fullscreen_rect.bottom, screen_size.cx, screen_size.cy);
+ registry_mode.dmPelsWidth, registry_mode.dmPelsHeight, screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
IDirectDrawSurface4_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2642,30 +2676,30 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDraw4_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface4_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2677,14 +2711,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2692,7 +2726,7 @@ static void test_coop_level_mode_set(void)
screen_size.cx = 0;
screen_size.cy = 0;
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
@@ -2700,16 +2734,16 @@ static void test_coop_level_mode_set(void)
ok(!screen_size.cx && !screen_size.cy, "Got unexpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface4_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2721,14 +2755,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2744,16 +2778,16 @@ static void test_coop_level_mode_set(void)
ok(!screen_size.cx && !screen_size.cy, "Got unexpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
IDirectDrawSurface4_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2765,14 +2799,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
/* DDSCL_NORMAL | DDSCL_FULLSCREEN behaves the same as just DDSCL_NORMAL.
@@ -2782,16 +2816,16 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface4_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2803,14 +2837,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2818,7 +2852,7 @@ static void test_coop_level_mode_set(void)
screen_size.cx = 0;
screen_size.cy = 0;
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
@@ -2826,16 +2860,16 @@ static void test_coop_level_mode_set(void)
ok(!screen_size.cx && !screen_size.cy, "Got unexpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface4_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2847,14 +2881,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2870,16 +2904,16 @@ static void test_coop_level_mode_set(void)
ok(!screen_size.cx && !screen_size.cy, "Got unexpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
IDirectDrawSurface4_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2891,21 +2925,21 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface4_Release(primary);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
/* Changing the coop level from EXCLUSIVE to NORMAL restores the screen resolution */
hr = IDirectDraw4_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2918,13 +2952,15 @@ static void test_coop_level_mode_set(void)
ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
expect_messages = NULL;
- ok(screen_size.cx == fullscreen_rect.right && screen_size.cy == fullscreen_rect.bottom,
+ ok(screen_size.cx == registry_mode.dmPelsWidth
+ && screen_size.cy == registry_mode.dmPelsHeight,
"Expected screen size %ux%u, got %ux%u.\n",
- fullscreen_rect.right, fullscreen_rect.bottom, screen_size.cx, screen_size.cy);
+ registry_mode.dmPelsWidth, registry_mode.dmPelsHeight,
+ screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2936,16 +2972,16 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface4_Release(primary);
/* The screen restore is a property of DDSCL_EXCLUSIVE */
hr = IDirectDraw4_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL | DDSCL_FULLSCREEN);
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
hr = IDirectDraw4_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
@@ -2960,10 +2996,10 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
IDirectDrawSurface4_Release(primary);
hr = IDirectDraw4_RestoreDisplayMode(ddraw);
@@ -2972,7 +3008,7 @@ static void test_coop_level_mode_set(void)
/* If the window is changed at the same time, messages are sent to the new window. */
hr = IDirectDraw4_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2989,17 +3025,17 @@ static void test_coop_level_mode_set(void)
expect_messages = NULL;
ok(!screen_size.cx && !screen_size.cy, "Got unexpected screen size %ux%u.\n",
screen_size.cx, screen_size.cy);
- ok(screen_size2.cx == fullscreen_rect.right && screen_size2.cy == fullscreen_rect.bottom,
+ ok(screen_size2.cx == registry_mode.dmPelsWidth && screen_size2.cy == registry_mode.dmPelsHeight,
"Expected screen size 2 %ux%u, got %ux%u.\n",
- fullscreen_rect.right, fullscreen_rect.bottom, screen_size2.cx, screen_size2.cy);
+ registry_mode.dmPelsWidth, registry_mode.dmPelsHeight, screen_size2.cx, screen_size2.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- s.left, s.top, s.right, s.bottom,
+ ok(EqualRect(&r, &ddraw_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ ddraw_rect.left, ddraw_rect.top, ddraw_rect.right, ddraw_rect.bottom,
r.left, r.top, r.right, r.bottom);
GetWindowRect(window2, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
memset(&ddsd, 0, sizeof(ddsd));
@@ -3011,18 +3047,18 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface4_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface4_Release(primary);
ref = IDirectDraw4_Release(ddraw);
ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- s.left, s.top, s.right, s.bottom,
+ ok(EqualRect(&r, &ddraw_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ ddraw_rect.left, ddraw_rect.top, ddraw_rect.right, ddraw_rect.bottom,
r.left, r.top, r.right, r.bottom);
expect_messages = NULL;
diff --git a/dlls/ddraw/tests/ddraw7.c b/dlls/ddraw/tests/ddraw7.c
index 3aebfa7..7850fb5 100644
--- a/dlls/ddraw/tests/ddraw7.c
+++ b/dlls/ddraw/tests/ddraw7.c
@@ -2165,10 +2165,30 @@ static LRESULT CALLBACK mode_set_proc2(HWND hwnd, UINT message, WPARAM wparam, L
return test_proc(hwnd, message, wparam, lparam);
}
+struct test_coop_level_mode_set_enum_param
+{
+ DWORD ddraw_width, ddraw_height;
+};
+
+static HRESULT CALLBACK test_coop_level_mode_set_enum_cb(DDSURFACEDESC2 *surface_desc, void *context)
+{
+ struct test_coop_level_mode_set_enum_param *param = context;
+
+ if (U1(U4(surface_desc)->ddpfPixelFormat).dwRGBBitCount != registry_mode.dmBitsPerPel)
+ return DDENUMRET_OK;
+ if (surface_desc->dwWidth == registry_mode.dmPelsWidth
+ && surface_desc->dwHeight == registry_mode.dmPelsHeight)
+ return DDENUMRET_OK;
+
+ param->ddraw_width = surface_desc->dwWidth;
+ param->ddraw_height = surface_desc->dwHeight;
+ return DDENUMRET_CANCEL;
+}
+
static void test_coop_level_mode_set(void)
{
IDirectDrawSurface7 *primary;
- RECT fullscreen_rect, r, s;
+ RECT registry_rect, ddraw_rect, r;
IDirectDraw7 *ddraw;
DDSURFACEDESC2 ddsd;
WNDCLASSA wc = {0};
@@ -2176,6 +2196,7 @@ static void test_coop_level_mode_set(void)
HRESULT hr;
ULONG ref;
MSG msg;
+ struct test_coop_level_mode_set_enum_param param;
static const UINT exclusive_messages[] =
{
@@ -2195,6 +2216,21 @@ static void test_coop_level_mode_set(void)
ddraw = create_ddraw();
ok(!!ddraw, "Failed to create a ddraw object.\n");
+ memset(¶m, 0, sizeof(param));
+ hr = IDirectDraw7_EnumDisplayModes(ddraw, 0, NULL, ¶m, test_coop_level_mode_set_enum_cb);
+ ok(SUCCEEDED(hr), "Failed to enumerate display mode, hr %#x.\n", hr);
+
+ if (!param.ddraw_width)
+ {
+ skip("Fewer than 2 different modes supported, skipping mode restore test.\n");
+ ref = IDirectDraw7_Release(ddraw);
+ ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
+ return;
+ }
+
+ SetRect(®istry_rect, 0, 0, registry_mode.dmPelsWidth, registry_mode.dmPelsHeight);
+ SetRect(&ddraw_rect, 0, 0, param.ddraw_width, param.ddraw_height);
+
wc.lpfnWndProc = mode_set_proc;
wc.lpszClassName = "ddraw_test_wndproc_wc";
ok(RegisterClassA(&wc), "Failed to register window class.\n");
@@ -2207,15 +2243,12 @@ static void test_coop_level_mode_set(void)
window2 = CreateWindowA("ddraw_test_wndproc_wc2", "ddraw_test", WS_OVERLAPPEDWINDOW,
0, 0, 100, 100, 0, 0, 0, 0);
- SetRect(&fullscreen_rect, 0, 0, registry_mode.dmPelsWidth, registry_mode.dmPelsHeight);
- SetRect(&s, 0, 0, 640, 480);
-
hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2227,14 +2260,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2242,26 +2275,26 @@ static void test_coop_level_mode_set(void)
screen_size.cx = 0;
screen_size.cy = 0;
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
expect_messages = NULL;
- ok(screen_size.cx == s.right && screen_size.cy == s.bottom,
+ ok(screen_size.cx == param.ddraw_width && screen_size.cy == param.ddraw_height,
"Expected screen size %ux%u, got %ux%u.\n",
- s.right, s.bottom, screen_size.cx, screen_size.cy);
+ param.ddraw_width, param.ddraw_height, screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- s.left, s.top, s.right, s.bottom,
+ ok(EqualRect(&r, &ddraw_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ ddraw_rect.left, ddraw_rect.top, ddraw_rect.right, ddraw_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface7_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2273,14 +2306,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- s.left, s.top, s.right, s.bottom,
+ ok(EqualRect(&r, &ddraw_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ ddraw_rect.left, ddraw_rect.top, ddraw_rect.right, ddraw_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2293,21 +2326,22 @@ static void test_coop_level_mode_set(void)
ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
expect_messages = NULL;
- ok(screen_size.cx == fullscreen_rect.right && screen_size.cy == fullscreen_rect.bottom,
+ ok(screen_size.cx == registry_mode.dmPelsWidth
+ && screen_size.cy == registry_mode.dmPelsHeight,
"Expected screen size %ux%u, got %ux%u.\n",
- fullscreen_rect.right, fullscreen_rect.bottom, screen_size.cx, screen_size.cy);
+ registry_mode.dmPelsWidth, registry_mode.dmPelsHeight, screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
IDirectDrawSurface7_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2319,30 +2353,30 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface7_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2354,14 +2388,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2369,7 +2403,7 @@ static void test_coop_level_mode_set(void)
screen_size.cx = 0;
screen_size.cy = 0;
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
@@ -2377,16 +2411,16 @@ static void test_coop_level_mode_set(void)
ok(!screen_size.cx && !screen_size.cy, "Got unexpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface7_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2398,14 +2432,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2421,16 +2455,16 @@ static void test_coop_level_mode_set(void)
ok(!screen_size.cx && !screen_size.cy, "Got unexpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
IDirectDrawSurface7_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2442,14 +2476,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
/* DDSCL_NORMAL | DDSCL_FULLSCREEN behaves the same as just DDSCL_NORMAL.
@@ -2459,16 +2493,16 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface7_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2480,14 +2514,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2495,7 +2529,7 @@ static void test_coop_level_mode_set(void)
screen_size.cx = 0;
screen_size.cy = 0;
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
@@ -2503,16 +2537,16 @@ static void test_coop_level_mode_set(void)
ok(!screen_size.cx && !screen_size.cy, "Got unexpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface7_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2524,14 +2558,14 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2547,16 +2581,16 @@ static void test_coop_level_mode_set(void)
ok(!screen_size.cx && !screen_size.cy, "Got unexpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
IDirectDrawSurface7_Release(primary);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2568,21 +2602,21 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface7_Release(primary);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
/* Changing the coop level from EXCLUSIVE to NORMAL restores the screen resolution */
hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2595,13 +2629,15 @@ static void test_coop_level_mode_set(void)
ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
expect_messages = NULL;
- ok(screen_size.cx == fullscreen_rect.right && screen_size.cy == fullscreen_rect.bottom,
+ ok(screen_size.cx == registry_mode.dmPelsWidth
+ && screen_size.cy == registry_mode.dmPelsHeight,
"Expected screen size %ux%u, got %ux%u.\n",
- fullscreen_rect.right, fullscreen_rect.bottom, screen_size.cx, screen_size.cy);
+ registry_mode.dmPelsWidth, registry_mode.dmPelsHeight,
+ screen_size.cx, screen_size.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2613,16 +2649,16 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface7_Release(primary);
/* The screen restore is a property of DDSCL_EXCLUSIVE */
hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL | DDSCL_FULLSCREEN);
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
@@ -2637,10 +2673,10 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
- s.right - s.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
- s.bottom - s.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == param.ddraw_width, "Expected surface width %u, got %u.\n",
+ param.ddraw_width, ddsd.dwWidth);
+ ok(ddsd.dwHeight == param.ddraw_height, "Expected surface height %u, got %u.\n",
+ param.ddraw_height, ddsd.dwHeight);
IDirectDrawSurface7_Release(primary);
hr = IDirectDraw7_RestoreDisplayMode(ddraw);
@@ -2649,7 +2685,7 @@ static void test_coop_level_mode_set(void)
/* If the window is changed at the same time, messages are sent to the new window. */
hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
- hr = set_display_mode(ddraw, 640, 480);
+ hr = set_display_mode(ddraw, param.ddraw_width, param.ddraw_height);
ok(SUCCEEDED(hr), "Failed to set display mode, hr %#x.\n", hr);
PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
@@ -2666,17 +2702,17 @@ static void test_coop_level_mode_set(void)
expect_messages = NULL;
ok(!screen_size.cx && !screen_size.cy, "Got unexpected screen size %ux%u.\n",
screen_size.cx, screen_size.cy);
- ok(screen_size2.cx == fullscreen_rect.right && screen_size2.cy == fullscreen_rect.bottom,
+ ok(screen_size2.cx == registry_mode.dmPelsWidth && screen_size2.cy == registry_mode.dmPelsHeight,
"Expected screen size 2 %ux%u, got %ux%u.\n",
- fullscreen_rect.right, fullscreen_rect.bottom, screen_size2.cx, screen_size2.cy);
+ registry_mode.dmPelsWidth, registry_mode.dmPelsHeight, screen_size2.cx, screen_size2.cy);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- s.left, s.top, s.right, s.bottom,
+ ok(EqualRect(&r, &ddraw_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ ddraw_rect.left, ddraw_rect.top, ddraw_rect.right, ddraw_rect.bottom,
r.left, r.top, r.right, r.bottom);
GetWindowRect(window2, &r);
- ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
+ ok(EqualRect(&r, ®istry_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ registry_rect.left, registry_rect.top, registry_rect.right, registry_rect.bottom,
r.left, r.top, r.right, r.bottom);
memset(&ddsd, 0, sizeof(ddsd));
@@ -2688,18 +2724,18 @@ static void test_coop_level_mode_set(void)
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
- ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
- fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
- ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
- fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
+ ok(ddsd.dwWidth == registry_mode.dmPelsWidth, "Expected surface width %u, got %u.\n",
+ registry_mode.dmPelsWidth, ddsd.dwWidth);
+ ok(ddsd.dwHeight == registry_mode.dmPelsHeight, "Expected surface height %u, got %u.\n",
+ registry_mode.dmPelsHeight, ddsd.dwHeight);
IDirectDrawSurface7_Release(primary);
ref = IDirectDraw7_Release(ddraw);
ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
GetWindowRect(window, &r);
- ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
- s.left, s.top, s.right, s.bottom,
+ ok(EqualRect(&r, &ddraw_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
+ ddraw_rect.left, ddraw_rect.top, ddraw_rect.right, ddraw_rect.bottom,
r.left, r.top, r.right, r.bottom);
expect_messages = NULL;
--
2.0.4
More information about the wine-patches
mailing list