7.4 程序中的击中测试

摘录于《Windows程序（第5版，珍藏版）.CHarles.Petzold 著》P230

        前面曾讨论了 Windows 资源管理器是如何响应鼠标单击和双击消息的。显然，程序（更确切地说，是 Windows 资源管理器所采用的列表视图控件）必须首先准确地判断用户鼠标所指的文件或目录位置。

        这就是“击中测试”。正如 DefWindowProc 在处理 WM_NCHITTEST 消息时必须做击中测试一样，窗口过程经常也必须在其客户区内做击中测试。概况地说，击中测试包含了对传递到窗口过程的 x 和 y 坐标的一些运算，其中 x 和 y 的值包含在鼠标消息的参数 lParam 中。

7.4.1  一个假想的例子

        下面是一个例子。假设程序需要显示几列按字母顺序排列的文件。通常，你会使用列表视图控件，因为它已实现了所有需要的“击中测试”功能。但是，假设由于某种原因不能使用它，那么久需要自己实现这些功能。假定文件名都保存在一个有序的字符串指针数组中，数组名为 szFileNames。

        假设文件列表从客户区的顶部开始，其中客户区的大小为 cxClient 像素宽和 cyClient 像素高。每列的宽度为 cxColWidth 像素；字符的高度为 cyChar 像素。那么每列可存放的文件数目为：

[cpp]  view plain  copy

1. iNumInCol = cyClient / cyChar;  

        当程序接收到一个鼠标单击消息时，从参数 lParam 中可以得到坐标值 cxMouse 和 cyMouse。然后，利用下面这个公式，可以计算得到用户所指的文件名位于那一列：

[cpp]  view plain  copy

1. iColumn = cxMouse / cxColWidth;  

文件名相对于列表顶部的位置为：

[cpp]  view plain  copy

1. iFromTop = cyMouse / cyChar;  

现在，计算文件名在数组 szFileNames 中的索引号：

[cpp]  view plain  copy

1. iIndex = iColumn * iNumInCol + iFromTop;  

如果 iIndex 大于数组中文件的个数，那么用户单击的位置是显示设备的空白区域 。

        在很多情况下，击中测试比这个实例更加复杂。当显示一个由很多小图形组成的图像时，必须确定其中每个图形的显示坐标。在击中测试计算中，则必须反过来根据坐标来找到相应的图形。对于一个采用可变字号的字处理程序来说，这种计算会变得相当繁琐，因为用户必须反过来查找字符在字符串中的位置。

7.4.2  一个简单的程序

        CHECKER1 程序展示了一些简单的击中测试。该程序将客户区划分成 25 个矩形，构成一个 5 * 5 的数组。如果在其中一个矩形内单击鼠标，就用 X 形填充该矩形。再次单击，则 X 形消失。

[cpp]  view plain  copy

1. /*-------------------------------------------------------- 
2.    CHECKER1.C -- Mouse Hit-Test Demo Program No. 1 
3.                  (c) Charles Petzold, 1998 
4.   --------------------------------------------------------*/  
5. #include <windows.h>  
6.   
7. #define DIVISIONS 5  
8.   
9. LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;  
10.   
11. int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,  
12.                     PSTR szCmdLine, int iCmdShow)  
13. {  
14.      static TCHAR szAppName[] = TEXT ("Checker1") ;  
15.      HWND         hwnd ;  
16.      MSG          msg ;  
17.      WNDCLASS     wndclass ;  
18.   
19.      wndclass.style         = CS_HREDRAW | CS_VREDRAW ;  
20.      wndclass.lpfnWndProc   = WndProc ;  
21.      wndclass.cbClsExtra    = 0 ;  
22.      wndclass.cbWndExtra    = 0 ;  
23.      wndclass.hInstance     = hInstance ;  
24.      wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;  
25.      wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;  
26.      wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ;  
27.      wndclass.lpszMenuName  = NULL ;  
28.      wndclass.lpszClassName = szAppName ;  
29.   
30.      if (!RegisterClass (&wndclass))  
31.      {  
32.           MessageBox (NULL, TEXT ("This program requires Windows NT!"),  
33.                       szAppName, MB_ICONERROR) ;  
34.           return 0 ;  
35.      }  
36.   
37.      hwnd = CreateWindow (szAppName, TEXT ("Checker1 Mouse Hit-Test Demo"),  
38.                           WS_OVERLAPPEDWINDOW,  
39.                           CW_USEDEFAULT, CW_USEDEFAULT,  
40.                           CW_USEDEFAULT, CW_USEDEFAULT,  
41.                           NULL, NULL, hInstance, NULL) ;  
42.   
43.      ShowWindow (hwnd, iCmdShow) ;  
44.      UpdateWindow (hwnd) ;  
45.   
46.      while (GetMessage (&msg, NULL, 0, 0))  
47.      {  
48.           TranslateMessage (&msg) ;  
49.           DispatchMessage (&msg) ;  
50.      }  
51.      return msg.wParam ;  
52. }  
53.   
54. LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)  
55. {  
56.      static BOOL  fState[DIVISIONS][DIVISIONS];  
57.      static int   cxBlock, cyBlock;  
58.      HDC          hdc;  
59.      int          x, y;  
60.      PAINTSTRUCT  ps;  
61.      RECT         rect;  
62.   
63.      switch (message)  
64.      {  
65.      case WM_SIZE:  
66.         cxBlock = LOWORD(lParam) / DIVISIONS;  
67.         cyBlock = HIWORD(lParam) / DIVISIONS;  
68.         return 0;  
69.   
70.     case WM_LBUTTONDOWN:  
71.         x = LOWORD(lParam) / cxBlock;  
72.         y = HIWORD(lParam) / cyBlock;  
73.   
74.         if (x < DIVISIONS && y < DIVISIONS)  
75.         {  
76.             fState[x][y] ^= 1;  
77.   
78.             rect.left   = x * cxBlock;  
79.             rect.top    = y * cyBlock;  
80.             rect.right  = (x + 1) * cxBlock;  
81.             rect.bottom = (y + 1) * cyBlock;  
82.   
83.             InvalidateRect(hwnd, &rect, FALSE);  
84.         }  
85.         else  
86.             MessageBeep(0);  
87.         return 0;  
88.   
89.      case WM_PAINT:  
90.           hdc = BeginPaint (hwnd, &ps) ;  
91.   
92.           for (x = 0; x < DIVISIONS; ++ x)  
93.                 for (y = 0; y < DIVISIONS; ++ y)  
94.           {  
95.               Rectangle(hdc, x * cxBlock, y * cyBlock,  
96.                         (x + 1) * cxBlock, (y + 1) * cyBlock);  
97.   
98.               if (fState[x][y])  
99.               {  
100.                   MoveToEx(hdc, x * cxBlock, y * cyBlock, NULL);  
101.                   LineTo(hdc, (x + 1) * cxBlock, (y + 1) * cyBlock);  
102.                   MoveToEx(hdc, x * cxBlock, (y + 1) * cyBlock, NULL);  
103.                   LineTo(hdc, (x + 1) * cxBlock, y * cyBlock);  
104.               }  
105.           }  
106.           EndPaint (hwnd, &ps) ;  
107.           return 0 ;  
108.   
109.      case WM_DESTROY:  
110.           PostQuitMessage (0) ;  
111.           return 0 ;  
112.      }  
113.      return DefWindowProc (hwnd, message, wParam, lParam) ;  
114. }  

        CHECKER1 程序的显示结果如图 7-5 所示。所有 25 个矩形具有相同的宽度和高度，这些宽度和高度分别被保存在 cxBlock 和 cyBlock 中。无论何时改变客户区的大小，程序都将重新计算 cxBlock 和 cyBlock。WM_LBUTTONDOWN 处理逻辑利用鼠标的坐标来判断哪个矩形被单击，然后在 fState 数组中计算出那个矩形的新状态，最后强制使该矩形失效，从而产生 WM_PAINT 消息。

