AU / MCA / R2009 / II Yr / IV Sem / MC9243 / VP / Unit I

UNIT I WINDOWS PROGRAMMING

The Windows Programming Model
In procedural programming model, programs execute from top to bottom in an orderly
fashion. Windows programming model is event-driven programming model, in which
applications respond to events by processing messages sent by the operating system. An
event could be a keystroke, a mouse click, a command for a window to repaint itself, etc.

The entry point for a Windows program is a function named WinMain, but most of the
action takes place in a function known as the window procedure. WinMain creates the
window and then enters a message loop, alternately retrieving messages and dispatching
them to the window procedure. Messages wait in a message queue until they are retrieved.
The message loop ends when a WM_QUIT message is retrieved from the message queue,
signaling that it is time for the application to end. When the message loop ends, WnMain
returns and the application terminates. The window procedure processes messages sent to
the window. The code provided to process a particular message is known as a message

1.1
VJS/Sr. AP/MCA/JCE

handler. Messages that an application doesn't process are passed on to an API function
named DefWindowProc, which provides default responses to unprocessed messages.

Event Driven Programming

In computer programming, event-driven programming or event-based
programming is a programming paradigm in which the flow of the program is determined
by events—i.e., sensor outputs or user actions (mouse clicks, key presses) or messages from
other programs or threads.

Event-driven programming can also be defined as an application architecture

technique in which the application has a main loop which is clearly divided down to two
sections: the first is event selection (or event detection), and the second is event handling.

Event-driven programs can be written in any language. Integrated development

environments provide code generation assistants that automate the most repetitive tasks
required for event handling.

Event-driven programming is widely used in graphical user interfaces because it has

been adopted by most commercial widget toolkits as the model for interaction.

Creating event handlers

The first step in developing an event-driven program is to write a series of

subroutines, or methods, called event-handler routines. These routines handle the events to
which the main program will respond. For example, a single left-button mouse-click on a
command button in a GUI program may trigger a routine that will open another window,
save data to a database or exit the application. Many modern day programming
environments provide the programmer with event templates so that the programmer only
needs to supply the event code.

The second step is to bind event handlers to events so that the correct function is
called when the event takes place. Graphical editors combine the first two steps: double-
click on a button, and the editor creates an (empty) event handler associated with the user
clicking the button and opens a text window so you can edit the event handler.

The third step in developing an event-driven program is to write the main loop. This
is a function that checks for the occurrence of events, and then calls the matching event
handler to process it. Most event-driven programming environments already provide this
main loop, so it need not be specifically provided by the application programmer.

GUI Concepts
A graphical user interface (GUI), pronounced G-U-I, is a type of user interface
that allows users to interact with programs in more ways than typing. A GUI consists of one
or more windows and each window contains one or more controls. GUIs are "event driven"
which means “react to events” - like a button that is clicked. A GUI offers graphical icons,
and visual indicators to fully represent the information and actions available to a user.

1.2
 AU / MCA / R2009 / II Yr / IV Sem / MC9243 / VP / Unit I

The real beauty of Windows lies in its ability to offer the world’s
richest set of Graphical User Interface (GUI) development APIs
(Application Programming Interface). By utilizing the strengths of the GUI
environment, applications can be improved to the point that end user
training and problems are minimized, and a higher level of satisfaction is
obtained by the vast majority of end users.

Overview of Windows programming

An Architectural Overview

Windows programming is a type of object-oriented programming, where the object

is known as “window”.

There are two types of windows:

1. Application window
2. Dialog box

The various push buttons, radio buttons, check boxes, list boxes, scroll bars, and
text-entry fields that adorn the surfaces of dialog boxes are called “child windows” or
“control windows” or “child window controls”.

The user sees these windows as objects on the screen and interacts directly with
them using the keyboard or the mouse. The window receives the user input in the form of
“messages”. A window also uses messages to communicate with other windows.

A window is always created based on a “window class”. Every window that a

program creates has an associated window procedure. This window procedure is a function
that could be either in the program itself or in a dynamic-link library. The window class
identifies the window procedure that processes messages to the window. Windows sends a
message to a window by calling the window procedure. The window procedure does some
processing based on the message and then returns control to Windows.

The use of a window class allows multiple windows to be based on the same
window class and hence use the same window procedure. For example, all buttons in all
Windows programs are based on the same window class. This window class is associated
with a window procedure located in a Windows dynamic-link library that processes
messages to all the button windows.
In object-oriented programming, an object is a combination of code and data. A
window is an object. The code is the window procedure. A window procedure processes
messages to the window. The data is information retained by the window procedure and
information retained by Windows for each window and window class that exists in the
system.

When a Windows program begins execution, Windows creates a “message queue”

for the program. This message queue stores messages to all the windows a program might
create. A Windows application includes a short code called the “message loop” to retrieve
these messages from the queue and dispatch them to the appropriate window procedure.

1.3
VJS/Sr. AP/MCA/JCE

Creating a program in the Visual C++ Developer Studio

1. Select New from the File menu.

2. In the New dialog box
2.1. Pick the Projects tab.
2.2. Select Win32 Application.
2.3. In the Location field, select a subdirectory.
2.4. In the Project Name field, type the name of the project.
(This will be a subdirectory of the directory indicated in the Location
field.)
2.5. The Create New Workspace button should be checked.
2.6. The Platforms section should indicate Win32.
2.7. Choose OK.
3. A dialog box labeled Win32 Application – Step 1 of 1 will appear.
3.1. Indicate to create an Empty Project.
3.2. Press the Finish button.
4. New Project Information dialog box appears.
4.1. Click OK.
5. Select New from the File menu again.
6. In the New dialog box
6.1. Pick the Files tab.
6.2. Select C++ Source File.
6.3. The Add To Project box should be checked.
6.4. The project name should be indicated in the field below.
6.5. Type a file name in the File Name field.
6.6. Choose OK.
7. Type in the program.
8. To compile, select Build from the Build menu, or press F7, or select the Build
icon from the Build toolbar.
9. To execute, select Execute from the Build menu, or press Ctrl+F5, or click the
Execute Program icon from the Build toolbar.

During the compile stage, the compiler generates an .OBJ file from the C source
code file. During the link stage, the linker combines the .OBJ file with .LIB files to create
the .EXE file.

The HELLOWIN Program

Creating a window first requires registering a window class, and that requires a
window procedure to process messages to the window.

#include <windows.h>

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,

PSTR szCmdLine, int iCmdShow) {
static TCHAR szAppName[] = TEXT ("HelloWin") ;
HWND hwnd ;
MSG msg ;

1.4
 AU / MCA / R2009 / II Yr / IV Sem / MC9243 / VP / Unit I

WNDCLASS wndclass ;

wndclass.style = CS_HREDRAW | CS_VREDRAW ;

wndclass.lpfnWndProc = WndProc ;
wndclass.cbClsExtra =0;
wndclass.cbWndExtra =0;
wndclass.hInstance = hInstance;
wndclass.hIcon = LoadIcon (NULL, IDI_APPLICATION) ;
wndclass.hCursor = LoadCursor (NULL, IDC_ARROW) ;
wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
wndclass.lpszMenuName = NULL ;
wndclass.lpszClassName = szAppName ;

if (!RegisterClass (&wndclass)) {
MessageBox (NULL, TEXT ("This program requires appropriate OS"),
szAppName, MB_ICONERROR) ;
return 0 ;
}

hwnd = CreateWindow (szAppName, TEXT ("The Hello Program"),

WS_OVERLAPPEDWINDOW, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
NULL, NULL, hInstance, NULL) ;
ShowWindow (hwnd, iCmdShow) ;
UpdateWindow (hwnd) ;

while (GetMessage (&msg, NULL, 0, 0)) {

TranslateMessage (&msg) ;
DispatchMessage (&msg) ;
}

return msg.wParam ;
}

LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam,

LPARAM lParam) {
HDC hdc ;
PAINTSTRUCT ps ;
RECT rect ;

switch (message) {

case WM_CREATE:
PlaySound (TEXT ("HelloWin.wav"), NULL,
SND_FILENAME|SND_ASYNC) ;
return 0 ;

case WM_PAINT:
hdc = BeginPaint (hwnd, &ps) ;
GetClientRect (hwnd, &rect) ;

1.5
VJS/Sr. AP/MCA/JCE

DrawText (hdc, TEXT ("Hello! World."), -1, &rect,

DT_SINGLELINE|DT_CENTER|DT_VCENTER) ;
EndPaint (hwnd, &ps) ;
return 0 ;

case WM_DESTROY:
PostQuitMessage (0) ;
return 0 ;
}
return DefWindowProc (hwnd, message, wParam, lParam) ;
}

The Windows Function Calls

LoadIcon Loads an icon for use by a program.

LoadCursor Loads a mouse cursor for use by a program.

GetStockObject Obtains a graphic object – in this case a brush used for painting the
window’s background.

RegisterClass Registers a window class for the program’s window.

MessageBox Displays a message box.

CreateWindow Create a window based on a window class.

ShowWindow Shows the window based on a window class.

UpdateWindow Directs the window to paint itself.

GetMessage Obtains a message from message queue.

TranslateMessage Translate some keyboard messages.

DispatchMessage Sends a message to a window procedure.

PlaySound Plays a sound file.

BeginPaint Initiates the beginning of window painting.

GetClientRect Obtains the dimensions of the window’s client area.

DrawText Displays a text string.

EndPaint Ends window painting.

PostQuitMessage Inserts a “quit” message into the message queue.

DefWindowProc Performs default processing of messages.

1.6
 AU / MCA / R2009 / II Yr / IV Sem / MC9243 / VP / Unit I

Uppercase Identifiers

The prefix indicates a general category to which the constant belongs.

Prefix Constant

CS Class style option

CW Create window option
DT Draw text option
IDI ID number for an icon
IDC ID number for a cursor
MB Message box options
SND Sound option
WM Window message
WS Window style

New Data Types

UINT - unsigned int, a 32-bit value

PSTR - pointer to a character string, that is, a char *

WPARAM - UINT

LPARAM - LONG, a 32-bit signed long integer

LRESULT - LONG

WINAPI and CALLBACK - defined as _stdcall, which refers to a special calling

sequence for function calls that occur between Windows
itself and the application.
Data Structures

MSG - Message structure

WNDCLASS - Window class structure
PAINTSTRUCT - Paint structure
RECT - Rectangle structure
Handles

A handle is simply a number (32 bits in size) that refers to an object. A program
obtains a handle by calling a Windows function.

1.7
VJS/Sr. AP/MCA/JCE

HINSTANCE - Handle to an “instance” – the program itself

HWND - Handle to a window
HDC - Handle to a device context
HICON - Handle to an icon
HCURSOR - Handle to a mouse cursor
HBRUSH - Handle to a graphics brush
Hungarian Notation

A variable-naming convention, in honor of the legendary Microsoft programmer

Charles Simonyi. The variable name begins with a lowercase letter or letters that denote the
data type of the variable.

Prefix Data Type

c char or WCHAR or TCHAR
by BYTE (unsigned char)
n short
i int
x, y int used as x-coordinate or y-coordinate
cx, cy int used as x or y length; c stands for “count”
b or f BOOL (int); f stands for “flag”
w WORD (unsigned short)
l LONG (long)
dw DWORD (unsigned long)
fn function
s string
sz string terminated by 0 character
h handle
p pointer

After WINUSER.H defines the WNDCLASSA and WNDCLASSW structures, the

header file defines WNDCLASS and pointers to WNDCLASS based on the definition of
the UNICODE identifier:

