Thread: Drawing to client area of tabbed window

1. Any variables local to the CALLBACK must be STATIC if you want them to retain a value for more than one message.

2. To generate a WM_PAINT after changing your memDC use;
InvalidateRect() //generate paint msg
UpdateWindow() // send paint directly to app callback bypassing OS msg queue

3. Only redraw the minimum area by using the RECT in the PAINTSTRUCT.
Do NOT always redraw the entire client area.
Not all paint msgs are generated inside your app (ie moving a msgbox over a corner of your app will redraw the entire screen).

4. Catch the default GDI objects when using SelectObject(), as you have done with the pen, but not with the bitmap. Select these default GDI objects back into the DC before deleting the GDIs (ie return the created MemDC back to the default state)


Generally complex TABs are done by creating an individual dialog for each TAB and positioned over the TAB client area.
Otherwise an array of DCs is used, or just a single DC that is redrawn based on the TAB selected.
In this case it is hard to determine the 'correct' approach (as I lack the details of the other TAbs).

As a pattern for single DCs;

WM_CREATE / WM_INITDIALOG
Create MemDC
Create the MemDC bitmap to the max size (ie screen res or app client area if app not resizeable).
This negates the need to resize the MemDC if the app changes size.

WM_SIZE
Redraw MemDC to new size / scale (StretchBit() is the easiest but will not work well for line drawings)

WM_PAINT
BitBlt() from MemDC to PAINTSTRUCT DC using PAINTSTRUCT rect

WM_CLOSE / DESTROY
Clean up GDI (put default GDI objects back into the MemDC, then delete the created bitmap, DC, etc).

TCN_SELCHANGE
Redraw MemDC based on TAB selected
Generate a paint msg

If you want to do mouse drawing I am sure I have posted code previously (in the last 10 years...)

>>I can't seem to figure out how to repaint just certain areas of the Tabbed window.

To clairfy; I ment in the WM_PAINT be sure to use the RECT from the PAINTSTRUCT in your BItBlt(). Do not always use the entire client area / size of the TAB in this BitBlt().

Code:

CASE WM_PAINT:
PAINTSTRUCT ps;
BeginPaint(hwnd, &ps);
BitBlt(	ps.hdc, 	
	ps.rcPaint.left,
	ps.rcPaint.top,
	ps.rcPaint.right-ps.rcPaint.left,
	ps.rcPaint.bottom-ps.rcPaint.top,
	memDC,
	ps.rcPaint.left,
	ps.rcPaint.top,
	SCRCOPY);
EndPaint(hwnd,&ps);
break;

You might also need some offset to draw on just the TAB, if it does not cover the entire main windows client area.

>>Invalidating anything but a window handle results in an error

Something like (not tested, written from memory...)

Code:

//some drawing changes the contents of memDC

//find the offset between the TAB and its parent's client

//if the TAB has width 200 and height 200
//get the TAB client area, top left point will be 0,0 and bottom right will be 200,200
GetClientRect(hTabWnd,&TABClient);

//convert from coods relative to the TAB control -> coords relative to the main windows 
//ie if the top left of the TAB controls client area was at 100,100 on the main window
//we would get top left point will be 100,100 and bottom right will be 300,300 (as 200 wide and high)

