CS410 Visual Programming Assignment 2 Solution Fall 2012

Q1: What is main importance of using function pointers in term of usability?

Q2: Why we use message queues for each application instead of using a single system message queue?

Q3: What are the four steps involved to code win32 application?

Q4: Paste pictures of the sample windows if the following properties are set. (Separate for each property)
* Images should be small (Paste 3 images on one MS-Word Page)


“Pointer is a kind of variable whose value is a memory address, typically of another variable”.

 int *p;
 int i = 3;
 p = &i;


In this piece of code, we have taken a pointer to integer denoted by “*p”. In second statement, an integer is declared and initialized by ‘3’. The next step is the most important one. Here we are passing the “Address” of the integer “i” in the pointer. Since pointers hold the variable addresses; so now the pointer “p” contains the address of the integer “i” which has a value of 3.


Pointer Advantages

  • This allows a function to “return” more than a single value (we are not really returning more than a single variable, but we are able to directly modify the values that are in main, from within a function).
  • This allows us to refer to larger data structures with just a single pointer. This cuts back on creating multiple copies of a structure, which consumes both memory and time.
  • This also opens the door to dynamic memory allocation.
  •  Use pointers when you want efficient results.
  • To develop plug-ins of existing software use pointers as much as you can.
  • Take extreme care while manipulating arrays with pointers.
  • Many bugs in large programmes arise due to pointers so only use pointers when necessary.
  • Make sure to initialize pointers with some valid value.
  • Don’t try to modify the contents of constant pointers.
  • Be sure that the data types of pointer variable and the pointed variable are same.
  • Do not assign system area addresses to pointer
  • Use function pointer only where it is required

Question # 2


Windows Messages

The system passes input to a window procedure in the form of messages. Messages are generated by both the system and applications. The system generates a message at each input event. The message to a window procedure with a set of four parameters:

  • Window handle system sends a
  • Message identifier
  • Two values called message parameters.

Message Types

This section describes the two types of messages:

  • System-Defined Messages
  • Application-Defined Messages

System-Defined Messages

The system sends or posts a system-defined message when it communicates with an application. It uses these messages to control the operations of applications and to provide input and other information for applications to process. An application can also send or post system-defined messages. Applications generally use these messages to control the operation of control windows created by using pre-registered window classes.

Each system-defined message has a unique message identifier and a corresponding symbolic constant (defined in the software development kit (SDK) header files) that states the purpose of the message. For example, the WM_PAINT constant requests that a window paint its contents.

Queued Messages

The system can display any number of windows at a time. To route mouse and keyboard input to the appropriate window, the system uses message queues.

The system maintains a single system message queue and one thread-specific message queue for each graphical user interface (GUI) thread. To avoid the overhead of creating a message queue for non–GUI threads, all threads are created initially without a message queue. The system creates a thread-specific message queue only when the thread makes its first call to one of the User or Windows Graphics Device Interface (GDI) functions.

Whenever the user moves the mouse, clicks the mouse buttons, or types on the keyboard, the device driver for the mouse or keyboard converts the input into messages and places them in the system message queue. The system removes the messages, one at a time, from the system message queue, examines them to determine the destination window, and then posts them to the message queue of the thread that created the destination window. A thread’s message queue receives all mouse and keyboard messages for the windows created by the thread. The thread removes messages from its queue and directs the system to send them to the appropriate window procedure for processing.

With the exception of the WM_PAINT message, the system always posts messages at the end of a message queue. This ensures that a window receives its input messages in the proper first in, first out (FIFO) sequence. The WM_PAINT message, however, is kept in the queue and is forwarded to the window procedure only when the queue contains no other messages. Multiple WM_PAINT messages for the same window are combined into a single WM_PAINT message, consolidating all invalid parts of the client area into a single area. Combining WM_PAINT messages reduces the number of times a window must redraw the contents of its client area.

The system posts a message to a thread’s message queue by filling an MSG structure and then copying it to the message queue.

A thread can post a message to its own message queue or to the queue of another thread by using the PostMessage or PostThreadMessage function.

An application can remove a message from its queue by using the GetMessage function.To examine a message without removing it from its queue, an application can use the PeekMessage function. This function fills MSG with information about the message.

After removing a message from its queue, an application can use the DispatchMessage function to direct the system to send the message to a window procedure for processing. DispatchMessage takes a pointer to MSG that was filled by a previous call to the GetMessage or PeekMessage function. DispatchMessage passes the window handle, the message identifier, and the two message parameters to the window procedure, but it does not pass the time the message was posted or mouse cursor position. An application can retrieve this information by calling the GetMessageTime and GetMessagePos functions while processing a message.

A thread can use the WaitMessage function to yield control to other threads when it has no messages in its message queue. The function suspends the thread and does not return until a new message is placed in the thread’s message queue.

You can call the SetMessageExtraInfo function to associate a value with the current thread’s message queue. Then call the GetMessageExtraInfo function to get the value associated with the last message retrieved by the GetMessage or PeekMessage function.

Nonqueued Messages

Nonqueued messages are sent immediately to the destination window procedure, bypassing the system message queue and thread message queue. The system typically sends nonqueued messages to notify a window of events that affect it. For example, when the user activates a new application window, the system sends the window a series of messages, including WM_ACTIVATE, WM_SETFOCUS, and WM_SETCURSOR. These messages notify the window that it has been activated, that keyboard input is being directed to the window, and that the mouse cursor has been moved within the borders of the window. Nonqueued messages can also result when an application calls certain system functions. For example, the system sends the WM_WINDOWPOSCHANGED message after an application uses theSetWindowPos function to move a window.

Some functions that send nonqueued messages are BroadcastSystemMessageBroadcastSystemMessageExSendMessageSendMessageTimeout, and SendNotifyMessage.


Question # 3

We will make window application in four steps:

We will make window application in four steps:

  1. In first step, we will register a windows class.
  2. In second step, we will create a window
  3. In third step, we will make a message loop and message handling procedure
  4. In our fourth step, we will write WinMain function and will make the application running.

 Question # 4

#include <windows.h> 
const char g_szClassName[] = "myWindowClass"; 
// Step 4: the Window Procedure 
case WM_CLOSE: DestroyWindow(hwnd);
case WM_DESTROY: PostQuitMessage(0);
default: return DefWindowProc(hwnd, msg, wParam, lParam);
return 0;
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) 
HWND hwnd;
MSG Msg; 
//Step 1: Registering the Window Class 
wc.cbSize = sizeof(WNDCLASSEX);
wc.style = 0;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wc.lpszMenuName = NULL;
wc.lpszClassName = g_szClassName; 
wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
MessageBox(NULL, "Window Registration Failed!", "Error!", MB_ICONEXCLAMATION | MB_OK);
return 0;
// Step 2: Creating the Window

hwnd = CreateWindowEx( WS_EX_CLIENTEDGE, g_szClassName, "virtual university", WS_OVERLAPPEDWINDOW | WS_CAPTION, CW_USEDEFAULT, CW_USEDEFAULT, 240, 120, NULL, NULL, hInstance, NULL);
if(hwnd == NULL) 
MessageBox(NULL, "Window Creation Failed!", "Error!", MB_ICONEXCLAMATION | MB_OK);
return 0;
ShowWindow(hwnd, nCmdShow);
// Step 3: The Message Loop 
while(GetMessage(&Msg, NULL, 0, 0) > 0) 
return Msg.wParam;