#ifdef UNICODE
typedef WNDCLASSW WNDCLASS ;
typedef PWNDCLASSW PWNDCLASS ;
typedef NPWNDCLASSW NPWNDCLASS ;
typedef LPWNDCLASSW LPWNDCLASS ;
#else

1.8
 AU / MCA / R2009 / II Yr / IV Sem / MC9243 / VP / Unit I

typedef WNDCLASSA WNDCLASS ;

typedef PWNDCLASSA PWNDCLASS ;
typedef NPWNDCLASSA NPWNDCLASS ;
typedef LPWNDCLASSA LPWNDCLASS ;
#endif

In WinMain, define a structure of type WNDCLASS, generally like:

WNDCLASS wndclass ;

and its functionally equivalent structure is

typedef struct {
UINT style ;
WNDPROC lpfnWndProc ;
int cbClsExtra ;
int cbWndExtra ;
HINSTANCE hInstance ;
HICON hIcon ;
HCURSOR hCursor ;
HBRUSH hbrBackground ;
LPCTSTR lpszMenuName ;
LPCTSTR lpszClassName ;
}
WNDCLASS, *PWNDCLASS;

Then initialize the 10 fields of the structure and call RegisterClass.

1. Combines two 32-bit “class style” identifiers with a “|” symbol. The
WINUSER.H defines these identifiers

#define CS_VREDRAW 0x0001

#define CS_HREDRAW 0x0002
#define CS_KEYCVTWINDOW 0x0004
#define CS_DBLCLKS 0x0008
#define CS_OWNDC 0x0020
#define CS_CLASSDC 0x0040
#define CS_PARENTDC 0x0080
#define CS_NOKEYCVT 0x0100
#define CS_NOCLOSE 0x0200
#define CS_SAVEBITS 0x0800
#define CS_BYTEALIGNCLIENT 0x1000
#define CS_BYTEALIGNWINDOW 0x2000
#define CS_GLOBALCLASS 0x4000
#define CS_IME 0x00010000

Identifiers defined in this way are called “bit flags” because each identifier sets a
single bit in a composite value.

1.9
VJS/Sr. AP/MCA/JCE

The identifiers CS_HREDRAW and CS_VREDREAW indicates that all

windows created based on this class are to be completely repainted whenever the
horizontal window size or the vertical window size changes.

2. The address of a window procedure used for all windows based on this class.

3. Used to reserve some extra space in the class structure that Windows maintains
internally.

4. Used to reserve some extra space in the window structure that Windows
maintains internally.

5. The instance handle of the program.

6. Sets an icon for all windows created based on this window class. The icon is a
small bitmap picture that represents the program to the user. To obtain a handle
to a predefined icon, call LoadIcon with the first argument set to NULL. While
loading a customized icons that are stored in the program’s .exe file on disk, this
argument would be set to hInstance, the instance handle of the program. The
second argument identifies the icon. For the predefined icons, this argument is
an identifier beginning with the prefix IDI defined in WINUSER.H. The
LoadIcon function returns a handle to this icon.

7. Similar to the previous, the LoadCursor function loads a predefined mouse

cursor and returns a handle to the cursor.

8. Specifies the background color of the client area of windows created based on
this class. A brush is a graphics term that refers to a colored pattern of pixels
used to fill an area.

9. Specifies the window class menu.

10. The text name of the window class. This may be whatever the user wants. In
programs that create only one window, the window class name is commonly set
to the name of the program.

Painting And Repainting

The client area is the part of the window on which a program is free to draw and
deliver visual information to the user. Displaying text or graphics in the client area is said
to be painting the client area.

Windows is a message-driven system. Windows informs applications of various

events by posting messages in the application’s message queue or sending messages to the
appropriate window procedure.

The WM_PAINT message

This message informs the window procedure that the client area must be painted. A
window procedure receives a WM_PAINT message whenever one of the following events
occurs:

1.10
 AU / MCA / R2009 / II Yr / IV Sem / MC9243 / VP / Unit I

• A previously hidden area of the window is brought into view when a user moves a
window or uncovers a window.

• The user resizes the window.

• The program uses the ScrollWindow or ScrollDC function to scroll part of its client
area.

• The program uses the InvalidateRect or InvalidateRgn function to explicitly generate

a WM_PAINT message.

In some cases when part of the client area is temporarily written over, Windows
attempts to save the area of display and restore it later. This is not always successful.
Windows may sometimes post a WM_PAINT message when:

• Windows removes a dialog box or message box that was overlaying part of the
window.

• A menu is pulled down and then released.

• A tool tip is displayed.

In a few cases, Windows always saves the area of the display it overwrites and then
restores it. This is the case whenever:

• The mouse cursor is moved across the client area.

• An icon is dragged across the client area.

Valid and Invalid Rectangles

Although a window procedure should be prepared to update the entire client area
whenever it receives a WM_PAINT message, it often needs to update only a small area,
most often a rectangular area within the client area. This area is known as an “invalid
region” or “update region”.

Windows internally maintains a “paint information structure” for each window.

This structure contains, among other information, the coordinates of the smallest rectangle
that encompasses the invalid region. This is known as the “invalid rectangle”. If another
region of the client area becomes invalid before the window procedure processes a pending
WM_PAINT message, Windows calculates a new invalid region that encompasses both
areas and stores this updated information in the paint information structure. Windows does
not place multiple WM_PAINT messages in the message queue.

A window procedure can invalidate a rectangle in its own client area by calling
InvalidateRect. If the message queue already contains a WM_PAINT message, Windows
calculates a new invalid rectangle. Otherwise, it places a WM_PAINT message in the
message queue. A window procedure can obtain the coordinates of the invalid rectangle

1.11
VJS/Sr. AP/MCA/JCE

when it receives a WM_PAINT message. It can also obtain these coordinates at any other
time by calling GetUpdateRect.