图 7-5  CHECKER1 程序的显示结果

        如果客户区的宽度或高度不能被 5 整除，客户区的左边或底部就会出现一个小长条区域，不被矩形覆盖。这里实现了一个错误处理，也就是在这片区域进行鼠标单击时，CHECKER1 程序会调用 MessageBeep 函数进行响应。

        当 CHECKER1 程序接收到 WM_PAINT 消息时，它会重新绘制整个客户区，利用 GDI 中的 Rectangle 函数画出所有的矩形。若 fState 值为真，则 CHECKER1 程序调用函数 MoveToEx 和 函数 LineTo 画出两条直线。在处理 WM_PAINT 消息的过程中，CHECKER1 程序不会检查每个矩形区是否是无效矩形，但是实际上它能够做到。检查无效性的一种方法是对循环内每个矩形块创建一个 RECT 结构（采用与 WM_LBUTTONDOWN 逻辑中相同的公式），然后利用 IntersectRect 函数检查该矩形是否与无效矩形（以 ps.rcPaint 形式存在）相交。

7.4.3  使用键盘模仿鼠标操作

        使用 CHECKER1 程序需要用到鼠标。很快我们会给程序增加一个键盘接口，正如我们在第 6 章所做的一样。不过，对于使用鼠标指针来实现指向的程序而言，增加一个键盘接口还必须考虑如何显示和移动鼠标的指针。

        即使没有安装鼠标，Windows 仍然能够显示鼠标的指针。Windows 为这种指针保留了一个“显示计数” (display count)。若安装了鼠标，则显示计数初始值为 0；否则，显示计数初始值为 -1。只有当显示计数为非负时，系统才显示鼠标指针。为了增加显示计数，可以调用以下语句：

[cpp]  view plain  copy

1. showCursor (TRUE);  

而减少显示计数则可以调用以下语句：

[cpp]  view plain  copy

1. showCursor (FALSE);  

        在调用 ShowCursor 函数之前，不需要检查是否已安装鼠标。如果想显示鼠标指针，不管鼠标是否存在，都可以简单地调用 ShowCursor 函数来增加显示计数。在增加一次显示计数后，如果没有没有安装鼠标，那么再减少显示计数就会隐藏指针；如果鼠标存在，减少显示计数仍然保留指针显示。

        即便没有安装鼠标，Windows 也能够保留当前鼠标指针的位置。如果在没有安装鼠标的情况下显示鼠标指针，那么这个指针可能会出现在屏幕的任意位置并保持不动，直到用户明确地移动它。为了获取指针的位置，可以调用以下语句：

[cpp]  view plain  copy

1. GetCursorPos (&pt);  

其中 pt 是一个 POINT 结构。函数向 POINT 字段填充鼠标的 x 和 y 坐标。利用下面这个函数，可以设置指针的位置：

[cpp]  view plain  copy

1. SetCursorPos (x, y);  