MapWindowPoints(hTABWnd, hwnd, &TABClient, (sizeof(RECT)/sizeof(POINT)); //or just use 2 instead of (sizeof(RECT)/sizeof(POINT)

//call for a paint the just the TAB control's client area on the main window
InvalidateRect(hwnd,&TABClient,FALSE);//use FALSE (not TRUE or 1) so you do not redraw the background
UpdateWindow(hwnd); //bypass OS msg queue and post to windows callback

EDIT: Make sure you check that I have the HWNDs the right way round and you are converting from the TAB control to the main window (not visa versa).

Also...

When debugging these types of things I used to colour the TABs client area and get the colour to change for each TAB index.

Something like (not compiled, written from memory)....

Code:

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    NMHDR *nmptr;
    
    HDC hdc;
    char str[80];
    TCITEM tci;
    
    //change to static
    static HDC memdc = null;
    static int tabnumber=0;//set to zero to start with
    static RECT WinDim ={0};
    //brush array
    static HBRUSH brushArray[3] = {0};
    //default bitmap from the memDC
    static HBITMAP hOrigBMP = null;

    switch (message)                 
    {
       case WM_CREATE:
          maxX=GetSystemMetrics(SM_CXSCREEN);
          maxY=GetSystemMetrics(SM_CYSCREEN);

         GetClientRect(hwnd,&WinDim);
         
         hTabWnd= CreateWindow(
             WC_TABCONTROL,
             "",
             WS_VISIBLE|WS_TABSTOP|WS_CHILD,0,0,WinDim.right,WinDim.bottom,
             hwnd,
             NULL,
             hInst,
             NULL
            );
          tci.mask=TCIF_TEXT;
          tci.iImage=-1;
          tci.pszText="One";
          TabCtrl_InsertItem(hTabWnd,0,&tci);
          tci.pszText="Two";
          TabCtrl_InsertItem(hTabWnd,1,&tci);
          tci.pszText="Three";
          TabCtrl_InsertItem(hTabWnd,2,&tci);

          //create memDC
          //get the main sceen DC
          hdc = GetDC(NULL);
          memdc=CreateCompatibleDC(hdc);
          hbit=CreateCompatibleBitmap(hdc,maxX,maxY);
          hOrigBMP = SelectObject(memdc, hbit);
          //release main screen DC
          ReleaseDC(hdc);

          //create brush array
          brushArray[0] = CreateSolidBrush(RGB(255,0,0));//red
          brushArray[1] = CreateSolidBrush(RGB(0,255,0));//green
          brushArray[2] = CreateSolidBrush(RGB(0,0,255));//blue  
   
          //fill the memDC with TAB index 1 colour (RED)
          //set our memDC rect
          SetRect(&WinDim, 0,0,maxX,maxY);
          FillRect(memDC,&WinDim, brushArray[tabnumber]);
          //call a paint
          GetClientRect(hTABWnd,&WinDim);
          MapWindowPoints(hTABWnd, hwnd, &WinDim, (sizeof(RECT)/sizeof(POINT)); 

          //generate paint msg
          InvalidateRect(hwnd,&WinDim,FALSE);//use FALSE (not TRUE or 1) so you do not redraw the background
          UpdateWindow(hwnd); //bypass OS msg queue and post to windows callback    

        break;

        case WM_NOTIFY:
          nmptr=(LPNMHDR) lParam;
          if(nmptr->code==TCN_SELCHANGE)
          {
             tabnumber=TabCtrl_GetCurSel((HWND)nmptr->hwndFrom);
             //fill rect with new colour
             //note as the WinDim RECT is static we do not need to change it unless we get a WM_SIZE
             FillRect(memDC,&WinDim, brushArray[tabnumber]);
             //generate a paint msg
	     InvalidateRect(hwnd,&WinDim,FALSE);//use FALSE (not TRUE or 1) so you do not redraw the background
             UpdateWindow(hwnd); //bypass OS msg queue and post to windows callback  
          }
          break;
        case WM_DESTROY:

            //put the DC back to default and delete
            SelectObject(memdc, hOrigBMP);
            DeleteObject(hbit);
            DeleteDC(memdc);
  
            //clean up the brush array
            DeleteObject(brushArray[0]);
            DeleteObject(brushArray[1]);
            DeleteObject(brushArray[2]);

            PostQuitMessage (0);
            break;
        case WM_PAINT:
            {
            PAINTSTRUCT ps;
            BeginPaint(hwnd, &ps);
            BitBlt(	ps.hdc, 	
            	ps.rcPaint.left,
            	ps.rcPaint.top,
            	ps.rcPaint.right-ps.rcPaint.left,
            	ps.rcPaint.bottom-ps.rcPaint.top,
            	memDC,
            	ps.rcPaint.left,
            	ps.rcPaint.top,
            	SCRCOPY);
            EndPaint(hwnd,&ps);
            break;
            }
        }
        default:                     
            return DefWindowProc (hwnd, message, wParam, lParam);
    }

    return 0;
}