Repainting over what's already there

In my knowledge, when the WM_PAINT message is received, the client area is invalid. Well, you see, I have this problem.

I want to draw rects on the client over and over each other. But then, when the client is invalid, I won't get them back. Do you understand what I mean?

I'll have one rectangle drawn. Than the user does something to draw another. But then won't the client be cleared and then painted all over again?

--Garfield

You could try an handle the WM_ERASEBKGND message, but probably your best bet is to draw everything to a memory dc and the whenever your application receives a paint message, Blit this memory dc.

How would I create this memory dc and then callback? And what do you mean,"Blit"?

Thanks.

--Garfield

If you're still going through Petzold, you might be getting a bit ahead of yourself. This wndproc will draw random rectangles to a memory dc and then the WM_PAINT Blits it -

Code:

---

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        PAINTSTRUCT ps;
        HDC hdc;
        static HDC memDC;
        static HBITMAP hBitmap;
        static int cScreenX,cScreenY;
        HBRUSH hBrush;
       

        switch (message)
        {

        case WM_CREATE:
                srand((unsigned)time(NULL));
                //Get Dimensions for Memory DC
                cScreenX=GetSystemMetrics(SM_CXSCREEN);
                cScreenY=GetSystemMetrics(SM_CYSCREEN);
                hdc=GetDC(hWnd);
                memDC = CreateCompatibleDC(hdc);
                //Create Bitmap to 'select' into Memory DC
                //to paint onto
                hBitmap = CreateCompatibleBitmap(hdc,cScreenX,cScreenY);
                SelectObject(memDC,hBitmap);
                //Get brush used for main window, so that
                //Memory DC will match
                hBrush = (HBRUSH)GetClassLong(hWnd,GCL_HBRBACKGROUND);
                SelectObject(memDC,hBrush);
                //Blit Brush to fill whole dimension of Memory DC
                PatBlt(memDC,0,0,cScreenX,cScreenY,PATCOPY);
                ReleaseDC(hWnd,hdc);

        case WM_SIZE:
                {
                        int a = rand()%250;
                        int b = rand()%250;
                        //Draw Rectangle to Memory DC
                        Rectangle(memDC,a,b,50,50);
                        InvalidateRect(hWnd,0,TRUE);
                }
        return 0 ;
         
    case WM_PAINT:
                hdc = BeginPaint (hWnd, &ps) ;
                //Blit Memory DC to window
                BitBlt(hdc,0,0,cScreenX,cScreenY,memDC,0,0,SRCCOPY);
            EndPaint (hWnd, &ps) ;
        return 0 ;

       
        case WM_DESTROY:
                DeleteDC(memDC);
                DeleteObject(hBitmap);
                PostQuitMessage(0);
                break;
        default:
                return DefWindowProc(hWnd, message, wParam, lParam);
        }
        return 0;
}

---

Okay, I think I pretty much understand what you are doing, but you are right, that is ahead of me. I haven't learned the BitBlt function yet, but (from context), I understand what you mean.

Thanks.

--Garfield

Yeah, I was aoubt to post the same thing...

it's basically a bitmap in memory, which you draw to as well as the normal hdc of your window, then you use BitBlt() to paint it to your window every time everything gets erased.

Okay, so then you have this "memory" hdc, you write a rectangle to this hdc every time something (programmer provided) happens. Then you, in WM_PAINT, paint it (as a bitmap) to the client area without "losing" the previous rects. Am I correct?

/*** Thanks ***/

--Garfield

Yes, because this DC is kept around until your program finishes, it acts as a back buffer that you can draw to. Unless you do something to clear it all previous paints will remain (if you're painting rectangles that are filled with a solid brush then you'll probably make portions of the inner rectangles dissapear).

This also becomes useful if your application is minimised. If you were drawing to the display dc then you'd have to keep a record of all the GDI objects that had been painted to it (eg an array of rectangles) and then re-paint them all when your program was maximised. By painting them to a memory dc you always have a record of what the output should look like, and so just have to transfer the data with a blit (bit block transfer) which will probably be faster an easier.

However, if the app you're producing needs to keep a record of it's output anyway (eg word processor), then you probably wouldn't use this method, but just read the information from your data structure and re-paint the relevant stuff to your client area.

/*** Thanks ***/ zen and Ken. Just what I needed.

--Garfield

If you use SelectObject() catch the return and save until you have finished using the GDI object. Then RETURN the original before using DeleteObject().

Save your GDI resources.

To clear the HDC

BitBlt(hdcScreen, 0, 0, iWidth, iHeight,hdcScreen, 0, 0, WHITENESS);