在前面两个语句中，x 和 y 坐标都是屏幕坐标，而不是客户区坐标。（这是很明显的，因为这两个函数都没有 hwnd 参数。）前面已经讲过， 调用 ScreenToClient 和 ClientToScreen 可以在屏幕坐标与客户区坐标之间转换 。

        在处理鼠标消息的过程中，如果调用 GetCursorPos 并将坐标转换成客户区坐标，那么这些坐标值会与鼠标消息的参数 lParam 中所包含的坐标值略微有些不同。GetCursorPos 函数返回的坐标值是指鼠标的当前位置，而参数 lParam 包含的坐标是指产生消息的那一刻的鼠标位置。

        你可能需要编写一段键盘处理逻辑，用键盘方向键来移动鼠标指针，并用空格键或 Enter 键来模拟鼠标按钮。此时，你“不应该”每按一次键，鼠标指针只移动一个像素，因为这需要长时间按住方向键，才能够移动鼠标。

        在为鼠标指针增加键盘逻辑时，为了仍能将指针放置在准确的像素位置，可以这样处理按键消息：按住方向键不懂时，刚开始鼠标指针只是缓慢地移动，然后再加速移动。回忆一下，在 WM_KEYDOWN 消息中，参数 lParam 指出了键盘按键消息是否是重复击键的结果。下面这个程序出色地利用这个信息。

7.4.4  在 CHECKER 中增加键盘接口

        除了包含一个键盘接口，CHECKER2 程序的内容与 CHECKER1 程序完全相同。利用←、→、↑ 和 ↓ 四个方向键可以在 25 个矩形之间移动鼠标指针。Home 键把鼠标指针移动到左上角的矩形；End 键使鼠标指针落到右下角的矩形。空格键和回车键都可以切换 X 形标记。

[cpp]  view plain  copy

1. /*-------------------------------------------------------- 
2.    CHECKER2.C -- Mouse Hit-Test Demo Program No. 2 
3.                  (c) Charles Petzold, 1998 
4.   --------------------------------------------------------*/  
5. #include <windows.h>  
6.   
7. #define DIVISIONS 5  
8.   
9. LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;  
10.   
11. int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,  
12.                     PSTR szCmdLine, int iCmdShow)  
13. {  
14.      static TCHAR szAppName[] = TEXT ("Checker2") ;  
15.      HWND         hwnd ;  
16.      MSG          msg ;  
17.      WNDCLASS     wndclass ;  
18.   
19.      wndclass.style         = CS_HREDRAW | CS_VREDRAW ;  
20.      wndclass.lpfnWndProc   = WndProc ;  
21.      wndclass.cbClsExtra    = 0 ;  
22.      wndclass.cbWndExtra    = 0 ;  
23.      wndclass.hInstance     = hInstance ;  
24.      wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;  
25.      wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;  
26.      wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ;  
27.      wndclass.lpszMenuName  = NULL ;  
28.      wndclass.lpszClassName = szAppName ;  
29.   
30.      if (!RegisterClass (&wndclass))  
31.      {  
32.           MessageBox (NULL, TEXT ("This program requires Windows NT!"),  
33.                       szAppName, MB_ICONERROR) ;  
34.           return 0 ;  
35.      }  
36.   
37.      hwnd = CreateWindow (szAppName, TEXT ("Checker2 Mouse Hit-Test Demo"),  
38.                           WS_OVERLAPPEDWINDOW,  
39.                           CW_USEDEFAULT, CW_USEDEFAULT,  
40.                           CW_USEDEFAULT, CW_USEDEFAULT,  
41.                           NULL, NULL, hInstance, NULL) ;  
42.   
43.      ShowWindow (hwnd, iCmdShow) ;  
44.      UpdateWindow (hwnd) ;  
45.   
46.      while (GetMessage (&msg, NULL, 0, 0))  
47.      {  
48.           TranslateMessage (&msg) ;  
49.           DispatchMessage (&msg) ;  
50.      }  
51.      return msg.wParam ;  
52. }  
53.   
54. LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)  
55. {  
56.      static BOOL  fState[DIVISIONS][DIVISIONS];  
57.      static int   cxBlock, cyBlock;  
58.      HDC          hdc;  
59.      int          x, y;  
60.      PAINTSTRUCT  ps;  
61.      POINT        point;  
62.      RECT         rect;  
63.   
64.      switch (message)  
65.      {  
66.      case WM_SIZE:  
67.         cxBlock = LOWORD(lParam) / DIVISIONS;  
68.         cyBlock = HIWORD(lParam) / DIVISIONS;  
69.         return 0;  
70.   
71.      case WM_SETFOCUS:  
72.         ShowCursor(TRUE);  
73.         return 0;  
74.   
75.      case WM_KILLFOCUS:  
76.         ShowCursor(FALSE);  
77.         return 0;  
78.   
79.      case WM_KEYDOWN:  
80.          GetCursorPos(&point);  
81.          ScreenToClient(hwnd, &point);  
82.   
83.          x = max(0, min(DIVISIONS - 1, point.x / cxBlock));  
84.          y = max(0, min(DIVISIONS - 1, point.y / cyBlock));  
85.   
86.          switch(wParam)  
87.          {  
88.         case VK_UP :  
89.             y--;  
90.             break;  
91.   
92.         case VK_DOWN:  
93.             y++;  
94.             break;  
95.   
96.         case VK_LEFT:  
97.             x--;  
98.             break;  
99.   
100.         case VK_RIGHT:  
101.             x++;  
102.             break;  
103.   
104.         case VK_HOME:  
105.             x = y = 0;  
106.             break;  
107.   
108.         case VK_END:  
109.             x = y = DIVISIONS - 1;  
110.             break;  
111.   
112.         case VK_RETURN :  
113.         case VK_SPACE:  
114.             SendMessage(hwnd, WM_LBUTTONDOWN, MK_LBUTTON,  
115.                         MAKELONG(x * cxBlock, y * cyBlock));  
116.             break;  
117.          }  
118.          x = (x + DIVISIONS) % DIVISIONS;  
119.          y = (y + DIVISIONS) % DIVISIONS;  
120.   
121.          point.x = x * cxBlock + cxBlock / 2;  
122.          point.y = y * cyBlock + cyBlock / 2;  
123.   
124.          ClientToScreen(hwnd, &point);  
125.          SetCursorPos(point.x, point.y);  
126.          return 0;  
127.   
128.     case WM_LBUTTONDOWN:  
129.         x = LOWORD(lParam) / cxBlock;  
130.         y = HIWORD(lParam) / cyBlock;  
131.   
132.         if (x < DIVISIONS && y < DIVISIONS)  
133.         {  
134.             fState[x][y] ^= 1;  
135.   
136.             rect.left   = x * cxBlock;  
137.             rect.top    = y * cyBlock;  
138.             rect.right  = (x + 1) * cxBlock;  
139.             rect.bottom = (y + 1) * cyBlock;  
140.   
141.             InvalidateRect(hwnd, &rect, FALSE);  
142.         }  
143.         else  
144.             MessageBeep(0);  
145.         return 0;  
146.   
147.      case WM_PAINT:  
148.           hdc = BeginPaint (hwnd, &ps) ;  
149.   
150.           for (x = 0; x < DIVISIONS; ++ x)  
151.                 for (y = 0; y < DIVISIONS; ++ y)  
152.           {  
153.               Rectangle(hdc, x * cxBlock, y * cyBlock,  
154.                         (x + 1) * cxBlock, (y + 1) * cyBlock);  
155.   
156.               if (fState[x][y])  
157.               {  
158.                   MoveToEx(hdc, x * cxBlock, y * cyBlock, NULL);  
159.                   LineTo(hdc, (x + 1) * cxBlock, (y + 1) * cyBlock);  
160.                   MoveToEx(hdc, x * cxBlock, (y + 1) * cyBlock, NULL);  
161.                   LineTo(hdc, (x + 1) * cxBlock, y * cyBlock);  
162.               }  
163.           }  
164.           EndPaint (hwnd, &ps) ;  
165.           return 0 ;  
166.   
167.      case WM_DESTROY:  
168.           PostQuitMessage (0) ;  
169.           return 0 ;  
170.      }  
171.      return DefWindowProc (hwnd, message, wParam, lParam) ;  
172. }  

        在 CHECKER2 程序中，处理 WM_KEYDOWN 时利用 GetCursorPos 判断指针的位置，并利用 ScreenToClient 将屏幕坐标转换成客户区坐标，然后将坐标值除以矩形块的宽和高，得到 x 和 y。这些 x 和 y 的值表示了矩形在 5 * 5 数组中的位置。当按下某个键时，鼠标指针可能在客户区也可能不在客户区内，因此 x 和 y 必须包含在 min 和 max 的宏处理之中，保证它们的范围处于 0 和 4 之间。

        对于方向键，CHECKER2 程序相应的增加或减少 x 和 y 的值。若按下回车键或空格键，CHECKER2 程序调用 SendMessage 给自己发送一个 WM_LBUTTONDOWN 消息。这种方法类似于第 6 章 SYSMETS 程序为窗口滚动条增加一个键盘接口所使用的方法。最后，WM_KEYDOWN 处理逻辑计算得到指向矩形中心的客户区坐标，并调用 ClientToScreen 将其转换成屏幕坐标，最后调用 SetCursorPos 设置指针的位置。