After the window procedure calls BeginPaint during the WM_PAINT message, the
entire client area is validated. A program can also validate any rectangular area within the
client area by calling the ValidateRect function. If this call has the effect of validating the
entire invalid area, then any WM_PAINT message currently in the queue is removed.

An Introduction To GDI
To paint the client area of the window, use Window’s Graphics Device Interface
(GDI) functions.

The Device Context

A handle, is a number that Windows uses for internal reference to an object. The
handle is obtained from Windows.

The device context (DC) is a data structure maintained internally by GDI. A device
context is associated with a particular display device.

When a program needs to paint, it must first obtain a handle to a device context.
When the handle is obtained, Windows fills the internal device context structure with
default attribute values. These defaults can be changed by calling various GDI functions.
After a program has finished painting its client area, it should release the device context
handle.

Getting a Device Context Handle: Method One

This method is used when the WM_PAINT messages are processed. Two functions
are involved: BeginPaint and EndPaint. These two functions require the handle to the
window, which is passed to the window procedure as an argument, and the address of the
structure variable of type PAINTSTRUCT, which is defined in the WINUSER.H header
file. Windows programmers usually name this structure variable ps and define it within the
window procedure like: PAINTSTRUCT ps ;

Getting a Device Context Handle: Method Two

To get a handle to the device context of the client area of the window, call GetDC to
obtain the handle and ReleaseDC after done with it.

hdc = GetDC (hwnd) ;

[GDI functions]
ReleaseDC (hwnd, hdc) ;

Like BeginPaint and EndPaint, the GetDC and ReleaseDC functions should be
called in pairs. Unlike the device context handle returned from BeginPaint, the device
context handle returned from GetDC has a clipping rectangle equal to the entire client area.

1.12
 AU / MCA / R2009 / II Yr / IV Sem / MC9243 / VP / Unit I

Unlike BeginPaint, GetDC does not validate any invalid regions. To validate the entire
client area, call

ValidateRect (hwnd, NULL) ;

Generally, the GetDC and ReleaseDC calls are used in response to the keyboard
messages or mouse messages.

A function similar to GetDC is GetWindowDC. While GetDC returns a device

context handle for writing on the client area of the window, GetWindowDC returns a device
context handle that lets to write on the entire window.

TextOut

TextOut is the most common GDI function for displaying text. Its syntax is

TextOut (hdc, x, y, psText, iLength) ;

The attributes of the device context, control the characteristics of the displayed text.
For instance, the default text color is black and text background color is white. When a
program writes text to the display, Windows uses this background color to fill in the
rectangular space surrounding each character, called the “character box”.

The system font is a “raster font”, which means that the characters are defined as
blocks of pixels. The size of the characters in the system font is based on the size of the
video display. The system font is designed to allow at least 25 lines of 80 character text to
fit on the screen.

The Size of a Character

A program can determine information about the sizes (or metrics) of user interface
items by calling the GetSystemMetrics function.

A program can determine font sizes by calling GetTextMetrics. This function

requires a handle to a device context because it returns information about the font currently
selected in the device context.

Windows copies the various values of text metrics into a structure of type
TEXTMETRIC defined in WINGDI.H. The TEXTMETRIC structure has 20 fields, but
knowing about only the first seven is necessary.

typedef struct tagTEXTMETRIC {

LONG tmHeight ;
LONG tmAscent ;
LONG tmDescent ;
LONG tmInternalLeading ;
LONG tmExternalLeading ;
LONG tmAveCharWidth ;
LONG tmMaxCharWidth ;
[other structure fields]
}

1.13
VJS/Sr. AP/MCA/JCE

TEXTMETRIC, * PTEXTMETRIC ;

To use the GetTextMetrics function, first define a structure variable, commonly

called tm as

TEXTMETRIC tm ;

When there is a need to determine the text metrics, get a handle to a device context and call
GetTextMetrics:
hdc = GetDC (hwnd) ;
GetTextMetrics (hdc, &tm) ;
ReleaseDC (hwnd, hdc) ;

Text Metrics: The Details

The TEXTMETRIC structure provides various types of information about the font
currently selected in the device context.

tmHeight – The sum of tmAscent and tmDescent. These two values represent the
maximum vertical extends of characters in the font above and below
the baseline.

tmInternalLeading - Specifies the amount of leading (space) inside the bounds set by the
tmHeight. Accent marks and other diacritical characters may occur in
this area. The designer may set this member to zero.

tmExternalLeading – This is an amount of space that the designer of the font suggests be
added between successive rows of displayed text.

tmAveCharWidth - Specifies the average width of characters in the font. This value does
not include the overhang required for bold or italic characters.

tmMaxCharWidth – The width of the widest character in the font.

Scroll Bars
Scroll bars are needed to display anything that requires more space than the space
available in the window’s client area. Scroll bars are positioned either vertically (for up and
down movement) or horizontally (for left and right movement). User can click with the
mouse the arrows at each end of a scroll bar or the area between the arrows. A “scroll box”
(or “thumb”) travels the length of the scroll bar to indicate the approximate location of the
material shown on the display in relation to the entire document. The thumb can also be
dragged with the mouse to move to a particular location.

To include a horizontal or vertical scroll bars in an application window, include the

window style identifier WS_VSCROLL (vertical scroll) or WS_HSCROLL (horizontal
scroll) or both in the third argument to CreateWindow.

1.14
 AU / MCA / R2009 / II Yr / IV Sem / MC9243 / VP / Unit I

The scroll bars specified in the CreateWindow function are always placed against the right
side or bottom of the window and extend the full length or width of the client area. The
client area does not include the space occupied by the scroll bars. The width of the vertical
scroll bar and the height of the horizontal scroll bar are constant for a particular video driver
and display resolution.

Windows takes care of processing all mouse messages to the scroll bars. However,
scroll bars do not have an automatic keyboard interface.

Scroll Bar Range and Position

