[PATCH v7 0/6] MR7708: Fix Imperiums: Greek Wars (1183470) not covering the entire screen in fullscreen mode.
-- v7: win32u: Properly scale monitor work area when emulate_modeset is enabled. win32u: Use a more fitting name for a helper function. win32u: Check against the monitor work area in update_maximized_pos().
From: Zhiyi Zhang zzhang@codeweavers.com
Previously, although none of the style in the test_style array in test_ShowWindow() has WS_CAPTION, WS_CAPTION is added implicitly by CreateWindow() when WS_POPUP and WS_CHILD are both not present, thus the behavior for ShowWindow(SW_MAXIMIZE) when WS_CAPTION is not set was not tested properly. --- dlls/user32/tests/win.c | 126 +++++++++++++++++++++++++++++++++++++--- 1 file changed, 119 insertions(+), 7 deletions(-)
diff --git a/dlls/user32/tests/win.c b/dlls/user32/tests/win.c index 8da4e11b635..4c4ee032570 100644 --- a/dlls/user32/tests/win.c +++ b/dlls/user32/tests/win.c @@ -7465,7 +7465,17 @@ static void test_ShowWindow(void) WS_OVERLAPPED | WS_VISIBLE | WS_SYSMENU | WS_THICKFRAME, WS_OVERLAPPED | WS_VISIBLE | WS_SYSMENU, WS_OVERLAPPED | WS_VISIBLE | WS_THICKFRAME, - WS_OVERLAPPED | WS_VISIBLE + WS_OVERLAPPED | WS_VISIBLE, + WS_POPUP | WS_VISIBLE | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_THICKFRAME, + WS_POPUP | WS_VISIBLE | WS_SYSMENU | WS_MINIMIZEBOX | WS_THICKFRAME, + WS_POPUP | WS_VISIBLE | WS_SYSMENU | WS_MAXIMIZEBOX | WS_THICKFRAME, + WS_POPUP | WS_VISIBLE | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX, + WS_POPUP | WS_VISIBLE | WS_SYSMENU | WS_MINIMIZEBOX, + WS_POPUP | WS_VISIBLE | WS_SYSMENU | WS_MAXIMIZEBOX, + WS_POPUP | WS_VISIBLE | WS_SYSMENU | WS_THICKFRAME, + WS_POPUP | WS_VISIBLE | WS_SYSMENU, + WS_POPUP | WS_VISIBLE | WS_THICKFRAME, + WS_POPUP | WS_VISIBLE };
SetRect(&rcClient, 0, 0, 90, 90); @@ -7737,6 +7747,12 @@ static void test_ShowWindow(void) 0, 0, 0, NULL); ok(hwnd != NULL, "Test %u: failed to create window with error %lu\n", i, GetLastError());
+ if (test_style[i] & WS_POPUP) + { + style = GetWindowLongW(hwnd, GWL_STYLE); + ok((style & WS_CAPTION) != WS_CAPTION, "Test %u: got unexpected WS_CAPTION.\n", i); + } + GetWindowRect(hwnd, &rcMain); ok(rcMain.left > mon_info.rcMonitor.left && rcMain.right < mon_info.rcMonitor.right && @@ -7744,7 +7760,7 @@ static void test_ShowWindow(void) rcMain.bottom < mon_info.rcMonitor.bottom, "Test %u: window should not be fullscreen\n", i);
- rcMaximized = (test_style[i] & WS_MAXIMIZEBOX) ? mon_info.rcWork : mon_info.rcMonitor; + rcMaximized = (test_style[i] & WS_MAXIMIZEBOX && !(test_style[i] & WS_POPUP)) ? mon_info.rcWork : mon_info.rcMonitor; AdjustWindowRectEx(&rcMaximized, GetWindowLongA(hwnd, GWL_STYLE) & ~WS_BORDER, 0, GetWindowLongA(hwnd, GWL_EXSTYLE));
@@ -7773,8 +7789,28 @@ static void test_ShowWindow(void) ok(EqualRect(&rcMain, &rc), "Test %u: expected %s, got %s\n", i, wine_dbgstr_rect(&rcMain), wine_dbgstr_rect(&rc));
- DestroyWindow(hwnd); + /* Remove the implicitly added WS_CAPTION when WS_POPUP and WS_CHILD are both not set */ + if (!(test_style[i] & WS_POPUP)) + { + style = GetWindowLongW(hwnd, GWL_STYLE); + SetWindowLongW(hwnd, GWL_STYLE, style & ~WS_CAPTION); + style = GetWindowLongW(hwnd, GWL_STYLE); + ok((style & WS_CAPTION) != WS_CAPTION, "Test %u: got unexpected WS_CAPTION.\n", i);
+ rcMaximized = mon_info.rcMonitor; + AdjustWindowRectEx(&rcMaximized, style & ~WS_BORDER, 0, GetWindowLongA(hwnd, GWL_EXSTYLE)); + + ret = ShowWindow(hwnd, SW_MAXIMIZE); + ok(ret, "Test %u: ShowWindow failed, error %lu.\n", i, GetLastError()); + style = GetWindowLongA(hwnd, GWL_STYLE); + ok(style & WS_MAXIMIZE, "Test %u: window should be maximized.\n", i); + GetWindowRect(hwnd, &rc); + todo_wine_if(test_style[i] & WS_MAXIMIZEBOX) + ok(EqualRect(&rcMaximized, &rc), "Test %u: expected %s, got %s.\n", i, + wine_dbgstr_rect(&rcMaximized), wine_dbgstr_rect(&rc)); + } + + DestroyWindow(hwnd); flush_events(TRUE); } } @@ -7912,11 +7948,37 @@ static void test_ShowWindow_owned(HWND hwndMain)
static void test_ShowWindow_child(HWND hwndMain) { - RECT rect, orig, expect, nc; + RECT rect, orig, expect, nc, maximized_rect; LPARAM ret; + MONITORINFO mon_info; HWND hwnd, hwnd2; - LONG style; + unsigned int i; POINT pt = {0}; + DWORD style; + + static const DWORD test_style[] = + { + WS_CHILD | WS_VISIBLE | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_THICKFRAME, + WS_CHILD | WS_VISIBLE | WS_SYSMENU | WS_MINIMIZEBOX | WS_THICKFRAME, + WS_CHILD | WS_VISIBLE | WS_SYSMENU | WS_MAXIMIZEBOX | WS_THICKFRAME, + WS_CHILD | WS_VISIBLE | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX, + WS_CHILD | WS_VISIBLE | WS_SYSMENU | WS_MINIMIZEBOX, + WS_CHILD | WS_VISIBLE | WS_SYSMENU | WS_MAXIMIZEBOX, + WS_CHILD | WS_VISIBLE | WS_SYSMENU | WS_THICKFRAME, + WS_CHILD | WS_VISIBLE | WS_SYSMENU, + WS_CHILD | WS_VISIBLE | WS_THICKFRAME, + WS_CHILD | WS_VISIBLE, + WS_CHILD | WS_CAPTION | WS_VISIBLE | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_THICKFRAME, + WS_CHILD | WS_CAPTION | WS_VISIBLE | WS_SYSMENU | WS_MINIMIZEBOX | WS_THICKFRAME, + WS_CHILD | WS_CAPTION | WS_VISIBLE | WS_SYSMENU | WS_MAXIMIZEBOX | WS_THICKFRAME, + WS_CHILD | WS_CAPTION | WS_VISIBLE | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX, + WS_CHILD | WS_CAPTION | WS_VISIBLE | WS_SYSMENU | WS_MINIMIZEBOX, + WS_CHILD | WS_CAPTION | WS_VISIBLE | WS_SYSMENU | WS_MAXIMIZEBOX, + WS_CHILD | WS_CAPTION | WS_VISIBLE | WS_SYSMENU | WS_THICKFRAME, + WS_CHILD | WS_CAPTION | WS_VISIBLE | WS_SYSMENU, + WS_CHILD | WS_CAPTION | WS_VISIBLE | WS_THICKFRAME, + WS_CHILD | WS_CAPTION | WS_VISIBLE, + };
SetRect(&orig, 20, 20, 210, 110); hwnd = CreateWindowA("MainWindowClass", "child", WS_CAPTION | WS_SYSMENU | @@ -8011,8 +8073,8 @@ static void test_ShowWindow_child(HWND hwndMain) style = GetWindowLongA(hwnd, GWL_STYLE); ok(!(style & WS_DISABLED), "window should not be disabled\n"); ok(style & WS_VISIBLE, "window should be visible\n"); - ok(!(style & WS_MINIMIZE), "window should be minimized\n"); - ok(style & WS_MAXIMIZE, "window should not be maximized\n"); + ok(!(style & WS_MINIMIZE), "window should not be minimized\n"); + ok(style & WS_MAXIMIZE, "window should be maximized\n"); GetWindowRect(hwnd, &rect); GetClientRect(hwndMain, &expect); AdjustWindowRectEx(&expect, GetWindowLongA(hwnd, GWL_STYLE) & ~WS_BORDER, @@ -8042,6 +8104,56 @@ static void test_ShowWindow_child(HWND hwndMain)
DestroyWindow(hwnd2); DestroyWindow(hwnd); + + mon_info.cbSize = sizeof(mon_info); + SetRect(&rect, 0, 0, 1, 1); + GetMonitorInfoW(MonitorFromRect(&rect, MONITOR_DEFAULTTOPRIMARY), &mon_info); + + hwnd = CreateWindowA("MainWindowClass", NULL, WS_POPUP | WS_VISIBLE, 0, 0, + GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), 0, 0, 0, NULL); + + for (i = 0; i < ARRAY_SIZE(test_style); ++i) + { + winetest_push_context("Test %u", i); + + hwnd2 = CreateWindowExA(0, "MainWindowClass", NULL, test_style[i], 1, 1, 100, 100, hwnd, 0, 0, NULL); + ok(hwnd2 != NULL, "CreateWindowExA failed, error %lu.\n", GetLastError()); + + style = GetWindowLongA(hwnd2, GWL_STYLE); + ok(style == test_style[i], "expected style %#lx, got %#lx.\n", test_style[i], style); + + GetWindowRect(hwnd2, &rect); + ok(rect.left > mon_info.rcMonitor.left && rect.right < mon_info.rcMonitor.right + && rect.top > mon_info.rcMonitor.top && rect.bottom < mon_info.rcMonitor.bottom, + "window should not be fullscreen, rect %s.\n", wine_dbgstr_rect(&rect)); + orig = rect; + + maximized_rect = mon_info.rcMonitor; + AdjustWindowRectEx(&maximized_rect, GetWindowLongA(hwnd2, GWL_STYLE) & ~WS_BORDER, + 0, GetWindowLongA(hwnd2, GWL_EXSTYLE)); + + ret = ShowWindow(hwnd2, SW_MAXIMIZE); + ok(ret, "ShowWindow failed, error %lu.\n", GetLastError()); + style = GetWindowLongA(hwnd2, GWL_STYLE); + ok(style & WS_MAXIMIZE, "window should be maximized.\n"); + GetWindowRect(hwnd2, &rect); + todo_wine_if((test_style[i] & WS_CAPTION) == WS_CAPTION && test_style[i] & WS_MAXIMIZEBOX) + ok(EqualRect(&maximized_rect, &rect), "expected %s, got %s.\n", + wine_dbgstr_rect(&maximized_rect), wine_dbgstr_rect(&rect)); + + ret = ShowWindow(hwnd2, SW_RESTORE); + ok(ret, "ShowWindow failed, error %lu.\n", GetLastError()); + style = GetWindowLongA(hwnd2, GWL_STYLE); + ok(!(style & WS_MAXIMIZE), "window should not be maximized\n"); + GetWindowRect(hwnd2, &rect); + ok(EqualRect(&orig, &rect), "expected %s, got %s.\n", wine_dbgstr_rect(&orig), wine_dbgstr_rect(&rect)); + + DestroyWindow(hwnd2); + flush_events(TRUE); + winetest_pop_context(); + } + + DestroyWindow(hwnd); }
static void test_ShowWindow_mdichild(HWND hwndMain)
From: Zhiyi Zhang zzhang@codeweavers.com
Partially fix Imperiums: Greek Wars (1183470) not covering the entire screen in fullscreen mode. --- dlls/user32/tests/win.c | 2 -- dlls/win32u/window.c | 7 ++----- 2 files changed, 2 insertions(+), 7 deletions(-)
diff --git a/dlls/user32/tests/win.c b/dlls/user32/tests/win.c index 4c4ee032570..8f9505ece9f 100644 --- a/dlls/user32/tests/win.c +++ b/dlls/user32/tests/win.c @@ -7805,7 +7805,6 @@ static void test_ShowWindow(void) style = GetWindowLongA(hwnd, GWL_STYLE); ok(style & WS_MAXIMIZE, "Test %u: window should be maximized.\n", i); GetWindowRect(hwnd, &rc); - todo_wine_if(test_style[i] & WS_MAXIMIZEBOX) ok(EqualRect(&rcMaximized, &rc), "Test %u: expected %s, got %s.\n", i, wine_dbgstr_rect(&rcMaximized), wine_dbgstr_rect(&rc)); } @@ -8137,7 +8136,6 @@ static void test_ShowWindow_child(HWND hwndMain) style = GetWindowLongA(hwnd2, GWL_STYLE); ok(style & WS_MAXIMIZE, "window should be maximized.\n"); GetWindowRect(hwnd2, &rect); - todo_wine_if((test_style[i] & WS_CAPTION) == WS_CAPTION && test_style[i] & WS_MAXIMIZEBOX) ok(EqualRect(&maximized_rect, &rect), "expected %s, got %s.\n", wine_dbgstr_rect(&maximized_rect), wine_dbgstr_rect(&rect));
diff --git a/dlls/win32u/window.c b/dlls/win32u/window.c index 3fb64755ba0..374b55e0011 100644 --- a/dlls/win32u/window.c +++ b/dlls/win32u/window.c @@ -2690,11 +2690,8 @@ static BOOL get_work_rect( HWND hwnd, RECT *rect ) *rect = mon_info.rcMonitor;
style = get_window_long( hwnd, GWL_STYLE ); - if (style & WS_MAXIMIZEBOX) - { - if ((style & WS_CAPTION) == WS_CAPTION || !(style & (WS_CHILD | WS_POPUP))) - *rect = mon_info.rcWork; - } + if (style & WS_MAXIMIZEBOX && (style & WS_CAPTION) == WS_CAPTION && !(style & WS_CHILD)) + *rect = mon_info.rcWork; return TRUE; }
From: Zhiyi Zhang zzhang@codeweavers.com
--- dlls/user32/tests/win.c | 73 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+)
diff --git a/dlls/user32/tests/win.c b/dlls/user32/tests/win.c index 8f9505ece9f..7e6bf809564 100644 --- a/dlls/user32/tests/win.c +++ b/dlls/user32/tests/win.c @@ -12826,6 +12826,79 @@ static void test_window_placement(void) ok(GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError());
DestroyWindow(hwnd); + + /* Test that when forgetting the maximized position for top level windows covering the work + * area, the work area means the monitor work area, not the the work area that a maximized + * window can cover depending on style. For example, a maximized WS_POPUP window can cover the + * whole screen when maximized. Also see See win32u/window.c#update_maximized_pos() */ + hwnd = CreateWindowA("MainWindowClass", "wp", WS_POPUP, orig.left, orig.top, + orig.right - orig.left, orig.bottom - orig.top, 0, 0, 0, 0); + ok(!!hwnd, "failed to create window, error %lu\n", GetLastError()); + ShowWindow(hwnd, SW_MAXIMIZE); + + GetWindowRect(hwnd, &rect); + ok(EqualRect(&rect, &mon_info.rcMonitor), "got unexpected maximized rect %s\n", wine_dbgstr_rect(&rect)); + + ret = GetWindowPlacement(hwnd, &wp); + ok(ret, "failed to get window placement, error %lu\n", GetLastError()); + ok(wp.showCmd == SW_SHOWMAXIMIZED, "got show cmd %u\n", wp.showCmd); + ok(wp.ptMinPosition.x == -1 && wp.ptMinPosition.y == -1, + "got minimized pos (%ld,%ld)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); + ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1, + "got maximized pos (%ld,%ld)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); + ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", + wine_dbgstr_rect(&wp.rcNormalPosition)); + + SetWindowPos(hwnd, 0, 100, 100, 100, 100, SWP_NOZORDER | SWP_NOACTIVATE); + + ret = GetWindowPlacement(hwnd, &wp); + ok(ret, "failed to get window placement, error %lu\n", GetLastError()); + ok(wp.showCmd == SW_SHOWMAXIMIZED, "got show cmd %u\n", wp.showCmd); + ok(wp.ptMinPosition.x == -1 && wp.ptMinPosition.y == -1, + "got minimized pos (%ld,%ld)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); + ok(wp.ptMaxPosition.x == 100 && wp.ptMaxPosition.y == 100, + "got maximized pos (%ld,%ld)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); + ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", + wine_dbgstr_rect(&wp.rcNormalPosition)); + + SetWindowPos(hwnd, 0, work_rect.left, work_rect.top, work_rect.right - work_rect.left, + work_rect.bottom - work_rect.top, SWP_NOZORDER | SWP_NOACTIVATE); + ret = GetWindowPlacement(hwnd, &wp); + ok(ret, "failed to get window placement, error %lu\n", GetLastError()); + ok(wp.showCmd == SW_SHOWMAXIMIZED, "got show cmd %u\n", wp.showCmd); + ok(wp.ptMinPosition.x == -1 && wp.ptMinPosition.y == -1, + "got minimized pos (%ld,%ld)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); + todo_wine + ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1, + "got maximized pos (%ld,%ld)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); + ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", + wine_dbgstr_rect(&wp.rcNormalPosition)); + + SetWindowPos(hwnd, 0, work_rect.left, work_rect.top, work_rect.right - work_rect.left - 1, + work_rect.bottom - work_rect.top, SWP_NOZORDER | SWP_NOACTIVATE); + ret = GetWindowPlacement(hwnd, &wp); + ok(ret, "failed to get window placement, error %lu\n", GetLastError()); + ok(wp.showCmd == SW_SHOWMAXIMIZED, "got show cmd %u\n", wp.showCmd); + ok(wp.ptMinPosition.x == -1 && wp.ptMinPosition.y == -1, + "got minimized pos (%ld,%ld)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); + ok(wp.ptMaxPosition.x == work_rect.left && wp.ptMaxPosition.y == work_rect.top, + "got maximized pos (%ld,%ld)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); + ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", + wine_dbgstr_rect(&wp.rcNormalPosition)); + + SetWindowPos(hwnd, 0, work_rect.left, work_rect.top, work_rect.right - work_rect.left, + work_rect.bottom - work_rect.top - 1, SWP_NOZORDER | SWP_NOACTIVATE); + ret = GetWindowPlacement(hwnd, &wp); + ok(ret, "failed to get window placement, error %lu\n", GetLastError()); + ok(wp.showCmd == SW_SHOWMAXIMIZED, "got show cmd %u\n", wp.showCmd); + ok(wp.ptMinPosition.x == -1 && wp.ptMinPosition.y == -1, + "got minimized pos (%ld,%ld)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); + ok(wp.ptMaxPosition.x == work_rect.left && wp.ptMaxPosition.y == work_rect.top, + "got maximized pos (%ld,%ld)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); + ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", + wine_dbgstr_rect(&wp.rcNormalPosition)); + + DestroyWindow(hwnd); }
static void test_arrange_iconic_windows(void)
From: Zhiyi Zhang zzhang@codeweavers.com
Fix Imperiums: Greek Wars (1183470) not covering the entire screen in fullscreen mode. --- dlls/user32/tests/win.c | 1 - dlls/win32u/window.c | 33 ++++++++++++++------------------- 2 files changed, 14 insertions(+), 20 deletions(-)
diff --git a/dlls/user32/tests/win.c b/dlls/user32/tests/win.c index 7e6bf809564..a748920ea14 100644 --- a/dlls/user32/tests/win.c +++ b/dlls/user32/tests/win.c @@ -12868,7 +12868,6 @@ static void test_window_placement(void) ok(wp.showCmd == SW_SHOWMAXIMIZED, "got show cmd %u\n", wp.showCmd); ok(wp.ptMinPosition.x == -1 && wp.ptMinPosition.y == -1, "got minimized pos (%ld,%ld)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); - todo_wine ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1, "got maximized pos (%ld,%ld)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", diff --git a/dlls/win32u/window.c b/dlls/win32u/window.c index 374b55e0011..aeef2a8ccab 100644 --- a/dlls/win32u/window.c +++ b/dlls/win32u/window.c @@ -2695,18 +2695,6 @@ static BOOL get_work_rect( HWND hwnd, RECT *rect ) return TRUE; }
-static RECT get_maximized_work_rect( HWND hwnd ) -{ - RECT work_rect = { 0 }; - - if ((get_window_long( hwnd, GWL_STYLE ) & (WS_MINIMIZE | WS_MAXIMIZE)) == WS_MAXIMIZE) - { - if (!get_work_rect( hwnd, &work_rect )) - work_rect = get_primary_monitor_rect( get_thread_dpi() ); - } - return work_rect; -} - /******************************************************************* * update_maximized_pos * @@ -2719,15 +2707,24 @@ static RECT get_maximized_work_rect( HWND hwnd ) * * Some applications (e.g. Imperiums: Greek Wars) depend on this. */ -static void update_maximized_pos( WND *wnd, RECT *work_rect ) +static void update_maximized_pos( WND *wnd ) { + RECT work_rect = { 0 }; + MONITORINFO mon_info; + if (wnd->parent && wnd->parent != get_desktop_window()) return;
+ if ((wnd->dwStyle & (WS_MINIMIZE | WS_MAXIMIZE)) == WS_MAXIMIZE) + { + mon_info = monitor_info_from_window( wnd->obj.handle, MONITOR_DEFAULTTOPRIMARY ); + work_rect = mon_info.rcWork; + } + if (wnd->dwStyle & WS_MAXIMIZE) { - if (wnd->rects.window.left <= work_rect->left && wnd->rects.window.top <= work_rect->top && - wnd->rects.window.right >= work_rect->right && wnd->rects.window.bottom >= work_rect->bottom) + if (wnd->rects.window.left <= work_rect.left && wnd->rects.window.top <= work_rect.top && + wnd->rects.window.right >= work_rect.right && wnd->rects.window.bottom >= work_rect.bottom) wnd->max_pos.x = wnd->max_pos.y = -1; } else @@ -2744,7 +2741,6 @@ static BOOL empty_point( POINT pt ) */ BOOL WINAPI NtUserGetWindowPlacement( HWND hwnd, WINDOWPLACEMENT *placement ) { - RECT work_rect = get_maximized_work_rect( hwnd ); WND *win = get_win_ptr( hwnd ); UINT win_dpi;
@@ -2803,7 +2799,7 @@ BOOL WINAPI NtUserGetWindowPlacement( HWND hwnd, WINDOWPLACEMENT *placement ) { win->normal_rect = win->rects.window; } - update_maximized_pos( win, &work_rect ); + update_maximized_pos( win );
placement->length = sizeof(*placement); if (win->dwStyle & WS_MINIMIZE) @@ -2884,7 +2880,6 @@ static void make_point_onscreen( POINT *pt )
static BOOL set_window_placement( HWND hwnd, const WINDOWPLACEMENT *wndpl, UINT flags ) { - RECT work_rect = get_maximized_work_rect( hwnd ); WND *win = get_win_ptr( hwnd ); WINDOWPLACEMENT wp = *wndpl; DWORD style; @@ -2907,7 +2902,7 @@ static BOOL set_window_placement( HWND hwnd, const WINDOWPLACEMENT *wndpl, UINT if (flags & PLACE_MAX) { win->max_pos = point_thread_to_win_dpi( hwnd, wp.ptMaxPosition ); - update_maximized_pos( win, &work_rect ); + update_maximized_pos( win ); } if (flags & PLACE_RECT) win->normal_rect = rect_thread_to_win_dpi( hwnd, wp.rcNormalPosition );
From: Zhiyi Zhang zzhang@codeweavers.com
Rename get_work_rect(), which gets the area the maximized window can cover depending on style, to get_maximized_rect(). So it's less likely to be confused with the monitor work area. --- dlls/win32u/window.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-)
diff --git a/dlls/win32u/window.c b/dlls/win32u/window.c index aeef2a8ccab..7950815adf9 100644 --- a/dlls/win32u/window.c +++ b/dlls/win32u/window.c @@ -2677,11 +2677,11 @@ HWND WINAPI NtUserRealChildWindowFromPoint( HWND parent, LONG x, LONG y ) }
/******************************************************************* - * get_work_rect + * get_maximized_rect * - * Get the work area that a maximized window can cover, depending on style. + * Get the area that a maximized window can cover, depending on style. */ -static BOOL get_work_rect( HWND hwnd, RECT *rect ) +static BOOL get_maximized_rect( HWND hwnd, RECT *rect ) { MONITORINFO mon_info; DWORD style; @@ -4200,7 +4200,7 @@ MINMAXINFO get_min_max_info( HWND hwnd ) DWORD style = get_window_long( hwnd, GWL_STYLE ); DWORD exstyle = get_window_long( hwnd, GWL_EXSTYLE ); UINT context; - RECT rc_work, rc_primary; + RECT rc_max, rc_primary; DWORD adjusted_style; MINMAXINFO minmax; INT xinc, yinc; @@ -4253,19 +4253,19 @@ MINMAXINFO get_min_max_info( HWND hwnd )
/* if the app didn't change the values, adapt them for the current monitor */
- if (get_work_rect( hwnd, &rc_work )) + if (get_maximized_rect( hwnd, &rc_max )) { rc_primary = get_primary_monitor_rect( get_thread_dpi() ); if (minmax.ptMaxSize.x == (rc_primary.right - rc_primary.left) + 2 * xinc && minmax.ptMaxSize.y == (rc_primary.bottom - rc_primary.top) + 2 * yinc) { - minmax.ptMaxSize.x = (rc_work.right - rc_work.left) + 2 * xinc; - minmax.ptMaxSize.y = (rc_work.bottom - rc_work.top) + 2 * yinc; + minmax.ptMaxSize.x = (rc_max.right - rc_max.left) + 2 * xinc; + minmax.ptMaxSize.y = (rc_max.bottom - rc_max.top) + 2 * yinc; } if (minmax.ptMaxPosition.x == -xinc && minmax.ptMaxPosition.y == -yinc) { - minmax.ptMaxPosition.x = rc_work.left - xinc; - minmax.ptMaxPosition.y = rc_work.top - yinc; + minmax.ptMaxPosition.x = rc_max.left - xinc; + minmax.ptMaxPosition.y = rc_max.top - yinc; } }
From: Zhiyi Zhang zzhang@codeweavers.com
--- dlls/win32u/sysparams.c | 95 ++++++++++++++++++++--------------------- 1 file changed, 47 insertions(+), 48 deletions(-)
diff --git a/dlls/win32u/sysparams.c b/dlls/win32u/sysparams.c index e33ff6e60e5..fe40a083f0a 100644 --- a/dlls/win32u/sysparams.c +++ b/dlls/win32u/sysparams.c @@ -1880,6 +1880,52 @@ static UINT monitor_get_dpi( struct monitor *monitor, MONITOR_DPI_TYPE type, UIN return min( *dpi_x, *dpi_y ); }
+/* display_lock must be held */ +static RECT map_monitor_rect( struct monitor *monitor, RECT rect, UINT dpi_from, MONITOR_DPI_TYPE type_from, + UINT dpi_to, MONITOR_DPI_TYPE type_to ) +{ + UINT x, y; + + assert( type_from != type_to ); + + if (monitor->source) + { + DEVMODEW current_mode = {.dmSize = sizeof(DEVMODEW)}, *mode_from, *mode_to; + UINT num, den, dpi; + + source_get_current_settings( monitor->source, ¤t_mode ); + + dpi = monitor_get_dpi( monitor, MDT_DEFAULT, &x, &y ); + if (!dpi_from) dpi_from = dpi; + if (!dpi_to) dpi_to = dpi; + + if (type_from == MDT_RAW_DPI) + { + monitor_virt_to_raw_ratio( monitor, &den, &num ); + mode_from = &monitor->source->physical; + mode_to = ¤t_mode; + } + else + { + monitor_virt_to_raw_ratio( monitor, &num, &den ); + mode_from = ¤t_mode; + mode_to = &monitor->source->physical; + } + + rect = map_dpi_rect( rect, dpi_from, dpi * 2 ); + OffsetRect( &rect, -mode_from->dmPosition.x * 2 - mode_from->dmPelsWidth, + -mode_from->dmPosition.y * 2 - mode_from->dmPelsHeight ); + rect = map_dpi_rect( rect, den, num ); + OffsetRect( &rect, mode_to->dmPosition.x * 2 + mode_to->dmPelsWidth, + mode_to->dmPosition.y * 2 + mode_to->dmPelsHeight ); + return map_dpi_rect( rect, dpi * 2, dpi_to ); + } + + if (!dpi_from) dpi_from = monitor_get_dpi( monitor, type_from, &x, &y ); + if (!dpi_to) dpi_to = monitor_get_dpi( monitor, type_to, &x, &y ); + return map_dpi_rect( rect, dpi_from, dpi_to ); +} + /* display_lock must be held */ static RECT monitor_get_rect( struct monitor *monitor, UINT dpi, MONITOR_DPI_TYPE type ) { @@ -1908,10 +1954,8 @@ static RECT monitor_get_rect( struct monitor *monitor, UINT dpi, MONITOR_DPI_TYP /* display_lock must be held */ static void monitor_get_info( struct monitor *monitor, MONITORINFO *info, UINT dpi ) { - UINT x, y; - info->rcMonitor = monitor_get_rect( monitor, dpi, MDT_DEFAULT ); - info->rcWork = map_dpi_rect( monitor->rc_work, monitor_get_dpi( monitor, MDT_DEFAULT, &x, &y ), dpi ); + info->rcWork = map_monitor_rect( monitor, monitor->rc_work, 0, MDT_RAW_DPI, dpi, MDT_DEFAULT ); info->dwFlags = is_monitor_primary( monitor ) ? MONITORINFOF_PRIMARY : 0;
if (info->cbSize >= sizeof(MONITORINFOEXW)) @@ -2526,51 +2570,6 @@ static RECT monitors_get_union_rect( UINT dpi, MONITOR_DPI_TYPE type ) return rect; }
-static RECT map_monitor_rect( struct monitor *monitor, RECT rect, UINT dpi_from, MONITOR_DPI_TYPE type_from, - UINT dpi_to, MONITOR_DPI_TYPE type_to ) -{ - UINT x, y; - - assert( type_from != type_to ); - - if (monitor->source) - { - DEVMODEW current_mode = {.dmSize = sizeof(DEVMODEW)}, *mode_from, *mode_to; - UINT num, den, dpi; - - source_get_current_settings( monitor->source, ¤t_mode ); - - dpi = monitor_get_dpi( monitor, MDT_DEFAULT, &x, &y ); - if (!dpi_from) dpi_from = dpi; - if (!dpi_to) dpi_to = dpi; - - if (type_from == MDT_RAW_DPI) - { - monitor_virt_to_raw_ratio( monitor, &den, &num ); - mode_from = &monitor->source->physical; - mode_to = ¤t_mode; - } - else - { - monitor_virt_to_raw_ratio( monitor, &num, &den ); - mode_from = ¤t_mode; - mode_to = &monitor->source->physical; - } - - rect = map_dpi_rect( rect, dpi_from, dpi * 2 ); - OffsetRect( &rect, -mode_from->dmPosition.x * 2 - mode_from->dmPelsWidth, - -mode_from->dmPosition.y * 2 - mode_from->dmPelsHeight ); - rect = map_dpi_rect( rect, den, num ); - OffsetRect( &rect, mode_to->dmPosition.x * 2 + mode_to->dmPelsWidth, - mode_to->dmPosition.y * 2 + mode_to->dmPelsHeight ); - return map_dpi_rect( rect, dpi * 2, dpi_to ); - } - - if (!dpi_from) dpi_from = monitor_get_dpi( monitor, type_from, &x, &y ); - if (!dpi_to) dpi_to = monitor_get_dpi( monitor, type_to, &x, &y ); - return map_dpi_rect( rect, dpi_from, dpi_to ); -} - /* map a monitor rect from MDT_RAW_DPI to MDT_DEFAULT coordinates */ RECT map_rect_raw_to_virt( RECT rect, UINT dpi_to ) {
On Mon Apr 7 09:00:26 2025 +0000, Rémi Bernon wrote:
This changes the logic and when window is both maximized and minimized, we may now set `max_pos.x = max_pos.y = -1`? It might be better to fix `monitor_info_from_window` instead and avoid calling `NtUserGetWindowPlacement` just to get the normal rect, maybe with a dedicated helper.
You're right. Let's use the old logic for now to avoid any complications.
This merge request was approved by Rémi Bernon.
On Mon Apr 7 10:28:50 2025 +0000, Zhiyi Zhang wrote:
~~You're right. Let's use the old logic for now to avoid any complications.~~
Giving it a second thought, using the old logic, when a window has both `WS_MAXIMIZE` and `WS_MINIMIZE`.
``` (WS_MINIMIZE | WS_MAXIMIZE) & (WS_MINIMIZE | WS_MAXIMIZE) = WS_MINIMIZE | WS_MAXIMIZE
(WS_MINIMIZE | WS_MAXIMIZE) != WS_MAXIMIZE ``` So the work rect is empty when both `WS_MINIMIZE` and `WS_MAXIMIZE` are present using the old logic. The only case work rect is not empty is when WS_MAXIMIZE is set and WS_MINIMIZE is not set. Thus, the logic in v6 is correct, isn't it?
On Mon Apr 7 10:28:59 2025 +0000, Zhiyi Zhang wrote:
Giving it a second thought, using the old logic, when a window has both `WS_MAXIMIZE` and `WS_MINIMIZE`.
(WS_MINIMIZE | WS_MAXIMIZE) & (WS_MINIMIZE | WS_MAXIMIZE) = WS_MINIMIZE | WS_MAXIMIZE (WS_MINIMIZE | WS_MAXIMIZE) != WS_MAXIMIZESo the work rect is empty when both `WS_MINIMIZE` and `WS_MAXIMIZE` are present using the old logic. The only case work rect is not empty is when WS_MAXIMIZE is set and WS_MINIMIZE is not set. Thus, the logic in v6 is correct, isn't it?
Maybe, I was looking at the initial change only as a way to avoid calling into `monitor_info_from_window` which didn't look right to have it there just to avoid triggering a recursion, but the old logic was already doing this and it is indeed equivalent.
-
Rémi Bernon (＠rbernon) -
Zhiyi Zhang
-
Zhiyi Zhang (＠zhiyi)