7.4.5  在击中测试中使用子窗口

        一些程序（如 Windows 画图程序）将客户区划分成几个更小的逻辑区域。画图程序的左边区域是用图标表示的工具箱；底部区域是颜色盒。在画图程序中单击这两部分区域时，在确定用户实际选择的工具或颜色之前，必须首先考虑小区域在整个客户区中的位置。

        实际上，不这么做也可以。画图程序可以简单地利用“子窗口”的方式来绘制这些小区域并进行击中测试。子窗口将整个客户区划分成几个更小的矩形区域。每个子窗口都有属于自己的句柄、窗口过程和客户区。每个子窗口过程只接收与自身窗口有关的鼠标消息。鼠标消息的参数 lParam 中包含的坐标是相对于子窗口客户区左上角的，而不是相对于“父”窗口（即画图的主程序窗口）的客户区。

        通过这种方式使用子窗口有助于程序的结构化和模式化。如果子窗口使用不同的窗口类，那么每个子窗口都有自己的窗口过程。不同的窗口类还可以定义不同的背景颜色和不同的默认鼠标指针。在第 9 章中，我们将介绍“子窗口控件”，其中的每个控件都是一个预先定义好的窗口，包括滚动条、按钮和编辑框。而现在，我们将在 CHECKER 程序中介绍子窗口的应用。

7.4.6  CHECKER 程序中的子窗口

        该版本的 CHECKER 程序创建了 25 个子窗口，用于处理鼠标单击操作。该程序没有包含键盘接口，但是也可以增加。

[cpp]  view plain  copy

