Home

Types of Windows

 

The Window's Real Estate

 

Application's Instance

A window is referred to as parent when it can be used to host, hold, or carry other windows. For examples, when the computer starts, it draws its main screen, also called the desktop, which occupies the widest area that the monitor screen can offer. This primary window becomes the host of all other window that will display as long as the computer is own. This desktop is also a complete window in its own right. As mentioned already, to get its handle, you can call the GetDesktopWindow() function.

After the desktop has been created, a window of yours can display if the user starts your application. This means that an application must have been created for the user to use it. When the user opens an application, we also say that the application has been instantiated or an instance of the application has been created. Based on this, any time you create an application, you must provide an instance of it. This allows the operating system to manage your application with regards to its interaction with the user and also its relationship with other resources. Therefore, you must always create an instance for your application. This is taken care of by the first argument of the WinMain() function.

If an application has already been created, to get its instance, you can call the GetWindowLong() function. Its syntax is:

LONG GetWindowLong(HWND hWnd, int nIndex);

Although this function is used for many other reasons, it can also help you get the instance of an application. To do this, pass the first argument as the handle to a window of the application you are examining and pass the second argument as GWL_HINSTANCE.

 

Window Parenting

There are two types of windows or object you will deal with in your applications. The type referred to here is defined by the relationship a window has with regards to other windows that are part of an application:

  • Parent: a window is referred to as a parent when there are, or there can be, other windows that depend on it. For example, the toolbar of your browser is equipped with some buttons. The toolbar is a parent to the buttons. When a parent is created, it "gives life" to other windows that can depend on it.
  • Child: A window is referred to as child when its existence and especially its visibility depend on another window called its parent.

When a parent is created, made active, or made visible, it gives existence and visibility to its children. When a parent gets hidden, it also hides its children. If a parent moves, it moves with its children. The children keep their positions and dimensions inside the parent. When a parent is destroyed, it also destroys its children (sometimes it does not happen so smoothly; a parent may make a child unavailable but the memory space the child was occupying after the parent has been destroyed may still be in use, sometimes filled with garbage, but such memory may not be available to other applications until you explicitly recover it).

Child controls depend on a parent because the parent "carries", "holds", or hosts them. All of the Windows controls you will use in your applications are child controls. A child window can also be a parent of another control. For example, a toolbar of the browser is the parent of the buttons on it. If you close or hide the toolbar, its children disappear. At the same time, the toolbar is a child of the application's frame. If you close the application, the toolbar disappears, along with its own children. In this example, the toolbar is a child of the frame but is a parent to its buttons.

After initializing an application with either the WNDCLASS, or the WNDCLASSEX structure and registering it, as we have done so far, you must create the primary parent of all objects of your class. This is usually done with either the CreateWindow() or the CreateWindowEx() function. Here is an example:

HWND hWndParent;

// Create the parent window
hWndParent = CreateWindowEx(0, ClassName, StrWndName,
			           WS_OVERLAPPEDWINDOW,
			           0, 100, 140, 320,
			           NULL, NULL, hInstance, NULL);
 

 

A Window's Childhood

After creating the main window, you can use it as a parent for other windows. To specify that a window is a child of another window, when creating it with either the CreateWindow() or the CreateWindowEx() function, pass the handle of the parent as the hWndParent argument. Here is an example:

// Create a window
CreateWindowEx(0, WndClassName, CaptionOrText,
               ChildStyle, Left, Top, Width, Height,
               hWndParent, NULL, hInstance, NULL);

If a window is a child of another window, to get a handle to its parent, you can call the GetParent() function. Its syntax is:

HWND GetParent(HWND hWnd);

The hWnd argument is a handle to the child window whose parent you want to find out. Alternatively, you can also use the GetWindowLong() function, passing the second argument as GWL_HWNDPARENT, to get a handle to the parent of a window.

 

The Borders of a Window

To distinguish a particular window from the other objects on a screen, a window can be defined by surrounding borders on the left, the top, the right, and the bottom. One of the effects the user may want to control on a window is its size. For example, the user may want to narrow, enlarge, shrink, or heighten a window. To do this, a user would position the mouse on one of the borders, click and drag in the desired direction. This action is referred to as resizing a window. For the user to be able to change the size of a window, the window must have a special type of border referred to as a thick frame. To provide this border, apply or add the WS_THICKFRAME style:

CreateWindow(ClsName, WndName,
       WS_VISIBLE | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_THICKFRAME);

