Win32 API Programming with Visual Basic

2017-07-07 02:10:07

Page 305

17. Window Classes and the Window Creation Process


		We have seen how the operating system communicates with a window using messages. In this chapter, we take a closer look at the nature of a window itself. We will discuss window classes and how a window is actually created. This is the process that every VC++ programmer must understand. Visual Basic takes care of all of this for the VB programmer. Nevertheless, advanced VB programmers should have some understanding of these issues in order to program the Windows API.


		To get a deeper understanding of what a window is and how it works, it is instructive to follow a brief (that is, as brief as possible) Visual C++ program that creates a window class and a window based on this class. Don't worry about understanding every line of code we are after a general understanding here.


		The basic steps in window creation under VC++ are as follows (although we will change the order a bit):


		Define a window class.


		Register the class.


		Set up the window procedure for the class.


		Create a window based on this class.


		Set up the message loop for the window.


	Window Classes


		Every window is an instance of a window class. In this sense, windows are object-oriented. Creating a window class is not hard. We begin by declaring a variable of type WNDCLASS. This is a structure with the following definition.

typedef struct WNDCLASS { UNIT style; // window style WNDPROC lpfnWndProc; // window procedure int cbClsExtra; int cbWndExtra; HANDLE hInstance; // instance handle of process HICON hIcon; // icon for window HCURSOR hCursor; // mouse cursor for window HBRUSH hbrBackground; // background color of window LPCTSTR lpszMenuName; // menu for window class LPCTSTR lpszClassName; // class name };

Page 306


		This structure defines the properties of the window class, and thus of each window that is based on this class. In particular, the structure has members to set the icon, mouse cursor background color, and menu for the class. The last member is used to give the class a name. In fact, the most important members of this structure are the class name and the window procedure.


		Note that we can change or augment the properties of any given window once it is created. The window class properties act only as a starting point.


		Here is some actual VC++ code:

WNDCLASS wndclass; // Define window class wndclass.style = CS_HREDRAW CS_VREDRAW; wndclass.lpfnWndProc = WndProc; wndclass.cbClsExtra = NULL; wndclass.cbWndExtra = Null; wndclass.hInstance = hInstance; wndclass.hIcon = NULL; wndclass.hCursor = NULL; wndclass.hbrBackground = (HBRUSH)GetStockObject(LTGRAY_BRUSH); wndclass.lpszMenuName = NULL; wndclass.lpszClassName = TEXT( rpiClass1 );


		The style member is defined as the conjunction (ORing) of two values. (A horizontal bar is the OR operator in VC++.) The CS_HREDRAW style causes Windows to redraw the window if its width is changed, and similarly for the CS_VREDRAW style. Thus, all windows based on this class will have these redrawing properties.


		The next step is to register the class with Windows. This is done using the RegisterClass function, which takes a pointer to the WNDCLASS structure for the class (the & means "address of"):

// Register class

RegisterClass (&wndclass)

Page 307


	Predefined Window Classes


		Fortunately, Windows defines several window classes that we can use for creating windows. There are:


		Button


		Combo box


		Edit (Text box)


		Listbox


		MDIclient (an MDI client window)


		RichEdit (Version 1.0)


		RichEdit_Class (Version 2.0)


		Scrollbar


		Static (A label, rectangle, or line used to label, box, or separate other controls. Static controls receive no input and produce no output, which is why they are called static.)


	The Window Procedure of a Window Class


		We have already discussed the fact that messages are processed in the window procedure of a window class. It is worth emphasizing that it is the window class that has a window procedure and not individual windows. Thus, all windows based on a certain class use the same window procedure.


		Here is an example of a window procedure. This example watches for only two types of messages: a WM_DESTROY message is sent to a window when it is being destroyed, and a WM_SIZE message is sent to a window after it has been resized by Windows (probably in response to user action with the mouse).

// Window procedure for this class

LRESULT CALLBACK WndProc (HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)

{

// a temporary string

char temp[50];

switch(iMsg) // like the VB Select Case structure

{

// process any resize messages

case WM_SIZE:

_itoa( (lParam & 0x0000FFFF) , temp, 10 );

SetWindowText (hwnd, temp);

return 0;

Page 308

// process the destroy message

case WM_DESTROY:

// Generate a quit message

PostQuitMessage(0);

return 0;

}

// Call Windows default window procedure

return DefWindowProc(hwnd, iMsg, wParam, lParam);

}


		If a WM_DESTROY message arrives, our window procedure sends a WM_QUIT message to terminate the thread that created the window (and thus the application if it is single-threaded). If a WM_SIZE message arrives, our window procedure grabs the width of the client area of the window (this is the portion of the window that does not include the caption or borders), which is returned in the lower 16 bits of the lParam parameter, and places it in the window's caption just for something to do.


		We should emphasize that programmers seldom call a window procedure directly. The window procedure is a callback function, that is, it is called by Windows in order to pass the message information (window handle, message ID, wParam, and lParam) to the application for processing.


		Finally, note that the final act of our window procedure is to call the default window procedure, which will supply default processing of all messages that are not processed by our window procedure (in this case, all messages except WM_SIZE and WM_DESTROY the VC++ return statement exits the window procedure). Of course, window procedures in most applications will be far more complicated than this one, possibly having code that depends upon the window that is the target of the message (as given by the hwnd parameter). In fact, for many Windows applications, the main action takes place in the window procedure!


	Creating a Window


		Once a window class is defined and registered, we can create a window based on this class. This is done using the CreateWindow function:

HWND CreateWindow( LPCTSTR lpClassName, // pointer to registered class name LPCTSTR lpWindowName, // pointer to window name DWORD dwStyle, // window style int x, // horizontal position of window int y, // vertical position of window int nWidth, // window width int nHeight, // window height HWND hWndParent, // handle to parent to owner window HMENU hMenu, // handle to menu of child-window identifier HANDLE hInstance, // handle to application instance LPVOID lpParam // pointer to window-creation data );

Page 309


		Notice that the parameters to this function are quite similar to the parameters of the WNDCLASS structure.


		The CreateWindow function requires the class name for the window and sets various properties of the window, such as its initial placement. The window name is used as a caption for those windows that have captions (application windows and command buttons, for instance).


		The CreateWindow function returns a handle to the newly created window. Here is an example:


	Window Styles


		As we have seen, every window has a style. This is a combination of the style defined for the window class as well as the setting of the dwStyle parameter in the CreateWindow function. The dwStyle parameter can be a combination of several style constants, both general constants and those that apply specifically to a particular type of window, such as a command button. Here are some examples of general style constants:

WS_BORDER

Creates a window that has a thin-line border

WS_CAPTION

Creates a window that has a titlebar (includes the WS_BORDER style)

WS_CHILD

Creates a child window

WS_DLGFRAME

Creates a window that has a border of a style typically used with dialog boxes

WS_HSCROLL

Creates a window that has a horizontal scrollbar

WS_MAXIMIZE

Creates a window that is initially maximized

Page 310

WS_MAXIMIZEBOX

Creates a window that has a Maximize button

WS_SYSMENU

Creates a window that has a window menu on its titlebar


		In addition, each type of predefined class has styles. For instance, the majority of button styles are shown here.


		To create a checkbox

BS_AUTO3STATE

A three-state checkbox that changes its state when the user selects it

BS_CHECKBOX

A checkbox with text


		To create a radio button (option button)

BS_RADIOBUTTON

A small circle with text

BS_AUTORADIOBUTTON

A radio button for which Windows automatically sets the button's state to checked and automatically sets the state for all other buttons in the same group to unchecked


		To create a command button (push button)

BS_DEFPUSHBUTTON

A push button that behaves like a BS_PUSHBUTTON-style button, but is also the default button (can be selected by hitting the ENTER key)

BS_PUSHBUTTON

A push button


		To place text

BS_LEFTTEXT

Places text on the left side of the radio button or checkbox

BS_BOTTOM

Places text at the bottom of the button rectangle

BS_CENTER

Centers text horizontally in the button rectangle

BS_MULTILINE

Wraps button text to multiple lines, if required

BS_VCENTER

Places text in the middle (vertically) of the button rectangle

Page 311


		Other

BS_GROUPBOX

A rectangle in which other controls can be grouped

BS_OWNERDRAW

An owner-drawn button (The programmer is responsible for the control's appearance.)

BS_BITMAP

Specifies that the button displays a bitmap

BS_ICON

Specifies that the button displays an icon

BS_TEXT

Specifies that the button displays text


		The most important thing to notice about the button styles is that what VB programmers think of as different controls command buttons, checkboxes, and option buttons are in reality just buttons with different styles.


		Changing a Window's Style


		The SetWindowLong function can be used to set the style of a window after the window has been created. As it happens, some styles can be effectively changed after the window has been created and others cannot (the result is either nothing or disaster).


		The only way to see whether changing a window's style will work is to try it. Here are a couple of examples that you might want to try. Just place a command button and two text boxes on a form:

Dim IStyle As Long

' Command button caption aligned at bottom

lStyle = GetWindowLong (Command1.hwnd, GWL_STYLE)

SetWindowLong Command1.hwnd, GWL_STYLE, lStyle Or BS_BOTTOM

' Textbox converts all input to lower case

lStyle = GetWindowLong(Text1.hwnd, GWL_STYLE)

SetWindowLong Text1.hwnd, GWL_STYLE, lStyle Or ES_LOWERCASE

' Textbox accepts only digits

lStyle = GetWindowLong(Text2.hwnd, GWL_STYLE)

SetWindowLong Text2.hwnd, GWL_STYLE, lStyle Or ES_NUMBER


		The main point to note about this code is that we must first get the current style so that we can make the necessary changes. It would be a mistake to simply set a window's style to, say, BS_BOTTOM, because this would clear all other style settings.

Page 312


	Windows and VB Controls


		Visual Basic controls are windows. The older controls have class names that begin with the word Thunder, because this was Microsoft's internal code name for Visual Basic 1.0. Note that some design-time controls are different than the corresponding runtime controls and thus may have different class names. Runtime control class names are based on the design-time name, but also include reference to the version of VB. For instance, a design-time listbox has class name ThunderListBox, Whereas a VB5 runtime listbox has class name ThunderRT5ListBox and a VB6 runtime listbox has class name ThunderRT6ListBox. Table 17-1 shows the design-time class names for some common VB controls.

Table 17-1. Controls and Their Design-time Class Names
Control	Class Name
Check	ThunderCheckBox
Combo	ThunderComboBox
Command	ThunderCommandButton
Dir	ThunderDirListBox
Drive	ThunderDriveListBox
File	ThunderFileListBox
Form	ThunderForm
Frame	ThunderFrame
Label	ThunderLabel
List	ThunderListBox
MDIForm	ThunderMDIForm
Option	ThunderOptionButton
Picture	ThunderPictureBox
Scroll (Horiz)	ThunderHScrollBar
Scroll (Vert)	ThunderVScrollBar
Text	ThunderTextBox
Timer	ThunderTimer
TabStrip	TabStript20WndClass
Toolbar	msvb_lib_toolbar
ProgressBar	ProgressBar20WndClass
StatusBar	StatusBat20WndClass
TreeView	TreeView20WndClass
ListView	ListView20WndClass
ImageList	ImageList20WndClass
Slider	Slider20WndClass

Page 313


	Example: Spying on Windows


		The rpiSpyWin application, whose complete source code is on the CD, is a little utility for getting information about a specific window. Figure 17-1 shows the main (and only) window for this program. In particular, the utility retrieves the window handle, class name, caption, styles, location, window ID, and process and thread IDs of any visible window. (The window identifier, or window ID, is a number that is passed to the CreateWindow function and identifies a child window from among its siblings. This value is occasionally useful in calling API functions, so I have included it here in case you run across it.)

Figure 17-1.

The Windows spying utility


		The utility takes advantage of the system-wide mouse capture that Windows creates when we drag a window with the mouse. So to use rpiSpyWin, just hold down the left mouse button over the red box and move the mouse. When you have found the window of interest, just release the mouse button. Incidentally, if rpiWinSpy leaves some residual lines on the screen, just move the mouse pointer over the red box again.


		Almost all of the program's action takes place in the MouseMove event for the red picture box:

Private Sub picSpy_MouseMove(Button As Integer, Shift As Integer, _

x As Single, y As Single)

Dim xValue As Long, yValue As Long

Dim pt As POINTAPI

' Convert X and Y to screen coordinates (pixels)

' X and Y are twips with respect to the upper left corner of drag window

' Top and Left are in twips with respect to client area of form

xValue = (x + picSpy.Left) \ Screen.TwipsPerPixelX

yValue = (y + picSpy.Top) \ Screen.TwipsPerPixelY

pt.x = xValue

pt.y = yValue

ClientToScreen Me.hwnd, pt

Page 314

txtX = "X = " & pt.x & " Y = " & pt.y

'txtY = pt.y

' Get window handle from mouse location

hCurrent = WindowFromPoint (pt.x, pt.y)

If hCurrent <> hPrevious Then

' Change of window

txthWnd = "&H" & Hex$ (hCurrent) & " (" & hCurrent & ")"

' Get class name

txtClass = GetClass(hCurrent)

' Get caption

txtCaption = GetCaption(hCurrent)

' Get style

txtStyle = "&H" & Hex$ (GetWindowLong(hCurrent, GWL_STYLE))

' Get extended style

txtEXStyle = "&H" Hex$ (GetWindowLong(hCurrent, GWL_EXSTYLE))

' Get window ID

txtID = GetWindowLong(hCurrent, GWL_ID)

' Get rectangle

lretSpy = GetWindowRect(hCurrent, rectCurrent)

' Invert the borders of previous rectangle

' Top line

rectTemp = rectPrev

rectTemp.Bottom = rectPrev.Top + PEN_WIDTH