1. /*-------------------------------------------------------- 
2.    CHECKER3.C -- Mouse Hit-Test Demo Program No. 3 
3.                  (c) Charles Petzold, 1998 
4.   --------------------------------------------------------*/  
5. #include <windows.h>  
6.   
7. #define DIVISIONS 5  
8.   
9. LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;  
10. LRESULT CALLBACK ChildWndProc (HWND, UINT, WPARAM, LPARAM);  
11.   
12. TCHAR szChildClass[] = TEXT ("Checker3_Child");  
13.   
14. int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,  
15.                     PSTR szCmdLine, int iCmdShow)  
16. {  
17.      static TCHAR szAppName[] = TEXT ("Checker3") ;  
18.      HWND         hwnd ;  
19.      MSG          msg ;  
20.      WNDCLASS     wndclass ;  
21.   
22.      wndclass.style         = CS_HREDRAW | CS_VREDRAW ;  
23.      wndclass.lpfnWndProc   = WndProc ;  
24.      wndclass.cbClsExtra    = 0 ;  
25.      wndclass.cbWndExtra    = 0 ;  
26.      wndclass.hInstance     = hInstance ;  
27.      wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;  
28.      wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;  
29.      wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ;  
30.      wndclass.lpszMenuName  = NULL ;  
31.      wndclass.lpszClassName = szAppName ;  
32.   
33.      if (!RegisterClass (&wndclass))  
34.      {  
35.           MessageBox (NULL, TEXT ("This program requires Windows NT!"),  
36.                       szAppName, MB_ICONERROR) ;  
37.           return 0 ;  
38.      }  
39.   
40.      wndclass.lpfnWndProc   = ChildWndProc;  
41.      wndclass.cbWndExtra    = sizeof (long);  
42.      wndclass.hIcon         = NULL;  
43.      wndclass.lpszClassName = szChildClass;  
44.   
45.      RegisterClass(&wndclass);  
46.   
47.      hwnd = CreateWindow (szAppName, TEXT ("Checker3 Mouse Hit-Test Demo"),  
48.                           WS_OVERLAPPEDWINDOW,  
49.                           CW_USEDEFAULT, CW_USEDEFAULT,  
50.                           CW_USEDEFAULT, CW_USEDEFAULT,  
51.                           NULL, NULL, hInstance, NULL) ;  
52.   
53.      ShowWindow (hwnd, iCmdShow) ;  
54.      UpdateWindow (hwnd) ;  
55.   
56.      while (GetMessage (&msg, NULL, 0, 0))  
57.      {  
58.           TranslateMessage (&msg) ;  
59.           DispatchMessage (&msg) ;  
60.      }  
61.      return msg.wParam ;  
62. }  
63.   
64. LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)  
65. {  
66.      static HWND  hwndChild[DIVISIONS][DIVISIONS];  
67.      int   cxBlock, cyBlock, x, y;  
68.   
69.      switch (message)  
70.      {  
71.      case WM_CREATE:  
72.         for (x = 0; x < DIVISIONS; ++ x)  
73.             for (y = 0; y < DIVISIONS; ++ y)  
74.                 hwndChild[x][y] = CreateWindow(szChildClass, NULL,  
75.                                                WS_CHILDWINDOW | WS_VISIBLE,  
76.                                                0, 0, 0, 0,  
77.                                                hwnd, (HMENU) (y << 8 | x),  
78.                                                (HINSTANCE) GetWindowLong(hwnd, GWL_HINSTANCE),  
79.                                                NULL );  
80.         return 0;  
81.   
82.      case WM_SIZE:  
83.         cxBlock = LOWORD(lParam) / DIVISIONS;  
84.         cyBlock = HIWORD(lParam) / DIVISIONS;  
85.   
86.         for (x = 0; x < DIVISIONS; ++ x)  
87.             for (y = 0; y < DIVISIONS; ++ y)  
88.                 MoveWindow(hwndChild[x][y],  
89.                            x * cxBlock, y * cyBlock,  
90.                            cxBlock, cyBlock, TRUE);  
91.         return 0;  
92.   
93.      case WM_LBUTTONDOWN:  
94.             MessageBeep(0);  
95.         return 0;  
96.   
97.      case WM_DESTROY:  
98.           PostQuitMessage (0) ;  
99.           return 0 ;  
100.      }  
101.      return DefWindowProc (hwnd, message, wParam, lParam) ;  
102. }  
103.   
104. LRESULT CALLBACK ChildWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)  
105. {  
106.     HDC         hdc;  
107.     PAINTSTRUCT ps;  
108.     RECT        rect;  
109.   
110.     switch (message)  
111.     {  
112.     case WM_CREATE:  
113.         SetWindowLong(hwnd, 0, 0);      // on/off flag  
114.         return 0;  
115.   
116.     case WM_LBUTTONDOWN:  
117.         SetWindowLong(hwnd, 0, 1 ^ GetWindowLong(hwnd, 0));  
118.         InvalidateRect(hwnd, NULL, FALSE);  
119.         return 0;  
120.     case WM_PAINT:  
121.         hdc = BeginPaint (hwnd, &ps) ;  
122.   
123.         GetClientRect(hwnd, &rect);  
124.         Rectangle(hdc, 0, 0, rect.right, rect.bottom);  
125.   
126.         if (GetWindowLong(hwnd, 0))  
127.         {  
128.             MoveToEx(hdc, 0, 0, NULL);  
129.             LineTo(hdc, rect.right, rect.bottom);  
130.             MoveToEx(hdc, 0, rect.bottom, NULL);  
131.             LineTo(hdc, rect.right, 0);  
132.         }  
133.         EndPaint(hwnd, &ps);  
134.         return 0;  
135.     }  
136.     return DefWindowProc(hwnd, message, wParam, lParam);  
137. }  

        CHECKER3 程序含有两个窗口过程：WndProc 和 ChildWndProc。WndProc 仍然是主窗口（或父窗口）的窗口过程，而 ChildWndProc 则是 25 个子窗口的窗口过程。 两个窗口过程都必须被定义成 CALLBLCK 函数 。

        在调用 RegisterClass 函数注册窗口类时，用户会定义一个窗口类结构，而每个窗口过程都与某个特定的窗口类结构有关。为此，CHECKER3 程序需要用到两个窗口类。第一个窗口类表示主窗口，名为“Checker3”。第二个窗口类名为“Checker3_Child”。不过，用户不一定需要为窗口选择如此有含义的名称。

        CHECKER3 程序在 WinMain 函数中注册了这两个窗口类。在注册完常规窗口类之后，为了注册 Checker3_Child 类，CHECKER3 程序简单地重用了 wndclass 结构的大部分字段。但是，对子窗口来说，其中四个字段的值不同：

• lpfnWndProc 字段被设置成 ChildWndProc，表示子窗口类的窗口过程。
• cbWndExtra 字段被设置成 4 个字节，或 更准确地说是一个长整形变量的大小(sizeof(long))。这个字段通知 Windows 在内部结构中给基于这个窗口类的每个窗口预留 4 个字节的额外空间。用户可以利用这些空间为每个窗口保存不同的信息。
• hIcon 字段被设置成 NULL，因为类似 CHECKER3 程序中的子窗口不需要图标。
• pszClassName 字段被设置成 “Checker3_Child”，即子窗口类的名称。

在 WinMain 函数中，CreateWindow 函数创建了基于 Checker3 类的主窗口。这是常规的处理。但是，当 WndProc 接收到一个 WM_CREATE 消息时，它会重复调用 CreateWindow 函数 25 次，创建 25 个基于 Checker3_Child 类的子窗口。下表对 WinMain 中 CreateWindow 函数所调用的参数与 WndProc 中用于创建 25 个子窗口的 CreateWindow 函数所调用的参数进行了比较。

参  数	主  窗  口	子  窗  口
窗口类	“Checker3”	“Checker3_Child”
窗口标题	“Checker3...”	NULL
窗口风格	WS_OVERLAPPEDWINDOW	WS_CHILDWINDOW | WS_VISIBLE
水平位置	CW_USEDEFAULT	0
垂直位置	CW_USEDEFAULT	0
宽度	CW_USEDEFAULT	0
高度	CW_USEDEFAULT	0
父窗口句柄	NULL	hwnd
菜单句柄/子 ID	NULL	(HMENU) (y << 8 | x)
实例句柄	hInstance	(HINSTANCE) GetWindowLong(hwnd, GWL_HINSTANCE)
额外参数	NULL	NULL

        通常，子窗口需要用到窗口位置和窗口大小参数，但是在 CHECKER3 程序中，子窗口的位置和大小在后面的 WndProc 函数中才定义。对主窗口来说，父窗口句柄为 NULL，因为它本身就是父类。而在调用 CreateWindow 创建子窗口时，需要用到相应的父窗口句柄。

        主窗口没有菜单，因此菜单句柄为 NULL。对子窗口来说，该参数称为“子 ID” (child ID) 或“子窗口 ID” (child windows ID)。这是一个用来唯一标识子窗口的数值。在处理对话框的子窗口控件时，子 ID 显得更加重要。在第 11 章我们将看到这一点。在 CHECKER3 程序中，根据每个窗口在主窗口 5 * 5 数组中的位置 x 和 y，我简单地将子 ID 设定成一个 x 和 y 的组合。

        CreateWindow 函数需要一个实例句柄。在 WinMain 中，很容易获取这个实例句柄，因为它是 WinMain 的一个参数。而创建子窗口时，CHECKER3 程序必须调用 GetWindowLong 从 Windows 给窗口保留的结构中提取 hInstance 的值。（与其每次调用 GetWindowLong 函数，还不如将这个 hInstance 保存为全局变量，以便直接使用。）

        hwndChild 数组为每个子窗口保存了一个不同的窗口句柄。当 WndProc 接收到 WM_SIZE 消息时，它会为这 25 个窗口中的每个窗口调用 MoveWindow 函数。MoveWindow 函数的参数包括子窗口左上角相对于父窗口客户区的坐标、子窗口的宽度和高度，以及是否需要重画子窗口的标志。

        现在考察窗口过程 ChildWndProc。这个窗口过程为所有的 25 个子窗口处理消息。ChildWndProc 的参数 hwnd 表示接收消息的子窗口句柄。当 ChildWndProc 处理一个 WM_CREATE 消息（一共发生 25 此，因为存在 25 个子窗口）时，它利用 SetWIndowWord 在窗口结构预留的额外空间中保存一个 0。（回顾前面，在定义窗口类时我们利用 cbWndExtra 字段预留了这个额外空间。）ChildWndProc 利用这个值保存矩形的当前状态(X 形或没有 X 形)。在单击子窗口时，WM_LBUTTONDOWN 处理逻辑简单地调换这个整数值(从 0 换到 1， 或从 1 换到 0)，并使整个子窗口无效。这个子窗口区域正是所单击的矩形。由于所画矩形的大小与其客户区的大小一致，所以 WM_PAINT 的处理就显得简单很多。

        由于 CHECKER3 程序的 C 源代码文件和 .EXE 文件都比 CHECKER1 大很多（更不用说我对程序的解释了），因此，我不会花心思让你相信 CHECKER3 程序比 CHECKER1“更简单”。但是要注意，此时我们不需要再做任何的鼠标击中测试！若 CHECKER3 程序的某个子窗口接收到 WM_LBUTTONDOWN 消息，则表示该窗口被击中，而这正是程序所需要的。

7.4.6  子窗口和键盘

        下一步是为 CHECKER3 程序增加一个键盘接口。但在这里，可以采用一种更合适的方法。在 CHECKER2 程序中，按下空格键，鼠标指针的位置住处哪个矩形得到选中标记。当处理子窗口时，我们可以从对话框的运行机制得到一些启发：在对话框中，每个子窗口会利用闪烁的插入符号或矩形虚拟框来表示自己是否具有输入焦点（因此可以用键盘来切换不同的子窗口）。

        我们不会重写所有 Windows 内部已经存在的对话框处理逻辑；我们只是大致描述一下如何在应用程序中模仿对话框的运行机制。 在这个过程中，你会发现，也许父窗口和子窗口应该共享对键盘消息的处理 。当按下空格键或回车键时，子窗口将反转当前选中状态。而当按下方向键时，父窗口会将输入焦点移向另一个子窗口。这里的逻辑略微有些复杂，因为在单击子窗口时，获得输入焦点的是父窗口，而不是子窗口。