Because many windows will need this functionality, a special style can combine them and it is called WS_OVERLAPPEDWINDOW. Therefore, you can create a resizable window as follows:

CreateWindow(ClsName, WndName, WS_OVERLAPPEDWINDOW,

 

 

Window's Location and Size

The location of a window is defined by the distance from the left border of the monitor to the window's left border and its distance from the top border of the monitor to its own top border. The size of a window is its width and its height. These can be illustrated for a main window frame as follows:

Window Location, Size, and Dimension

For a Win32 application, the original distance from the left border of the monitor is passed as the x argument to the CreateWindow() or the CreateWindowEx() function. The distance from top is specified using the y argument. The x and y arguments define the location of the window. The distance from the left border of the monitor to the right border of the window is specified as the nWidth argument. The distance from the top border of the monitor to the lower border of the window is specified with the nHeight value.

If you cannot make up your mind for these four values, you can use the CW_USEDEFAULT (when-Creating-the-Window-USE-the-DEFAULT-value) constant for either one or all four arguments. In such a case, the compiler would select a value for the argument. Here is an example:

INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
               LPSTR lpCmdLine, int nCmdShow)
{
	WNDCLASSEX WndClsEx;

	. . .

	RegisterClassEx(&WndClsEx);

	HWND hWnd = CreateWindow(ClsName,
			       WndName,
			       WS_OVERLAPPEDWINDOW,
			       CW_USEDEFAULT,
			       CW_USEDEFAULT,
			       CW_USEDEFAULT,
			       CW_USEDEFAULT,
	return 0;
}

 

Displaying the Window

Once a window has been created and if this was done successfully, you can display it to the user. This is done by calling the ShowWindow() function. Its syntax is:

BOOL ShowWindow(HWND hWnd, int nCmdShow);

The hWnd argument is a handle to the window that you want to display. It could be the window returned by the CreateWindow() or the CreateWindowEx() function.

The nCmdShow specifies how the window must be displayed. Its possible values are:

  Value Description
  SW_SHOW Displays a window and makes it visible
  SW_SHOWNORMAL Displays the window in its regular size. In most circumstances, the operating system keeps track of the last location and size a window such as Internet Explorer or My Computer had the last time it was displaying. This value allows the OS to restore it.
  SW_SHOWMINIMIZED Opens the window in its minimized state, representing it as a button on the taskbar
  SW_SHOWMAXIMIZED Opens the window in its maximized state
  SW_SHOWMINNOACTIVE Opens the window but displays only its icon. It does not make it active
  SW_SHOWNA As previous
  SW_SHOWNOACTIVATE Retrieves the window's previous size and location and displays it accordingly
  SW_HIDE Used to hide a window
  SW_MINIMIZE Shrinks the window and reduces it to a button on the taskbar
SW_MAXIMIZE Maximizes the window to occupy the whole screen area
  SW_RESTORE If the window was minimized or maximized, it would be restored to its previous location and size

To show its presence on the screen, the window must be painted. This can be done by calling the UpdateWindow() function. Its syntax is:

BOOL UpdateWindow(HWND hWnd);

This function simply wants to know what window needs to be painted. This window is specified by its handle. Here is an example:

INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
               LPSTR lpCmdLine, int nCmdShow)
{
	WNDCLASSEX WndClsEx;

	. . .

	RegisterClassEx(&WndClsEx);

	HWND hWnd = CreateWindow(ClsName, WndName, WS_OVERLAPPEDWINDOW,
			       CW_USEDEFAULT, CW_USEDEFAULT,
			       CW_USEDEFAULT, CW_USEDEFAULT,
			       NULL, NULL, hInstance, NULL);
	
	if( !hWnd ) // If the window was not created,
		return 0; // stop the application

	ShowWindow(hWnd, SW_SHOWNORMAL);
	UpdateWindow(hWnd);

	return 0;
}

 

 

The Multiple Document Interface (MDI)

 

Introduction

A multiple document is the type of application that uses a main, external window that acts as a frame and hosts other, floating window that act as its children. This concept allows the user to open more than one document at a time in an application, making it possible to switch from one document to another without closing the application.

MDI Application Creation

You start an MDI like the types of applications we have created so far. One of the primary differences is that the window procedure must return the DefFrameProc() function. Its syntax is:

LRESULT DefFrameProc(HWND hWnd,
                     HWND hWndMDIClient,
                     UINT uMsg,
                     WPARAM wParam,
                     LPARAM lParam);

 


Previous Copyright © 2003 FunctionX, Inc. Next