winapi: GetUpdateRect() with bRepaint TRUE inside WM_PAINT doesn't clear the paint region, but InvalidateRect() outside WM_PAINT does?

My custom drawing area's WM_PAINT looks something like this:

// TRUE to clear the background
if (GetUpdateRect(hwnd, &r, TRUE) == 0)
    return; // no update rect; do nothing
dc = BeginPaint(hwnd, &ps);
// check return
// paint some RGBA image data with GDI+
EndPaint(hwnd, &ps);

(Disregard the sending a HDC to GDI+ for now.)

I use GetUpdateRect() here instead of getting the update rect from BeginPaint() because I always want to draw over a blank canvas, especially since I'm doing alpha-mixed drawing here. Furthermore, the docs for WM_PAINT say not to call BeginPaint() if GetUpdateRect() fails.

However, when my custom drawing area actually does this WM_PAINT, it isn't clearing the drawing area. I can tell because the alpha-enabled image is drawn on top of itself, resulting in darker colors.

In another part of my code, I respond to a keyboard event by calling InvalidateRect() to force an update of the whole area. If I change the equivalent of

InvalidateRect(hwnd, NULL, FALSE);

to

InvalidateRect(hwnd, NULL, TRUE);

the area does get cleared properly.

So what exactly AM I doing wrong here? Thanks.

(The actual code is this; it's written in Go. This is also why I am working with GDI+ directly. (I have yet to figure out how to do alpha-mixed stuff with regular GDI.))

InvalidateRect invalidates the region, which means it is followed by erase/repaint requests. You compare it to GetUpdateRect which does not do validation or invalidation and with TRUE parameter erases the region the same way you would have it erased with standard painting. Furthermore as MSDN states:

> The update rectangle retrieved by the BeginPaint function is identical to that retrieved by GetUpdateRect.
>
> BeginPaint automatically validates the update region, so any call to GetUpdateRect made immediately after the call to BeginPaint retrieves an empty update region.

All together I don't see any reason to call GetUpdateRect the way you do it in paint handler. BeginPaint does it the same way, with validation, and you need to do it as soon as you are in paint handler anyway. Once you're there, erase handler is already called with no need to call it once again through GetUpdateRect.

BeginPaint's PAINTSTRUCT::rcPaint gets you the update region the same way, just don't do anything before calling EndPaint if the update region is empty.

Re:

>However, when my custom drawing area actually does this WM_PAINT, it isn't clearing the drawing area. I can tell because the alpha-enabled image is drawn on top of itself, resulting in darker colors.

There is nothing about WM_PAINT or the functions you call that will clear the region. If you want it cleared, you must do that yourself. Most programs don't, because clearing followed by painting causes flicker. If you don't clear and you do paint a transparent object, you have a problem. The solution may be to use off-screen drawing.

InvalidateRegion(,,true) is different. It sends WM_ERASEBKGND and WM_NCPAINT messages to the region is erased and painted.

There is no support for transparency in GDI. Some kinds of transparency can be simulated using masking operations.

Transparency support was introduced with GDI+, and is reasonably extensive although not much used. It's not hard to retrofit GDI+ effects into legacy code, including alpha-channel PNGs and the like.

The fancy effects from Vista depend on DirectX, which is a rather different drawing system. The Visual in WPF is very different from the old DC. You might want to consider writing new code using that system.

Thanks to both of you. Stack Overflow will only let me award one check at a time though... And yep, after doing the clearing properly I got the flicker mentioned in the checked answer.

Ultimately I decided to throw out what I have so far, especially at the advice of Treeki/Ninjifox, who suggested I use the AlphaBlend() function instead. Now, though, I have more problems... but that'll be for another question, with a standalone example program.