[cpp]  view plain  copy

1. /*-------------------------------------------------------- 
2.    CHECKER4.C -- Mouse Hit-Test Demo Program No. 4 
3.                  (c) Charles Petzold, 1998 
4.   --------------------------------------------------------*/  
5. #include <windows.h>  
6.   
7. #define DIVISIONS 5  
8.   
9. LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;  
10. LRESULT CALLBACK ChildWndProc (HWND, UINT, WPARAM, LPARAM);  
11.   
12. int idFocus = 0;  
13. TCHAR szChildClass[] = TEXT ("Checker4_Child");  
14.   
15. int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,  
16.                     PSTR szCmdLine, int iCmdShow)  
17. {  
18.      static TCHAR szAppName[] = TEXT ("Checker4") ;  
19.      HWND         hwnd ;  
20.      MSG          msg ;  
21.      WNDCLASS     wndclass ;  
22.   
23.      wndclass.style         = CS_HREDRAW | CS_VREDRAW ;  
24.      wndclass.lpfnWndProc   = WndProc ;  
25.      wndclass.cbClsExtra    = 0 ;  
26.      wndclass.cbWndExtra    = 0 ;  
27.      wndclass.hInstance     = hInstance ;  
28.      wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;  
29.      wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;  
30.      wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ;  
31.      wndclass.lpszMenuName  = NULL ;  
32.      wndclass.lpszClassName = szAppName ;  
33.   
34.      if (!RegisterClass (&wndclass))  
35.      {  
36.           MessageBox (NULL, TEXT ("This program requires Windows NT!"),  
37.                       szAppName, MB_ICONERROR) ;  
38.           return 0 ;  
39.      }  
40.   
41.      wndclass.lpfnWndProc   = ChildWndProc;  
42.      wndclass.cbWndExtra    = sizeof (long);  
43.      wndclass.hIcon         = NULL;  
44.      wndclass.lpszClassName = szChildClass;  
45.   
46.      RegisterClass(&wndclass);  
47.   
48.      hwnd = CreateWindow (szAppName, TEXT ("Checker4 Mouse Hit-Test Demo"),  
49.                           WS_OVERLAPPEDWINDOW,  
50.                           CW_USEDEFAULT, CW_USEDEFAULT,  
51.                           CW_USEDEFAULT, CW_USEDEFAULT,  
52.                           NULL, NULL, hInstance, NULL) ;  
53.   
54.      ShowWindow (hwnd, iCmdShow) ;  
55.      UpdateWindow (hwnd) ;  
56.   
57.      while (GetMessage (&msg, NULL, 0, 0))  
58.      {  
59.           TranslateMessage (&msg) ;  
60.           DispatchMessage (&msg) ;  
61.      }  
62.      return msg.wParam ;  
63. }  
64.   
65. LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)  
66. {  
67.      static HWND  hwndChild[DIVISIONS][DIVISIONS];  
68.      int   cxBlock, cyBlock, x, y;  
69.   
70.      switch (message)  
71.      {  
72.      case WM_CREATE:  
73.         for (x = 0; x < DIVISIONS; ++ x)  
74.             for (y = 0; y < DIVISIONS; ++ y)  
75.                 hwndChild[x][y] = CreateWindow(szChildClass, NULL,  
76.                                                WS_CHILDWINDOW | WS_VISIBLE,  
77.                                                0, 0, 0, 0,  
78.                                                hwnd, (HMENU) (y << 8 | x),  
79.                                                (HINSTANCE) GetWindowLong(hwnd, GWL_HINSTANCE),  
80.                                                NULL );  
81.         return 0;  
82.   
83.      case WM_SIZE:  
84.         cxBlock = LOWORD(lParam) / DIVISIONS;  
85.         cyBlock = HIWORD(lParam) / DIVISIONS;  
86.   
87.         for (x = 0; x < DIVISIONS; ++ x)  
88.             for (y = 0; y < DIVISIONS; ++ y)  
89.                 MoveWindow(hwndChild[x][y],  
90.                            x * cxBlock, y * cyBlock,  
91.                            cxBlock, cyBlock, TRUE);  
92.         return 0;  
93.   
94.      case WM_LBUTTONDOWN:  
95.             MessageBeep(0);  
96.         return 0;  
97.   
98.         // On set-focus message, set focus to child window  
99.   
100.      case WM_SETFOCUS:  
101.           SetFocus(GetDlgItem(hwnd, idFocus));  
102.           return 0;  
103.   
104.           // On key-down message, possibly change the focus window  
105.   
106.      case WM_KEYDOWN:  
107.         x = idFocus & 0xFF;  
108.         y = idFocus >> 8;  
109.   
110.         switch(wParam)  
111.         {  
112.             case VK_UP:     y--;                    break;  
113.             case VK_DOWN:   y++;                    break;  
114.             case VK_LEFT:   x--;                    break;  
115.             case VK_RIGHT:  x++;                    break;  
116.             case VK_HOME:   x = y = 0;              break;  
117.             case VK_END:    x = y = DIVISIONS - 1;  break;  
118.             default: return 0;  
119.         }  
120.   
121.         x = (x + DIVISIONS) % DIVISIONS;  
122.         y = (y + DIVISIONS) % DIVISIONS;  
123.   
124.         idFocus = y << 8 | x;  
125.         SetFocus(GetDlgItem(hwnd, idFocus));  
126.         return 0;  
127.   
128.      case WM_DESTROY:  
129.           PostQuitMessage (0) ;  
130.           return 0 ;  
131.      }  
132.      return DefWindowProc (hwnd, message, wParam, lParam) ;  
133. }  
134.   
135. LRESULT CALLBACK ChildWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)  
136. {  
137.     HDC         hdc;  
138.     PAINTSTRUCT ps;  
139.     RECT        rect;  
140.   
141.     switch (message)  
142.     {  
143.     case WM_CREATE:  
144.         SetWindowLong(hwnd, 0, 0);      // on/off flag  
145.         return 0;  
146.   
147.     case WM_KEYDOWN:  
148.             // Send most key presses to the parent window  
149.   
150.         if (wParam != VK_RETURN && wParam != VK_SPACE)  
151.         {  
152.             SendMessage(GetParent(hwnd), message, wParam, lParam);  
153.             return 0;  
154.         }  
155.   
156.         // For Return and Space, fall through to toggle the square  
157.   
158.     case WM_LBUTTONDOWN:  
159.         SetWindowLong(hwnd, 0, 1 ^ GetWindowLong(hwnd, 0));  
160.         SetFocus(hwnd);  
161.         InvalidateRect(hwnd, NULL, FALSE);  
162.         return 0;  
163.   
164.             // For focus messages, invalidate the window for repaint  
165.   
166.     case WM_SETFOCUS:  
167.         idFocus = GetWindowLong(hwnd, GWL_ID);  
168.   
169.             // Fall through  
170.   
171.     case WM_KILLFOCUS:  
172.         InvalidateRect(hwnd, NULL, TRUE);  
173.         return 0;  
174.   
175.     case WM_PAINT:  
176.         hdc = BeginPaint (hwnd, &ps) ;  
177.   
178.         GetClientRect(hwnd, &rect);  
179.         Rectangle(hdc, 0, 0, rect.right, rect.bottom);  
180.   
181.             // Draw the "X" mark  
182.   
183.         if (GetWindowLong(hwnd, 0))  
184.         {  
185.             MoveToEx(hdc, 0, 0, NULL);  
186.             LineTo(hdc, rect.right, rect.bottom);  
187.             MoveToEx(hdc, 0, rect.bottom, NULL);  
188.             LineTo(hdc, rect.right, 0);  
189.         }  
190.   
191.             // Draw the "focus" rectangle  
192.   
193.             if (hwnd == GetFocus())  
194.             {  
195.                 // 下面注释代码可行  
196. //               // ShowCursor(FALSE);  
197. //                POINT pt;  
198. //                pt.x = rect.right / 2;  
199. //                pt.y = rect.bottom / 2;  
200. //                ClientToScreen(hwnd, &pt);  
201. //                SetCursorPos(pt.x, pt.y);  
202. //               // ShowCursor(TRUE);  
203.   
204.                 rect.left   += rect.right / 10;  
205.                 rect.right  -= rect.left;  
206.                 rect.top    += rect.bottom / 10;  
207.                 rect.bottom -= rect.top;  
208.   
209.                 SelectObject(hdc, GetStockObject(NULL_BRUSH));  
210.                 SelectObject(hdc, CreatePen(PS_DASH, 0, 0));  
211.                 Rectangle(hdc, rect.left, rect.top, rect.right, rect.bottom);  
212.                 DeleteObject(SelectObject(hdc, GetStockObject(BLACK_PEN)));  
213.             }  
214.         EndPaint(hwnd, &ps);  
215.         return 0;  
216.     }  
217.     return DefWindowProc(hwnd, message, wParam, lParam);  
218. }  

        回顾一下，当调用 CreateWindow 创建窗口时，每个子窗口都定义了一个唯一的“子窗口 ID” 数值。在 CHECKER3 程序中，这个 ID 数值由矩形的 x 和 y 坐标组合而成。为了获取一个具体子窗口的子窗口 ID，程序调用如下：