Every scroll bar has an associated “range” and “position”. The scroll bar range is a
pair of integers representing a minimum or maximum value associated with the scroll bar.
The position is the location of the thumb with the range. When the thumb is at the top (or
left) of the scroll bar, the position of the thumb is the minimum value of the range and at the
bottom (or right) of the scroll bar, the thumb position is the maximum value of the range.

By default, the range of a scroll bar is 0 (top or left) through 100 (bottom or right).
To change the range

SetScrollRange (hwnd, iBar, iMin, iMax, bRedraw) ;

iBar - SB_VERT or SB_HORZ

iMin and iMax - the new minimum and maximum positions of the range
bRedraw - Specifies whether the scroll bar should be redrawn to reflect the
change. If TRUE, the scroll bar is redrawn. If it is FALSE, the
scroll bar is not redrawn.

To set a new thumb position within the scroll bar range:

SetScrollPos (hwnd, iBar, iPos, bRedraw) ;

iPos - the new position and must be within the range of iMin and iMax
To obtain the current range and position of a scroll bar
- GetScrollRange
- GetScrollPos

When the scroll bars are used within the program, responsibilities are shared with
Windows for the maintaining the scroll bars and updating the position of the scroll bar
thumb.

Windows’ responsibilities:
- Handle all processing of mouse messages to the scroll bar.
- Provide a reverse-video when the user clicks the scroll bar.
- Move the thumb as the user drags the thumb within the scroll bar.
- Send scroll bar messages to the window procedure of the window containing the
scroll bar.

Responsibilities of the program:

1.15
VJS/Sr. AP/MCA/JCE

- Initialize the range and position of the scroll bar.

- Process the scroll bar messages to the window procedure.
- Update the position of the scroll bar thumb.
- Change the contents of the client area in response to a change in the scroll bar.
Scroll Bar Messages

Windows sends the window procedure WM_VSCROLL (vertical scroll) and

WM_HSCROLL (horizontal scroll) messages when the scroll bar is clicked with the mouse
or the thumb is dragged. Each mouse action on the scroll bar generates at least two
messages, one when the mouse button is pressed and another when it is released.

Like all messages, WM_VSCROLL and WM_HSCROLL are accompanied by the

wParam and lParam message parameters. lParam is ignored if scroll bars are created as part
of the window; it is used only for scroll bars created as child windows.

The wParam message parameter is divided into a low word and high word. The low
word of the wParam is a number that indicates what the mouse is doing to the scroll bar.
This number is referred to as a “notification code”. Notification codes have values defined
by identifiers that begin with SB, which stands for “scroll bar”. The notification codes are:

SB_LINEUP 0
SB_LINELEFT 0
SB_LINEDOWN 1
SB_LINERIGHT 1
SB_PAGEUP 2
SB_PAGELEFT 2
SB_PAGEDOWN 3
SB_PAGERIGHT 3
SB_THUMBPOSITION 4
SB_THUMBTRACK 5
SB_TOP 6
SB_LEFT 6
SB_BOTTOM 7
SB_RIGHT 7
SB_ENDSCROLL 8

The identifiers containing the words LEFT and RIGHT are used for horizontal scroll bars,
and the identifiers with UP, DOWN, TOP and BOTTOM with vertical scroll bars.

When the mouse button is held down on the various parts of the scroll bar (except
thumb) the program can receive multiple scroll bar messages. When the mouse button is
released, the program gets a message with a notification code of SB_ENDSCROLL; these
messages are generally ignored.

When the position of the mouse cursor is over the scroll bar thumb and the mouse
button is pressed, the thumb can be moved. This generates scroll bar messages with
notification codes of SB_THUMBTRACK and SB_THUMBPOSITION. When the low
word of wParam is SB_THUMBTRACK, the high word of wParam is the current position
of the scroll bar thumb as the user is dragging it. When the low word of wParam is

1.16
 AU / MCA / R2009 / II Yr / IV Sem / MC9243 / VP / Unit I

SB_THUMBPOSITION, the high word of wParam is the final position of the scroll bar
thumb when the user releases the mouse button.

The Keyboard
Keyboard Basics

Keyboard input is delivered to the program’s window procedure in the form of

messages. The window that receives a particular keyboard event is the window that has
input focus (active window). A window procedure can determine when its window has the
input focus by trapping WM_SETFOCUS and WM_KILLFOCUS messages.
WM_SETFOCUS indicates that the window is receiving the input focus, and
WM_KILLFOCUS signals that the window is losing the input focus.

As the user presses and releases keys on the keyboard, Windows and the keyboard
device driver translate the hardware scan codes into formatted messages. These messages
are not placed in an application’s message queue. Instead, Windows stores these messages
in the system message queue. The system message queue is a single message queue
maintained by Windows specifically for the preliminary storage of user input from the
keyboard and the mouse. Windows will take the next message from the system message
queue and place it in an application’s message queue only when a Windows application has
finished processing a previous user input message.

The reason for this is that the window that is supposed to receive keyboard input is
the window with the input focus. A user can be typing faster than an application can handle
the keystrokes, and a particular keystroke might have the effect of switching focus from one
window to another. Subsequent keystrokes should then go to another window. But they
won’t if the subsequent keystrokes have already been addressed with a destination window
and placed in an application message queue.

The Caret (not the cursor)

When text is typed into a program, a little underline, vertical bar, or a box shows
where the next character to be typed will appear on the screen. This may be known as a
“cursor”. In Windows, it is called the “caret”. The word “cursor” is reserved for the little
bitmap image that represents the mouse position.

The Caret Functions

There are five essential caret functions:

• CreateCaret Creates a caret associated with a window.

• SetCaretPos Sets the position of the caret within the window.
• ShowCaret Shows the caret.

1.17
VJS/Sr. AP/MCA/JCE

• HideCaret Hides the caret.

• DestroyCaret Destroys the caret.

