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 theGetWindowLong() function. Its syntax is:

1. <span style="font-family:Comic Sans MS;">LONG GetWindowLong(HWND hWnd, int nIndex);</span>

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:

1. <span style="font-family:Comic Sans MS;">HWND hWndParent;
2. // Create the parent window
3. hWndParent = CreateWindowEx(0, ClassName, StrWndName,
4. WS_OVERLAPPEDWINDOW,
5. 0, 100, 140, 320,
6. NULL, NULL, hInstance, NULL);</span>

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:

1. <span style="font-family:Comic Sans MS;">// Create a window
2. CreateWindowEx(0, WndClassName, CaptionOrText,
3. ChildStyle, Left, Top, Width, Height,
4. hWndParent, NULL, hInstance, NULL);</span>

If a window is a child of another window, to get a handle to its parent, you can call theGetParent() 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 theWS_THICKFRAME style:

1. <span style="font-family:Comic Sans MS;">CreateWindow(ClsName, WndName,
2. WS_VISIBLE | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_THICKFRAME);</span>

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:

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:

1. <span style="font-family:Comic Sans MS;">INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
2. LPSTR lpCmdLine, int nCmdShow)
3. {
4. WNDCLASSEX WndClsEx;
5. . . .
6. RegisterClassEx(&WndClsEx);
7. HWND hWnd = CreateWindow(ClsName,
8. WndName,
9. WS_OVERLAPPEDWINDOW,
10. CW_USEDEFAULT,
11. CW_USEDEFAULT,
12. CW_USEDEFAULT,
13. CW_USEDEFAULT,
14. return 0;
15. }
16. </span>

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:

1. <span style="font-family:Comic Sans MS;">BOOL ShowWindow(HWND hWnd, int nCmdShow);</span>

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:

1. <span style="font-family:Comic Sans MS;">BOOL UpdateWindow(HWND hWnd);</span>

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

1. <span style="font-family:Comic Sans MS;">INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
2. LPSTR lpCmdLine, int nCmdShow)
3. {
4. WNDCLASSEX WndClsEx;
5. . . .
6. RegisterClassEx(&WndClsEx);
7. HWND hWnd = CreateWindow(ClsName, WndName, WS_OVERLAPPEDWINDOW,
8. CW_USEDEFAULT, CW_USEDEFAULT,
9. CW_USEDEFAULT, CW_USEDEFAULT,
10. NULL, NULL, hInstance, NULL);
11. if( !hWnd ) // If the window was not created,
12. return 0; // stop the application
13. ShowWindow(hWnd, SW_SHOWNORMAL);
14. UpdateWindow(hWnd);
15. return 0;
16. }
17. </span>

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:

1. <span style="font-family:Comic Sans MS;">LRESULT DefFrameProc(HWND hWnd,
2. HWND hWndMDIClient,
3. UINT uMsg,
4. WPARAM wParam,
5. LPARAM lParam);</span>

转载自：http://www.functionx.com/win32/Lesson08.htm

http://blog.csdn.net/x356982611/article/details/9352499