[cpp]  view plain  copy

1. idChild = GetWindowLong(hwndChild, GWL_ID);  

下面这个函数功能一样：

[cpp]  view plain  copy

1. idChild = GetDlgCtrlId (hwndChild);  

正如函数名称所示，它主要与对话框和控件窗口一起使用。如果知道父窗口的句柄和子窗口 ID，还可能得到子窗口的句柄：

[cpp]  view plain  copy

1. hwndChild = GetDlgItem (hwndParent, idChild);  

        在 CHECKER4 程序中，全局变量 idFocus 用于保存当前具有输入焦点的窗口的子 ID 数值。先前曾提到，在子窗口上单击鼠标时，子窗口不能自动地获得输入焦点。因此，在 CHECKER4 程序中，父窗口调用下面的这个函数来处理 WM_SETFOCUS 消息，从而给其中一个子窗口设置输入焦点：

[cpp]  view plain  copy

1. setFocus (GetDlgItem (hwnd, idFocus));  

        窗口过程 ChildWndProc 同时处理 WM_SETFOCUS 消息和 WM_KILLFOCUS 消息。处理 WM_SETFOCUS 消息时，它将接收输入焦点的子窗口 ID 保存在全局变量 idFocus 中。对这两个消息，程序都将使窗口无效，并产生 WM_PAINT 消息。如果 WM_PAINT 消息所绘制的子窗口带有输入焦点，程序就会利用 PS_DASH 画笔绘制一个矩形，表示该窗口带有输入焦点。

        窗口过程 ChildWndProc 还要处理 WM_KEYDOWN 消息。对于除了空格键和回车键之外的其他任何键，WM_KEYDOWN 消息都会被传递到主窗口。而对空格键和回车键，窗口过程会执行与 WM_LBUTTONDOWN 消息一样的处理。

        对鼠标移动键的处理交给了主窗口来完成。与 CHECKER2 中的方法类似，此程序获取具有输入焦点的子窗口的 x 和 y 坐标，再根据按下的具体方向键改变这些坐标值。然后调用 SetFocus 将输入焦点设置一个新的子窗口。