There are also functions

• To get the current caret position GetCaretPos

• To get the caret blink time GetCaretBlinkTime
• To set the caret blink time SetCaretBlinkTime

In Windows, the caret is customarily a horizontal line or box that is the size of a
character, or a vertical line that is the height of a character. The vertical line caret is
recommended to be used with proportional font in which the characters are not of a fixed
size.

Using the caret is simple: in window procedure call CreateCaret during the
WM_SETFOCUS message and call DestroyCaret during the WM_KILLFOCUS message.
The caret is created hidden. After calling CreateCaret the window procedure must call
ShowCaret for the caret to be visible. In addition, the window procedure must hide the
caret by calling HideCaret whenever it draws something on its window during a message
other than WM_PAINT. After it finishes drawing on the window, the program must call
ShowCaret to display it.

WM_KEYDOWN Message

Posted to the window with the keyboard focus when a nonsystem key is pressed. A
nonsystem key is a key that is pressed when the ALT key is not pressed.

wParam

The virtual-key code of the nonsystem key.

lParam

Other parameters

WM_CHAR Message

Posted to the window with the keyboard focus when a WM_KEYDOWN message is
translated by the TranslateMessage function. The WM_CHAR message contains the
character code of the key that was pressed.

wParam The character code of the key.

lParam Other parameters

1.18
 AU / MCA / R2009 / II Yr / IV Sem / MC9243 / VP / Unit I

SendMessage Function

Sends the specified message to a window or windows. The SendMessage function calls the
window procedure for the specified window and does not return until the window procedure
has processed the message.

SendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam );

LRESULT CALLBACK WndProc(HWND hwnd,UINT message,WPARAM

wParam,LPARAM lParam) {

HDC hdc; // device context

PAINTSTRUCT ps; // client area paint info
static int cxChar, // width of char. in logical units
cyChar, // height of char. in logical units
cxClient, // width of client area in pixels
cyClient, // height of client area in pixels
cxClientChar, // width of client area in characters
cyClientChar, // height of client area in character
caretX, // x-position of caret
caretY; // y-position of caret
static UINT uOldBlink; // previous blink rate
int x, y; // coordinates for text matrix
TEXTMETRIC tm; // font information
static char *pTextMatrix = NULL; // points to text matrix

switch (message)
{
case WM_CREATE:

// Select a fixed-width system font, and get its text metrics.

hdc = GetDC(hwnd);
SelectObject(hdc, GetStockObject(
SYSTEM_FIXED_FONT));
GetTextMetrics(hdc, &tm);

ReleaseDC(hwnd, hdc);

// Save the avg. width and height of characters.

cxChar = tm.tmAveCharWidth;
cyChar = tm.tmHeight;

return 0;

case WM_SIZE:
// Determine the width of the client area, in pixels and in number of characters.

cxClient = LOWORD(lParam);
cxClientChar = max(1, cxClient/cxChar);

// Determine the height of the client area, in pixels and in number of characters

1.19
VJS/Sr. AP/MCA/JCE

cyClient = HIWORD(lParam);
cyClientChar = max(1, cyClient/cyChar);

// Clear the buffer that holds the text input.

if (pTextMatrix != NULL)
free(pTextMatrix);
// If there is enough memory, allocate space for the text input buffer.

pTextMatrix = malloc(cxClientChar * cyClientChar);

if (pTextMatrix == NULL) {
MessageBox(NULL,TEXT("Not enough memory."),TEXT("Error"),
MB_ICONERROR);
return 0;
}
else
for (y = 0; y < cyClientChar; y++)
for (x = 0; x < cxClientChar; x++)
TEXTMATRIX(x, y) = ' ';

// Move the caret to the origin.

SetCaretPos(0, 0);

return 0;

case WM_KEYDOWN:
switch (wParam)
{
case VK_HOME: // Home
caretX = 0;
break;

case VK_END: // End

caretX = cxClientChar - 1;
break;

case VK_PRIOR: // Page Up

caretY = 0;
break;

case VK_NEXT: // Page Down

caretY = cyClientChar -1;
break;

case VK_LEFT: // Left arrow

caretX = max(caretX - 1, 0);
break;

1.20
 AU / MCA / R2009 / II Yr / IV Sem / MC9243 / VP / Unit I

case VK_RIGHT: // Right arrow

caretX = min(caretX + 1, cxClientChar - 1);
break;

case VK_UP: // Up arrow

caretY = max(caretY - 1, 0);
break;

case VK_DOWN: // Down arrow

caretY = min(caretY + 1,
cyClientChar - 1);
break;

case VK_DELETE: // Delete

// Move all the characters that followed the

// deleted character (on the same line) one
// space back (to the left) in the matrix.

for (x = caretX; x < cxClientChar; x++)

TEXTMATRIX(x, caretY) = TEXTMATRIX(x + 1, caretY);

// Replace the last character on the

// line with a space.

TEXTMATRIX(cxClientChar - 1, caretY) = ' ';

// The application will draw outside the

// WM_PAINT message processing, so hide the caret.

HideCaret(hwnd);

// Redraw the line, adjusted for the

// deleted character.

hdc = GetDC(hwnd);
SelectObject(hdc, GetStockObject(SYSTEM_FIXED_FONT));

TextOut(hdc, caretX * cxChar, caretY * cyChar,

&TEXTMATRIX(caretX, caretY), cxClientChar - caretX);

ReleaseDC(hwnd, hdc);

// Display the caret.

ShowCaret(hwnd);

break;
}

// Adjust the caret position based on the

1.21
VJS/Sr. AP/MCA/JCE

// virtual-key processing.

SetCaretPos(caretX * cxChar, caretY * cyChar);

return 0;

case WM_CHAR:
switch (wParam)
{
case 0x08: // Backspace
// Move the caret back one space, and then
// process this like the DEL key.

if (caretX > 0)
{
caretX--;
SendMessage(hwnd, WM_KEYDOWN, VK_DELETE, 1L);
}
break;

case 0x09: // Tab

// Tab stops exist every four spaces, so add
// spaces until the user hits the next tab.

do
{
SendMessage(hwnd, WM_CHAR, ' ', 1L);
} while (caretX % 4 != 0);
break;

case 0x0D: // Carriage return

// Go to the beginning of the next line.
// The bottom line wraps around to the top.

caretX = 0;

if (++caretY == cyClientChar)
caretY = 0;
break;

case 0x1B: // Escape

case 0x0A: // Linefeed
MessageBeep((UINT) -1);
break;

default:
// Add the character to the text buffer.

TEXTMATRIX(caretX, caretY) = (char) wParam;

1.22
 AU / MCA / R2009 / II Yr / IV Sem / MC9243 / VP / Unit I

// The application will draw outside the

// WM_PAINT message processing, so hide the caret.

HideCaret(hwnd);

// Draw the character on the screen.

hdc = GetDC(hwnd);
SelectObject(hdc, GetStockObject(SYSTEM_FIXED_FONT));

TextOut(hdc, caretX * cxChar, caretY * cyChar,

&TEXTMATRIX(caretX, caretY), 1);

ReleaseDC(hwnd, hdc);

// Display the caret.

ShowCaret(hwnd);

// Prepare to wrap around if you reached the

// end of the line.

if (++caretX == cxClientChar)
{
caretX = 0;
if (++caretY == cyClientChar)
caretY = 0;
}
break;
}

// Adjust the caret position based on the

// character processing.

SetCaretPos(caretX * cxChar, caretY * cyChar);

return 0;

case WM_PAINT:
// Draw all the characters in the buffer, line by line.

hdc = BeginPaint(hwnd, &ps);

SelectObject(hdc, GetStockObject(SYSTEM_FIXED_FONT));

for (y = 0; y < cyClientChar; y++)

TextOut(hdc, 0, y * cyChar, &TEXTMATRIX(0, y), cxClientChar);

1.23
VJS/Sr. AP/MCA/JCE

EndPaint(hwnd, &ps);

case WM_SETFOCUS:

// The window has the input focus.

// Create the caret.

CreateCaret(hwnd, (HBITMAP) NULL, 2, cyChar);

// Adjust the caret position.

SetCaretPos(caretX * cxChar, caretY * cyChar);

// Display the caret.

ShowCaret(hwnd);

break;

case WM_KILLFOCUS:
// The window is losing the input focus,
// so destroy the caret.

DestroyCaret();
break;

case WM_DESTROY:
PostQuitMessage (0) ;
return 0 ;
}
return DefWindowProc(hwnd, message, wParam, lParam);
}

