Thread: brush handle in FillRect function - why does this work?

There is a difference between 'working' and 'undefined behaviour returning the right result on this occasion'.

The difference is that 'working' always does what you told it to but undefined behaviour does not always return the expected result.

You are probably testing in a DEBUG mode and the IDE is protecting you from your mistakes (by not selecting into the DC a unititialised GDI object).

Originally Posted by megafiddle

Could it be that the handle for DC_BRUSH is zero, and hBrush was also zero?

No DC_BRUSH can not be zero AND valid.

HBRUSH is a HANDLE or pointer (memory address) so can not be NULL and valid.

In DEBUG mode (as opposed to Release mode build) the hBrush is probably initialised to NULL by the IDE.

FillRect() would call SelectObject() and probably is coded not to allow a NULL GDI object to be selected into a DC (as then the DC would throw errors when it tried to use the non existent GDI object).

Code:

//why is the PAINTSTUCT static?

HDC hdcPaint = BeginPaint(hWnd, &ps);

FillRect(hDc, &ps.rcPaint, hBrush);
//should be 
FillRect(ps.hdc, &ps.rcPaint, GetStockObject(WHITE_BRUSH));
// or
FillRect(hdcPaint , &ps.rcPaint, GetStockObject(WHITE_BRUSH));

EndPaint(hWnd, &ps);
//then there is no need to create or clean up any GDI objects

BUT!

Other events generate WM_PAINT msgs (ie another window crossing yours) with differing invalidated rects in the PAINTSTRUCT so your code will not always draw the way you expect.

Originally Posted by megafiddle

What is the difference between hDc and ps.hdc? Shouldn't they have the same value?

hDc appears to be a global HDC variable (but you did not show where or how you created it).

ps.hdc is the HDC specific to this specific dialog/window/control's screen that has just been invalidated.

They probably contain different GDI objects.

Your hDc is not required and, in general, global variables are bad (or show poor design). [in some cases global varaibles are required / better, but the exception proves the rule.]

Originally Posted by megafiddle

Code:

hBrush = GetStockObject(DC_BRUSH);

FillRect(ps.hdc, &ps.rcPaint, hBrush);

Yes, that code is the interchangeable.

No.

Your current paint method does not need a HDC.

Re-read my previous posts, they show you 2 ways to get the required DC.

Originally Posted by novacain

No.

Your current paint method does not need a HDC.

Re-read my previous posts, they show you 2 ways to get the required DC.

I fixed my updateclient, using handle returned from begin paint. No problem with that. It's
about the other parts of the program that need an HDC. I use MoveTo, LineTo, SetPixel, etc
in many different parts of the program.

How do I retrieve a valid HDC to pass to these other subroutines?

Originally Posted by megafiddle

How do I retrieve a valid HDC to pass to these other subroutines?

You require a form of 'double buffering'

The 'rules' are;

You have a member DC (global is normally not required and can be eliminated by better design). Generally this DC is called the 'memDC' or memory DC. Making it a member means you do not need to pass the HDC, otherwise make it static in the callback and pass into the methods.
All drawing should be done in other methods, which update your memDC and then generate a paint message.
Your paint handler should never consist of more than a single BitBlt(), where the memDC is copied to the HDC from BeginPaint() using the rect in the PAINTSTRUCT
You create memDC as a compatible DC in the WM_CREATE / WM_INITDIALOG msg and compatible bitmap.
You destroy the current bitmap and create a new bitmap the correct size in WM_SIZE msgs (coping the current one with BitBlt() or StretchBlt() as required).
You clean up the memDC in the WM_CLOSE
You generate fast paint by using InvalidateRect() followed by UpdateWindow() [this is IMPORTANT!]
You only invalidate the minimun rect required (not the entire client area).

Search my posts for actual code.

Member variables are used to provide encapsulation in C++ and C#.

Classes have 'member' variables; variables that are local to the class and are accessable in any of the classes methods / functions. [not available in C as C has no classes]
Member variables have 'global' scope within the class but are not accessable outside an instance of the class (a class variable) unless marked as 'public'.

[google 'member variable' or 'encapsulation' for more detail]

Each instance of the class has its own copy of the variable (unless the member is declared as 'static').

To answer your next question. 'Why use this feature?'
google 'inheritance in c++'

>>Are there any cases where you can draw using the DC for the client area?

Yes and no.
It all depends on the requirements of the application. If you read my posts carefully you will notice I mention your 'current paint'. This is because simple drawing (as in your example code), or drawing that does not need to be presistent, can be done in the WM_PAINT.

>>This question came up because some examples for using the GDI from msdn and other tutorials,
use the DC for the client area and do the drawing directly onto it.

These are simple examples used to show basic concepts, not actual implementations used in more complex applications.

I assume you are refering to my comment;

>>You only invalidate the minimun rect required (not the entire client area).<<

By 'invalidate' I mean 'mark the rectangle for painting' (ie set it to be redrawn in the paint).

You make an area 'invalid' by calling InvalidateRect(). This generates a WM_PAINT msg for the given window (HWND) and for the given area (RECT).

You can use the whole client rect or, better, the minimum rect that includes all the changes.

When you call BeginPaint() this invalidated RECT is copied into the PAINTSTRUCT rcPaint RECT struct.

You then use the rcPaint RECT in your drawing (ie in the BitBlt())