Windows NT Systems Programming

Hot Spots

How do Buttons Work?

What do we know?

Messages are addressed to Windows
Messages contain a message ID (integer) which identifies the message type.
Message contain two 32 bit parameters
Message Map associates message IDs with message handling function calls.
MessageMap Macros convert the (generic) message parameters into specific message handling function parameters.
CButton objects send messages to the parent window when clicked.
MessageMaps are associated with Classes not Objects.

Questions: How does a CButton object

know when it is clicked?
know which object is clicked?
know which window to send message to?
know the appropriate MessageID?
actually send the message?

Let's simulate a CButton object a little bit by making hot spots on the parent window which sends message to the button message handlers.

HotSpots

A HotSpot is a section of a window which responds to a mouse click.

We need to know how to identify (visually) a hot spot on the window
Respond to a mouse click in this section of the window.

A little about Drawing in a Window: (Chapter 2)

Problem: Draw colored rectangles under the buttons in the "Edit Message Demo" to identify the "hot spots"

Identify the hot spot rectangles ( in main.h)

// Define Rectangular Hot Spots Under the normal buttons
CRect saveHotSpot(CPoint(0,650),CSize(100,50));
CRect loadHotSpot(CPoint(200,650),CSize(100,50));
CRect clearHotSpot(CPoint(400,650),CSize(100,50));

Define OnPaint message handler to draw rectangles there

	// in main.h in the public functions of CMainWindow among the other message handlers
	afx_msg void OnPaint();	// paints hot spots

// in main.cpp in the MESSAGE_MAP entries
		ON_WM_PAINT()

Define OnPaint function

// Repaint the hot spots
void CMainWindow::OnPaint()
{
	CPaintDC dc(this);
	CBrush* pOldBrush; // to restore current brush
	CBrush redBrush (RGB(255,0,0));
	CBrush greenBrush(RGB(0,255,0));
	CBrush blueBrush(RGB(0,0,255));
	
	// Now identify the "hot buttons" areas of the window underneath the real buttons
	pOldBrush = dc.SelectObject(&redBrush);
	dc.Rectangle(saveHotSpot);
	dc.SelectObject(&greenBrush);
	dc.Rectangle(loadHotSpot);
	dc.SelectObject(&blueBrush);
	dc.Rectangle(clearHotSpot);
	dc.SelectObject(pOldBrush);
}

A little about Mouse Handling (Chapter 3)

Mostly we are interested in left button up mouse events.
These generate WM_LBUTTONUP messages.
Need to define a message handler for this message.
In the message handler, need to test which (if any) hot spot was clicked
Generate a button clicked message if appropriate
(to be handled by the existing button message handler)

// in main.h, in the message handler public section of CMainWindow

afx_msg void OnLButtonUp(UINT, CPoint); // handle hot spot clicks

// in main.cpp, add appropriate MESSAGE_MAP entries and define handler

// Check to see if mouse click is in one of the Hot Spots
// If so, then send message to appropriate message handler
// THis simulates the action of pressing the appropriate buttons
void CMainWindow::OnLButtonUp(UINT nFlags, CPoint point)
{
	if(saveHotSpot.PtInRect(point))
		SendMessage(WM_COMMAND,IDC_SAVE, NULL);
	if(loadHotSpot.PtInRect(point))
		SendMessage(WM_COMMAND,IDC_LOAD, NULL);
	if(clearHotSpot.PtInRect(point))
		SendMessage(WM_COMMAND,IDC_CLEAR, NULL);
}

Drawing rectangles over the "hot spots" wasn't necessary to the logic.
just helps the user identify where a mouse click will have impact.

The entire example is available here.

HotSpot.gif (9898 bytes)