The Mouse
The mouse is a pointing device.

To determine if a mouse is present use the GetSystemMetrics function:

fMouse = GetSystemMetrics (SM_MOUSEPRESENT) ;

The value of fMouse will be

- TRUE (nonzero) if a mouse is installed and
-0 if a mouse is not installed

1.24
 AU / MCA / R2009 / II Yr / IV Sem / MC9243 / VP / Unit I

To determine the number of buttons on the installed mouse, use

cButtons = GetSystemMetrics (SM_CMOUSEBUTTONS) ;

When the user moves the mouse, Windows moves a small bitmapped picture on the
display. This is called the “mouse cursor”. The mouse cursor has a single-pixel “hot spot”
that points to a precise location on the display.

Windows supports several predefined mouse cursors that programs can use.
IDC_ARROW- slanted arrow. The hot spot is the tip of the arrow.
IDC_CROSS - cross. The hot spot is the center of the crosshair pattern.
IDC_WAIT - hourglass. Used by programs to indicate they are busy.
Programmers can also design their own cursors. The default cursor for a particular window
is specified when defining the window class structure.

The following terms describe the actions with mouse buttons:

• Clicking - Pressing and releasing a mouse button.
• Double-clicking - Pressing and releasing a mouse button twice a quick
succession.
• Dragging - Moving the mouse while holding down a button.

The buttons on a mouse are called the left button, the middle button, and the right
button. The identifiers defined in the Windows header files related to these buttons are
LBUTTON, MBUTTON, and RBUTTON respectively.

Client Area Mouse Messages

Windows sends keyboard messages only to the window that has the input focus.
But a window procedure receives mouse messages whenever the mouse passes over the
window or is clicked within the window, even if the window is not active or does not have
the input focus.

Windows defines 21 messages for the mouse. 11 of these messages do not relate to
the client area. These are called “nonclient-area messages”.

When the mouse is moved over the client area of a window, the window procedure
receives the message WM_MOUSEMOVE. When a mouse button is pressed or released
within the client area of a window, the window procedure receives the following messages:

Button Pressed Released Pressed (Second Click)

Left WM_LBUTTONDOWN WM_LBUTTONUP WM_LBUTTONDBLCLK

Middle WM_MBUTTONDOWN WM_MBUTTONUP WM_MBUTTONDBLCLK

Right WM_RBUTTONDOWN WN_RBUTTONUP WM_RBUTTONDBLCLK

1.25
VJS/Sr. AP/MCA/JCE

For all these messages, the value of lParam contains the position of the mouse. The
low word is the x-coordinate, and the high word is the y-coordinate relative to the upper left
corner of the client area of the window. These values can be extracted using the LOWORD
and HIWORD macros:

x = LOWORD (lParam) ;
y = HIWORD (lParam) ;

The value of wParam indicates the state of the mouse buttons and the Shift and Ctrl
keys. The MK prefix stands for “mouse key”.

MK_LBUTTON - Left button is down

MK_MBUTTON - Middle button is down
MK_RBUTTON - Right button is down
MK_SHIFT - Shift key is down
MK_CONTROL - Ctrl key is down

Example: This program connects every point to every other point

#define MAXPOINTS 100

LRESULT CALLBACK WndProc (HWND hwnd, UINT message,

WPARAM wParam, LPARAM lParam)
{
static POINT pt[MAXPOINTS] ;
static int iCount ;
HDC hdc ;
int i, j ;
PAINTSTRUCT ps ;

switch (message)
{
case WM_LBUTTONDOWN:
iCount = 0 ;
InvalidateRect (hwnd, NULL, TRUE) ;
return 0 ;

case WM_MOUSEMOVE:
if (wParam & MK_LBUTTON && iCount < MAXPOINTS)
{
pt[iCount].x = LOWORD (lParam) ;
pt[iCount++].y = HIWORD (lParam) ;

hdc = GetDC (hwnd) ;

SetPixel (hdc, LOWORD (lParam), HIWORD (lParam), 0) ;

ReleaseDC (hwnd, hdc) ;

1.26
 AU / MCA / R2009 / II Yr / IV Sem / MC9243 / VP / Unit I

}
return 0 ;

case WM_LBUTTONUP:
InvalidateRect (hwnd, NULL, FALSE) ;
return 0 ;

case WM_PAINT:
hdc = BeginPaint (hwnd, &ps) ;
for (i=0; i<iCount-1; i++) {
for (j=i+1; j<iCount; j++) {
MoveToEx (hdc, pt[i].x, pt[i].y, NULL) ;
LineTo (hdc, pt[j].x, pt[j].y) ;
}
}
EndPaint (hwnd, &ps) ;
return 0 ;
case WM_DESTROY:
PostQuitMessage (0) ;
return 0 ;

}
return DefWindowProc (hwnd, message, wParam, lParam) ;
}

Processing Shift and Ctrl Keys

if (wParam & MK_SHIFT) {

if (wParam & MK_CONTROL) {
[Shift and Ctrl keys are down]
}
else {
[Shift key is down]
}
}
else {
if (wParam & WM_CONTROL) {
[Ctrl key is down]
}
else {
[neither Shift nor Ctrl key is down]
}
}

To know the status of the mouse buttons or shift key or control key call the function
GetKeyState using virtual key codes VK_LBUTTON, VK_MBUTTON, VK_RBUTTON,
VK_SHIFT and VK_CONTROL. The button or key is down if the value returned from
GetKeyState is negative.

Moue Double-Clicks

1.27
VJS/Sr. AP/MCA/JCE

A mouse double-click is two click in quick succession. To qualify as double-click,

the two clicks must occur in close physical proximity of one another and within a specific
interval of time called the “double-click speed”.

To process double-click mouse messages in a window procedure, include the

identifier CS_DBLCLKS when initializing the style field in the window class structure
before calling RegisterClass:

wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS

Nonclient-Area Mouse Messages

If the mouse is outside a window’s client area but within the window, Windows
sends the window procedure a “nonclient-area” mouse message. The nonclient area of a
window includes the title bar, the menu, and the window scroll bars.

The nonclient-area mouse messages are almost like the client-area mouse messages.
The message identifiers include the letters “NC” to indicate “nonclient”. For example, if
the mouse is moved within a nonclient area of a window, the window procedure receives
the message WM_NCMOUSEMOVE. The mouse buttons generate messages similar to
this.

The wParam parameter indicates the nonclient area where the mouse was moved or
clicked. It is set to one of the identifiers beginning with HT (standing for “hit-test”).

The lParam parameter contains an x-coordinate in the low word and a y-coordinate
in the high word. These are screen coordinates. For screen coordinates, the upper-left
corner of the display area has x and y values of 0. Values of x increase towards the right
and values of y increase towards down.

To convert screen coordinates to client-area coordinates and vice verse call

ScreenToClient (hwnd, &pt) ;

ClientToScreen (hwnd, &pt);

where pt is a POINT structure. If a screen-coordinate point is above or to the left of

window’s client area, the x or y value of the client-area coordinate could be negative.

The Hit-Test Message

The last message is WM_NCHITTEST, which stands for “nonclient hit test”. This
message precedes all other client-area and nonclient-are mouse messages. The lParam
parameter contains the x and y screen coordinates of the mouse position. The wParam
parameter is not used. Windows applications generally pass this message to
DefWindowProc.

Note:

To display or hide cursor: ShowCursor (Bool bShow) ;

Example:
ShowCursor (TRUE) ;

1.28
 AU / MCA / R2009 / II Yr / IV Sem / MC9243 / VP / Unit I

ShowCursor (FALSE) ;

To set the cursor shape: SetCursor (HCURSOR hCursor) ;

Example:
SetCursor (LoadCursor (NULL, IDC_ARROW)) ;
SetCursor (LoadCursor (NULL, IDC_WAIT)) ;

To set the cursor position: SetCursorPos(int X, int Y) ;

Example:
SetCursorPos(300, 200) ;

To obtain the cursor position: GetCursorPos(LPPOINT lpPoint) ;

Example:
POINT cursorPos ;
GetCursorPos(&cursorPos) ;

int x = cursorPos.x ;
int y = cursorPos.y ;

Menus
A menu is a list of available options. A menu tells the user what operations an
application is capable of performing.

A menu is the most important part of the user interface in Windows programs. For
adding a menu to the program: define the menu and specify the name of the menu in the
window class structure. Each selectable menu item is given a unique ID number. When the
user chooses a menu item, Windows sends the program a WM_COMMAND message
containing that ID.

Keyboard accelerators are key combinations that are used to duplicate menu
functions.

Menu Concepts

A window’s menu bar is displayed immediately below the caption bar. This menu
bar is also called a program’s “main menu” or the “top-level menu”. Items listed in the top-
level menu usually invoke drop-down menus, which are also called “popup menus” or
“submenus”. Multiple nesting of popup can be defined. Sometimes items in popup menus
invoke a dialog box for more information.

1.29