Ros-diffs

ros-diffs@reactos.org

81390 discussions

[reactos] 01/01: [NOTEPAD] Handle serialized maximized state (#5806)
by Whindmar Saksit 02 Sep '24

02 Sep '24

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=814f3a15f9cfa0f5efa85… commit 814f3a15f9cfa0f5efa85724d8925c1f5bece5a0 Author: Whindmar Saksit <whindsaks(a)proton.me> AuthorDate: Mon Sep 2 23:13:28 2024 +0200 Commit: GitHub <noreply(a)github.com> CommitDate: Mon Sep 2 23:13:28 2024 +0200 [NOTEPAD] Handle serialized maximized state (#5806) Fixes a bug where if you close Notepad while it is maximized, the next time Notepad is started it will start with its window placed as if maximized but it is still in the SW_RESTORE state and the "real normal placement" is lost. SetWindowPlacement also takes care of making sure the window is placed correctly on the monitor workarea. --- base/applications/notepad/main.c | 38 ++++++++++++-------------- base/applications/notepad/notepad.h | 3 +- base/applications/notepad/settings.c | 53 ++++++++++++++++++++++++------------ 3 files changed, 54 insertions(+), 40 deletions(-) diff --git a/base/applications/notepad/main.c b/base/applications/notepad/main.c index 85cd029610c..3668527a0d9 100644 --- a/base/applications/notepad/main.c +++ b/base/applications/notepad/main.c @@ -557,10 +557,7 @@ int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE prev, LPTSTR cmdline, int sh MSG msg; HACCEL hAccel; WNDCLASSEX wndclass; - HMONITOR monitor; - MONITORINFO info; - INT x, y; - RECT rcIntersect; + WINDOWPLACEMENT wp; static const TCHAR className[] = _T("Notepad"); static const TCHAR winName[] = _T("Notepad"); @@ -579,7 +576,7 @@ int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE prev, LPTSTR cmdline, int sh aFINDMSGSTRING = (ATOM)RegisterWindowMessage(FINDMSGSTRING); NOTEPAD_InitData(hInstance); - NOTEPAD_LoadSettingsFromRegistry(); + NOTEPAD_LoadSettingsFromRegistry(&wp); ZeroMemory(&wndclass, sizeof(wndclass)); wndclass.cbSize = sizeof(wndclass); @@ -602,25 +599,14 @@ int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE prev, LPTSTR cmdline, int sh return 1; } - /* Setup windows */ - - monitor = MonitorFromRect(&Globals.main_rect, MONITOR_DEFAULTTOPRIMARY); - info.cbSize = sizeof(info); - GetMonitorInfoW(monitor, &info); - - x = Globals.main_rect.left; - y = Globals.main_rect.top; - if (!IntersectRect(&rcIntersect, &Globals.main_rect, &info.rcWork)) - x = y = CW_USEDEFAULT; - /* Globals.hMainWnd will be set in WM_CREATE handling */ CreateWindow(className, winName, WS_OVERLAPPEDWINDOW, - x, - y, - Globals.main_rect.right - Globals.main_rect.left, - Globals.main_rect.bottom - Globals.main_rect.top, + CW_USEDEFAULT, + CW_USEDEFAULT, + CW_USEDEFAULT, + CW_USEDEFAULT, NULL, NULL, Globals.hInstance, @@ -631,7 +617,17 @@ int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE prev, LPTSTR cmdline, int sh return 1; } - ShowWindow(Globals.hMainWnd, show); + /* Use the result of CW_USEDEFAULT if the data in the registry is not valid */ + if (wp.rcNormalPosition.right == wp.rcNormalPosition.left) + { + GetWindowPlacement(Globals.hMainWnd, &wp); + } + /* Does the parent process want to force a show action? */ + if (show != SW_SHOWDEFAULT) + { + wp.showCmd = show; + } + SetWindowPlacement(Globals.hMainWnd, &wp); UpdateWindow(Globals.hMainWnd); if (!HandleCommandLine(cmdline)) diff --git a/base/applications/notepad/notepad.h b/base/applications/notepad/notepad.h index 494fd8ba1ba..1e65ea10de8 100644 --- a/base/applications/notepad/notepad.h +++ b/base/applications/notepad/notepad.h @@ -84,7 +84,6 @@ typedef struct FINDREPLACE find; WNDPROC EditProc; - RECT main_rect; BOOL bWasModified; } NOTEPAD_GLOBALS; @@ -93,7 +92,7 @@ extern NOTEPAD_GLOBALS Globals; BOOL ReadText(HANDLE hFile, HLOCAL *phLocal, ENCODING *pencFile, EOLN *piEoln); BOOL WriteText(HANDLE hFile, LPCWSTR pszText, DWORD dwTextLen, ENCODING encFile, EOLN iEoln); -void NOTEPAD_LoadSettingsFromRegistry(void); +void NOTEPAD_LoadSettingsFromRegistry(PWINDOWPLACEMENT pWP); void NOTEPAD_SaveSettingsToRegistry(void); BOOL NOTEPAD_FindNext(FINDREPLACE *pFindReplace, BOOL bReplace, BOOL bShowAlert); diff --git a/base/applications/notepad/settings.c b/base/applications/notepad/settings.c index 6c0c1672144..24ddf3f8a4e 100644 --- a/base/applications/notepad/settings.c +++ b/base/applications/notepad/settings.c @@ -102,12 +102,12 @@ static BOOL QueryString(HKEY hKey, LPCTSTR pszValueName, LPTSTR pszResult, DWORD * * Load settings from registry HKCU\Software\Microsoft\Notepad. */ -void NOTEPAD_LoadSettingsFromRegistry(void) +void NOTEPAD_LoadSettingsFromRegistry(PWINDOWPLACEMENT pWP) { HKEY hKey; HFONT hFont; - DWORD dwPointSize, cx, cy; - DWORD cxScreen = GetSystemMetrics(SM_CXSCREEN), cyScreen = GetSystemMetrics(SM_CYSCREEN); + DWORD dwPointSize; + DWORD x = CW_USEDEFAULT, y = CW_USEDEFAULT, cx = 0, cy = 0; /* Set the default values */ Globals.bShowStatusBar = TRUE; @@ -118,10 +118,6 @@ void NOTEPAD_LoadSettingsFromRegistry(void) dwPointSize = 100; Globals.lfFont.lfWeight = FW_NORMAL; Globals.lfFont.lfPitchAndFamily = FIXED_PITCH | FF_MODERN; - Globals.main_rect.left = CW_USEDEFAULT; - Globals.main_rect.top = CW_USEDEFAULT; - cx = min((cxScreen * 3) / 4, 640); - cy = min((cyScreen * 3) / 4, 480); /* FIXME: Globals.fSaveWindowPositions = FALSE; */ /* FIXME: Globals.fMLE_is_broken = FALSE; */ @@ -154,8 +150,8 @@ void NOTEPAD_LoadSettingsFromRegistry(void) QueryDword(hKey, _T("iMarginRight"), (DWORD*)&Globals.lMargins.right); QueryDword(hKey, _T("iMarginBottom"), (DWORD*)&Globals.lMargins.bottom); - QueryDword(hKey, _T("iWindowPosX"), (DWORD*)&Globals.main_rect.left); - QueryDword(hKey, _T("iWindowPosY"), (DWORD*)&Globals.main_rect.top); + QueryDword(hKey, _T("iWindowPosX"), &x); + QueryDword(hKey, _T("iWindowPosY"), &y); QueryDword(hKey, _T("iWindowPosDX"), &cx); QueryDword(hKey, _T("iWindowPosDY"), &cy); @@ -163,10 +159,23 @@ void NOTEPAD_LoadSettingsFromRegistry(void) QueryString(hKey, _T("replaceString"), Globals.szReplaceText, _countof(Globals.szReplaceText)); } - Globals.lfFont.lfHeight = HeightFromPointSize(dwPointSize); - Globals.main_rect.right = Globals.main_rect.left + cx; - Globals.main_rect.bottom = Globals.main_rect.top + cy; + pWP->length = sizeof(*pWP); + pWP->flags = 0; + pWP->showCmd = SW_SHOWDEFAULT; + if (cy & 0x80000000) + { + cy &= ~0x80000000; + pWP->flags |= WPF_RESTORETOMAXIMIZED; + pWP->showCmd = SW_SHOWMAXIMIZED; + } + pWP->rcNormalPosition.left = x; + pWP->rcNormalPosition.right = x + cx; + pWP->rcNormalPosition.top = y; + pWP->rcNormalPosition.bottom = y + cy; + pWP->ptMaxPosition.x = x; + pWP->ptMaxPosition.y = y; + Globals.lfFont.lfHeight = HeightFromPointSize(dwPointSize); if (!hKey || !QueryString(hKey, _T("lfFaceName"), Globals.lfFont.lfFaceName, _countof(Globals.lfFont.lfFaceName))) { @@ -228,8 +237,18 @@ void NOTEPAD_SaveSettingsToRegistry(void) { HKEY hKey; DWORD dwDisposition; + WINDOWPLACEMENT wp; + UINT x, y, cx, cy; + + wp.length = sizeof(wp); + GetWindowPlacement(Globals.hMainWnd, &wp); + x = wp.rcNormalPosition.left; + y = wp.rcNormalPosition.top; + cx = wp.rcNormalPosition.right - x; + cy = wp.rcNormalPosition.bottom - y; + if (wp.flags & WPF_RESTORETOMAXIMIZED) + cy |= 0x80000000; - GetWindowRect(Globals.hMainWnd, &Globals.main_rect); if (RegCreateKeyEx(HKEY_CURRENT_USER, s_szRegistryKey, 0, NULL, 0, KEY_SET_VALUE, NULL, @@ -256,10 +275,10 @@ void NOTEPAD_SaveSettingsToRegistry(void) SaveDword(hKey, _T("iMarginTop"), Globals.lMargins.top); SaveDword(hKey, _T("iMarginRight"), Globals.lMargins.right); SaveDword(hKey, _T("iMarginBottom"), Globals.lMargins.bottom); - SaveDword(hKey, _T("iWindowPosX"), Globals.main_rect.left); - SaveDword(hKey, _T("iWindowPosY"), Globals.main_rect.top); - SaveDword(hKey, _T("iWindowPosDX"), Globals.main_rect.right - Globals.main_rect.left); - SaveDword(hKey, _T("iWindowPosDY"), Globals.main_rect.bottom - Globals.main_rect.top); + SaveDword(hKey, _T("iWindowPosX"), x); + SaveDword(hKey, _T("iWindowPosY"), y); + SaveDword(hKey, _T("iWindowPosDX"), cx); + SaveDword(hKey, _T("iWindowPosDY"), cy); SaveString(hKey, _T("searchString"), Globals.szFindText); SaveString(hKey, _T("replaceString"), Globals.szReplaceText);

1 0

[reactos] 01/01: [NTUSER] Optimize BroadcastSystemMessage a bit. Follow-up of #6884 (#7215)
by Doug Lyons 01 Sep '24

01 Sep '24

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=07abea90d9fecbce58a84… commit 07abea90d9fecbce58a84ef16018b6603cfb272d Author: Doug Lyons <douglyons(a)douglyons.com> AuthorDate: Sun Sep 1 13:24:22 2024 -0500 Commit: GitHub <noreply(a)github.com> CommitDate: Sun Sep 1 13:24:22 2024 -0500 [NTUSER] Optimize BroadcastSystemMessage a bit. Follow-up of #6884 (#7215) Optimize BroadcastSystemMessage with Environment parameter. Minimize processing when UserModeMsg->lParam is NULL and KernelModeMsg->message != WM_WININICHANGE Make sure that we have a UNICODE_NULL within lParamMsg based on comment from @whindsaks --- win32ss/user/ntuser/message.c | 26 ++++++++++---------------- 1 file changed, 10 insertions(+), 16 deletions(-) diff --git a/win32ss/user/ntuser/message.c b/win32ss/user/ntuser/message.c index c86754abc56..d28f35e3c79 100644 --- a/win32ss/user/ntuser/message.c +++ b/win32ss/user/ntuser/message.c @@ -453,7 +453,7 @@ CopyMsgToKernelMem(MSG *KernelModeMsg, MSG *UserModeMsg, PMSGMEMORY MsgMemoryEnt NTSTATUS Status; PVOID KernelMem; - UINT Size, i; + UINT Size; *KernelModeMsg = *UserModeMsg; @@ -483,23 +483,15 @@ CopyMsgToKernelMem(MSG *KernelModeMsg, MSG *UserModeMsg, PMSGMEMORY MsgMemoryEnt { TRACE("Copy Message %u from usermode buffer\n", KernelModeMsg->message); /* Don't do extra testing for 1 word messages. For examples see - * https://wiki.winehq.org/List_Of_Windows_Messages. */ - if (Size > 1) + * https://wiki.winehq.org/List_Of_Windows_Messages and + * we are just handling WM_WININICHANGE here. */ + if (Size > 1 && UserModeMsg->lParam && + KernelModeMsg->message == WM_WININICHANGE) { WCHAR lParamMsg[_countof(StrUserKernel[0]) + 1] = { 0 }; _SEH2_TRY { - if (UserModeMsg->lParam) - RtlCopyMemory(lParamMsg, (WCHAR*)UserModeMsg->lParam, sizeof(lParamMsg)); - /* Make sure that the last WCHAR is a UNICODE_NULL */ - for (i = 0; i < ARRAYSIZE(lParamMsg); ++i) - { - if (lParamMsg[i] == 0) - break; - } - /* If we did not find a UNICODE_NULL, then set last WCHAR to one */ - if (i == ARRAYSIZE(lParamMsg)) - lParamMsg[_countof(StrUserKernel[0])] = UNICODE_NULL; + RtlCopyMemory(lParamMsg, (WCHAR*)UserModeMsg->lParam, sizeof(lParamMsg)); } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { @@ -507,8 +499,10 @@ CopyMsgToKernelMem(MSG *KernelModeMsg, MSG *UserModeMsg, PMSGMEMORY MsgMemoryEnt } _SEH2_END; - if (UserModeMsg->lParam && !UserModeMsg->wParam && - PosInArray(lParamMsg) >= 0) + /* Make sure that we have a UNICODE_NULL within lParamMsg */ + lParamMsg[ARRAYSIZE(lParamMsg) - 1] = UNICODE_NULL; + + if (!UserModeMsg->wParam && PosInArray(lParamMsg) >= 0) { TRACE("Copy String '%S' from usermode buffer\n", lParamMsg); wcscpy(KernelMem, lParamMsg);

1 0

[reactos] 01/01: [NTGDI:FREETYPE] Account for spaces in x-dimension of IntExtTextOutW function (#7274)
by Doug Lyons 01 Sep '24

01 Sep '24

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=a1bff5b94efa36b9e48d3… commit a1bff5b94efa36b9e48d37f91b56428131c10531 Author: Doug Lyons <douglyons(a)douglyons.com> AuthorDate: Sun Sep 1 13:18:23 2024 -0500 Commit: GitHub <noreply(a)github.com> CommitDate: Sun Sep 1 13:18:23 2024 -0500 [NTGDI:FREETYPE] Account for spaces in x-dimension of IntExtTextOutW function (#7274) @I_Kill_Bugs fix CORE-11787, CORE-17721 and CORE-19721 For function IntExtTextOutW with space character, the x-dimension should be taken into account. Fixes HexEdit 1.2.1 right side of display window not being cleared. Account for x-dimension if TA_UPDATECP flag set and 'String' is not NULL. Clarify 'etx' is ASCII End of Text --- win32ss/gdi/ntgdi/freetype.c | 23 ++++++++++++++++++++--- 1 file changed, 20 insertions(+), 3 deletions(-) diff --git a/win32ss/gdi/ntgdi/freetype.c b/win32ss/gdi/ntgdi/freetype.c index 6a72112f2c9..5a6f8479bbc 100644 --- a/win32ss/gdi/ntgdi/freetype.c +++ b/win32ss/gdi/ntgdi/freetype.c @@ -6795,8 +6795,9 @@ IntExtTextOutW( FONT_CACHE_ENTRY Cache; FT_Matrix mat; BOOL bNoTransform; - DWORD ch0, ch1; + DWORD ch0, ch1, etx = 3; // etx is ASCII End of Text FONTLINK_CHAIN Chain; + SIZE spaceWidth; /* Check if String is valid */ if (Count > 0xFFFF || (Count > 0 && String == NULL)) @@ -7062,6 +7063,22 @@ IntExtTextOutW( bitSize.cx = realglyph->bitmap.width; bitSize.cy = realglyph->bitmap.rows; + /* Do chars other than space and etx have a bitSize.cx of zero? */ + if (ch0 != L' ' && ch0 != etx && bitSize.cx == 0) + DPRINT1("WARNING: WChar 0x%04x has a bitSize.cx of zero\n", ch0); + + /* Don't ignore spaces when computing offset. + * This completes the fix of CORE-11787. */ + if ((pdcattr->flTextAlign & TA_UPDATECP) && ch0 == L' ' && bitSize.cx == 0) + { + IntUnLockFreeType(); + /* Get the width of the space character */ + TextIntGetTextExtentPoint(dc, TextObj, L" ", 1, 0, NULL, 0, &spaceWidth, 0); + IntLockFreeType(); + bitSize.cx = spaceWidth.cx; + realglyph->left = 0; + } + MaskRect.right = realglyph->bitmap.width; MaskRect.bottom = realglyph->bitmap.rows; @@ -7166,8 +7183,8 @@ IntExtTextOutW( previous = glyph_index; } - - if (pdcattr->flTextAlign & TA_UPDATECP) + /* Don't update position if String == NULL. Fixes CORE-19721. */ + if ((pdcattr->flTextAlign & TA_UPDATECP) && String) pdcattr->ptlCurrent.x = DestRect.right - dc->ptlDCOrig.x; if (plf->lfUnderline || plf->lfStrikeOut) /* Underline or strike-out? */

1 0

[reactos] 01/01: [INTEROP_UNITTEST] Add interoperability tests for localized strings (#7129)
by Stanislav Motylkov 01 Sep '24

01 Sep '24

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=b6ae42492b06950d583b0… commit b6ae42492b06950d583b0d5bdcdefaa892137aa4 Author: Stanislav Motylkov <x86corez(a)gmail.com> AuthorDate: Sun Sep 1 15:22:29 2024 +0300 Commit: GitHub <noreply(a)github.com> CommitDate: Sun Sep 1 15:22:29 2024 +0300 [INTEROP_UNITTEST] Add interoperability tests for localized strings (#7129) Finally, an automated way to verify all these localized strings that must be in sync between multiple modules. CORE-18893 --- modules/rostests/unittests/CMakeLists.txt | 1 + modules/rostests/unittests/interop/CMakeLists.txt | 16 + modules/rostests/unittests/interop/LocaleTests.cpp | 369 +++++++++++++++++++++ modules/rostests/unittests/interop/interop.h | 12 + modules/rostests/unittests/interop/testlist.c | 18 + 5 files changed, 416 insertions(+) diff --git a/modules/rostests/unittests/CMakeLists.txt b/modules/rostests/unittests/CMakeLists.txt index 65ab7eb4c20..cdf63636002 100644 --- a/modules/rostests/unittests/CMakeLists.txt +++ b/modules/rostests/unittests/CMakeLists.txt @@ -1,4 +1,5 @@ +add_subdirectory(interop) if(ISAPNP_ENABLE) add_subdirectory(isapnp) endif() diff --git a/modules/rostests/unittests/interop/CMakeLists.txt b/modules/rostests/unittests/interop/CMakeLists.txt new file mode 100644 index 00000000000..68eece5682c --- /dev/null +++ b/modules/rostests/unittests/interop/CMakeLists.txt @@ -0,0 +1,16 @@ + +PROJECT(interop_unittest) + +include_directories(../../apitests/include) + +list(APPEND SOURCE + LocaleTests.cpp + testlist.c) + +add_executable(interop_unittest ${SOURCE}) + +target_link_libraries(interop_unittest cppstl) +set_module_type(interop_unittest win32cui) +target_compile_definitions(interop_unittest PRIVATE UNICODE _UNICODE _STLP_NO_EXCEPTIONS) +add_importlibs(interop_unittest shell32 user32 msvcrt kernel32) +add_rostests_file(TARGET interop_unittest) diff --git a/modules/rostests/unittests/interop/LocaleTests.cpp b/modules/rostests/unittests/interop/LocaleTests.cpp new file mode 100644 index 00000000000..ab2dd665dad --- /dev/null +++ b/modules/rostests/unittests/interop/LocaleTests.cpp @@ -0,0 +1,369 @@ +/* + * PROJECT: ReactOS interoperability tests + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Formal locale verification tests + * COPYRIGHT: Copyright 2024 Stanislav Motylkov <x86corez(a)gmail.com> + * Copyright 2024 Katayama Hirofumi MZ <katayama.hirofumi.mz(a)gmail.com> + */ + +#include "interop.h" + +#include <winnls.h> +#include <strsafe.h> +#include <shlwapi.h> + +#include <set> +#include <map> + +enum E_MODULE +{ + shell32, + userenv, + syssetup, + mmsys, + explorer_old, +}; + +enum E_STRING +{ + SH32_PROGRAMS, + SH32_STARTUP, + SH32_STARTMENU, + SH32_PROGRAM_FILES, + SH32_PROGRAM_FILES_COMMON, + SH32_ADMINTOOLS, + UENV_STARTMENU, + UENV_PROGRAMS, + UENV_STARTUP, + SYSS_PROGRAMFILES, + SYSS_COMMONFILES, + MMSY_STARTMENU, + EOLD_PROGRAMS, +}; + +typedef struct PART_TEST +{ + E_MODULE eModule; + UINT id; + SIZE_T nParts; + SIZE_T gotParts; +} PART_TEST; + +typedef struct PART +{ + E_STRING Num; + UINT Idx; +} PART; + +typedef struct PART_MATCH +{ + PART p1, p2; +} PART_MATCH; + +DWORD dwVersion; +LCID curLcid = 0; +std::set<LANGID> langs; +std::map<E_MODULE, HMODULE> mod; +std::map<E_STRING, PART_TEST> parts; + +struct PART_PAIR +{ + E_STRING eString; + PART_TEST part_test; +}; + +static void InitParts(void) +{ + static const PART_PAIR s_pairs[] = + { + // { eString, { eModule, id, nParts } } + { SH32_PROGRAMS, { shell32, 45 /* IDS_PROGRAMS "Start Menu\Programs" */, 2 } }, + { SH32_STARTUP, { shell32, 48 /* IDS_STARTUP "Start Menu\Programs\StartUp" */, 3 } }, + { SH32_STARTMENU, { shell32, 51 /* IDS_STARTMENU "Start Menu" */, 1 } }, + { SH32_PROGRAM_FILES, { shell32, 63 /* IDS_PROGRAM_FILES "Program Files" */, 1 } }, + { SH32_PROGRAM_FILES_COMMON, { shell32, 65 /* IDS_PROGRAM_FILES_COMMON "Program Files\Common Files" */, 2 } }, + { SH32_ADMINTOOLS, { shell32, 67 /* IDS_ADMINTOOLS "Start Menu\Programs\Administrative Tools" */, 3 } }, + { UENV_STARTMENU, { userenv, 11 /* IDS_STARTMENU "Start Menu" */, 1 } }, + { UENV_PROGRAMS, { userenv, 12 /* IDS_PROGRAMS "Start Menu\Programs" */, 2 } }, + { UENV_STARTUP, { userenv, 13 /* IDS_STARTUP "Start Menu\Programs\StartUp" */, 3 } }, + { SYSS_PROGRAMFILES, { syssetup, 3600 /* IDS_PROGRAMFILES "%SystemDrive%\Program Files" */, 2 } }, + { SYSS_COMMONFILES, { syssetup, 3601 /* IDS_COMMONFILES "Common Files" */, 1 } }, + { MMSY_STARTMENU, { mmsys, 5851 /* IDS_STARTMENU "Start Menu" */, 1 } }, + { EOLD_PROGRAMS, { explorer_old, 10 /* IDS_PROGRAMS "Programs" */, 1 } }, + }; + for (auto& pair : s_pairs) + { + parts.insert(std::make_pair(pair.eString, pair.part_test)); + } +} + +static PART_MATCH PartMatches[] = +{ + // Start Menu + { { SH32_PROGRAMS, 0 }, { SH32_STARTUP, 0 } }, + { { SH32_PROGRAMS, 0 }, { SH32_STARTMENU, 0 } }, + { { SH32_PROGRAMS, 0 }, { SH32_ADMINTOOLS, 0 } }, + { { SH32_PROGRAMS, 0 }, { UENV_STARTMENU, 0 } }, + { { SH32_PROGRAMS, 0 }, { UENV_PROGRAMS, 0 } }, + { { SH32_PROGRAMS, 0 }, { UENV_STARTUP, 0 } }, + { { SH32_PROGRAMS, 0 }, { MMSY_STARTMENU, 0 } }, + // Programs + { { SH32_PROGRAMS, 1 }, { SH32_STARTUP, 1 } }, + { { SH32_PROGRAMS, 1 }, { SH32_ADMINTOOLS, 1 } }, + { { SH32_PROGRAMS, 1 }, { UENV_PROGRAMS, 1 } }, + { { SH32_PROGRAMS, 1 }, { UENV_STARTUP, 1 } }, + { { SH32_PROGRAMS, 1 }, { EOLD_PROGRAMS, 0 } }, + // StartUp + { { SH32_STARTUP, 2 }, { UENV_STARTUP, 2 } }, + // Program Files + { { SH32_PROGRAM_FILES, 0 }, { SH32_PROGRAM_FILES_COMMON, 0 } }, + { { SH32_PROGRAM_FILES, 0 }, { SYSS_PROGRAMFILES, 1 } }, + // Common Files + { { SH32_PROGRAM_FILES_COMMON, 1 }, { SYSS_COMMONFILES, 0 } }, +}; + +static int GetLocalisedText(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_ LPWSTR lpBuffer, _In_ int cchBufferMax) +{ + HRSRC hRes = FindResourceExW(hInstance, (LPWSTR)RT_STRING, + MAKEINTRESOURCEW((uID >> 4) + 1), curLcid); + + if (!hRes) + hRes = FindResourceExW(hInstance, (LPWSTR)RT_STRING, + MAKEINTRESOURCEW((uID >> 4) + 1), + MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), SORT_DEFAULT)); + + if (!hRes) + return 0; + + HGLOBAL hMem = LoadResource(hInstance, hRes); + if (!hMem) + return 0; + + PWCHAR p = (PWCHAR)LockResource(hMem); + for (UINT i = 0; i < (uID & 0x0F); i++) p += *p + 1; + + int len = (*p > cchBufferMax ? cchBufferMax : *p); + memcpy(lpBuffer, p + 1, len * sizeof(WCHAR)); + lpBuffer[len] = UNICODE_NULL; + return len; +} + +static int LoadStringWrapW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_ LPWSTR lpBuffer, _In_ int cchBufferMax) +{ + if (dwVersion < _WIN32_WINNT_WS03) + // Windows XP or lower: SetThreadLocale doesn't select user interface language + return GetLocalisedText(hInstance, uID, lpBuffer, cchBufferMax); + else + return LoadStringW(hInstance, uID, lpBuffer, cchBufferMax); +} + +static DWORD CountParts(_In_ LPWSTR str) +{ + DWORD count = 0; + LPWSTR ptr = str; + + if (*ptr == UNICODE_NULL) + return 0; + + while ((ptr = wcschr(ptr, L'\\'))) + { + count++; + ptr++; + } + + return count + 1; +} + +static LPWSTR GetPart(_In_ LPWSTR str, _In_ SIZE_T num, _Out_ SIZE_T* len) +{ + DWORD count = 0; + LPWSTR ptr = str, next; + + while (count < num && (ptr = wcschr(ptr, L'\\')) != NULL) + { + count++; + ptr++; + } + + if (!ptr) + ptr = str; + + next = wcschr(ptr, L'\\'); + *len = next ? next - ptr : wcslen(ptr); + return ptr; +} + +static BOOL CALLBACK find_locale_id_callback( + _In_ HMODULE hModule, _In_ LPCWSTR type, _In_ LPCWSTR name, _In_ LANGID lang, _In_ LPARAM lParam) +{ + langs.insert(lang); + return TRUE; +} + +static void SetLocale(_In_ LCID lcid) +{ + SetThreadLocale(lcid); + SetThreadUILanguage(lcid); + curLcid = lcid; +} + +static void TEST_NumParts(void) +{ + for (auto& p : parts) + { + E_MODULE m = p.second.eModule; + + if (!mod[m]) + { + skip("No module for test %d\n", p.first); + continue; + } + + WCHAR szBuffer[MAX_PATH]; + + LoadStringWrapW(mod[m], p.second.id, szBuffer, _countof(szBuffer)); + p.second.gotParts = CountParts(szBuffer); + + ok(p.second.nParts == p.second.gotParts, "Locale 0x%lX: Num parts mismatch %d - expected %lu, got %lu\n", + curLcid, p.first, p.second.nParts, p.second.gotParts); + } +} + +static BOOL LoadPart(_In_ PART* p, _Out_ LPWSTR str, _In_ SIZE_T size) +{ + auto s = parts[p->Num]; + E_MODULE m = s.eModule; + + if (!mod[m]) + { + SetLastError(ERROR_FILE_NOT_FOUND); + return FALSE; + } + + if (s.nParts != s.gotParts) + { + SetLastError(ERROR_INVALID_DATA); + return FALSE; + } + + WCHAR szBuffer[MAX_PATH]; + LPWSTR szPart; + SIZE_T len; + + LoadStringWrapW(mod[m], s.id, szBuffer, _countof(szBuffer)); + szPart = GetPart(szBuffer, p->Idx, &len); + StringCchCopyNW(str, size, szPart, len); + + return TRUE; +} + +static void TEST_PartMatches(void) +{ + for (auto& match : PartMatches) + { + WCHAR szP1[MAX_PATH], szP2[MAX_PATH]; + + if (!LoadPart(&match.p1, szP1, _countof(szP1))) + { + skip("%s for match test %d (pair 1)\n", GetLastError() == ERROR_FILE_NOT_FOUND + ? "No module" : "Invalid data", match.p1.Num); + continue; + } + + if (!LoadPart(&match.p2, szP2, _countof(szP2))) + { + skip("%s for match test %d (pair 2)\n", GetLastError() == ERROR_FILE_NOT_FOUND + ? "No module" : "Invalid data", match.p2.Num); + continue; + } + + ok(wcscmp(szP1, szP2) == 0, "Locale 0x%lX: Mismatching pairs %u:%u / %u:%u '%S' vs. '%S'\n", + curLcid, match.p1.Num, match.p1.Idx, match.p2.Num, match.p2.Idx, szP1, szP2); + } +} + +static void TEST_LocaleTests(void) +{ + // Initialization + InitParts(); + + OSVERSIONINFOEXW osvi; + memset(&osvi, 0, sizeof(osvi)); + osvi.dwOSVersionInfoSize = sizeof(osvi); + + GetVersionExW((LPOSVERSIONINFOW)&osvi); + dwVersion = (osvi.dwMajorVersion << 8) | osvi.dwMinorVersion; + + WCHAR szOldDir[MAX_PATH], szBuffer[MAX_PATH]; + GetCurrentDirectoryW(_countof(szOldDir), szOldDir); + + std::map<E_MODULE, LPCWSTR> lib; +#define ADD_LIB(eModule, pszPath) lib.insert(std::make_pair(eModule, pszPath)) + + GetModuleFileNameW(NULL, szBuffer, _countof(szBuffer)); + LPCWSTR pszFind = StrStrW(szBuffer, L"modules\\rostests\\unittests"); + if (pszFind) + { + // We're running in ReactOS output folder + WCHAR szNewDir[MAX_PATH]; + + StringCchCopyNW(szNewDir, _countof(szNewDir), szBuffer, pszFind - szBuffer); + SetCurrentDirectoryW(szNewDir); + + ADD_LIB(shell32, L"dll\\win32\\shell32\\shell32.dll"); + ADD_LIB(userenv, L"dll\\win32\\userenv\\userenv.dll"); + ADD_LIB(syssetup, L"dll\\win32\\syssetup\\syssetup.dll"); + ADD_LIB(mmsys, L"dll\\cpl\\mmsys\\mmsys.cpl"); + ADD_LIB(explorer_old, L"modules\\rosapps\\applications\\explorer-old\\explorer_old.exe"); + } + else + { + ADD_LIB(shell32, L"shell32.dll"); + ADD_LIB(userenv, L"userenv.dll"); + ADD_LIB(syssetup, L"syssetup.dll"); + ADD_LIB(mmsys, L"mmsys.cpl"); + ADD_LIB(explorer_old, L"explorer_old.exe"); + } +#undef ADD_LIB + + for (auto& lb : lib) + { + E_MODULE m = lb.first; + + mod[m] = LoadLibraryExW(lib[m], NULL, LOAD_LIBRARY_AS_DATAFILE); + if (!mod[m]) + { + trace("Failed to load '%S', error %lu\n", lib[m], GetLastError()); + continue; + } + + EnumResourceLanguagesW(mod[m], (LPCWSTR)RT_STRING, (LPCWSTR)LOCALE_ILANGUAGE, + find_locale_id_callback, NULL); + } + + // Actual tests + for (auto& lang : langs) + { + SetLocale(MAKELCID(lang, SORT_DEFAULT)); + + TEST_NumParts(); + TEST_PartMatches(); + } + + // Perform cleanup + for (auto& m : mod) + { + if (!m.second) + continue; + + FreeLibrary(m.second); + m.second = NULL; + } + + SetCurrentDirectoryW(szOldDir); +} + +START_TEST(LocaleTests) +{ + TEST_LocaleTests(); +} diff --git a/modules/rostests/unittests/interop/interop.h b/modules/rostests/unittests/interop/interop.h new file mode 100644 index 00000000000..077234af306 --- /dev/null +++ b/modules/rostests/unittests/interop/interop.h @@ -0,0 +1,12 @@ +/* + * PROJECT: ReactOS interoperability tests + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Main header file + * COPYRIGHT: Copyright 2024 Stanislav Motylkov <x86corez(a)gmail.com> + */ + +#pragma once + +#include <ntstatus.h> +#define WIN32_NO_STATUS +#include <apitest.h> diff --git a/modules/rostests/unittests/interop/testlist.c b/modules/rostests/unittests/interop/testlist.c new file mode 100644 index 00000000000..c098a49a6f9 --- /dev/null +++ b/modules/rostests/unittests/interop/testlist.c @@ -0,0 +1,18 @@ +/* + * PROJECT: ReactOS interoperability tests + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: List of tests + * COPYRIGHT: Copyright 2024 Stanislav Motylkov <x86corez(a)gmail.com> + */ + +#define STANDALONE +#include <wine/test.h> + +extern void func_LocaleTests(void); + +const struct test winetest_testlist[] = +{ + { "LocaleTests", func_LocaleTests }, + + { 0, 0 } +};

1 0

[reactos] 01/01: [USER32_APITEST] Improve RedrawWindow API test by testing flags (#7160)
by Tomáš Veselý 01 Sep '24

01 Sep '24

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=52d6a714611e43b2b9241… commit 52d6a714611e43b2b92414c523e05386810fd8e3 Author: Tomáš Veselý <turican0(a)gmail.com> AuthorDate: Sun Sep 1 13:32:43 2024 +0200 Commit: GitHub <noreply(a)github.com> CommitDate: Sun Sep 1 14:32:43 2024 +0300 [USER32_APITEST] Improve RedrawWindow API test by testing flags (#7160) As part of fixing some bugs like CORE-13149, extend the tests to include more detailed examination of rendering functions. Extend the RedrawWindow test to include tests of all flags. As part of it, I am also testing the 2-point states of the render areas. I moved the original test without changes into a separate function GetMessageRedrawWindowTest. For the flag tests I added FlagsRedrawWindowTest function. It sequentially tests the RedrawWindow with different flag combinations and compares the results with those discovered in Windows XP and Windows 11 (the values in both versions confirmed to be identical). The API test turned out well in ReactOS, the only deviation was that in many cases (whenever the RDW_INVALIDATE flag is present) a WM_ERASEBKGND message is received after the window is rendered without the RDW_ERASE flag. (this is what I'm focusing on now in https://github.com/turican0/reactos/tree/fix-RDW_ERASE-in-co_UserRedrawWind…, but before I merge it, I want to create more API tests) --- modules/rostests/apitests/user32/RedrawWindow.c | 1100 ++++++++++++++++++++++- 1 file changed, 1098 insertions(+), 2 deletions(-) diff --git a/modules/rostests/apitests/user32/RedrawWindow.c b/modules/rostests/apitests/user32/RedrawWindow.c index 50ed0ea19e8..c5ce8d333f4 100644 --- a/modules/rostests/apitests/user32/RedrawWindow.c +++ b/modules/rostests/apitests/user32/RedrawWindow.c @@ -3,6 +3,7 @@ * LICENSE: LGPL-2.1+ (https://spdx.org/licenses/LGPL-2.1+) * PURPOSE: Test for RedrawWindow * COPYRIGHT: Copyright 2018 Thomas Faber <thomas.faber(a)reactos.org> + * Copyright 2024 Tomáš Veselý <turican0(a)gmail.com> */ #include "precomp.h" @@ -10,6 +11,11 @@ static DWORD dwThreadId; static BOOL got_paint; +BOOL resultWmEraseGnd = FALSE; +BOOL resultWmNcPaint = FALSE; +int paintIndex = 0; +const wchar_t CHILD_CLASS_NAME[] = L"ChildWindowClass"; + static LRESULT CALLBACK @@ -28,8 +34,7 @@ WndProc( return DefWindowProcW(hWnd, message, wParam, lParam); } - -START_TEST(RedrawWindow) +void GetMessageRedrawWindowTest() { HWND hWnd; MSG msg; @@ -86,3 +91,1094 @@ START_TEST(RedrawWindow) DeleteObject(hRgn); DestroyWindow(hWnd); } + +void DrawContent(HDC hdc, RECT* rect, COLORREF color) +{ + HBRUSH hBrush = CreateSolidBrush(color); + FillRect(hdc, rect, hBrush); + DeleteObject(hBrush); + + SetBkMode(hdc, TRANSPARENT); + SetTextColor(hdc, RGB(255, 255, 255)); + DrawTextW(hdc, L"Test RedrawWindow", -1, rect, DT_CENTER | DT_VCENTER | DT_SINGLELINE); +} + +LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + switch (uMsg) + { + case WM_DESTROY: + { + PostQuitMessage(0); + return 0; + } + case WM_PAINT: + { + PAINTSTRUCT ps; + HDC hdc = BeginPaint(hwnd, &ps); + RECT rect; + GetClientRect(hwnd, &rect); + DrawContent(hdc, &rect, RGB(0, 255, 0)); + EndPaint(hwnd, &ps); + paintIndex++; + return 0; + } + case WM_ERASEBKGND: + { + if(paintIndex != 0) + resultWmEraseGnd = TRUE; + return 0; + } + case WM_NCPAINT: + { + if (paintIndex != 0) + resultWmNcPaint = TRUE; + return 0; + } + } + return DefWindowProc(hwnd, uMsg, wParam, lParam); +} + +LRESULT CALLBACK ChildWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + switch (uMsg) { + case WM_SYNCPAINT: + { + PAINTSTRUCT ps; + HDC hdc = BeginPaint(hwnd, &ps); + HBRUSH brush = CreateSolidBrush(RGB(0, 0, 255)); + FillRect(hdc, &ps.rcPaint, brush); + DeleteObject(brush); + EndPaint(hwnd, &ps); + break; + } + case WM_PAINT: + { + PAINTSTRUCT ps; + HDC hdc = BeginPaint(hwnd, &ps); + HBRUSH brush = CreateSolidBrush(RGB(0, 0, 255)); + FillRect(hdc, &ps.rcPaint, brush); + DeleteObject(brush); + EndPaint(hwnd, &ps); + break; + } + case WM_DESTROY: + { + PostQuitMessage(0); + return 0; + } + } + return DefWindowProc(hwnd, uMsg, wParam, lParam); +} + +typedef struct STRUCT_TestRedrawWindow +{ + const wchar_t* testName; + DWORD flags; + BOOL useRegion; + RECT regRect; + BOOL useRect; + RECT rectRect; + BOOL forcePaint; + BOOL redrawResult; + int testPixelPre1x; + int testPixelPre1y; + int testPixelPre2x; + int testPixelPre2y; + int testPixelPost1x; + int testPixelPost1y; + int testPixelPost2x; + int testPixelPost2y; + int testChild; + COLORREF resultColorPre1; + COLORREF resultColorPre2; + COLORREF resultColorPost1; + COLORREF resultColorPost2; + RECT resultUpdateRect; + BOOL resultNeedsUpdate; + BOOL resultRedraw; + BOOL resultWmEraseGnd; + BOOL resultWmNcPaint; + int resultPaintIndex; +} STRUCT_TestRedrawWindow; + +typedef struct STRUCT_TestRedrawWindowCompare +{ + COLORREF resultColorPre1; + COLORREF resultColorPre2; + COLORREF resultColorPost1; + COLORREF resultColorPost2; + RECT resultUpdateRect; + BOOL resultNeedsUpdate; + BOOL resultWmEraseGnd; + BOOL resultWmNcPaint; + int resultPaintIndex; +} STRUCT_TestRedrawWindowCompare; + +void ServeSomeMessages(int messageTime, int messageCount) +{ + DWORD startTime; + + MSG msg = { 0 }; + startTime = GetTickCount(); + while (GetTickCount() - startTime < messageTime * messageCount) + { + if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) + { + TranslateMessage(&msg); + DispatchMessage(&msg); + } + else + { + Sleep(messageTime); + } + } +} + +void TestRedrawWindow(STRUCT_TestRedrawWindow* ptestRW) { + DWORD style; + int width; + int height; + HWND hChildWnd = NULL; + HRGN RgnUpdate; + RECT* prect; + + resultWmEraseGnd = FALSE; + resultWmNcPaint = FALSE; + paintIndex = 0; + + WNDCLASSW wc = { 0 }; + wc.lpfnWndProc = WindowProc; + wc.hInstance = GetModuleHandle(NULL); + wc.lpszClassName = ptestRW->testName; + RegisterClassW(&wc); + RECT rectWin = { 0, 0, 800, 600 }; + style = WS_OVERLAPPEDWINDOW; + AdjustWindowRectEx(&rectWin, style, FALSE, 0); + width = rectWin.right - rectWin.left; + height = rectWin.bottom - rectWin.top; + HWND hwnd = CreateWindowExW(0, wc.lpszClassName, wc.lpszClassName, WS_OVERLAPPEDWINDOW, + CW_USEDEFAULT, CW_USEDEFAULT, width, height, NULL, NULL, GetModuleHandle(NULL), NULL); + if (hwnd == NULL) + return; + + ShowWindow(hwnd, SW_SHOW); + if(!ptestRW->testChild) + UpdateWindow(hwnd); + + if (ptestRW->testChild) + { + WNDCLASSW wcChild = { 0 }; + wcChild.lpfnWndProc = ChildWindowProc; + wcChild.hInstance = GetModuleHandle(NULL); + wcChild.lpszClassName = CHILD_CLASS_NAME; + RegisterClassW(&wcChild); + + hChildWnd = CreateWindowExW( + 0, + CHILD_CLASS_NAME, + L"Child Window", + WS_CHILD | WS_VISIBLE, + 10, 10, 200, 200, + hwnd, + NULL, + GetModuleHandle(NULL), + NULL + ); + } + + HDC hdc = GetDC(hwnd); + RECT drect = { 0, 0, 800, 600 }; + DrawContent(hdc, &drect, RGB(255, 0, 0)); + ReleaseDC(hwnd, hdc); + + RgnUpdate = NULL; + if (ptestRW->useRegion) + { + RgnUpdate = CreateRectRgn(ptestRW->regRect.left, ptestRW->regRect.top, ptestRW->regRect.right, ptestRW->regRect.bottom); + } + + prect=NULL; + if (ptestRW->useRect) + { + prect = &ptestRW->rectRect; + } + + if (ptestRW->testChild) + { + ServeSomeMessages(10, 10); + } + + ptestRW->resultRedraw = RedrawWindow(hwnd, prect, RgnUpdate, ptestRW->flags); + + if (ptestRW->testChild) + { + ServeSomeMessages(10, 10); + } + + hdc = GetDC(hwnd); + ptestRW->resultColorPre1 = GetPixel(hdc, ptestRW->testPixelPre1x, ptestRW->testPixelPre1y); + ptestRW->resultColorPre2 = GetPixel(hdc, ptestRW->testPixelPre2x, ptestRW->testPixelPre2y); + ReleaseDC(hwnd, hdc); + + ptestRW->resultNeedsUpdate = GetUpdateRect(hwnd, &ptestRW->resultUpdateRect, FALSE); + + if (ptestRW->forcePaint) + { + UpdateWindow(hwnd); + } + + hdc = GetDC(hwnd); + ptestRW->resultColorPost1 = GetPixel(hdc, ptestRW->testPixelPost1x, ptestRW->testPixelPost1y); + ptestRW->resultColorPost2 = GetPixel(hdc, ptestRW->testPixelPost2x, ptestRW->testPixelPost2y); + ReleaseDC(hwnd, hdc); + + ptestRW->resultWmEraseGnd = resultWmEraseGnd; + ptestRW->resultWmNcPaint = resultWmNcPaint; + ptestRW->resultPaintIndex = paintIndex; + + if (RgnUpdate) DeleteObject(RgnUpdate); + + if (hChildWnd != NULL) + DestroyWindow(hChildWnd); + if (hwnd != NULL) + DestroyWindow(hwnd); +} + +UINT TestRedrawWindow2(STRUCT_TestRedrawWindow* ptestRW, STRUCT_TestRedrawWindowCompare* ptestRWcompare) +{ + UINT countErrors = 0; + + TestRedrawWindow(ptestRW); + + if (ptestRW->resultRedraw) + { + if (ptestRWcompare->resultColorPre1 != ptestRW->resultColorPre1) + { + trace("DIFFERENCE-resultColorPre1 0x%06x 0x%06x\n", (int)ptestRW->resultColorPre1, (int)ptestRWcompare->resultColorPre1); + countErrors++; + } + if (ptestRWcompare->resultColorPre2 != ptestRW->resultColorPre2) + { + trace("DIFFERENCE-resultColorPre2 0x%06x 0x%06x\n", (int)ptestRW->resultColorPre2, (int)ptestRWcompare->resultColorPre2); + countErrors++; + } + if (ptestRWcompare->resultColorPost1 != ptestRW->resultColorPost1) + { + trace("DIFFERENCE-resultColorPost1 0x%06x 0x%06x\n", (int)ptestRW->resultColorPost1, (int)ptestRWcompare->resultColorPost1); + countErrors++; + } + if (ptestRWcompare->resultColorPost2 != ptestRW->resultColorPost2) + { + trace("DIFFERENCE-resultColorPost2 0x%06x 0x%06x\n", (int)ptestRW->resultColorPost2, (int)ptestRWcompare->resultColorPost2); + countErrors++; + } + if (ptestRWcompare->resultNeedsUpdate != ptestRW->resultNeedsUpdate) + { + trace("DIFFERENCE-resultNeedsUpdate %d %d\n", ptestRW->resultNeedsUpdate, ptestRWcompare->resultNeedsUpdate); + countErrors++; + } + if (ptestRW->resultNeedsUpdate) + { + if (ptestRWcompare->resultUpdateRect.left != ptestRW->resultUpdateRect.left) + { + trace("DIFFERENCE-resultUpdateRect.left %d %d\n", (int)ptestRW->resultUpdateRect.left, (int)ptestRWcompare->resultUpdateRect.left); + countErrors++; + } + if (ptestRWcompare->resultUpdateRect.top != ptestRW->resultUpdateRect.top) + { + trace("DIFFERENCE-resultUpdateRect.top %d %d\n", (int)ptestRW->resultUpdateRect.top, (int)ptestRWcompare->resultUpdateRect.top); + countErrors++; + } + if (ptestRWcompare->resultUpdateRect.right != ptestRW->resultUpdateRect.right) + { + trace("DIFFERENCE-resultUpdateRect.right %d %d\n", (int)ptestRW->resultUpdateRect.right, (int)ptestRWcompare->resultUpdateRect.right); + countErrors++; + } + if (ptestRWcompare->resultUpdateRect.bottom != ptestRW->resultUpdateRect.bottom) + { + trace("DIFFERENCE-resultUpdateRect.bottom %d %d\n", (int)ptestRW->resultUpdateRect.bottom, (int)ptestRWcompare->resultUpdateRect.bottom); + countErrors++; + } + } + if (ptestRWcompare->resultWmEraseGnd != ptestRW->resultWmEraseGnd) + { + trace("DIFFERENCE-resultWmEraseGnd %d %d\n", ptestRW->resultWmEraseGnd, ptestRWcompare->resultWmEraseGnd); + countErrors++; + } + if (ptestRWcompare->resultWmNcPaint != ptestRW->resultWmNcPaint) + { + trace("DIFFERENCE-resultWmNcPaint %d %d\n", ptestRW->resultWmNcPaint, ptestRWcompare->resultWmNcPaint); + countErrors++; + } + if (ptestRWcompare->resultPaintIndex != ptestRW->resultPaintIndex) + { + trace("DIFFERENCE-resultPaintIndex %d %d\n", ptestRW->resultPaintIndex, ptestRWcompare->resultPaintIndex); + countErrors++; + } + } + if (countErrors > 0) + { + trace("COUNT OF DIFFERENCES - %d\n", countErrors); + } + + return countErrors; +} + +void InitRect(RECT *rect, int left, int top, int right, int bottom) { + rect->left = left; + rect->top = top; + rect->right = right; + rect->bottom = bottom; +} + +void FlagsRedrawWindowTest() +{ + STRUCT_TestRedrawWindow testRW; + STRUCT_TestRedrawWindowCompare testRWcompare; + + testRW.testPixelPre1x = 50; + testRW.testPixelPre1y = 50; + testRW.testPixelPre2x = 50; + testRW.testPixelPre2y = 550; + testRW.testPixelPost1x = 50; + testRW.testPixelPost1y = 50; + testRW.testPixelPost2x = 50; + testRW.testPixelPost2y = 550; + + // RDW_ERASE tests + testRW.testName = L"Test1"; + testRW.flags = 0; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x000000FF; + InitRect(&testRWcompare.resultUpdateRect, 0, 0, 200, 200); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test1 fail\n"); + + testRW.testName = L"Test2"; + testRW.flags = RDW_ERASE; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x000000FF; + InitRect(&testRWcompare.resultUpdateRect, 0, 0, 200, 200); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test2 fail\n"); + + testRW.testName = L"Test3"; + testRW.flags = RDW_INVALIDATE; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = TRUE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 2; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test3 fail\n"); + + testRW.testName = L"Test4"; + testRW.flags = RDW_INVALIDATE | RDW_ERASE; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = TRUE; + testRWcompare.resultWmEraseGnd = TRUE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 2; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test4 fail\n"); + + // RDW_FRAME tests + testRW.testName = L"Test5"; + testRW.flags = RDW_FRAME; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x000000FF; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test5 fail\n"); + + testRW.testName = L"Test6"; + testRW.flags = RDW_INVALIDATE | RDW_FRAME; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = TRUE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = TRUE; + testRWcompare.resultPaintIndex = 2; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test6 fail\n"); + + // RDW_INTERNALPAINT tests + testRW.testName = L"Test7"; + testRW.flags = RDW_INTERNALPAINT; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x000000FF; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 2; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test7 fail\n"); + + testRW.testName = L"Test8"; + testRW.flags = RDW_INVALIDATE | RDW_INTERNALPAINT; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = TRUE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 2; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test8 fail\n"); + + // RDW_NOERASE tests + testRW.testName = L"Test9"; + testRW.flags = RDW_NOERASE; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x000000FF; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test9 fail\n"); + + testRW.testName = L"Test10"; + testRW.flags = RDW_INVALIDATE | RDW_NOERASE; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = TRUE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 2; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test10 fail\n"); + + testRW.testName = L"Test11"; + testRW.flags = RDW_NOERASE | RDW_ERASE; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x000000FF; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test11 fail\n"); + + testRW.testName = L"Test12"; + testRW.flags = RDW_INVALIDATE | RDW_NOERASE | RDW_ERASE; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = TRUE; + testRWcompare.resultWmEraseGnd = TRUE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 2; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test12 fail\n"); + + // RDW_NOFRAME tests + testRW.testName = L"Test13"; + testRW.flags = RDW_NOFRAME; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x000000FF; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test13 fail\n"); + + testRW.testName = L"Test14"; + testRW.flags = RDW_INVALIDATE | RDW_NOFRAME; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = TRUE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 2; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test14 fail\n"); + + testRW.testName = L"Test15"; + testRW.flags = RDW_INVALIDATE | RDW_VALIDATE | RDW_NOFRAME; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = TRUE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 2; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test15 fail\n"); + + testRW.testName = L"Test16"; + testRW.flags = RDW_VALIDATE | RDW_NOFRAME; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x000000FF; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test16 fail\n"); + + // RDW_NOINTERNALPAINT tests + testRW.testName = L"Test17"; + testRW.flags = RDW_NOINTERNALPAINT; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x000000FF; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test17 fail\n"); + + testRW.testName = L"Test18"; + testRW.flags = RDW_INVALIDATE | RDW_NOINTERNALPAINT; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = TRUE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 2; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test18 fail\n"); + + testRW.testName = L"Test19"; + testRW.flags = RDW_VALIDATE | RDW_NOINTERNALPAINT; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x000000FF; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test19 fail\n"); + + // RDW_ERASENOW tests + testRW.testName = L"Test20"; + testRW.flags = RDW_ERASENOW; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x000000FF; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test20 fail\n"); + + testRW.testName = L"Test21"; + testRW.flags = RDW_INVALIDATE | RDW_ERASENOW; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = TRUE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 2; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test21 fail\n"); + + testRW.testName = L"Test22"; + testRW.flags = RDW_VALIDATE | RDW_ERASENOW; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x000000FF; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test22 fail\n"); + + // RDW_UPDATENOW tests + testRW.testName = L"Test23"; + testRW.flags = RDW_UPDATENOW; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x000000FF; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test23 fail\n"); + + testRW.testName = L"Test24"; + testRW.flags = RDW_INVALIDATE | RDW_UPDATENOW; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x0000FF00; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 2; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test24 fail\n"); + + testRW.testName = L"Test25"; + testRW.flags = RDW_VALIDATE | RDW_UPDATENOW; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x000000FF; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test25 fail\n"); + + // RDW_ALLCHILDREN/RDW_NOCHILDREN tests + testRW.testName = L"Test26"; + testRW.flags = RDW_NOCHILDREN; + testRW.useRegion = FALSE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = TRUE; + + testRWcompare.resultColorPre1 = 0x00FF0000; + testRWcompare.resultColorPre2 = 0x0000FF00; + testRWcompare.resultColorPost1 = 0x00FF0000; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test26 fail\n"); + + testRW.testName = L"Test27"; + testRW.flags = RDW_INVALIDATE | RDW_NOCHILDREN; + testRW.useRegion = FALSE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = TRUE; + + testRWcompare.resultColorPre1 = 0x0000FF00; + testRWcompare.resultColorPre2 = 0x0000FF00; + testRWcompare.resultColorPost1 = 0x0000FF00; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 2; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test27 fail\n"); + + testRW.testName = L"Test28"; + testRW.flags = RDW_VALIDATE | RDW_NOCHILDREN; + testRW.useRegion = FALSE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = TRUE; + + testRWcompare.resultColorPre1 = 0x00FF0000; + testRWcompare.resultColorPre2 = 0x0000FF00; + testRWcompare.resultColorPost1 = 0x00FF0000; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test28 fail\n"); + + testRW.testName = L"Test29"; + testRW.flags = RDW_ALLCHILDREN; + testRW.useRegion = FALSE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = TRUE; + + testRWcompare.resultColorPre1 = 0x00FF0000; + testRWcompare.resultColorPre2 = 0x0000FF00; + testRWcompare.resultColorPost1 = 0x00FF0000; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test29 fail\n"); + + testRW.testName = L"Test30"; + testRW.flags = RDW_INVALIDATE | RDW_ALLCHILDREN; + testRW.useRegion = FALSE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = TRUE; + + testRWcompare.resultColorPre1 = 0x00FF0000; + testRWcompare.resultColorPre2 = 0x0000FF00; + testRWcompare.resultColorPre1 = 0x00FF0000; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 2; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test30 fail\n"); + + testRW.testName = L"Test31"; + testRW.flags = RDW_VALIDATE | RDW_ALLCHILDREN; + testRW.useRegion = FALSE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = TRUE; + + testRWcompare.resultColorPre1 = 0x00FF0000; + testRWcompare.resultColorPre2 = 0x0000FF00; + testRWcompare.resultColorPost1 = 0x00FF0000; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test31 fail\n"); + + testRW.testName = L"Test32"; + testRW.flags = RDW_NOCHILDREN; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = TRUE; + + testRWcompare.resultColorPre1 = 0x00FF0000; + testRWcompare.resultColorPre2 = 0x0000FF00; + testRWcompare.resultColorPost1 = 0x00FF0000; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test32 fail\n"); + + testRW.testName = L"Test33"; + testRW.flags = RDW_INVALIDATE | RDW_NOCHILDREN; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = TRUE; + + testRWcompare.resultColorPre1 = 0x00FF0000; + testRWcompare.resultColorPre2 = 0x0000FF00; + testRWcompare.resultColorPre1 = 0x00FF0000; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 2; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test33 fail\n"); + + testRW.testName = L"Test34"; + testRW.flags = RDW_VALIDATE | RDW_NOCHILDREN; + testRW.useRegion = TRUE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = FALSE; + InitRect(&testRW.rectRect, 0, 0, 200, 200); + testRW.forcePaint = TRUE; + testRW.testChild = TRUE; + + testRWcompare.resultColorPre1 = 0x00FF0000; + testRWcompare.resultColorPre2 = 0x0000FF00; + testRWcompare.resultColorPost1 = 0x00FF0000; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test34 fail\n"); + + // rect defined area tests + testRW.testName = L"Test35"; + testRW.flags = 0; + testRW.useRegion = FALSE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = TRUE; + InitRect(&testRW.rectRect, 0, 500, 800, 600); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x000000FF; + InitRect(&testRWcompare.resultUpdateRect, 0, 0, 200, 200); + testRWcompare.resultNeedsUpdate = FALSE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 1; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test35 fail\n"); + + testRW.testName = L"Test36"; + testRW.flags = RDW_INVALIDATE | RDW_ERASENOW; + testRW.useRegion = FALSE; + InitRect(&testRW.regRect, 0, 500, 800, 600); + testRW.useRect = TRUE; + InitRect(&testRW.rectRect, 0, 500, 800, 600); + testRW.forcePaint = TRUE; + testRW.testChild = FALSE; + + testRWcompare.resultColorPre1 = 0x000000FF; + testRWcompare.resultColorPre2 = 0x000000FF; + testRWcompare.resultColorPost1 = 0x000000FF; + testRWcompare.resultColorPost2 = 0x0000FF00; + InitRect(&testRWcompare.resultUpdateRect, 0, 500, 800, 600); + testRWcompare.resultNeedsUpdate = TRUE; + testRWcompare.resultWmEraseGnd = FALSE; + testRWcompare.resultWmNcPaint = FALSE; + testRWcompare.resultPaintIndex = 2; + ok(0 == TestRedrawWindow2(&testRW, &testRWcompare),"Test36 fail\n"); +} + +START_TEST(RedrawWindow) +{ + FlagsRedrawWindowTest(); + GetMessageRedrawWindowTest(); +}

1 0

[reactos] 01/01: [FREELDR] Fix boot timeout regression on AMD64 (#7281)
by Adam Słaboń 01 Sep '24

01 Sep '24

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=e168d60bc50058ec0cf78… commit e168d60bc50058ec0cf78275d333ce80f90c1ffd Author: Adam Słaboń <asaillen(a)protonmail.com> AuthorDate: Sun Sep 1 08:54:28 2024 +0000 Commit: GitHub <noreply(a)github.com> CommitDate: Sun Sep 1 11:54:28 2024 +0300 [FREELDR] Fix boot timeout regression on AMD64 (#7281) Initialize the BootMgrInfo struct globally, so the TimeOut value is guaranteed to be negative when no Multiboot cmdline is provided. This could happen when BootMain is called with a NULL pointer: https://git.reactos.org/?p=reactos.git;a=blob;f=boot/freeldr/freeldr/arch/a… so CmdLine == NULL and LoadSettings is called with NULL, thus the CmdLineParse isn't run. Fixes boot timeout regression introduced in commit 7bee32d2372feb55949714eec5c92ca7ef2754bf which occured only on AMD64 builds. --- boot/freeldr/freeldr/settings.c | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/boot/freeldr/freeldr/settings.c b/boot/freeldr/freeldr/settings.c index 82051714bcc..7f1e44e51af 100644 --- a/boot/freeldr/freeldr/settings.c +++ b/boot/freeldr/freeldr/settings.c @@ -15,7 +15,7 @@ static CCHAR DebugString[256]; static CCHAR DefaultOs[256]; -BOOTMGRINFO BootMgrInfo = {0}; +BOOTMGRINFO BootMgrInfo = {NULL, NULL, -1, 0}; /* FUNCTIONS ******************************************************************/ @@ -26,12 +26,6 @@ CmdLineParse( PCHAR End, Setting; ULONG_PTR Length, Offset = 0; - /* Set defaults */ - BootMgrInfo.DebugString = NULL; - BootMgrInfo.DefaultOs = NULL; - BootMgrInfo.TimeOut = -1; - // BootMgrInfo.FrLdrSection = 0; - /* * Get the debug string, in the following format: * "debug=option1=XXX;option2=YYY;..."

1 0

[reactos] 01/01: [SDK][SHELL32] Make CLSID_NetworkConnections the default name (#7266)
by Vitaly Orekhov 01 Sep '24

01 Sep '24

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=06024c97fea534c935a0b… commit 06024c97fea534c935a0b2f781495ceba112bbcd Author: Vitaly Orekhov <crce2000(a)mail.ru> AuthorDate: Sun Sep 1 11:40:24 2024 +0300 Commit: GitHub <noreply(a)github.com> CommitDate: Sun Sep 1 11:40:24 2024 +0300 [SDK][SHELL32] Make CLSID_NetworkConnections the default name (#7266) - [SDK][INCLUDE] Redirect CLSID_ConnectionFolder to CLSID_NetworkConnections CLSID_NetworkConnections is the official known name for the class behind it, thus to avoid breaking current code I 'softlink' CLSID_ConnectionFolder to the currently used CLSID_NetworkConnections in shlguid_undoc.h. - [SHELL32] Refer to CLSID_NetworkConnections from PSDK --- dll/win32/shell32/wine/shellpath.c | 5 +---- sdk/include/reactos/shlguid_undoc.h | 2 +- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/dll/win32/shell32/wine/shellpath.c b/dll/win32/shell32/wine/shellpath.c index 6537e052a0d..e55b48b1c33 100644 --- a/dll/win32/shell32/wine/shellpath.c +++ b/dll/win32/shell32/wine/shellpath.c @@ -3214,11 +3214,8 @@ HRESULT WINAPI SHGetFolderLocation( #ifdef __REACTOS__ case CSIDL_CONNECTIONS: - { - EXTERN_C const CLSID CLSID_ConnectionFolder; - hr = SHGetFolderLocationHelper(hwndOwner, CSIDL_CONTROLS, &CLSID_ConnectionFolder, ppidl); + hr = SHGetFolderLocationHelper(hwndOwner, CSIDL_CONTROLS, &CLSID_NetworkConnections, ppidl); break; - } #endif default: diff --git a/sdk/include/reactos/shlguid_undoc.h b/sdk/include/reactos/shlguid_undoc.h index 99baa6ccf58..b72e61c9e3d 100644 --- a/sdk/include/reactos/shlguid_undoc.h +++ b/sdk/include/reactos/shlguid_undoc.h @@ -127,7 +127,7 @@ DEFINE_GUID(CLSID_InboundConnectionUi, 0x7007ACC3, 0x3202, 0x11D1, 0xAA, 0xD DEFINE_GUID(CLSID_InternetConnectionUi, 0x7007ACC4, 0x3202, 0x11D1, 0xAA, 0xD2, 0x00, 0x80, 0x5F, 0xC1, 0x27, 0x0E); DEFINE_GUID(CLSID_LanConnectionUi, 0x7007ACC5, 0x3202, 0x11D1, 0xAA, 0xD2, 0x00, 0x80, 0x5F, 0xC1, 0x27, 0x0E); DEFINE_GUID(CLSID_VpnConnectionUi, 0x7007ACC6, 0x3202, 0x11D1, 0xAA, 0xD2, 0x00, 0x80, 0x5F, 0xC1, 0x27, 0x0E); -DEFINE_GUID(CLSID_ConnectionFolder, 0x7007ACC7, 0x3202, 0x11D1, 0xAA, 0xD2, 0x00, 0x80, 0x5F, 0xC1, 0x27, 0x0E); +#define CLSID_ConnectionFolder CLSID_NetworkConnections DEFINE_GUID(CLSID_ConnectionFolderEnum, 0x7007ACC8, 0x3202, 0x11D1, 0xAA, 0xD2, 0x00, 0x80, 0x5F, 0xC1, 0x27, 0x0E); DEFINE_GUID(CLSID_ConnectionTray, 0x7007ACCF, 0x3202, 0x11D1, 0xAA, 0xD2, 0x00, 0x80, 0x5F, 0xC1, 0x27, 0x0E); DEFINE_GUID(CLSID_ConnectionCommonUi, 0x7007ACD1, 0x3202, 0x11D1, 0xAA, 0xD2, 0x00, 0x80, 0x5F, 0xC1, 0x27, 0x0E);

1 0

[reactos] 01/01: [HALX86] acpi/madt.c: Rewrite it (#6032)
by Serge Gautherie 31 Aug '24

31 Aug '24

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=2c8d083fc019cdfb465b8… commit 2c8d083fc019cdfb465b8e64fd1438d394629c4c Author: Serge Gautherie <32623169+SergeGautherie(a)users.noreply.github.com> AuthorDate: Sat Aug 31 23:35:50 2024 +0200 Commit: GitHub <noreply(a)github.com> CommitDate: Sat Aug 31 14:35:50 2024 -0700 [HALX86] acpi/madt.c: Rewrite it (#6032) Especially HalpParseApicTables() which looked early-WIP and was buggy. And keep smp/mps/mps.c in sync'. --- hal/halx86/acpi/madt.c | 248 ++++++++++++++++++++++++++++++++++++++++------- hal/halx86/include/smp.h | 13 ++- hal/halx86/smp/mps/mps.c | 29 ++++-- 3 files changed, 239 insertions(+), 51 deletions(-) diff --git a/hal/halx86/acpi/madt.c b/hal/halx86/acpi/madt.c index cd26be67b21..f61d51b5d02 100644 --- a/hal/halx86/acpi/madt.c +++ b/hal/halx86/acpi/madt.c @@ -3,6 +3,7 @@ * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) * PURPOSE: Source File for MADT Table parsing * COPYRIGHT: Copyright 2021 Justin Miller <justinmiller100(a)gmail.com> + * Copyright 2023 Serge Gautherie <reactos-git_serge_171003(a)gautherie.fr> */ /* INCLUDES *******************************************************************/ @@ -12,77 +13,250 @@ /* ACPI_BIOS_ERROR defined in acoutput.h and bugcodes.h */ #undef ACPI_BIOS_ERROR #include <smp.h> + #define NDEBUG #include <debug.h> +// See HalpParseApicTables(). Only enable this to local-debug it. +// That needs, for example, to test-call the function later or to use the "FrLdrDbgPrint" hack. +#if DBG && 0 + #define DPRINT01 DPRINT1 + #define DPRINT00 DPRINT +#else +#if defined(_MSC_VER) + #define DPRINT01 __noop + #define DPRINT00 __noop +#else + #define DPRINT01(...) do { if(0) { DbgPrint(__VA_ARGS__); } } while(0) + #define DPRINT00(...) do { if(0) { DbgPrint(__VA_ARGS__); } } while(0) +#endif // _MSC_VER +#endif // DBG && 0 + /* GLOBALS ********************************************************************/ -PROCESSOR_IDENTITY HalpStaticProcessorIdentity[MAXIMUM_PROCESSORS] = {{0}}; -PPROCESSOR_IDENTITY HalpProcessorIdentity = NULL; HALP_APIC_INFO_TABLE HalpApicInfoTable; -ACPI_TABLE_MADT *MadtTable; -ACPI_SUBTABLE_HEADER *AcpiHeader; -ACPI_MADT_LOCAL_APIC *LocalApic; + +// ACPI_MADT_LOCAL_APIC.LapicFlags masks +#define LAPIC_FLAG_ENABLED 0x00000001 +#define LAPIC_FLAG_ONLINE_CAPABLE 0x00000002 +// Bits 2-31 are reserved. + +static PROCESSOR_IDENTITY HalpStaticProcessorIdentity[MAXIMUM_PROCESSORS]; +const PPROCESSOR_IDENTITY HalpProcessorIdentity = HalpStaticProcessorIdentity; + +#if 0 +extern ULONG HalpPicVectorRedirect[16]; +#endif /* FUNCTIONS ******************************************************************/ +// Note: HalpParseApicTables() is called early, so its DPRINT*() do nothing. VOID HalpParseApicTables( _In_ PLOADER_PARAMETER_BLOCK LoaderBlock) { + ACPI_TABLE_MADT *MadtTable; + ACPI_SUBTABLE_HEADER *AcpiHeader; ULONG_PTR TableEnd; - ULONG ValidProcessorCount; - /* We only support legacy APIC for now, this will be updated in the future */ - HalpApicInfoTable.ApicMode = 0x10; - MadtTable = HalAcpiGetTable(LoaderBlock, 'CIPA'); + MadtTable = HalAcpiGetTable(LoaderBlock, APIC_SIGNATURE); + if (!MadtTable) + { + DPRINT01("MADT table not found\n"); + return; + } + + if (MadtTable->Header.Length < sizeof(*MadtTable)) + { + DPRINT01("Length is too short: %p, %u\n", MadtTable, MadtTable->Header.Length); + return; + } - AcpiHeader = (ACPI_SUBTABLE_HEADER*)MadtTable; - AcpiHeader->Length = sizeof(ACPI_TABLE_MADT); - TableEnd = (ULONG_PTR)MadtTable + MadtTable->Header.Length; + DPRINT00("MADT table: Address %08X, Flags %08X\n", MadtTable->Address, MadtTable->Flags); - HalpApicInfoTable.ProcessorCount = 0; - HalpProcessorIdentity = HalpStaticProcessorIdentity; +#if 1 - AcpiHeader = (ACPI_SUBTABLE_HEADER*)MadtTable; - AcpiHeader->Length = sizeof(ACPI_TABLE_MADT); - TableEnd = (ULONG_PTR)MadtTable + MadtTable->Header.Length; + // TODO: We support only legacy APIC for now + HalpApicInfoTable.ApicMode = HALP_APIC_MODE_LEGACY; + // TODO: What about 'MadtTable->Flags & ACPI_MADT_PCAT_COMPAT'? - while ((ULONG_PTR)AcpiHeader <= TableEnd) +#else // TODO: Is that correct? + + if ((MadtTable->Flags & ACPI_MADT_PCAT_COMPAT) == ACPI_MADT_DUAL_PIC) + { + HalpApicInfoTable.ApicMode = HALP_APIC_MODE_LEGACY; + } + else // if ((MadtTable->Flags & ACPI_MADT_PCAT_COMPAT) == ACPI_MADT_MULTIPLE_APIC) { - LocalApic = (ACPI_MADT_LOCAL_APIC*)AcpiHeader; +#if 1 + DPRINT01("ACPI_MADT_MULTIPLE_APIC support is UNIMPLEMENTED\n"); + return; +#else + HalpApicInfoTable.ApicMode = HALP_APIC_MODE_xyz; +#endif + } - if (LocalApic->Header.Type == ACPI_MADT_TYPE_LOCAL_APIC && - LocalApic->Header.Length == sizeof(ACPI_MADT_LOCAL_APIC)) - { - ValidProcessorCount = HalpApicInfoTable.ProcessorCount; +#endif + + HalpApicInfoTable.LocalApicPA = MadtTable->Address; - HalpProcessorIdentity[ValidProcessorCount].LapicId = LocalApic->Id; - HalpProcessorIdentity[ValidProcessorCount].ProcessorId = LocalApic->ProcessorId; + AcpiHeader = (ACPI_SUBTABLE_HEADER *)((ULONG_PTR)MadtTable + sizeof(*MadtTable)); + TableEnd = (ULONG_PTR)MadtTable + MadtTable->Header.Length; + DPRINT00(" MadtTable %p, subtables %p - %p\n", MadtTable, AcpiHeader, (PVOID)TableEnd); - HalpApicInfoTable.ProcessorCount++; + while ((ULONG_PTR)(AcpiHeader + 1) <= TableEnd) + { + if (AcpiHeader->Length < sizeof(*AcpiHeader)) + { + DPRINT01("Length is too short: %p, %u\n", AcpiHeader, AcpiHeader->Length); + return; + } - AcpiHeader = (ACPI_SUBTABLE_HEADER*)((ULONG_PTR)AcpiHeader + AcpiHeader->Length); + if ((ULONG_PTR)AcpiHeader + AcpiHeader->Length > TableEnd) + { + DPRINT01("Length mismatch: %p, %u, %p\n", + AcpiHeader, AcpiHeader->Length, (PVOID)TableEnd); + return; } - else + + switch (AcpiHeader->Type) { - /* End the parsing early if we don't use the currently selected table */ - AcpiHeader = (ACPI_SUBTABLE_HEADER*)((ULONG_PTR)AcpiHeader + 1); + case ACPI_MADT_TYPE_LOCAL_APIC: + { + ACPI_MADT_LOCAL_APIC *LocalApic = (ACPI_MADT_LOCAL_APIC *)AcpiHeader; + + if (AcpiHeader->Length != sizeof(*LocalApic)) + { + DPRINT01("Type/Length mismatch: %p, %u\n", AcpiHeader, AcpiHeader->Length); + return; + } + + DPRINT00(" Local Apic, Processor %lu: ProcessorId %u, Id %u, LapicFlags %08X\n", + HalpApicInfoTable.ProcessorCount, + LocalApic->ProcessorId, LocalApic->Id, LocalApic->LapicFlags); + + if (!(LocalApic->LapicFlags & (LAPIC_FLAG_ONLINE_CAPABLE | LAPIC_FLAG_ENABLED))) + { + DPRINT00(" Ignored: unusable\n"); + break; + } + + if (HalpApicInfoTable.ProcessorCount == _countof(HalpStaticProcessorIdentity)) + { + DPRINT00(" Skipped: array is full\n"); + // We assume ignoring this processor is acceptable, until proven otherwise. + break; + } + + // Note: ProcessorId and Id are not validated in any way (yet). + HalpProcessorIdentity[HalpApicInfoTable.ProcessorCount].ProcessorId = + LocalApic->ProcessorId; + HalpProcessorIdentity[HalpApicInfoTable.ProcessorCount].LapicId = LocalApic->Id; + + HalpApicInfoTable.ProcessorCount++; + + break; + } + case ACPI_MADT_TYPE_IO_APIC: + { + ACPI_MADT_IO_APIC *IoApic = (ACPI_MADT_IO_APIC *)AcpiHeader; + + if (AcpiHeader->Length != sizeof(*IoApic)) + { + DPRINT01("Type/Length mismatch: %p, %u\n", AcpiHeader, AcpiHeader->Length); + return; + } + + DPRINT00(" Io Apic: Id %u, Address %08X, GlobalIrqBase %08X\n", + IoApic->Id, IoApic->Address, IoApic->GlobalIrqBase); + + // Ensure HalpApicInfoTable.IOAPICCount consistency. + if (HalpApicInfoTable.IoApicPA[IoApic->Id] != 0) + { + DPRINT01("Id duplication: %p, %u\n", IoApic, IoApic->Id); + return; + } + + // Note: Address and GlobalIrqBase are not validated in any way (yet). + HalpApicInfoTable.IoApicPA[IoApic->Id] = IoApic->Address; + HalpApicInfoTable.IoApicIrqBase[IoApic->Id] = IoApic->GlobalIrqBase; + + HalpApicInfoTable.IOAPICCount++; + + break; + } + case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: + { + ACPI_MADT_INTERRUPT_OVERRIDE *InterruptOverride = + (ACPI_MADT_INTERRUPT_OVERRIDE *)AcpiHeader; + + if (AcpiHeader->Length != sizeof(*InterruptOverride)) + { + DPRINT01("Type/Length mismatch: %p, %u\n", AcpiHeader, AcpiHeader->Length); + return; + } + + DPRINT00(" Interrupt Override: Bus %u, SourceIrq %u, GlobalIrq %08X, IntiFlags %04X / UNIMPLEMENTED\n", + InterruptOverride->Bus, InterruptOverride->SourceIrq, + InterruptOverride->GlobalIrq, InterruptOverride->IntiFlags); + + if (InterruptOverride->Bus != 0) // 0 = ISA + { + DPRINT01("Invalid Bus: %p, %u\n", InterruptOverride, InterruptOverride->Bus); + return; + } + +#if 1 + // TODO: Implement it. +#else // TODO: Is that correct? + if (InterruptOverride->SourceIrq > _countof(HalpPicVectorRedirect)) + { + DPRINT01("Invalid SourceIrq: %p, %u\n", + InterruptOverride, InterruptOverride->SourceIrq); + return; + } + + // Note: GlobalIrq is not validated in any way (yet). + HalpPicVectorRedirect[InterruptOverride->SourceIrq] = InterruptOverride->GlobalIrq; + // TODO: What about 'InterruptOverride->IntiFlags'? +#endif + + break; + } + default: + { + DPRINT01(" UNIMPLEMENTED: Type %u, Length %u\n", + AcpiHeader->Type, AcpiHeader->Length); + return; + } } + + AcpiHeader = (ACPI_SUBTABLE_HEADER *)((ULONG_PTR)AcpiHeader + AcpiHeader->Length); + } + + if ((ULONG_PTR)AcpiHeader != TableEnd) + { + DPRINT01("Length mismatch: %p, %p, %p\n", MadtTable, AcpiHeader, (PVOID)TableEnd); + return; } } VOID HalpPrintApicTables(VOID) -{ - UINT32 i; +{ +#if DBG + ULONG i; - DPRINT1("HAL has detected a physical processor count of: %d\n", HalpApicInfoTable.ProcessorCount); + DPRINT1("Physical processor count: %lu\n", HalpApicInfoTable.ProcessorCount); for (i = 0; i < HalpApicInfoTable.ProcessorCount; i++) { - DPRINT1("Information about the following processor is for processors number: %d\n" - " The BSPCheck is set to: %X\n" - " The LapicID is set to: %X\n", - i, HalpProcessorIdentity[i].BSPCheck, HalpProcessorIdentity[i].LapicId); + DPRINT1(" Processor %lu: ProcessorId %u, LapicId %u, ProcessorStarted %u, BSPCheck %u, ProcessorPrcb %p\n", + i, + HalpProcessorIdentity[i].ProcessorId, + HalpProcessorIdentity[i].LapicId, + HalpProcessorIdentity[i].ProcessorStarted, + HalpProcessorIdentity[i].BSPCheck, + HalpProcessorIdentity[i].ProcessorPrcb); } +#endif } diff --git a/hal/halx86/include/smp.h b/hal/halx86/include/smp.h index 7efa12afc39..d38a5be4f16 100644 --- a/hal/halx86/include/smp.h +++ b/hal/halx86/include/smp.h @@ -15,22 +15,25 @@ typedef struct _PROCESSOR_IDENTITY BOOLEAN ProcessorStarted; BOOLEAN BSPCheck; PKPRCB ProcessorPrcb; - } PROCESSOR_IDENTITY, *PPROCESSOR_IDENTITY; /* This table is counter of the overall APIC constants acquired from madt */ +#define HALP_APIC_INFO_TABLE_IOAPIC_NUMBER 256 // ACPI_MADT_IO_APIC.Id is a UINT8. typedef struct _HALP_APIC_INFO_TABLE { ULONG ApicMode; ULONG ProcessorCount; /* Count of all physical cores, This includes BSP */ ULONG IOAPICCount; ULONG LocalApicPA; // The 32-bit physical address at which each processor can access its local interrupt controller - ULONG IoApicVA[256]; - ULONG IoApicPA[256]; - ULONG IoApicIrqBase[256]; // Global system interrupt base - + ULONG IoApicVA[HALP_APIC_INFO_TABLE_IOAPIC_NUMBER]; + ULONG IoApicPA[HALP_APIC_INFO_TABLE_IOAPIC_NUMBER]; + ULONG IoApicIrqBase[HALP_APIC_INFO_TABLE_IOAPIC_NUMBER]; // Global system interrupt base } HALP_APIC_INFO_TABLE, *PHALP_APIC_INFO_TABLE; +/* HALP_APIC_INFO_TABLE.ApicMode values */ +// TODO: What are the other modes/values? +#define HALP_APIC_MODE_LEGACY 0x00000010 + VOID HalpParseApicTables( _In_ PLOADER_PARAMETER_BLOCK LoaderBlock); diff --git a/hal/halx86/smp/mps/mps.c b/hal/halx86/smp/mps/mps.c index a55a962f02d..7b1a279772f 100644 --- a/hal/halx86/smp/mps/mps.c +++ b/hal/halx86/smp/mps/mps.c @@ -9,14 +9,17 @@ #include <hal.h> #include <smp.h> + #define NDEBUG #include <debug.h> /* GLOBALS ********************************************************************/ -PROCESSOR_IDENTITY HalpStaticProcessorIdentity[MAXIMUM_PROCESSORS] = {{0}}; -PPROCESSOR_IDENTITY HalpProcessorIdentity = NULL; -UINT32 PhysicalProcessorCount = 0; +static // TODO: While HalpParseApicTables() is UNIMPLEMENTED. +ULONG PhysicalProcessorCount; + +static PROCESSOR_IDENTITY HalpStaticProcessorIdentity[MAXIMUM_PROCESSORS]; +const PPROCESSOR_IDENTITY HalpProcessorIdentity = HalpStaticProcessorIdentity; /* FUNCTIONS ******************************************************************/ @@ -24,20 +27,28 @@ VOID HalpParseApicTables( _In_ PLOADER_PARAMETER_BLOCK LoaderBlock) { + UNREFERENCED_PARAMETER(LoaderBlock); + + // TODO: Fill HalpStaticProcessorIdentity[]. UNIMPLEMENTED; } VOID HalpPrintApicTables(VOID) { - UINT32 i; +#if DBG + ULONG i; - DPRINT1("HAL has detected a physical processor count of: %d\n", PhysicalProcessorCount); + DPRINT1("Physical processor count: %lu\n", PhysicalProcessorCount); for (i = 0; i < PhysicalProcessorCount; i++) { - DPRINT1("Information about the following processor is for processors number: %d\n" - " The BSPCheck is set to: %X\n" - " The LapicID is set to: %X\n", - i, HalpProcessorIdentity[i].BSPCheck, HalpProcessorIdentity[i].LapicId); + DPRINT1(" Processor %lu: ProcessorId %u, LapicId %u, ProcessorStarted %u, BSPCheck %u, ProcessorPrcb %p\n", + i, + HalpProcessorIdentity[i].ProcessorId, + HalpProcessorIdentity[i].LapicId, + HalpProcessorIdentity[i].ProcessorStarted, + HalpProcessorIdentity[i].BSPCheck, + HalpProcessorIdentity[i].ProcessorPrcb); } +#endif }

1 0

[reactos] 01/01: [ADVPACK] files.c: Properly mark Wine diff
by Serge Gautherie 31 Aug '24

31 Aug '24

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=7661f7826c991d5d30692… commit 7661f7826c991d5d30692d9ceccb456000e95a12 Author: Serge Gautherie <reactos-git_serge_171003(a)gautherie.fr> AuthorDate: Thu Oct 13 19:56:10 2022 +0200 Commit: Stanislav Motylkov <x86corez(a)gmail.com> CommitDate: Sun Sep 1 00:18:42 2024 +0300 [ADVPACK] files.c: Properly mark Wine diff Addendum to 6eb8a1d (0.4.15-dev-6918). --- dll/win32/advpack/files.c | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/dll/win32/advpack/files.c b/dll/win32/advpack/files.c index 6f06bf0e9ab..f373e78dda7 100644 --- a/dll/win32/advpack/files.c +++ b/dll/win32/advpack/files.c @@ -341,17 +341,13 @@ static HRESULT DELNODE_recurse_dirtree(LPWSTR fname, DWORD flags) HANDLE hFindFile; WIN32_FIND_DATAW w32fd; BOOL done = TRUE; - int fname_len; - + int fname_len = lstrlenW(fname); #ifdef __REACTOS__ if (flags & ADN_DEL_IF_EMPTY) - { goto deleteinitialdirectory; - } #endif /* Generate a path with wildcard suitable for iterating */ - fname_len = lstrlenW(fname); if (fname_len && fname[fname_len-1] != '\\') fname[fname_len++] = '\\'; lstrcpyW(fname + fname_len, asterisk); @@ -381,7 +377,9 @@ static HRESULT DELNODE_recurse_dirtree(LPWSTR fname, DWORD flags) { #ifdef __REACTOS__ deleteinitialdirectory: +#endif TRACE("%s: directory\n", debugstr_w(fname)); +#ifdef __REACTOS__ SetFileAttributesW(fname, FILE_ATTRIBUTE_NORMAL); if (RemoveDirectoryW(fname)) #else @@ -454,7 +452,7 @@ HRESULT WINAPI DelNodeW(LPCWSTR pszFileOrDirName, DWORD dwFlags) HRESULT ret = E_FAIL; TRACE("(%s, %d)\n", debugstr_w(pszFileOrDirName), dwFlags); - + #ifdef __REACTOS__ if (dwFlags & ~ADN_DEL_IF_EMPTY) FIXME("Flags %#x ignored!\n", dwFlags & ~ADN_DEL_IF_EMPTY);

1 0

[reactos] 01/01: [NTOS:KE] Clear NpxThread on rundown for SMP as well (#7151)
by Justin Miller 31 Aug '24

31 Aug '24

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=49e07292edb09a3739a17… commit 49e07292edb09a3739a172e3caee4d053dce85a7 Author: Justin Miller <justin.miller(a)reactos.org> AuthorDate: Sat Aug 31 13:18:07 2024 -0700 Commit: GitHub <noreply(a)github.com> CommitDate: Sat Aug 31 13:18:07 2024 -0700 [NTOS:KE] Clear NpxThread on rundown for SMP as well (#7151) clear NpxThread on rundown for SMP as well Fixes the crash whenever a usermode thread is destroyed on x86 --- ntoskrnl/include/internal/i386/ke.h | 4 ---- 1 file changed, 4 deletions(-) diff --git a/ntoskrnl/include/internal/i386/ke.h b/ntoskrnl/include/internal/i386/ke.h index 01cef59b053..81194e91e0e 100644 --- a/ntoskrnl/include/internal/i386/ke.h +++ b/ntoskrnl/include/internal/i386/ke.h @@ -386,7 +386,6 @@ FORCEINLINE VOID KiRundownThread(IN PKTHREAD Thread) { -#ifndef CONFIG_SMP /* Check if this is the NPX Thread */ if (KeGetCurrentPrcb()->NpxThread == Thread) { @@ -394,9 +393,6 @@ KiRundownThread(IN PKTHREAD Thread) KeGetCurrentPrcb()->NpxThread = NULL; Ke386FnInit(); } -#else - /* Nothing to do */ -#endif } CODE_SEG("INIT")

1 0

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs