de/d22/RedrawWindow_8c_source.html

/*

 * PROJECT:     ReactOS API tests

 * LICENSE:     LGPL-2.1+ (https://spdx.org/licenses/LGPL-2.1+)

 * PURPOSE:     Test for RedrawWindow

 * COPYRIGHT:   Copyright 2018 Thomas Faber <thomas.faber@reactos.org>

 *              Copyright 2024 Tomáš Veselý <turican0@gmail.com>

 */


#include "precomp.h"


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

WndProc(

    _In_ HWND hWnd,

    _In_ UINT message,

    _In_ WPARAM wParam,

    _In_ LPARAM lParam)

{

    disable_success_count

    ok(GetCurrentThreadId() == dwThreadId, "Thread 0x%lx instead of 0x%lx\n", GetCurrentThreadId(), dwThreadId);

    if (message == WM_PAINT)

    {

        got_paint = TRUE;

    }

    return DefWindowProcW(hWnd, message, wParam, lParam);

}


void GetMessageRedrawWindowTest()

{

    HWND hWnd;

    MSG msg;

    HRGN hRgn;

    BOOL ret;

    int i;


    SetCursorPos(0,0);


    dwThreadId = GetCurrentThreadId();

    RegisterSimpleClass(WndProc, L"CreateTest");


    hWnd = CreateWindowExW(0, L"CreateTest", NULL, 0,  10, 10, 20, 20,  NULL, NULL, 0, NULL);

    ok(hWnd != NULL, "CreateWindow failed\n");


    ShowWindow(hWnd, SW_SHOW);


    while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))

    {

        DispatchMessageA( &msg );

    }


    ok(got_paint == TRUE, "Did not process WM_PAINT message\n");

    got_paint = FALSE;


    hRgn = CreateRectRgn(0, 0, 1, 1);

    ok(hRgn != NULL, "CreateRectRgn failed\n");

    ret = RedrawWindow(hWnd, NULL, hRgn, RDW_INTERNALPAINT | RDW_INVALIDATE);

    ok(ret == TRUE, "RedrawWindow failed\n");


    i = 0;

    while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))

    {

        RECORD_MESSAGE(1, msg.message, POST, 0, 0);

        if (msg.message == WM_PAINT)

        {

            i++;

            if (i == 10)

            {

                ok(got_paint == FALSE, "Received unexpected WM_PAINT message\n");

            }

        }

        if (msg.message != WM_PAINT || i >= 10)

        {

            DispatchMessageA( &msg );

        }

    }


    ok(i == 10, "Received %d WM_PAINT messages\n", i);

    ok(got_paint == TRUE, "Did not process WM_PAINT message\n");


    TRACE_CACHE();


    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();

}

ChildWindowProc
LRESULT CALLBACK ChildWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
Definition: RedrawWindow.c:142

FlagsRedrawWindowTest
void FlagsRedrawWindowTest()
Definition: RedrawWindow.c:435

resultWmNcPaint
BOOL resultWmNcPaint
Definition: RedrawWindow.c:15

paintIndex
int paintIndex
Definition: RedrawWindow.c:16

InitRect
void InitRect(RECT *rect, int left, int top, int right, int bottom)
Definition: RedrawWindow.c:428

WndProc
static LRESULT CALLBACK WndProc(_In_ HWND hWnd, _In_ UINT message, _In_ WPARAM wParam, _In_ LPARAM lParam)
Definition: RedrawWindow.c:22

TestRedrawWindow2
UINT TestRedrawWindow2(STRUCT_TestRedrawWindow *ptestRW, STRUCT_TestRedrawWindowCompare *ptestRWcompare)
Definition: RedrawWindow.c:348

dwThreadId
static DWORD dwThreadId
Definition: RedrawWindow.c:11

TestRedrawWindow
void TestRedrawWindow(STRUCT_TestRedrawWindow *ptestRW)
Definition: RedrawWindow.c:238

got_paint
static BOOL got_paint
Definition: RedrawWindow.c:12

CHILD_CLASS_NAME
const wchar_t CHILD_CLASS_NAME[]
Definition: RedrawWindow.c:17

resultWmEraseGnd
BOOL resultWmEraseGnd
Definition: RedrawWindow.c:14

DrawContent
void DrawContent(HDC hdc, RECT *rect, COLORREF color)
Definition: RedrawWindow.c:95

ServeSomeMessages
void ServeSomeMessages(int messageTime, int messageCount)
Definition: RedrawWindow.c:218

GetMessageRedrawWindowTest
void GetMessageRedrawWindowTest()
Definition: RedrawWindow.c:37

WindowProc
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
Definition: RedrawWindow.c:106

style
Arabic default style
Definition: afstyles.h:94

trace
#define trace
Definition: atltest.h:70

ok
#define ok(value,...)
Definition: atltest.h:57

START_TEST
#define START_TEST(x)
Definition: atltest.h:75

msg
#define msg(x)
Definition: auth_time.c:54

hWnd
HWND hWnd
Definition: settings.c:17

GetPixel
DWORD GetPixel(LPDIRECTDRAWSURFACE7 Surface, UINT x, UINT y)
Definition: blt.cpp:2

wParam
WPARAM wParam
Definition: combotst.c:138

lParam
LPARAM lParam
Definition: combotst.c:139

NULL
#define NULL
Definition: types.h:112

TRUE
#define TRUE
Definition: types.h:120

FALSE
#define FALSE
Definition: types.h:117

CALLBACK
#define CALLBACK
Definition: compat.h:35

GetTickCount
DWORD WINAPI GetTickCount(VOID)
Definition: time.c:455

startTime
static ULONGLONG startTime
Definition: main.c:113

RGB
#define RGB(r, g, b)
Definition: precomp.h:71

BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94

DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95

DeleteObject
pKey DeleteObject()

height
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546

width
GLint GLint GLsizei width
Definition: gl.h:1546

color
GLuint color
Definition: glext.h:6243

top
GLdouble GLdouble GLdouble GLdouble top
Definition: glext.h:10859

right
GLdouble GLdouble right
Definition: glext.h:10859

left
GLint left
Definition: glext.h:7726

bottom
GLint GLint bottom
Definition: glext.h:7726

i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248

void
Definition: nsiface.idl:2307

hdc
HDC hdc
Definition: main.c:9

HDC
static HDC
Definition: imagelist.c:88

hRgn
static HRGN hRgn
Definition: mapping.c:33

_In_
#define _In_
Definition: ms_sal.h:308

RECORD_MESSAGE
#define RECORD_MESSAGE(...)
Definition: msgtrace.h:60

TRACE_CACHE
#define TRACE_CACHE()
Definition: msgtrace.h:58

POST
@ POST
Definition: msgtrace.h:7

UINT
unsigned int UINT
Definition: ndis.h:50

DrawTextW
INT WINAPI DrawTextW(HDC hdc, LPCWSTR str, INT count, LPRECT rect, UINT flags)
Definition: defwnd.c:16

L
#define L(x)
Definition: ntvdm.h:50

WS_CHILD
#define WS_CHILD
Definition: pedump.c:617

WS_OVERLAPPEDWINDOW
#define WS_OVERLAPPEDWINDOW
Definition: pedump.c:637

WS_VISIBLE
#define WS_VISIBLE
Definition: pedump.c:620

DefWindowProc
#define DefWindowProc
Definition: ros2win.h:31

disable_success_count
#define disable_success_count
Definition: test.h:184

rect
& rect
Definition: startmenu.cpp:1413

STRUCT_TestRedrawWindowCompare
Definition: RedrawWindow.c:206

STRUCT_TestRedrawWindowCompare::resultColorPre1
COLORREF resultColorPre1
Definition: RedrawWindow.c:207

STRUCT_TestRedrawWindowCompare::resultColorPre2
COLORREF resultColorPre2
Definition: RedrawWindow.c:208

STRUCT_TestRedrawWindowCompare::resultUpdateRect
RECT resultUpdateRect
Definition: RedrawWindow.c:211

STRUCT_TestRedrawWindowCompare::resultWmNcPaint
BOOL resultWmNcPaint
Definition: RedrawWindow.c:214

STRUCT_TestRedrawWindowCompare::resultWmEraseGnd
BOOL resultWmEraseGnd
Definition: RedrawWindow.c:213

STRUCT_TestRedrawWindowCompare::resultPaintIndex
int resultPaintIndex
Definition: RedrawWindow.c:215

STRUCT_TestRedrawWindowCompare::resultColorPost2
COLORREF resultColorPost2
Definition: RedrawWindow.c:210

STRUCT_TestRedrawWindowCompare::resultNeedsUpdate
BOOL resultNeedsUpdate
Definition: RedrawWindow.c:212

STRUCT_TestRedrawWindowCompare::resultColorPost1
COLORREF resultColorPost1
Definition: RedrawWindow.c:209

STRUCT_TestRedrawWindow
Definition: RedrawWindow.c:175

STRUCT_TestRedrawWindow::resultColorPre2
COLORREF resultColorPre2
Definition: RedrawWindow.c:194

STRUCT_TestRedrawWindow::resultColorPre1
COLORREF resultColorPre1
Definition: RedrawWindow.c:193

STRUCT_TestRedrawWindow::testPixelPost1y
int testPixelPost1y
Definition: RedrawWindow.c:189

STRUCT_TestRedrawWindow::rectRect
RECT rectRect
Definition: RedrawWindow.c:181

STRUCT_TestRedrawWindow::resultColorPost1
COLORREF resultColorPost1
Definition: RedrawWindow.c:195

STRUCT_TestRedrawWindow::testPixelPost2x
int testPixelPost2x
Definition: RedrawWindow.c:190

STRUCT_TestRedrawWindow::testPixelPre1x
int testPixelPre1x
Definition: RedrawWindow.c:184

STRUCT_TestRedrawWindow::resultUpdateRect
RECT resultUpdateRect
Definition: RedrawWindow.c:197

STRUCT_TestRedrawWindow::useRegion
BOOL useRegion
Definition: RedrawWindow.c:178

STRUCT_TestRedrawWindow::redrawResult
BOOL redrawResult
Definition: RedrawWindow.c:183

STRUCT_TestRedrawWindow::resultWmEraseGnd
BOOL resultWmEraseGnd
Definition: RedrawWindow.c:200

STRUCT_TestRedrawWindow::resultWmNcPaint
BOOL resultWmNcPaint
Definition: RedrawWindow.c:201

STRUCT_TestRedrawWindow::forcePaint
BOOL forcePaint
Definition: RedrawWindow.c:182

STRUCT_TestRedrawWindow::resultRedraw
BOOL resultRedraw
Definition: RedrawWindow.c:199

STRUCT_TestRedrawWindow::testPixelPre2x
int testPixelPre2x
Definition: RedrawWindow.c:186

STRUCT_TestRedrawWindow::resultColorPost2
COLORREF resultColorPost2
Definition: RedrawWindow.c:196

STRUCT_TestRedrawWindow::testName
const wchar_t * testName
Definition: RedrawWindow.c:176

STRUCT_TestRedrawWindow::testPixelPre1y
int testPixelPre1y
Definition: RedrawWindow.c:185

STRUCT_TestRedrawWindow::useRect
BOOL useRect
Definition: RedrawWindow.c:180

STRUCT_TestRedrawWindow::resultNeedsUpdate
BOOL resultNeedsUpdate
Definition: RedrawWindow.c:198

STRUCT_TestRedrawWindow::resultPaintIndex
int resultPaintIndex
Definition: RedrawWindow.c:202

STRUCT_TestRedrawWindow::testPixelPost1x
int testPixelPost1x
Definition: RedrawWindow.c:188

STRUCT_TestRedrawWindow::regRect
RECT regRect
Definition: RedrawWindow.c:179

STRUCT_TestRedrawWindow::flags
DWORD flags
Definition: RedrawWindow.c:177

STRUCT_TestRedrawWindow::testPixelPost2y
int testPixelPost2y
Definition: RedrawWindow.c:191

STRUCT_TestRedrawWindow::testPixelPre2y
int testPixelPre2y
Definition: RedrawWindow.c:187

STRUCT_TestRedrawWindow::testChild
int testChild
Definition: RedrawWindow.c:192

_WNDCLASSW
Definition: winuser.h:3178

_WNDCLASSW::lpszClassName
LPCWSTR lpszClassName
Definition: winuser.h:3188

_WNDCLASSW::hInstance
HINSTANCE hInstance
Definition: winuser.h:3183

_WNDCLASSW::lpfnWndProc
WNDPROC lpfnWndProc
Definition: winuser.h:3180

message
Definition: tftpd.h:60

tagPAINTSTRUCT
Definition: winuser.h:3107

tagPAINTSTRUCT::rcPaint
RECT rcPaint
Definition: winuser.h:3110

tagRECT
Definition: windef.h:305

tagRECT::right
LONG right
Definition: windef.h:308

tagRECT::bottom
LONG bottom
Definition: windef.h:309

tagRECT::top
LONG top
Definition: windef.h:307

tagRECT::left
LONG left
Definition: windef.h:306

Sleep
VOID WINAPI DECLSPEC_HOTPATCH Sleep(IN DWORD dwMilliseconds)
Definition: synch.c:790

MSG
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1829

RegisterSimpleClass
static __inline ATOM RegisterSimpleClass(WNDPROC lpfnWndProc, LPCWSTR lpszClassName)
Definition: user32testhelpers.h:4

ret
int ret
Definition: wcstombs-tests.c:31

precomp.h

GetCurrentThreadId
DWORD WINAPI GetCurrentThreadId(void)
Definition: thread.c:459

GetModuleHandle
#define GetModuleHandle
Definition: winbase.h:3827

hwnd
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023

LPARAM
LONG_PTR LPARAM
Definition: windef.h:208

LRESULT
LONG_PTR LRESULT
Definition: windef.h:209

WPARAM
UINT_PTR WPARAM
Definition: windef.h:207

COLORREF
DWORD COLORREF
Definition: windef.h:300

CreateRectRgn
HRGN WINAPI CreateRectRgn(_In_ int, _In_ int, _In_ int, _In_ int)

TRANSPARENT
#define TRANSPARENT
Definition: wingdi.h:950

FillRect
int WINAPI FillRect(HDC, LPCRECT, HBRUSH)

SetBkMode
int WINAPI SetBkMode(_In_ HDC, _In_ int)
Definition: dc.c:1056

SetTextColor
COLORREF WINAPI SetTextColor(_In_ HDC, _In_ COLORREF)
Definition: text.c:918

CreateSolidBrush
HBRUSH WINAPI CreateSolidBrush(_In_ COLORREF)

WM_PAINT
#define WM_PAINT
Definition: winuser.h:1623

ReleaseDC
int WINAPI ReleaseDC(_In_opt_ HWND, _In_ HDC)

WM_ERASEBKGND
#define WM_ERASEBKGND
Definition: winuser.h:1628

DispatchMessageA
LRESULT WINAPI DispatchMessageA(_In_ const MSG *)

RedrawWindow
BOOL WINAPI RedrawWindow(_In_opt_ HWND, _In_opt_ LPCRECT, _In_opt_ HRGN, _In_ UINT)

TranslateMessage
BOOL WINAPI TranslateMessage(_In_ const MSG *)

ShowWindow
BOOL WINAPI ShowWindow(_In_ HWND, _In_ int)

DT_CENTER
#define DT_CENTER
Definition: winuser.h:527

DefWindowProcW
LRESULT WINAPI DefWindowProcW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)

WM_SYNCPAINT
#define WM_SYNCPAINT
Definition: winuser.h:1693

PostQuitMessage
__analysis_noreturn void WINAPI PostQuitMessage(_In_ int)

DT_SINGLELINE
#define DT_SINGLELINE
Definition: winuser.h:540

RegisterClassW
ATOM WINAPI RegisterClassW(_In_ CONST WNDCLASSW *)

RDW_NOINTERNALPAINT
#define RDW_NOINTERNALPAINT
Definition: winuser.h:1220

AdjustWindowRectEx
BOOL WINAPI AdjustWindowRectEx(_Inout_ LPRECT, _In_ DWORD, _In_ BOOL, _In_ DWORD)

RDW_UPDATENOW
#define RDW_UPDATENOW
Definition: winuser.h:1223

RDW_ERASE
#define RDW_ERASE
Definition: winuser.h:1214

RDW_NOCHILDREN
#define RDW_NOCHILDREN
Definition: winuser.h:1225

SetCursorPos
BOOL WINAPI SetCursorPos(_In_ int, _In_ int)
Definition: cursoricon.c:2706

GetClientRect
BOOL WINAPI GetClientRect(_In_ HWND, _Out_ LPRECT)

RDW_ALLCHILDREN
#define RDW_ALLCHILDREN
Definition: winuser.h:1224

CreateWindowExW
HWND WINAPI CreateWindowExW(_In_ DWORD dwExStyle, _In_opt_ LPCWSTR lpClassName, _In_opt_ LPCWSTR lpWindowName, _In_ DWORD dwStyle, _In_ int X, _In_ int Y, _In_ int nWidth, _In_ int nHeight, _In_opt_ HWND hWndParent, _In_opt_ HMENU hMenu, _In_opt_ HINSTANCE hInstance, _In_opt_ LPVOID lpParam)

EndPaint
BOOL WINAPI EndPaint(_In_ HWND, _In_ const PAINTSTRUCT *)

PM_REMOVE
#define PM_REMOVE
Definition: winuser.h:1199

RDW_ERASENOW
#define RDW_ERASENOW
Definition: winuser.h:1222

RDW_FRAME
#define RDW_FRAME
Definition: winuser.h:1215

UpdateWindow
BOOL WINAPI UpdateWindow(_In_ HWND)

PeekMessage
#define PeekMessage
Definition: winuser.h:5842

GetDC
HDC WINAPI GetDC(_In_opt_ HWND)

DT_VCENTER
#define DT_VCENTER
Definition: winuser.h:543

CW_USEDEFAULT
#define CW_USEDEFAULT
Definition: winuser.h:225

SW_SHOW
#define SW_SHOW
Definition: winuser.h:778

WM_DESTROY
#define WM_DESTROY
Definition: winuser.h:1612

RDW_NOFRAME
#define RDW_NOFRAME
Definition: winuser.h:1219

DispatchMessage
#define DispatchMessage
Definition: winuser.h:5777

BeginPaint
HDC WINAPI BeginPaint(_In_ HWND, _Out_ LPPAINTSTRUCT)

RDW_INTERNALPAINT
#define RDW_INTERNALPAINT
Definition: winuser.h:1216

RDW_NOERASE
#define RDW_NOERASE
Definition: winuser.h:1218

GetUpdateRect
BOOL WINAPI GetUpdateRect(_In_ HWND, _Out_opt_ LPRECT, _In_ BOOL)

RDW_VALIDATE
#define RDW_VALIDATE
Definition: winuser.h:1221

DestroyWindow
BOOL WINAPI DestroyWindow(_In_ HWND)

RDW_INVALIDATE
#define RDW_INVALIDATE
Definition: winuser.h:1217

WM_NCPAINT
#define WM_NCPAINT
Definition: winuser.h:1690