Windows是基于图形界面的，所以在Win32编程中，图形操作是最常用的操作。GDI的意义在于将程序对图形界面的操作和硬件设备隔绝开来，在程序中可以将所有的图形设备都看成是虚拟设备，包括视频显示器和打印机等，然后通过GDI函数用同样的方法去操作它们，由Windows负责将函数调用转化成针对具体硬件的操作。只要一个设备提供了和Windows兼容的驱动程序，它就可以被看做是一个标准的设备。以前在DOS系统下写应用程序的时候，如果要进行图形操作，那么就要考虑到市场上每种显示卡的不同，否则在装配某种显卡的计算机上就可能无法正常运行，对汇编程序员来说，这真是一个恶梦。在Win32编程中，正是GDI函数让这个恶梦成为历史。

GDI函数全部包括在GDI32.DLL中，在编程的时候，注意要在源程序的开头加上相应的包含语句：

include          gdi32.inc

includelib       gdi32.lib

和GDI相关的内容真是太庞大了，只要查看一下gdi32.inc文件就可以发现，函数的总数达到了300多个，和GDI相关的数据结构也非常多，为了能了解GDI的原理和基本的使用方法：

归纳起来，GDI操作可以从3个方面去了解——When, Where和How：

When——指的是进行图形操作的时机，究竟什么时刻最适合程序进行图形操作呢？——“GDI程序的结构”

Where——指的是图形该往哪里画，既然Windows隔离了硬件图形设备，那么该把什么地方当做“下笔”的地方呢？——“设备环境”

How——了解了上面两个问题后，最后还要知道“如何画”，这就涉及如何使用大部分GDI函数的问题了。

一、GDI程序的结构

1、客户区的刷新

正如上面所说的，这里讨论的是“When”的问题，读者可能会问：为什么会有这个问题，如果要向窗口输出图形，程序想在什么时候输出那就是什么时候，难道这个时刻还有规定不成？

在DOS操作系统中编程的时候，程序把文字或图形输出到屏幕，在输出新的内容之前，这些内容总是保留在屏幕原处，这些内容会被意外覆盖的唯一情况是激活一个TSR程序，但TSR程序在退出之前有义务恢复原来的屏幕，如果它无法恢复屏幕的内容，那么这是它的责任，我们不会在自己的程序中去考虑屏幕内容会无缘无故消失这种情况，所以可以把屏幕看成是应用程序私有的。

如果程序输出的内容过多，如用dir显示一个含有很多文件的目录，用户根本无法看清快速上翻的屏幕，这时程序可以设计一个参数来暂停一下，如dir/p。这已经是DOS程序最“体贴”的做法了，如果用户想回过头去看已经滚出屏幕的内容，那可对不起，只能再执行一遍了！

所以对DOS程序来说，程序想在什么时候输出信息那就是什么时候，根本不存在When这个问题。

但在Windows操作系统中，屏幕是多个程序“公用”的，用户程序不要指望输出到窗口中的内容经过一段时间后还会保留在那里，它们可能被别的东西覆盖，如其他窗口、鼠标箭头或下拉的菜单等。在Windows中，恢复被覆盖内容的责任大部分属于用户程序自己，理由很简单：Windows是个多任务的操作系统，假如程序B覆盖了程序A的窗口内容，覆盖掉的内容由程序B负责恢复的话，它就必须保存它覆盖掉的内容，但是在它将保存的内容恢复之前，程序A也在运行，并可能在程序B恢复以前已经向它自己的窗口输出新的内容，结果当程序B恢复它保存的窗口内容时，保存的内容可能是过时的（而DOS的情况就不同，TSR程序激活的时候，用户程序是被挂起的），所以最好的办法就是让程序A自己来决定如何恢复。

Windows系统采用的方法是：当Windows检测到窗口被覆盖的地方需要恢复的时候，它会向用户程序发送一个WM_PAINT消息，消息中包括了需要恢复的区域，然后由用户程序来决定如何恢复被覆盖的内容。

如果程序因为忙于处理其他事务以至于无法及时响应WM_PAINT消息，那么窗口客户区原先被覆盖的地方可能会被Windows暂时画成一块白色（或者背景色）的矩形，或者根本就是保留被覆盖时的情形，直到程序有时间去响应WM_PAINT消息为止。我们常常可以看到这种情况发生在死锁程序的客户区内，这就是因为死锁的程序无法响应WM_PAINT消息来恢复客户区造成的。

所以对于“When”这个问题，答案是：程序应该在Windows要求的时候绘画客户区，也就是在收到WM_PAINT消息的时候。如果程序需要主动刷新客户区，那么可以通过调用InvalidateRect等函数引发一条WM_PAINT消息，因为在WM_PAINT消息中刷新客户区的代码是必须存在的，所以用这种看似“舍近求远”的办法实际上可以节省一份重复的代码。即使是在游戏程序这种“主动刷新”远远多于“被动刷新”的程序中，只要窗口有被其他东西覆盖的可能，那么这个原则就是适用的。

2、GDI程序的结构

对于Win32程序来说，WM_PAINT消息随时可能发生，这就意味着，程序再也不能像在DOS下一样输出结果后就不管了，反过来，程序在任何时刻都应该知道如何恢复整个或局部客户区中以前输出的内容。

如果程序的功能比较简单，可以将计算及刷新整个客户区的代码全部安排在WM_PAINT消息中完成，这样，每次当客户区的全部或部分需要被更新的时候，程序重新执行整个生成客户区屏幕数据的功能模块并刷新客户区。这种结构适用于功能模块很短小且执行速度很快的情况，整个过程的时间最好不超过几百ms，否则，用户会在一个明显的等待时间后才看到程序把客户区中的“空洞”补上。

当生成屏幕数据的功能模块有些复杂的时候，就应该考虑采用如下结构，即功能模块和客户区刷新模块分别在不同的子程序中实现，功能模块单独用一个子程序完成，这个子程序可以由用户通过选择菜单项在WM_COMMAND消息中执行，也可以新建另外一个线和来完成，总之，它最后把计算结果放到一个缓冲区中，而每当客户区需要刷新时，程序在WM_PAINT消息中调用客户区刷新子程序，这个子程序从计算好的缓冲区中取出数据并输出到客户区中，由于单纯的屏幕刷新过程是很快的，所以用户根本来不及看到客户区中的空洞。

3、探讨WM_PAINT消息

当客户区被覆盖并重新显示的时候，Windows并不是在所有的的下都发送WM_PAINT消息，下面是几种不同的情况：

l         当鼠标光标移过窗口客户区以及图标拖过客户区这两种情况，Windows总是自己保存被覆盖的区域并恢复它，并不需要发送WM_PAINT消息通知用户程序。

l         当窗口客户区被自己的下拉式菜单覆盖，或者被自己弹出的对话框覆盖后，Windows会尝试保存被覆盖的区域并在以后恢复它，如果因为某种原因无法保存并恢复的话，Windows会发送一个WM_PAINT消息通知程序。

l         别的情况造成窗口的一部分从不可见变到可见，如程序从最小化的状态恢复，其他的窗口覆盖客户区后移开，用户改变了窗口的大小不一和用户按动滚动条等，在这些情况下，Windows会向窗口发送WM_PAINT消息。

l         一些函数会引发WM_PAINT消息，如UpdateWindow，InvalidateRect以及InvalidateRgn函数等。

窗口过程收到WM_PAINT消息后，并不代表整个客户区都需要被刷新，有可能客户区被覆盖的区域只有一小块，这个区域就叫做“无效区域”，程序只需要更新这个区域。

和WM_TIMER消息类似，WM_PAINT消息也是一个低级别的消息，虽然它不会像WM_TIMER消息一样被丢弃，但Windows总是在消息循环空的时候才把WM_PAINT放入其中，实际上，Windows为每个窗口维护一个“绘图信息结构”，无效区域的坐标就在其中，每当消息循环空的时候，如果Windows发现存在一个无效区域，就会放入一个WM_PAINT消息。

无效区域的坐标并不附带在WM_PAINT消息的参数中，在程序中有其他方法可以获取，WM_PAINT消息只是通知程序有个区域需要更新而已，所以Windows也不会同时将两条WM_PAINT消息放入消息循环，当Windows要放入一条WM_PAINT消息的时候，如果发现已存在一个无效区域了，那么它只需要把新旧两个无效区域合并计算出一个新的无效区域就可以了，消息循环中还是只需要一条WM_PAINT消息。

由于存在“无效区域”这样一个东西，所以程序在WM_PAINT消息中对客户区刷新完毕后工作并没有结束，如果不使无效区域变得有效，Windows会在下一轮消息循环中继续放入一个WM_PAINT消息。当Windows检查“绘图信息结构”的时候发现没有了无效区域，也就不会继续发送WM_PAINT消息了。

WM_PAINT消息的处理流程一般是：

.if    eax == WM_PAINT      ;eax为uMsg

       invoke BeginPaint, hWnd, addr stPS

       ;刷新客户区的代码

       invoke EndPaint, hWnd, addr stPS

       xor eax, eax

       ret

读者可以发现中间并没有调用ValidateRect来使无效区域变得有效，这是因为BeginPaint函数和EndPaint函数隐含有这个功能，如果不是以BeginPaint/EndPaint当做消息处理代码的头尾的话，那么在WM_PAINT消息返回的时候就必须调用ValidateRect函数。

BeginPaint函数的第二个参数是一个绘图信息结构的缓冲区地址，Windows会在这里返回绘图信息结构，结构中包含了无效区域的位置和大小，绘图信息结构的定义如下：

PAINTSTRUCT STRUCT

       hdc                DWORD        ?

       fErase            DWORD        ?

       rcPaint           RECT            <>

       fRestore         DWORD        ?

       fIncUpdate     DWORD        ?

       rgbReserved   BYTE 32 dup(?)

PAINTSTRUCT ENDS

其中hdc字段是窗口的设备环境句柄，rcPaint字段是一个RECT结构，它指定了无效区域矩形的对角顶点，fErase字段如果为非零值，表示Windows在发送WM_PAINT消息前已经用背景色擦除了无效区域，后面3个字段是Windows内部使用的，应用程序不必去理会它们。

二、设备环境

解决了“When”的总是后，再考虑一下“Where”的问题。

在DOS操作系统中，向屏幕输出数据实际上是把输出内容拷贝到视频缓冲区中，如果在文本模式下显示信息，只需要把内容拷贝到B8000h处的内存中；显示图形信息，可以把图形数据拷贝到A0000h处的内存中。

在Windows中，GDI接口把程序和硬件分隔出来，在Win32编程中，再也不能通过直接向视频缓冲区拷贝数据的办法来显示信息了，那么，究竟该往哪里输出图形呢——这就是“Where”的问题。答案是：通过“设备环境”来输出图形。

1、什么是设备环境

在Windows中，所有与图形相关的操作都是用统一的方法来完成的（不然就不能称为“图形设备接口”了）。不管是绘画屏幕上的一个窗口，还是把图形输出到打印机，或者对一幅位图进行绘画，使用的绘图函数都是相同的，为了实现方法上的统一，必须将所有的图形对象看成是一个虚拟的设备，这些设备可能有不同的属性，如黑白打印机和彩色屏幕的颜色深度是不同的，不同打印机的尺寸和分辨率可能是不同的，绘图仪只支持矢量而不支持位图等。不同设备的不同属性就构成了一个绘图的“环境”，就像DOS操作系统中把视频缓冲区当做图形操作的对象一样，这个绘图的“环境”就是Win32编程中图形操作的对象，把它叫做“设备环境”。设备环境实际上是一个数据结构，结构中保存的就是设备的属性，当对设备环境进行图形操作的时候，Windows可以根据这些属性找到对应的设备进行相关的操作。

在实际使用中，通过“设备环境”可以操作的对象很广泛，除了可以是打印机或绘图仪等硬件设备外，也可以是窗口的客户区，包括大大小小的所有可以被称为窗口的按钮与控件等的客户区，也可以是一个位图。总之，任何需要用到图形操作的东西都可以通过“设备环境”进行绘图。

为了更好地理解“设备环境”是什么，先来看一个例子：

//DcCopy.asm

                .386

                .model flat, stdcall

                option casemap:none

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; Include 文件定义

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

include         windows.inc

include         gdi32.inc

includelib      gdi32.lib

include         user32.inc

includelib      user32.lib

include         kernel32.inc

includelib      kernel32.lib

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

ID_TIMER        equ     1

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; 数据段

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                .data?

hInstance       dd      ?

hWin1           dd      ?

hWin2           dd      ?

                .const

szClass1        db      'SourceWindow',0

szClass2        db     'DestWindow',0

szCaption1      db      '请尝试用别的窗口覆盖本窗口!',0

szCaption2      db      '本窗口图像拷贝自另一窗口',0

szText          db      'Win32 Assembly, Simple and powerful!',0

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                .code

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; 定时器过程

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

_ProcTimer      proc    _hWnd, uMsg, _idEvent, _dwTime

                local   @hDc1, @hDc2

                local   @stRect:RECT

                invoke GetDC, hWin1

                mov     @hDc1, eax

                invoke GetDC, hWin2

                mov     @hDc2,eax

                invoke GetClientRect, hWin1, addr @stRect

                invoke BitBlt, @hDc2, 0, 0, @stRect.right, @stRect.bottom, @hDc1, 0, 0, SRCCOPY

                invoke ReleaseDC, hWin1, @hDc1

                invoke ReleaseDC, hWin2, @hDc2

                ret

_ProcTimer      endp

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; 窗口过程

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

_ProcWinMain    proc    uses ebx edi esi, hWnd, uMsg, wParam, lParam

                local   @stPs:PAINTSTRUCT

                local   @stRect:RECT

                local   @hDc

                mov     eax, uMsg

                mov     ecx, hWnd

;****************************************************************

                .if     eax == WM_PAINT && ecx == hWin1

                        invoke BeginPaint, hWnd, addr @stPs

                        mov     @hDc, eax

                        invoke GetClientRect, hWnd, addr @stRect

                        invoke DrawText, @hDc, addr szText, -1, addr @stRect, DT_SINGLELINE or DT_CENTER or DT_VCENTER

                        invoke EndPaint, hWnd, addr @stPs

;****************************************************************

                .elseif eax == WM_CLOSE

                        invoke PostQuitMessage, NULL

                        invoke DestroyWindow, hWin1

                        invoke DestroyWindow, hWin2

;****************************************************************

                .else

                        invoke DefWindowProc, hWnd, uMsg, wParam, lParam

                        ret

                .endif

;****************************************************************

                xor eax, eax

                ret

_ProcWinMain    endp

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

_WinMain proc

        local   @stWndClass:WNDCLASSEX

        local   @stMsg:MSG

        local   @hTimer

        invoke GetModuleHandle, NULL

        mov     hInstance, eax

        invoke RtlZeroMemory, addr @stWndClass, sizeof @stWndClass

;****************************************************************

        invoke   LoadCursor, 0, IDC_ARROW

        mov      @stWndClass.hCursor, eax

        push     hInstance

        pop      @stWndClass.hInstance

        mov      @stWndClass.cbSize, sizeof WNDCLASSEX

        mov      @stWndClass.style, CS_HREDRAW or CS_VREDRAW

        mov      @stWndClass.lpfnWndProc, offset _ProcWinMain

        mov      @stWndClass.hbrBackground, COLOR_WINDOW + 1

        mov      @stWndClass.lpszClassName, offset szClass1

        invoke   RegisterClassEx, addr @stWndClass

        invoke   CreateWindowEx, WS_EX_CLIENTEDGE, offset szClass1, offset szCaption1, WS_OVERLAPPEDWINDOW, 450, 100, 300, 300, NULL, NULL, hInstance, NULL

        mov      hWin1, eax

        invoke   ShowWindow, hWin1, SW_SHOWNORMAL

        invoke   UpdateWindow, hWin1

;****************************************************************

        mov     @stWndClass.lpszClassName, offset szClass2

        invoke RegisterClassEx, addr @stWndClass

        invoke CreateWindowEx, WS_EX_CLIENTEDGE, offset szClass2, offset szCaption2, WS_OVERLAPPEDWINDOW, 100, 100, 300, 300, NULL, NULL, hInstance, NULL

        mov     hWin2, eax

        invoke ShowWindow, hWin2, SW_SHOWNORMAL

        invoke UpdateWindow, hWin2

;****************************************************************

; 设置定时器

;****************************************************************

        invoke SetTimer, NULL, NULL, 100, addr _ProcTimer

        mov     @hTimer, eax

;****************************************************************

; 消息循环

;****************************************************************

        .while TRUE

                invoke GetMessage, addr @stMsg, NULL, 0, 0

                .break .if eax == 0

                invoke TranslateMessage, addr @stMsg

                invoke DispatchMessage, addr @stMsg

        .endw

;****************************************************************

; 清除定时器

;****************************************************************

        invoke KillTimer, NULL, @hTimer

        ret

_WinMain endp

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

start:

        call    _WinMain

        invoke ExitProcess, NULL

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

        end start

这个程序的代码用到的大部分知识都是前面已经讲到的，在_WinMain中，用一个同样的窗口类建立了两个窗口，两个窗口属于同一个窗口类，所以它们的窗口过程都是_ProcWinMain，为了关闭任何一个窗口都可以结束程序，WM_CLOSE消息中用DestroyWindow函数摧毁了两个窗口。程序设置了一个周期为100ms的定时器，Windows会每隔100ms调用_ProcTimer子程序。在_ProcTimer中，将其中一个窗口的客户区拷贝到另一个窗口的客户区中，方法是通过GetDC获取窗口的DC句柄，并用BitBlt函数完成拷贝工作，所以在右边的窗口显示了一句“Win32 Assembly, Simple and powerful!”，左边的窗口中也会出现这句话。

程序每100ms将右边窗口的客户区拷贝到左边的窗口客户区中，通过左边窗口的客户区就可以了解右边客户区的DC对应的究竟是什么内容。

通过左边窗口的变化可以惊奇地发现：右边窗口客户区的内容并不是程序自己输出到客户区的那句文本，而是以客户区为矩形区域的屏幕上我们真正看到的东西，它竟然包括其他窗口覆盖在上面的东西。这就意味着，扫雷游戏和纸牌游戏通过自己客户区对应的设备环境画图形，图形数据竟然画到了DcCopy窗口客户区对应的设备环境中。

这个例子验证了“设备环境”只是“环境”而不是“设备”，它并不存储发给它的图形数据，图形数据透过它写到了它所描述的“设备”上，每个窗口客户区的“设备环境”对应的设备都是屏幕，但它们在位置上可能重叠，所以向一个窗口的客户区写数据相当于同时写了下层窗口的客户区。

为了让当前激活的窗口在视觉上保持在最上面，下层窗口向自己客户区写的内容首先要经过Windows的“过滤”，只有没有被其他窗口覆盖掉的部分才真正被写到了屏幕上。

读者应该时刻提醒自己——“设备环境”只是一个环境，是设备属性的一组定义，程序输出的图形数据透过“设备环境”被定向到了具体的设备上，“设备环境”本身并不存储这些数据。

Device Context中Context的含义：设备环境的上面是应用程序，下面是具体设备，而它是用来“联系上下关系”用的。

有人可能认为：屏幕上的窗口就像放在桌面上的一张张纸，虽然一张纸可能暂时被另一张遮住，但纸上写的东西还是存在的，移开另一张纸就可以再次露出来。但实际情况是：桌面更像一个用粉笔写的公告黑板，一个窗口相当于划了一块空间写告示，写另一个告示的时候要把老告示的内容擦去一部分以便写新的内容，擦去的东西也就不存在了，如果要恢复老告示，那么必须把擦去的部分重新写上去。

2、获取设备环境句柄

要想对任何设备绘图，首先必须获取设备的“设备环境句柄”（hDC），几乎所有的GDI函数的操作目标都是hDC，在程序中得到一个hDC有几种方法。

最常用的方法是在WM_PAINT消息中用BeginPaint函数得到hDC，WM_PAINT消息的代码结构一般是：

.if    eax == WM_PAINT      ;eax为uMsg

       invoke BeginPaint, hWnd, addr stPS

       ;刷新客户区的代码

       invoke EndPaint, hWnd, addr stPS

       xor eax, eax

       ret

BeginPaint函数的返回值就是需要刷新区域的hDC。要注意的是：BeginPaint返回的hDC对应的尺寸仅是无效区域，无法用它绘画到这个区域以外的地方去。由于窗口过程每次接收WM_PAINT消息时的无效区域可能是不同的，所以这个hDC的值仅在WM_PAINT消息中有效，程序不应该保存它并把它用在WM_PAINT消息以外的代码中。基于同样的道理，BeginPaint和EndPaint函数只能用在WM_PAINT消息中，因为只有这时候才存在无效区域。

程序中常常有这种需求，就是在非WM_PAINT消息中主动绘画客户区，由于BeginPaint和EndPaint函数必须在WM_PAINT消息中使用，所以这时必须用另外的方法获取hDC，可以使用以下的方法：

invoke GetDC, hWnd            ;获取hDC

;返回值是hDC

;绘图代码

invoke ReleaseDC, hWnd      ;释放hDC

GetDC函数返回的hDC对应窗口的整个客户区，当使用完毕的时候，hDC必须用ReleaseDC函数释放。对于用GetDC获取的hDC，Windows建议使用的范围限于单条消息内，当程序在处理某条消息的时候需要绘画客户区时，可以用GetDC获取hDC，但在消息返回前，必须用ReleaseDC将它释放掉，如果在下一条消息中需要继续使用到hDC，那么必须重新用GetDC函数获取。

上面的两种方法获取的hDC都是窗口的hDC，如果要操作的是其他的东西，如打印机、位图等，就不能使用BeginPaint或GetDC函数了。当绘图的对象是一个设备的时候，可以用CreateDC函数来建立一个DC：

invoke CreateDC, lpszDriver, lpszDevice, lpszOutput, lpInitData

lpszDriver指向设备名称，如显示设备的设备名是DISPLAY，打印机的设备名一般为WINSPOOL，下面这几句代码建立的DC对应整个屏幕：

szDriver         db    “DISPLAY”,0

                     …

                     invoke CreateDC, addr szDriver, NULL, NULL, NULL

                     mov hDC, eax

当绘图对象是位图的时候，同样需要一个和位图句柄相联系的DC，这时可以用函数CreateCompatibleDC来创建一个显示表面仅存在于内存中的DC：

invoke CreateCompatibleDC, hDC

参数中的hDC是用来参考的DC句柄，如果指定的参数是NULL，那么建立的DC将和当前屏幕的设置兼容，为了用CreateCompatibleDC建立的DC绘画一个位图，还需要用SelectObject函数将hDC和位图句柄联系起来。

用CreateDC和CreateCompatibleDC函数建立的hDC在使用结束以后，必须用DeleteDC函数删除，注意这里不能用ReleaseDC，这个函数是和GetDC配合用的。

用BeginPaint/EndPaint以及GetDC获取的hDC的使用时间不能超出本条消息，与此相比，用CreateDC以及CreateCompatibleDC建立的hDC就没有这个限制，可以在任何时刻建立它并且一直使用到不再需要为止。

三、色彩和坐标

1、Windows中的色彩

可以表示的颜色总数由颜色深度决定，也就是存储每个像素所用的位数，各种显示设备可以显示的颜色总数可能大不相同，如果设备支持的颜色深度太浅，就会影响到图像的质量，会让人看起来觉得很粗糙和不自然。

一种颜色可以分解成红、绿、蓝三原色，所以可以用红、绿、蓝3个分量的组合来表示各种颜色。

当设备支持的颜色深度少于等于8位时（如8位（256色）、4位（16色）、2位（4色）或1位（2色）），总体位数太少，不足以用来表达3个颜色分量，这时系统建立一个色彩表，像素数据用来做索引在色彩表中获取颜色值，所以低于8位的颜色称为索引色。

只有当颜色深度大于8位的时候，像素数据中才直接包含红、绿、蓝3个分量。当颜色深度为16位的时候，红、绿、蓝各用5位表示，剩下的1位用做属性位，实际可以表示的颜色数目为2^15=32 768种，16位深度的彩色又称为16位色、高彩色或增强色。当颜色深度为24位的时候，3个分量各用8位表示，实际可以表示的颜色数目为2^24=16777216种，24位深度的彩色又称为24位色、16M色或真彩色。对于人的眼睛来说，超过16位的颜色就已经很难分辨了。

在Win32的编程中，统一使用32位的整数表示一个深度为24位的颜色，在这32位中只使用低24位，每一种原色分量占用8位，其中0~7位为红色，8~15位为绿色，16~23位为蓝色。在程序中用到一种颜色常数的时候，可以如下使用：

move ax, 红色 + 绿色*100h + 蓝色*10000h ;将颜色放入eax中

当显示设备无法表示24位色的时候，Windows会自动用设备可以显示的最接近的颜色来代替它，当显示设备的颜色深度比较低的时候，可以通过函数GetNearestColor来得知一种颜色（颜色）会被系统替换成哪种颜色：

invoke GetNearestColor, hDC, dwColor       ;返回真正使用的颜色值

但是当显示设备颜色深度太低的时候，经过Windows自动转换的图像可能会让人觉得很不自然，所以在有些时候，程序员可能希望预先得知设备的颜色深度，然后根据具体情况显示不同的图形。

显示设备的颜色深度可以用以下函数获取：

invoke GetDeviceCaps, hDC, PLANES

mov ebx, dwPlanes

invoke GetDeviceCaps, hDC, BITSPIXEL

mul ebx

mov dwColorDepth, eax

第一个函数调用返回DC的色彩平面数，第二个函数调用返回每个像素的色彩位数，颜色深度最后可以通过dwPlanes乘以dwBitsPixel得到。

2、Windows中的坐标系

要用GDI函数绘图，就必须首先了解这些函数使用的坐标系，在默认的状态下，Windows坐标系以左上角做坐标原点，以右方当做X坐标的正方向，以下方当做Y坐标的正方向。坐标的数值要用一个有符号的16位数来表示，范围从-32 768~32767，坐标的单位为像素。这种坐标系定义方法的好处是：窗口中每一点的坐标不会因为窗口的大小改变而改变，试想一下，如以数学中通常的表示方法，以左下角做坐标原点，那么当窗口高度被用户调整的时候，客户区中每一点的Y坐标都会变化，在具体使用中就会有诸多不便。

但是Windows也提供了其他的一些坐标映射方法供程序员使用，可以用SetMapMode函数来为一个DC设置新的坐标映射方法：

invoke SetMapMode, hDC, iMapMode

可以设置的参数包括坐标原点、坐标和逻辑单位和坐标的正方向等，参数中的iMapMode为新的映射方式，其可以选择的取值如下表所示，Windows默认使用的映射方式为MM_TEXT。

Windows中可用的坐标映射方式

可以看到，除了默认的MM_TEXT方式外，下面5种映射方式：MM_HIENGLISH，MM_LOENGLISH，MM_HIMETRIC，MM_LOMETRIC和MM_TWIPS采用的都是原点位于左上角、X正方向向上的映射方式，另外，它们的坐标逻辑单位是不同的。

最后的两种映射方式MM_ISOTROPIC和MM_ANISOTROPIC提供了更灵活的选择，设置为这两种映射方式后，程序可以继续调用SetViewportOrgEx，SetViewportExtEx和SetWindowExtEx函数来自由设置坐标系的原点、逻辑单位和坐标的正方向等所有参数。在其他映射方式下的时候，不能使用这3个设置函数，这时任何对它们的调用都会被忽略。

1、定时器简介

在应用程序需要使用定时器时，可以用SetTimer函数向Windows申请一个定时器，要求系统在指定的时间以后“通知”应用程序，如果申请成功的话，系统会以指定的时间周期调用SetTimer函数指定的回调函数，或者向指定的窗口过程发送WM_TIMER消息，和DOS操作系统固定以55ms的间隔触发中断服务程序相比，SetTimer函数可以指定的时间间隔更为灵活——以ms为单位，可以指定的时间周期为一个32位的整数，也就是从1~4294 967 295ms，这可是一个将近50天的范围！

但是在具体的使用中不要被这个参数所迷惑：由于Windows的定时器同样是基于时钟中断的，所以虽然参数的单位是ms，但精度还是55ms，如果指定一个小于55ms的周期，不管是1ms还是54ms，Windows最快也只能在每个时钟中断的时候触发这个定时器，也就是说，实际上这个定时器是以55ms为触发周期的；另外，当指定一个时间间隔的时候，Windows以和这个间隔最接近的55ms的整数位时间来触发定时器，假定建立一个周期为1000ms的定时器，定时器的触发周期实际上不是1s而是989ms（55ms*18）。

使用定时器时还有一个要点就是定时器消息是一个低级别的消息，这表现在两个方面：首先就是Windows只有在消息队列中没有其他消息的情况下才会发送WM_TIMER消息，如果窗口过程忙于处理某个消息没有返回，使消息队列中有消息积累起来，那么WM_TIMER消息就会被丢弃，在消息队列再度空闲的时候，被丢弃的WM_TIMER消息不会被补发；其次，消息队列中不会有多条WM_TIMER消息，如果消息队列中已经有一条WM_TIMER消息，还没来得及处理，又到了定时的时刻，那么两条WM_TIMER消息会被合并成一条。

所以，应用程序不能依靠定时器来保证某件事情必须在规定的时刻被处理，另外，也不能依赖对定时器消息计数来确定已经过去了多少时间。

2、定时器的使用

//Timer.rc

#include <resource.h>

#define DLG_MAIN 1

#define ICO_1 1

#define ICO_2 2

#define IDC_SETICON 100

#define IDC_COUNT 101

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

ICO_1 ICON "1.ico"

ICO_2 ICON "2.ico"

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

DLG_MAIN DIALOG 50, 50, 113, 40

STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU

CAPTION "定时器例子"

FONT 9 "宋体"

{

    ICON ICO_1, IDC_SETICON, 8, 9, 18, 21

    LTEXT "计数：", -1, 35, 16, 25, 10

    LTEXT "", IDC_COUNT, 62, 16, 40, 10

}

对资源的定义读者现在一定不会陌生了，这个文件中定义了两个图标和一个对话框，对话框中定义了一个图标框和两个文本框，其中的一个文本框中的文字为空，这是以后显示每秒一次的计数值用的。

//Timer.asm

                .386

                .model flat, stdcall

                option casemap:none

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; Include 文件定义

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

include         windows.inc

include         user32.inc

includelib      user32.lib

include         kernel32.inc

includelib      kernel32.lib

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

ID_TIMER1       equ     1

ID_TIMER2       equ     2

ICO_1           equ     1

ICO_2           equ     2

DLG_MAIN        equ     1

IDC_SETICON     equ     100

IDC_COUNT       equ     101

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; 数据段

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                .data?

hInstance       dd      ?

hWinMain        dd      ?

dwCount         dd      ?

idTimer         dd      ?

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; 代码段

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                .code

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; 定时器过程

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

_ProcTimer      proc    _hWnd, uMsg, _idEvent, _dwTime

                pushad

                invoke GetDlgItemInt, hWinMain, IDC_COUNT, NULL, FALSE

                inc    eax

                invoke SetDlgItemInt, hWinMain, IDC_COUNT, eax, FALSE

                popad

                ret

_ProcTimer      endp

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; 窗口过程

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

_ProcDlgMain    proc    uses ebx edi esi, hWnd, uMsg, wParam, lParam

                mov eax, uMsg

;**********************************************************************************

                .if     eax == WM_TIMER

                        mov     eax, wParam

                        .if     eax == ID_TIMER1

                                inc     dwCount

                                mov     eax, dwCount

                                and     eax, 1

                                inc     eax

                                invoke LoadIcon, hInstance, eax

                                invoke SendDlgItemMessage, hWnd, IDC_SETICON, STM_SETIMAGE, IMAGE_ICON, eax

                        .elseif eax == ID_TIMER2

                                invoke MessageBeep, -1

                        .endif

;**********************************************************************************

                .elseif eax == WM_INITDIALOG

                        push    hWnd

                        pop     hWinMain

                        invoke SetTimer, hWnd, ID_TIMER1, 250, NULL

                        invoke SetTimer, hWnd, ID_TIMER2, 2000, NULL

                        invoke SetTimer, NULL, NULL, 1000, addr _ProcTimer

                        mov     idTimer, eax

;**********************************************************************************

                .elseif eax == WM_CLOSE

                        invoke KillTimer, hWnd, ID_TIMER1

                        invoke KillTimer, hWnd, ID_TIMER2

                        invoke KillTimer, NULL, idTimer

                        invoke EndDialog, hWnd, NULL

;**********************************************************************************

                .else

                        mov     eax, FALSE

                        ret

                .endif

                mov     eax, TRUE

                ret

_ProcDlgMain    endp

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

start:

                invoke GetModuleHandle, NULL

                mov hInstance, eax

                invoke DialogBoxParam, hInstance, DLG_MAIN, NULL, offset _ProcDlgMain, NULL

                invoke ExitProcess, NULL

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                end start

这个程序的基本结构非常简单，就是一个标准的对话框程序而已，在WM_INITDIALOG中用SetTimer申请了3个定时器，并在WM_CLOSE消息中用KillTimer撤销这3个定时器。

申请一个定时器使用SetTimer函数，函数的使用方法如下：

invoke SetTimer, hWnd, nIDEvent, uElapse, lpTimerFunc

hWnd参数是WM_TIMER消息发往的窗口句柄；nIDEvent参数是一个用户指定的任意整数，用来标识一个程序中的多个定时器；uElapse是时间周期，以ms为单位，这个参数是必须指定的；lpTimerFunc是定时器过程，在下面的内容中有详细介绍。如果定时器建立成功的话，函数的返回值是定时器的标识符。

撤销定时器的函数是KillTimer，该函数的使用方法是：

invoke KillTimer, hWnd, uIDEvent

参数hWnd和uIDEvent就是建立定时器时使用的数值。

使用SetTimer函数的方法有两种，第一种方法是要求Windows将WM_TIMER消息发往指定的窗口过程，这时候lpTimerFunc必须为NULL，如例子中的：

invoke SetTimer, hWnd, ID_TIMER1, 250, NULL

invoke SetTimer, hWnd, ID_TIMER2, 2000, NULL

这两个句子设置了两个标识分别为ID_TIMER1和ID_TIMER2的定时器，定时周期分别为250ms和2s。在窗口过程收到WM_TIMER消息的时候，wParam中是用SetTimer建立定时器时使用的标识uIDEvent，所以程序可以建立一个分支，通过判断wParam来处理不同的定时器引起的WM_TIMER的消息。在例子中，当wParam是ID_TIMER1的时候更换图标框中的图标，是ID_TIMER2的时候用MessageBeep函数来发出一声“嘟”的声音。如果要撤销用这种方法建立的定时器，那么只需要用建立时的hWnd和uIDEvent参数简单地调用KillTimer就可以了。

还有一种使用定时器的方法，那就是要求Windows在时间到的时候调用指定的定时器过程，而不是某个窗口过程，那么只需要指定lpTimerFunc参数，如例子中的：

invoke SetTimer, NULL, NULL, 1000, addr _ProcTimer

这句语句要求系统把定时器消息发送到_ProcTimer定时器过程中去，但是，这时候没有参数用来指定定时器标识，到最后如何用KillTimer撤销这个定时器呢？答案是SetTimer函数会返回一个标识，程序可以保存这个标识并在KillTimer函数中使用。

当然，这种用法中的定时器标识也可以自己指定，但这时候一定要同时指定hWnd，虽然这个hWnd没有实际的用途，如果hWnd为NULL，那么即使指定了定时器标识，这个标识也会被忽略，如：

invoke SetTimer, hWnd, ID_TIMER3, 1000, addr _ProcTimer

这个语句定义了一个标识为ID_TIMER3、消息发往_ProcTimer子程序的定时器。

定时器过程是如下定义的：

TimerProc      proc        hWnd, uMsg, idEvent, dwTime

Windows回调定时器过程的时候会有4个参数，uMsg总是WM_TIMER，hWnd和idEvent是窗口句柄和定时器标识。由于有idEvent参数，所以我们同样可以把多个定时器消息指向同一个定时器过程中，并且根据idEvent参数构建一个分支来处理不同定时器引发的消息。

程序中还可能遇到一种情况：当在SetTimer中指定的定时器标识已经存在会怎样呢？答案是Windows会用新的参数代替老的定时器参数，函数执行以后，这个标识的定时器消息将以新的时间周期发送。

注意：例子程序的窗口过程中把WM_TIMER的消息的处理代码放在第一个分支上，这是对程序的简单优化，把频繁发生的消息放到前面可以使程序少执行一系列的比较指令，像WM_CREATE和WM_DESTROY等仅发生一次的消息可以放到分支的最后面。

3、取Windows时间

“定时器”这个词很容易让人联想到时钟，但是在前面介绍过，定时器是不能用来构造时钟的，定时器用于时钟程序中只能是用在定时刷新屏幕这个功能上，要得到系统的时间还是要靠别的方法。

在Win32编程中，和获得系统时间相关的函数有3个：

invoke GetLocalTime, lpSystemTime

invoke GetSystemTime, lpSystemTime

invoke GetTickCount

它们之间的区别是：

GetTickCout返回的是本次Windows启动以来的ms数，得到的时间数值直接在eax中返回，由于这是一个32位的整数，可以表示的范围是1~ffffffffms，所以当Windows连续运行49.7天以后，计数器会清零并重新开始。

GetLocalTime返回当前的时间，GetSystemTime返回当前的格林威治标准时间，这两个函数返回的时间数据包括年、月、日、时、分、秒、毫秒以及星期，数据比较多，所以无法放在eax中返回，应用程序需要预先设置一个SYSTEMTIME结构的缓冲区，并将缓冲区地址lpSystemTime当参数传递给函数，函数会把时间数据返回到这个缓冲区中。

SYSTEMTIME结构的定义如下：

SYSTEMTIME STRUCT

       wYear                   WORD           ?      ;年

       wMonth                WORD           ?      ;月

       wDayOfWeek        WORD           ?      ;星期，0=星期日，1=星期一，……

       wDay                    WORD           ?      ;日

       wHour                  WORD           ?      ;时

       wMinute                WORD           ?      ;分

       wSecond               WORD           ?      ;秒

       wMilliseconds        WORD           ?      ;毫秒

SYSTEMTIME ENDS

需要注意的是，结构中的字段全部是word类型的，而Win32程序中用的往往是dword型变量，所以在使用这些数据之前往往要先把它们转换为dword类型，用movzx指令就可以很方便地完成这个工作，如movzx eax, stSystemTime.wYear将wYear字段扩展到32位后放在eax中。

和获得系统时间的函数相对应，可以用下面的两个函数设置系统时间：

invoke SetLocalTime, lpSystemTime

invoke SetSystemTime, lpSystemTime

同样，SetLocalTime中的参数代表本地时间，SetSysTime中的参数代表格林威治标准时间，在调用函数之前，要把需要设置的时间放到一个SYSTEMTIME结构中并把结构地址当做参数传递给Windows。

1、使用二进制资源

DOS的exe文件可以带一个覆盖部分，覆盖部分实际上就是在真正的可执行部分后面附加的数据，然后由程序在运行中打开自身文件并使用这些数据。Win32的可执行文件中除了上面介绍的这些标准类型的资源外，也可以在程序中附带其他数据，当然方法完全不同——Win32资源中允许用户自己定义二进制的资源或者自定义格式的资源，资源的内容可以是任何数据，也可以将一个磁盘文件按二进制格式包括进去。

二进制资源的定义格式是：

资源ID REDATA [DISCARDABLE]

BEGIN

              数据定义

              …

END

也可以用一个磁盘文件当做资源的内容：

资源ID RCDATA [DISCARDABLE] 文件名

在程序中要使用资源的内容时，可以通过以下步骤将资源装入内存使用：

（1）用FindResource(hInstance, lpName, lpType)查找资源。lpName的值为资源ID，lpType的值为RT_RCDATA，如果找到资源。那么函数返回一个资源信息句柄。

（2）用LoadResource(hInstance, hResInfo)装入资源。hResInfo是上一步中得到的资源信息句柄，装入成功的话函数会返回一个资源句柄。

（3）用LckResource(hResData)将资源锁定到内存中。hResData是上一步得到的资源句柄，函数返回资源装入的内存地址，程序就可以使用内存中的数据了。

（4）如果想知道装入资源的大小是多少，可以使用FindResource返回的hResInfo来调用SizeofResource(hInstance, hResInfo)从而得到资源大小。

下面是一个装入资源ID为ID_MYRES的RCDATA类型资源的例子：

invoke FindResource, hInstance, ID_MYRES, RT_RCDATA ；寻找资源

.if eax

mov hResInfo, eax

invoke SizeofResource, hInstance, eax        ;获取资源尺寸

mov dwResSize, eax

invoke LoadResource, hInstance, hResInfo ;装入资源

.if eax

    invoke LockResource, eax   ;锁定资源

    .if eax

        mov lpRes, eax

        ;处理lpRes指向的资源内容

    .endif

.endif

.endif

2、使用自定义资源

自定义资源的定义格式比二进制资源更灵活，它和二进制资源的区别在于可以指定资源类别为自定义的名称：

资源ID 类型ID [DISCARDABLE]

BEGIN

              数据定义

              …

END

或用一个磁盘文件当做资源的内容：

资源ID 类型ID [DISCARDABLE] 文件名

类型ID可以是大于255的数值（255及以下的数值由Windows使用）或字符串，如可以定义如下：

1000   WAVE   “Hello.wav”   ;定义类型为“WAVE”，资源ID为1000的资源

1000   TEXT    “Readme.txt” ;定义类型为“TEXT”，资源ID为1000的资源

1000   1000     “Test.bin”     ;定义类型为1000，资源ID为1000的资源

在程序中使用自定义资源的方法和使用二进制资源类似，唯一的区别是使用FindResource得到hResInfo的参数有些区别，得到hResInfo以后的步骤是一模一样的。针对上面3句定义，查找资源的方法可以是：

szResType1        db       “WAVE”,0

szResType2        db       “TEXT”,0

…

invoke FindResource, hInstance, 1000, addr szResType1 ;针对上面第一句

invoke FindResource, hInstance, 1000, addr szResType2 ;针对上面第二句

invoke FindResource, hInstance, 1000, 1000            ;针对上面第三句

在使用完二进制或自定义资源以后，不必使用任何函数去释放它们，Windows在程序退出的时候会自动将它们释放。

程序中用到的字符串常常定义在.const字段中，但Windows也提供了另外一种使用字符串常量的方法，那就是在资源中定义。虽然在资源中定义字符串使用起来比直接在.const段中定义要复杂一点，但它带来的好处是便于开发不同语言的版本，比如，要推出其他语种的版本只需要修改资源中的字符串表就可以了，即使语言转换的工作是由第三方通过修改可执行文件来做的（如编程受好者常常做的汉化工作），修改资源也远比修改代码来得快捷和安全。

在资源脚本中定义字符串的语法是：

STRINGTABLE [DISCARDABLE]

BEGIN

       字符串ID1    “字符串1”

       字符串ID2    “字符串2”

       …

END

全部字符串组成一个字符串表，和其他资源定义不同，由于整个资源文件中只能定义一个字符串表，所以字符串表没有资源ID，但是表中的不同字符串分别有一个字符串ID。

在程序中使用字符串资源也很简单，用LoadString把字符串装入到缓冲区中去就可以用了：

       invoke LoadString, hInstance, 字符串ID, addr 缓冲区, sizeof 缓冲区

为了防止溢出，最后一个参数指定缓冲区的长度。

如果要在单个可执行文件中实现多语种，那么可以在字符串表中定义不同语言的字符串。同一语种的字符串按规律排列，如下列中文的以1000开头，英文的以2000开头：

stringtable

{

       1001       “文件未找到！”

       1002       “无法打开文件！”

       …

       2001       “File not found!”

       2002       “Can not open file”

       …

}

在程序中使用的时候，先确定一种语言并预先设置在dwLanguage变量中，使用中文时将dwLanguage设置为1000，使用英文时设置为2000，再写一个读取不同版本字符串的子程序_GetString，这样调用_GetString子程序后就不用考虑版本问题了：

_GetString      proc        _dwID, _lpBuffer, _dwSize

                     pushad

                     mov        eax, _dwID

                     invoke     LoadString, hInstance, eax, _lpBuffer, _dwSize

                     popad

                     ret

_GetString      endp

8、使用列表框

列表框提供一个可供用户选择的列表，用户可以一次选择一个项目，也可以同时选中多个项目。

//Listbox.rc

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

#include <resource.h>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

#define ICO_MAIN 0x1000 //图标

#define DLG_MAIN 1

#define IDC_LISTBOX1 101

#define IDC_LISTBOX2 102

#define IDC_SEL1 103

#define IDC_RESET 104

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

ICO_MAIN   ICON    "Main.ico"

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

DLG_MAIN DIALOG 163, 160, 190, 108

STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU

CAPTION "列表框控件示例"

FONT 9, "宋体"

{

    LISTBOX IDC_LISTBOX1, 6, 5, 55, 86, LBS_STANDARD

    LISTBOX IDC_LISTBOX2, 68, 5, 115, 86, LBS_STANDARD | LBS_MULTIPLESEL

    LTEXT "", IDC_SEL1, 6, 93, 55, 8

    PUSHBUTTON "复位(&R)", IDC_RESET, 89, 90, 45, 14

    DEFPUSHBUTTON "查看(&S)", IDOK, 139, 90, 45, 14, WS_DISABLED

}

//Listbox.asm

                .386

                .model flat, stdcall

                option casemap :none

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; Include 文件定义

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

include         windows.inc

include         user32.inc

includelib      user32.lib

include         kernel32.inc

includelib      kernel32.lib

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; Equ等值定义

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

ICO_MAIN        equ     1000h

DLG_MAIN        equ     1

IDC_LISTBOX1    equ     101

IDC_LISTBOX2    equ     102

IDC_SEL1        equ     103

IDC_RESET       equ     104

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; 数据段

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                .data?

hInstance       dd      ?

                .const

szText1         db      '项目1',0

szText2         db      '项目2',0

szText3         db      '项目3',0

szPath          db      '*.*',0

szMessage       db      '选择结果：%s',0

szTitle         db      '您的选择',0

szSelect        db      '您选择了以下的项目：'

szReturn        db      0dh,0ah,0

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; 代码段

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                .code

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

_ProcDlgMain    proc    uses ebx edi esi hWnd, wMsg, wParam, lParam

                local   @szBuffer[128]:byte

                local   @szBuffer1[128]:byte

                local   @szTextBuff[2048]:byte

                local   @dwCount

                mov     eax, wMsg

                .if     eax == WM_CLOSE

                        invoke EndDialog, hWnd, NULL

                .elseif eax == WM_INITDIALOG

                        invoke LoadIcon, hInstance, ICO_MAIN

                        invoke SendMessage, hWnd, WM_SETICON, ICON_BIG, eax

;********************************************************************************

; 初始化列表框

;********************************************************************************

                        invoke SendDlgItemMessage, hWnd, IDC_LISTBOX1, LB_ADDSTRING, 0, addr szText1

                        invoke SendDlgItemMessage, hWnd, IDC_LISTBOX1, LB_ADDSTRING, 0, addr szText2

                        invoke SendDlgItemMessage, hWnd, IDC_LISTBOX1, LB_ADDSTRING, 0, addr szText3

                        invoke SendDlgItemMessage, hWnd, IDC_LISTBOX2, LB_DIR, DDL_ARCHIVE or DDL_DRIVES or DDL_DIRECTORY, addr szPath

;********************************************************************************

                .elseif eax == WM_COMMAND

                        mov     eax, wParam

                        .if     ax == IDOK

                                invoke SendDlgItemMessage, hWnd, IDC_LISTBOX2, LB_GETSELCOUNT, 0, 0

                                mov @dwCount, eax

                                invoke SendDlgItemMessage, hWnd, IDC_LISTBOX2, LB_GETSELITEMS, 128/4, addr @szBuffer

                                invoke lstrcpy, addr @szTextBuff, addr szSelect

                                lea     esi, @szBuffer

                                .while @dwCount

                                        lodsd

                                        lea     ecx, @szBuffer1

                                        invoke SendDlgItemMessage, hWnd, IDC_LISTBOX2, LB_GETTEXT, eax, ecx

                                        invoke lstrcat, addr @szTextBuff, addr szReturn

                                        invoke lstrcat, addr @szTextBuff, addr @szBuffer1

                                        dec     @dwCount

                                .endw

                                invoke MessageBox, hWnd, addr @szTextBuff, addr szTitle, MB_OK

                        .elseif ax == IDC_RESET

                                invoke SendDlgItemMessage, hWnd, IDC_LISTBOX2, LB_SETSEL, FALSE, -1

                        .elseif ax == IDC_LISTBOX1

                                shr     eax, 16

                                .if     ax == LBN_SELCHANGE

;********************************************************************************

; 将鼠标点击结果显示在文本框中

;********************************************************************************

                                        invoke SendMessage, lParam, LB_GETCURSEL, 0, 0

                                        lea     ecx, @szBuffer

                                        invoke SendMessage, lParam, LB_GETTEXT, eax, ecx

                                        invoke SetDlgItemText, hWnd, IDC_SEL1, addr @szBuffer

;********************************************************************************

; 双击项目则弹出对话框

;********************************************************************************

                                .elseif ax == LBN_DBLCLK

                                        invoke SendMessage, lParam, LB_GETCURSEL, 0, 0

                                        lea     ecx, @szBuffer

                                        invoke SendMessage, lParam, LB_GETTEXT, eax, ecx

                                        invoke wsprintf, addr @szBuffer1, addr szMessage, addr @szBuffer

                                        invoke MessageBox, hWnd, addr @szBuffer1, addr szTitle, MB_OK

                                .endif

;********************************************************************************

                        .elseif ax == IDC_LISTBOX2

                                shr     eax, 16

                                .if     ax == LBN_SELCHANGE

                                        invoke SendMessage, lParam, LB_GETSELCOUNT, 0, 0

                                        mov     ebx, eax

                                        invoke GetDlgItem, hWnd, IDOK

                                        invoke EnableWindow, eax, ebx

                                .endif

                        .endif

                .else

                        mov     eax, FALSE

                        ret

                .endif

                mov     eax, TRUE

                ret

_ProcDlgMain    endp

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

start:

               invoke GetModuleHandle, NULL

                mov    hInstance, eax

                invoke DialogBoxParam, hInstance, DLG_MAIN, NULL, offset _ProcDlgMain, NULL

                invoke ExitProcess, NULL

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                end start

程序中总共定义了两个列表框。左边列表框为IDC_LISTBOX1，这是一个单选的列表框，选择一个项目的时候下面的文本会显示出选择的项目，双击某个项目的时候会弹出消息框，显示所选中的项目。右边的列表框是IDC_LISTBOX2，是一个多选的列表框，选择完毕可以用“查看”按钮弹出消息框，消息框中显示了所有选中的项目。按下“复位”按钮清除列表框的选择。

列表框可以使用的风格

一般单选列表框只需定义LBS_STANDARD就可以了。

列表框使用说明：

当列表框有 LBS——NOTIFY风格的时候，用户有所动作时列表框会向父窗口发送WM_COMMAND，同时在wParam的高16位中指定通知码，列表框的通知码种类很少，基本上就是以下几种：

l         LBN_DBLCLK                     用户双击了一个项目。

l         LBN_ERRSPACE                 插入项目时无法申请到足够的内存。

l         LBN_KILLFOCUS        输入焦点被切换到其他控件中，列表框丢失了焦点。

l         LBN_SELCANCEL        用户撤销了一个选择。

l         LBN_SELCHANGE              选定状态改变。

l         LBN_SETFOCUS                 列表框得到输入焦点。

我们最关心的是LBN_DBLCLK和LBN_SELCHANGE通知码，在单选列表框中，如果程序用双击来选择项目，那么就要处理LBN_DBLCLK通知，例子程序中当用户双击IDC_LISTBOX1时弹出一个消息框，读者可以查看其使用方法。在多选列表框中，由于用户可能选择了多个项目，所以一般不用双击的方法选定：如果收到LBN_SELCHANGE通知的话，可以得知用户有一个选择动作，在这里可以进行相应的操作。

       列表框通知父窗口是通过发送WM_COMMAND消息，而程序控制列表框的时候是通过向列表框发送消息来完成的。

       常用的列表框消息如下表所示：

这些消息中LB_DIR是个比较有趣的消息，它可以将指定目录中的文件名自动列出来并加入列表框中，如例子中用*.*将当前目录中的全部文件名加到列表框中。LB_DIR消息中wParam参数可以指定的属性可以是是以下值的组合：

DDL_ARCHIVE            加入归档属性的文件。

DDL_DIRECTORY       加入目录。

DDL_DRIVES              加入驱动器名。

DDL_HIDDEN             包含隐含文件。

DDL_READONLY        包含只读文件。

DDL_READWRITE      包含可读写的文件。

DDL_SYSTEM             包含系统文件。

       在列表框中初始化时加入项目可以使用LB_ADDSTRING和LB_INSERTSTRING消息，删除项目可以用LB_DELETESTRING消息，删除全部项目用LB_RESETCONTENT消息。

       对于单选列表框，要获取选中项目可以发送LB_GETCURSEL消息，要得到这个项目的字符串需要用索引值通过LB_GETTEXT消息获取，读者可以查看例子中处理LBN_DBLCLK通知码的部分代码。

       对于多选列表框，需要用LB_GETSELITEMS消息获取全部选中项目，这个消息返回的是一个列表，所有选中项目的索引按顺序排列返回到缓冲区中，所以在例子中处理“查看”按钮消息（IDOK）的时候，程序先发送LB_GETSELCOUNT消息得到选中的项目数，以便在下面用一个循环获取所有的项目，得到数目数后，再用LB_GETSELITEMS将选中项目的索引取到@szBuffer中，接下来进入一个循环，循环的次数就是LB_GETSELCOUNT得到的数值，在循环中，程序从@szBuffer中将索引值逐个取出并用LB_GETTEXT消息获取每一项的字符串，最后用一个MessageBox显示出来。

       由于子窗口控件实际上就是窗口，大部分窗口函数对它们都是适用的，如可以用EnableWindow在灰化和允许状态之间切换，可以用ShowWindow在显示和隐藏之间切换，可以用GetWindowText和SetWindowText来改变上面的文字，也可以用MoveWindow来改变大小和移动位置等。在Control.asm中用“显示图片”复选框切换图片框的隐藏和显示，用的就是ShowWindow函数，处理“允许更换图片”复选框时切换“更换图片”按钮的状态，用的是EnableWindow函数。

       除了可以用对子窗口控件使用窗口的通用函数外，还可以使用针对它们的专用函数。下面介绍一些常用的函数。

       在资源脚本文件中定义的是控件的ID，当这些子窗口控件被创建以后同样会有一个窗口句柄，但既然它们不是由我们由自己创建的，那么怎么知道它们的窗口句柄呢？有一个函数可以从ID中获取子窗口句柄：

       invoke GetDlgItem, hDlg, dwIDDlgItem

       mov    hDlgItem, eax

       函数的输入参数是对话框句柄和ID值，返回值是子窗口句柄；反过来，有两种方法可以从子窗口句柄获取ID：

       （1）invoke GetDlgCtrolID, hWndCtrl ;输入子窗口句柄，返回值是控件ID

       （2）invoke GetWindowLong, hWndCtrl, GWL_ID

       当需要向控件发送消息的时候，当然可以先用GetDlgItem获取子窗口句柄再用SendMessage函数，但有一个函数更为简便：

       invoke SendDlgItemMessage, hDlg, dwIDDlgItem, Msg, wParam, lParam

       这个函数可以直接向控件发送消息，只需要在参数中指定对话框句柄和子窗口ID（注意：并没有PostDlgItemMessage这样的函数！）。

       如果要想知道在一个控件上按下了Tab键或Shift+Tab键会跳到哪一个控件上去，也就是说下一个或上一个Tab停留位在哪里，可以使用GetNextDlgTabItem函数：

       invoke GetNextDlgTabItem, hDlg, hCtl, bPrevious

       .if eax

        mov hWinNext, eax

.endif

其中的bPrevious参数指定了搜索的方向；与之相似，使用GetNextDlgGroupItem函数可以返回下一个分组的位置：

invoke GetNextDlgGroupItem, hDlg, hCtl, bPrevious

.if eax

   mov hWinNext, eax

.endif

3、使用单选钮和复选框

       单选钮是互斥的选择钮，同一组的多个单选钮只能有一个被选中，单选钮的外形是一个圆形的标记加上文本，圆形中有黑点表示被选中。复选框不是互斥的，多个复选框的状态不会互相影响，复选框的外形是一个方框加上文本，方框中可以用有无对钩来表示是否被选中。

       单选钮和复选框控件都是基于Button类的，只不过它们的窗口风格分别是BS_RADIOBUTTON和BS_CHECKBOX。既然它们是特殊的“按钮”，所以和它们有关的函数都带有“Button”一词，查看一个单选钮或复选框是否被选中可以用下面的函数来检测：

       invoke IsDlgButtonChecked, hDlg, nIDButton

       函数的返回值可能是BST_CHECKED（选中状态），BST_INDETERMINATE（3态复选框的灰化状态）或BST_UNCHECKED（未选中状态）。也可以用向子窗口控件发送BM_GETCHECK消息的方法来检测，返回值和上面的函数是一样的。

       如果想设置单选钮或复选框的状态，可以使用下面的语句：

       invoke CheckDlgButton, hDlg, nIDButton, uCheck

       参数uCheck用BST_CHECKED，BST_INDETERMINATE或BST_UNCHECKED来表示需要设置的状态，含义同上。向控件发送BM_SETCHECK消息也可以取得同样的效果，这时消息的wParam中放置需要设置的状态。

       复选框是不互斥的，所以可以随意设置状态。而对于BS_RADIOBUTTON风格的单选钮来说，并不是把某个按钮设置为选中状态以后，同组的其他按钮就会自动变成非选中状态，所以用CheckDlgButton函数选中了一个单选钮以后，如果不是手动把同组的其他按钮全部改为非选中状态（逐个地调用CheckDlgButton），就会看到同时有两个单选钮是选中的。但把同组的所有单选钮逐个地设置显得有点麻烦，所以针对单选钮有一个专用函数：

       invoke CheckRadioButton, hDlg, nIDFirstButton, nIDLastButton, nIDCheckButton

       这个函数把ID在nIDFirstButton和nIDLastButton之间的单选钮全部设置为非选中状态，只有nIDCheckButton是选中状态，当然在使用中要注意将这一批ID定义为连续的数值。

       如果还嫌CheckRadioButton有点麻烦，还有一种最简单的办法——使用自动单选钮，同组的AUTORADIOBUTTON会随着用户选中一个而自动清除其他单选钮的状态，所以在程序中只需要在初始化的时候预设一次，其他时间就可以不必关心设置问题了，以后唯一用到的就是调用IsDlgButtonChecked检查状态了。

4、使用静态控件

       静态控件是基于Static类的子窗口控件，之所以叫“静态”控件，是因为它是“安静”的——它们不向对话框发送WM_COMMAND消息，所以静态控件的ID一般是没有用处的，定义时常常将它们定义为-1，如果需要在程序中改变属性，那么也可以为静态控件指定一个唯一的ID。

       资源脚本文件中可以使用缩写的基于Static类的有LTEXT，CTEXT，RTEXT（文本框）和ICON（图标框），除了这些常用的类型之外，Static类还可以用CONTROL语句通过指定不同的窗口风格派生出不同用途的控件来。

       下面说明静态控件的一些用法。

       对于文本框，文本长度超过边界的时候默认是自动换行的，但如果同时指定SS_SIMPLE风格的话，就不会自动换行。读者可以在程序中用SetWindowText或发送WM_SETTEXT消息来动态改变显示的文本，同样，也可以用GetWindowText或发送WM_GETTEXT消息来获取其中的文本。

       静态控件可以用来构筑简单的线条和图形，如果指定SS_BLACKFRAME，SS_GRAYFRAME或SS_WHITEFRAME风格，那么静态控件显示为填充的矩形，填充颜色分别是黑色、灰色或白色；而指定SS_BLACKRECT，SS_GRAYRECT或SS_WHITERECT风格的话，则显示为非填充的矩形框，边线颜色是黑色、灰色或白色。

       静态控件也可以用来做立体感的线条或边框，指定SS_ETCHEDHORZ风格显示为横线，指定SS_ETCHEDVERT风格显示为竖线，指定SS_ETCHEDFRAME风格则显示为立体的矩形框，视觉上的效果似于没有文字的GROUPBOX。

       静态控件还有一个用途是做图形显示，当图形是图标的时候，用ICON语句就可能定义了，其默认的风格是SS_ICON，如果想使用位图，那么可以指定SS_BITMAP风格，例子程序中的图片框就是这样定义的。

CONTROL IDB_1, IDC_BMP, “Static”, SS_BITMAP | WS_CHILD | WS_VISIBLE, 5, 5, 40, 95

       在这里，“文字”部分指定位图资源的ID，前面已经把Picture1.bmp的资源ID定义为IDB_1，IDC_BMP是图片框自己的ID，如果不需要在程序中改变图片的话，那么这里可以定义为-1。

       在程序中可以通过向控件发送STM_SETIMAGE消息来设置新的图片，消息的wParam指定图片的格式，取值可以是IMAGE_BITMAP，IMAGE_CURSOR和IMAGE_ICON，分别对应新图片的格式，lParam是图片的句柄，如果是位图，lParam就是用LoadBitmap装入的位图句柄，同样，图片类型是光标和图标的时候，这里就是用LoadCursor和LoadIcon装入的句柄。

       在例子程序中，用来改变图片框图片的语句是：

       invoke SendDlgItemMessage, hWnd, IDC_BMP, STM_SETIMAGE, IMAGE_BITMAP, eax

       eax中是位图句柄，IDC_BMP是图片框的ID，wParam用IMAGE_BITMAP表示要设置的图片类型是位图。

5、使用文本编辑控件

       文本编辑控件是基于Edit类的控件，可以用缩写EDITTEXT定义，读者可以在文本编辑控件中输入并编辑文本。每当用户在文本编辑控件中输入一个字符的时候，控件就会向对话框过程发送一个WM_COMMAND消息，所以在例子程序中，当在自定义文字的编辑框中每输入一个字，标题栏文字就会马上改变。

       要获取编辑框中的文本有多种方法，可以用GetWindowText，也可以用发送WM_GETTEXT消息的办法，要设置文本，同样可以用SetWindowText或发送WM_SETTEXT，但最简便的办法还是使用下面的函数：

       invoke GetDlgItemText, hDlg, nIDDlgItem, lpString, nMaxCount      ;取文本

       invoke SetDlgItemText, hDlg, nIDDlgItem, lpString                         ;设置文本

       lpString是放置字符的缓冲区地址，用GetDlgItemText函数来获取文本的时候，要用nMaxCount参数指定缓冲区的最大长度，以免获取的文本长度超过缓冲区长度引起溢出，设置的时候若使用SetDlgItemText函数时就不需要这个参数。

       在实际使用中，经常要在文本编辑控件中输入输出数值型参数，将文本转换为数值比较麻烦，把数值转换为文本也要经过一个wsprintf调用，为了简化操作，Windows提供了两个函数来处理这个问题：

       invoke SetDlgItemInt, hDlg, nIDDlgItem, uValue, bSigned                ;设置控件中的数值

       invoke GetDlgItemInt, hDlg, nIDDlgItem, lpTranslated, bSigned              ;取控件中的数值

       SetDlgItemInt函数将uValue参数先转换成字符串格式，然后设置到文本编辑控件中，bSigned参数指定了uValue的格式，如果是TRUE的话，表示uValue是有符号数；是FALSE的话，表示uValue是无符号数。

       GetDlgItemInt函数则将对话框中的文本转换成数值型返回，同样，用bSigned指定转换的方式，TRUE表示按照符号数格式转换，这时函数会检测文本的第一个字符是不是负号；FALSE则按照无符号数转换。参数lpTranslated是指向一个dword型变量的指针，GetDlgItemInt会在这个变量中返回BOOL类型值表示函数是否调用成功，成功则返回TRUE，有这样一个参数的原因是函数的返回值用来返回转换后的数值了，以至于没有地方可以表示函数是否执行成功。当然，lpTranslated参数也可以输入NULL，这样，当函数返回0的时候就无法知道是文本框是“0”还是文本不符合格式造成转换失败。

       SetDlgItemInt和GetDlgItemInt函数不仅适用于文本编辑控件，所有对其上面的文本可以修改的控件都可以使用它们。

       使用文本编辑控件的时候，文本的长度也是个需要注意的问题。如果控件的宽度定义得过窄，当字符填充到最右边的时候，编辑框就不允许继续输入了，为了继续输入并让文本自动卷动，可以指定WS_HSCROLL风格；反之，定义WS_HSCROLL风格后输入文本的长度不受限制又不好，那么可以用向控件发送EM_LIMITTEXT消息的方式来设定最大长度。

       下面的例子将IDC_EDIT的输入最大长度定为10个字符：

       invoke SendDlgItemMessage, hDlg, IDC_EDIT, EM_LIMITTEXT, 10, NULL

       另外，有时候可能需要把编辑框设置为只读的（和灰化不同，灰化的编辑框中文本无法进行任何操作，包括卷动操作，而只读的仅仅是不能修改），要把初始状态定义为只读的，只需在定义语句中加上ES_READONLY风格，在程序中需要动态改变只读状态可以发送EM_SETREADONLY消息，下面的第一句把编辑框设为只读，第二句把编辑框改回到可写状态：

       invoke SendDlgItemMessage, hDlg, IDC_EDIT, EM_SETREADONLY, TRUE, NULL ;只读

       invoke SendDlgItemMessage, hDlg, IDC_EDIT, EM_SETREADONLY, FALSE, NULL;可写

       文本编辑框在默认状态下是单行的，也可以通过加上EM_MULTILINE风格变成多行的，这时可以同时加上WS_VSCROLL风格显示一个垂直方向的滚动条。

6、使用滚动条

       滚动条有水平和垂直两种，默认的SCROLLBAR语句定义的是水平的滚动条，它的默认风格是SBS_HORZ，例子程序中用下面的语句定义了一个水平滚动条：

       SCROLLBAR IDC_SCROLL, 6, 118, 125, 10

       如果要定义垂直的滚动条，那么要指明SBS_VERT风格：

       SCROLLBAR IDC_SCROLL, x, y, 宽度, 高度, SBS_VERT

       和其他子窗口控件发送WM_COMMAND消息不同，水平滚动条向对话框窗口发送WM_HSCROLL消息，而垂直滚动条则发送WM_VSCROLL消息，所以针对两种方式的滚动条要分别处理不同的消息。

       WM_xSCROLL消息的参数如下所示：

       wParam的低16位 = nScrollCode             ;动作码

       wParam的高16位 = nPos                       ;滚动条当前位置

       lParam = hwndScrollBar                                   ;滚动条控件的窗口句柄

       其中nScrollCode代表了滚动条的当前动作，定义值及其含义如下：

       SB_BOTTOM                      滚动条移到了最下/右边。

       SB_ENDSCROLL                用户停止了滚动动作。

       SB_THUMBPOSITION        滚动条被拖动到某处。

       SB_THUMBTRACK             滚动条在拖动中。

       SB_TOP                              滚动条移到了最上/左边。

       SB_LINELEFT                    滚动条左移了一格（对于水平滚动条）。

       SB_LINERIGHT                  滚动条右移了一格（对于水平滚动条）。

       SB_PAGELEFT                    滚动条左移了一页（对于水平滚动条）。

       SB_PAGERIGHT                 滚动条右移了一页（对于水平滚动条）。

       SB_LINEDOWN                  滚动条下移了一格（对于垂直滚动条）。

       SB_LINEUP                        滚动条上移了一格（对于垂直滚动条）。

       SB_PAGEDOWN                 滚动条下移了一页（对于垂直滚动条）。

       SB_PAGEUP                        滚动条上移了一页（对于垂直滚动条）。

       nPos的值只有当动作码是SB_THUMBPOSITION或SB_THUMBTRACK时才有效，其他的时候为0。

       第一眼看到SB_xxx动作码的时候，读者可能会以为水平滚动条和垂直滚动条的动作码是不相同的——水平滚动条是SB_xxxLEFT、SB_xxxRIGHT，而垂直滚动条是SB_xxxUP、SB_xxxDOWN，但在Windows.inc中查看一下就可以发现，SB_xxxLEFT和SB_xxxUP在数值上是相同的，SB_xxxRIGHT和SB_xxxDOWN也是如此，所以不同定义方法只是为了直观起见而已。

       以水平滚动条为例，处理滚动条消息的代码一般是如下结构：

       .elseif eax == WM_HSCROLL          ;窗口的消息处理分支，eax为wMsg

              mov eax, lParam

           .if    eax == hWnd滚动条1

                 mov eax, wParam

                 .if ax == SB_LINELEFT

                     dec 位置变量

                 .elseif ax == SB_LINERIGHT

                     inc   位置变量

                 .elseif ax == SB_PAGELEFT

                     sub   位置变量，页长

                 .elseif ax == SB_PAGERIGHT

                     add   位置变量，页长

                 .elseif ax == SB_THUMBPOSITION || ax == SB_THUMBTRACK

                     mov   eax, wParam

                     shr    eax, 16

                     mov   位置变量，eax

                 .endif

       .elseif eax == hWnd滚动条2

           ;处理滚动条2的代码，同上面的结构

…

.endif

在例子程序Control.asm中只定义了一个滚动条，所有的消息肯定都是它发出的，所以去掉了判断lParam是哪个滚动条的步骤直接处理wParam中的动作码。

在用户按动滚动条后，滚动条不会自己移动位置，它只是将用户的动作以WM_xSCROLL消息的形式反馈给程序，真正要移动它还是要靠程序来设置，所以代码中要根据不同的动作首先计算新的位置，并判断新的位置是否越界，例子程序中的这些代码判断新的位置是否超出0~100的范围，如果是，则校正到0~100之间：

cmp dwPos, 0

jge @F

mov dwPos, 0

@@:

cmp dwPos, 100

jle @F

mov dwPos,100

在介绍MASM语句的时候提到过，.if dwPos > 0语句只可以用来比较无符号数，所以在这里使用cmp指令自己测试分支而不是使用.if伪指令。

不计算好新位置的时候要将位置设置回去，用户才会看到滚动条移动了，方法是向滚动发送SBM_SETPOS消息：

invoke SendDlgItemMessage, hWnd, IDC_SCROLL, SBM_SETPOS, dwPos, TRUE

最后一个参数为TRUE表示设置后重新绘画滚动条。

在初始化的时候，要给滚动条发送SBM_SETRANGE消息来设定滚动范围：

invoke SendDlgItemMessage, hWnd, IDC_SCROLL, SBM_SETRANGE, 最小值, 最大值

如果需要获取滚动条的信息，可以尝试发送下面两个消息：SBM_GETPOS可以获取滚动条的当前位置，也就是上一次用SBM_SETPOS设置的值；SBM_GETRANGE可以获取滚动的范围，也就是用SBM_SETRANGE设置的值。

7、使用组合框

       顾名思义，组合框是一个“组合”起来的东西，它由一个可供选择的列表和一个可供输入的edit类组合而成。组合框让用户既可以自己输入文本，也可以选择列表中的某一项当做输入。用不同的风格定义可以产生3种类型的组合框。

       CBS_SIMPLE风格的组合框，它的上面可以输入文本，下面的列表可供选择预设文本；

       CBS_DROPDOWN风格的组合框，上面同样可以输入文本，但下面的列表是下拉式的，平时处于收起状态，点击编辑框右边的三角形才会拉下来；

       CBS_DROPDOWNLIST风格的组合框，它仅是一个下拉的选择框，上面的框中不允许输入文字。

       组合框中还有几种常用的、可以附加的风格：

       CBS_AUTOHSCROLL          输入过长的文本时输入框自动卷动。

       CBS_LOWERCASE              自动将所有的文本转换成小写。

       CBS_SORT                         自动将插入的文本项排序。

       CBS_UPPERCASE        自动将所有的文本转换成大写。

       组合框中列表框部分的文字添加、项目的选择等操作都是通过发送消息来完成的，主要的消息如下表所示：

组合框的消息

       当用户在组合框中进行选择操作时，Windows向对话框过程发送WM_COMMAND消息，消息中wParam参数的低16位是组合框ID，高16位是通知码，用来表示用户的操作，通知码的定义如下表所示。

用户操作组合框后的通知码

       如果想在用户选择了一个项目后做相应的动作，最好的办法就是处理CBN_SELENDOK通知码，因为这才意味着用户真正完成了一个选择动作，例子程序中就是这样处理的：

.elseif ax == IDC_TITLETEXT         ;在WM_COMMAND消息中

       shr eax,16

       .if ax == CBN_SELENDOK

           invoke SendDlgItemMessage, hWnd, IDC_TITLETEXT, CB_GETCURSEL, 0, 0

                 ;根据返回的eax值做相应动作…

       .endif

       以上的操作都是针对下拉列表部分的，另外也有很多消息是针对组合框中的编辑控件的，对组合框的窗口句柄发送WM_GETTEXT和WM_SETTEXT，操作的对象就是组合框的编辑控件；如果要限制控件中文本的最大输入长度，可以发送CB_LIMITTEXT的消息，这时候wParam参数指定最大数量；当用户在编辑框中编辑文本的时候，Windows在用户输入之后、字符显示之前会发送CBN_EDITUPDATE通知码；当字符在编辑框中显示以后，又会发送CBN_EDITCHANGE通知码。所以在处理WM_COMMAND消息时通过处理这两个通知码可以检测到用户的输入操作。

       组合框是子窗口控件中比较复杂的一种，这里仅介绍了常用的消息和通知码。

FATAL                  严重错误
cannot open file      不能打开文件
I/O error closing file   I/O错误 正在关闭文件
I/O error writing file   I/O错误 正在写文件
I/O error reading file            I/O错误 正在读取文件
out of memory              缺少内存
assembler limit : macro parameter name table full      汇编限制：宏参数名表已满
invalid command-line option           无效命令行参数
nesting level too deep             嵌套过深
unmatched macro nesting            不正确的宏嵌套
line too long                  行太长
unmatched block nesting                   不正确的区、段嵌套
directive must be in control block                指令必须在控制段
error count exceeds 100; stopping assembly             错误数超过100，停止汇编
invalid numerical command-line argument                无效命令行参数
too many arguments                                     太多参数、定义、冲突
statement too complex                                   声明太复杂
Internal Assembler Error                         内部汇编错误
missing source filename                                找不到源文件名
COFF error writing file                      COFF错误，正在写文件
invalid debug and browser data; file exceeds line limit        不能排除故障和浏览数据；文件超过行限制
cannot find link.exe                              找不到连接程序
cannot find cvpack.exe                          找不到cvpack.exe
SEVERE                              严重的错误
memory operand not allowed in context                  内存操作数无法载入上下文环境
immediate operand not allowed                      当前操作数无法载入
cannot have more than one ELSE clause per IF block            IF段只能有一个ELSE从句
extra characters after statement                           附加的字符在声明之后
symbol type conflict                             符号类型冲突
symbol redefinition                           符号已经定义
undefined symbol                          符号没有定义
non-benign record redefinition                      没有利于记录的定义
syntax error                                语法错误
syntax error in expression                   表达式存在语法错误
invalid type expression                      无效的类型表达式
distance invalid for word size of current segment           当前区、段的大小命令无效
PROC, MACRO, or macro repeat directive must precede LOCAL      PROC, MACRO, 或 macro repeat指令必须在LOCAL之前
.MODEL must precede this directive                           .MODEL必须在指令之前
cannot define as public or external                     不能定义为公有或外部的
segment attributes cannot change                        区、段属性不能更换
expression expected                   预期表达式
operator expected                      预期操作数
invalid use of external symbol               使用了无效的外部符号
operand must be RECORD type or field            操作数必须是RECORD类型或域
identifier not a record                      没有记录标示符
record constants may not span line breaks                 连续记录不能超过行间隔
instruction operands must be the same size        命令操作数必须是一样的长度
instruction operand must have size             命令操作数必须有长度
invalid operand size for instruction            操作数长度对于指令无效
operands must be in same segment              操作数必须在相同的段
constant expected                         连续预期
operand must be a memory expression             操作数必须是一个内存表达式
expression must be a code address             表达式必须是一个代码地址
multiple base registers not allowed             不允许多重基础寄存器
multiple index registers not allowed           不允许多重标志寄存器
must be index or base register                  必须是基础或标志寄存器
invalid use of register                     使用的寄存器无效
invalid INVOKE argument                   无效的INVOKE符号
must be in segment block                  必须在区、段、块中
DUP too complex                          DUP太复杂
too many initial values for structure                太多结构的基础资料
statement not allowed inside structure definition         声明不允许在结构里面
missing operand for macro operator             找不到宏的操作数
line too long
segment register not allowed in context            上下文不允许有寄存器
string or text literal too long                 文本或字符串太长
statement too complex                    声明太复杂
identifier too long                       标识符太长
invalid character in file                 文件里有无效字符
missing angle bracket or brace in literal         语句里找不到同样的括弧或框架
missing single or double quotation mark in string          找不到单引号或双引号
empty (null) string                没有字符串
nondigit in number                   没有总数
syntax error in floating-point constant           不确定的指向中有语法错误
real or BCD number not allowed                不允许real或BCD编码
text item required                       必须的文本项
forced error                           强制错误
forced error : value equal to 0                 标准等于零
forced error : value not equal to 0             标准不等于零
forced error : symbol not defined            符号没有定义
forced error : symbol defined               符号已定义
forced error : string blank                   字符串是空的
forced error : string not blank             字符串不是空的
forced error : strings equal              字符串是相同的
forced error : strings not equal              字符串不是相同的
[ELSE]IF2/.ERR2 not allowed : single-pass assembler          [ELSE]IF2/.ERR2不允许单独汇编
expression too complex for .UNTILCXZ             .UNTILCXZ表达式太复杂
can ALIGN only to power of 2                    仅能对齐到2的幂
structure alignment must be 1, 2, 4, 8, or 16             结构对齐必须是1，2，4，8或16
expected               预定义 
incompatible CPU mode and segment size              不匹配的CPU模式和段尺寸
LOCK must be followed by a memory operation          LOCK指令必须跟在内存操作之后
instruction prefix not allowed                    不允许的命令前缀
no operands allowed for this instruction          指令没有操作数
invalid instruction operands                   无效的指令操作数
initializer magnitude too large for specified size        初始指定尺寸太大
cannot access symbol in given segment or group        在特定的段或类不能存取符号
operands have different frames                  操作数存在不同的结构
cannot access label through segment registers        在段寄存器中不能存取标记
jump destination too far                            跳转目标太远
jump destination must specify a label           跳转目标必须指定一个标记
instruction does not allow NEAR indirect addressing      指令不允许近间接寻址
instruction does not allow FAR indirect addressing      指令不允许远间接寻址
instruction does not allow FAR direct addressing       指令不允许远直接寻址
jump distance not possible in current CPU mode       跳转距离不适合当前CPU模式
missing operand after unary operator                 一元运算符之后找不到操作数
cannot mix 16- and 32-bit registers                 不能结合16位和32位寄存器
invalid scale value                                无效范围标准
constant value too large             连续标准太多
instruction or register not accepted in current CPU mode   当前CPU模式不认可的指令或寄存器
reserved word expected                      预期的保留字
instruction form requires 80386/486                 指令需要80386/486指示  
END directive required at end of file                        END指令必须在文件结尾
too many bits in RECORD                                      太多位在记录里
positive value expected                                      预期的明确的标准
index value past end of string                              索引标准在字符串结尾之后
count must be positive or zero                              计数必须是零或明确的
count value too large                                        计数标准太多
operand must be relocatable                                  操作数必须是转移表
constant or relocatable label expected                       预期的转移表或连续的
segment, group, or segment register expected                   预期的段，类型或段寄存器
segment expected                                                预期的区段
invalid operand for OFFSET                                    OFFSET操作数无效
invalid use of external absolute                             由于完全外部的使用无效
segment or group not allowed                               区段或类型不允许
cannot add two relocatable labels                         不能增加双重转移表标记
cannot add memory expression and code label                  不能增加内存表达式和代码标记

简介

顾名思义，对话框完成的是“对话”功能，应用程序一般建立一个主窗口用做工作界面，大部分的工作分在主窗口的客户区完成，但程序往往需要和用户交互，如输入参数和输入文本等，这些界面不必要全部放在主窗口中，习惯的做法是通过选择菜单项弹出一个窗口，然后在这个窗口中完成对话，这个窗口就是“对话框”，对话框中的按钮、文本框和图标等称为“子窗口控件”。

为了提示用户，习惯于在会引出对话框的菜单项后面加上省略号。如“文件”菜单中的“另存为…”表示会引出一个选择文件名的对话框，所以“另存为”3个字后面加了个省略号。对话框最典型的例子就是写字板“查找”菜单弹出的窗口以及IE浏览器中选择“Internet 选项”菜单项弹出的设置窗口。

1、对话框的类型

对话框分两类：modal对话框和modeless对话框，翻译成中文就是“模态的”和“非模态的”（也有的地方翻译成“模式的”和“非模式的”，Visual FoxPro中文版式就是这样），它们之间的区别在于是否允许用户在不同窗口间进行切换：当显示非模态对话框时，用户可以随意在这个对话框和其它窗口之间切换；而显示一个模态对话框时，用户在关闭对话框之前不允许切换到同一程序的其它窗口中，但可以切换到其他程序的窗口中；如果显示的是操作系统所属的模态对话框（即“系统模态的”），则切换到其他任何程序的窗口都是不允许的。

Windows在资源文件中定义对话框，然后在程序中利用这个模板创建对话框，模态对话框和非模态对话框的资源定义是相同的，只是创建时调用的函数不同而已。

2、对话框的工作原理

很明显，对话框和普通窗口之间有很多相似之处，实际上对话框就是基于窗口的，对话框的窗口风格使用的就是普通窗口的风格定义，对话框也有一个类似于窗口过程的对话框过程，但对话框和普通窗口在实现上又有很多不同之处，模态对话框和非模态对话框的实现也是不同的。普通的窗口在建立之前需要用RegisterClass注册一个窗口类，然后用CreateWindow建立窗口，建立窗口所需的参数如窗口风格、大小位置和窗口过程地址等由窗口类以及CreateWindow中的参数共同提供。

建立对话框的时候并不使用CreateWindow函数，取而代之，建立模态对话框的函数是DialogBoxParam，建立非模态对话框的函数是CreateDialogParam，调用这两个函数创建对话框窗口之前不需要注册对话框的窗口类。

Windows在这两个函数的内部调用CreateWindowEx来建立对话框，使用的风格、大小和位置参数取自资源中定义的对话框模板，使用的窗口类则是Windows内部定义的类，如果读者用一些工具去查看，会发现类名是“#32770”之类的字符串，在这个名字奇特的窗口类中，窗口过程被定义到了Windows内部的“对话框管理器”代码中，Windows在这里处理对话框的大部分消息，如维护客户区的刷新，键盘接口（按Tab键在不同子窗口之间切换、按回车调用默认按钮等），对话框管理器在初始化对话框时会根据对话框模板中定义的子窗口控件建立对话框中所有的子窗口。

用户程序中的对话框过程是由对话框管理器调用的，在处理消息前，对话框管理器会先调用用户指定的对话框过程，再根据对话框过程的返回值决定是否处理它们。

Windows对模态对话框，和非模态对话框的处理有些不同。在创建并显示模态对话框后，Windows会为它在内部建立一个消息循环，在这个消息循环中把消息发送给对话框管理器，对话框管理器在处理消息的过程中会调用用户定义的对话框过程，当对话框关闭的时候，Windows退出内建的消息循环，并从DialogBoxParam函数返回。而对于非模态对话框，CreateDialogParam函数在创建对话框后直接返回，对话框窗口的消息是通过用户程序中的消息循环派送的。

由于模态对话框的特征，使得用户它来做小程序的主窗口非常方便，因为用一句DialogBoxParam函数就可以搞定了，既不用注册窗口类，也不用写消息循环，这对看到创建窗口的几十句代码就烦的读者来说可真是个福音，这种方法的缺点就是无法使用依赖消息循环来完成的功能，很明显，加速键就不能用了。

对话框的资源定义

对话框资源定义的语法

在资源脚本中定义对话框的语法是：

       对话框ID      DIALOG        [DISCARDABLE] x坐标, y坐标, 宽度, 高度

       [可选属性]

       BEGIN

                     子窗口控件

                     …

       END

对话框中的子窗口控件语句定义在BEGIN/END（当然也可以以用花括号）之中，在这之前，可以定义对话框的一些可选属性，每种属性单独用一行定义，常用的可选属性如下表所示：

                     对话框的可选属性

本节例子程序的资源脚本文件Dialog.rc定义如下：

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

#include    <resource.h>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

#define         ICO_MAIN        0x1000      //图标

#define         DLG_MAIN        1

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

ICO_MAIN        ICON            "Main.ico"

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

DLG_MAIN        DIALOG 50, 50, 113, 64

STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU

CAPTION "对话框模板"

FONT 9, "宋体"

{

    ICON    ICO_MAIN, -1, 10, 11, 18, 21

    CTEXT   "简单的对话框例子\n 用Win32ASM编写", -1, 36, 14, 70, 19

    DEFPUSHBUTTON "退出(&X)", IDOK, 58, 46, 50, 14

    CONTROL "", -1, "Static", SS_ETCHEDHORZ | WS_CHILD | WS_VISIBLE, 6, 39, 103, 1

}

脚本文件中除了定义图标之外，另外还定义了一个ID为1的对话框，对话框中有4个子窗口控件，分别是图标、文本、按钮和一个横线，按钮的ID为IDOK，其他的子窗口控件由于是静态控件，不会向对话框过程发送命令，所以ID就设置为-1，这些控件的具体用法将在后面的内容中详细介绍。

定义中还指定了一些可选属性，STYLE语句定义了对话框窗口的风格，CAPTION语句把标题栏定义为“对话框模板”，FONT语句指定了对话框使用的字体是大小为9的宋体。

对话框的位置为（50，50），大小为宽113单位，高64单位，读者可能已经注意到：这个对话框的大小好像比宽113像素、高64像素的窗口要大，事实上的确如此，这也正是大小是“单位”而不是“像素”的原因。对话框的位置、大小以及所有子窗口控件的度量单位是根据系统字体的大小来决定的，横向（x坐标和宽度）每单位为系统字符平均宽度的1/4，纵向（y坐标和高度）每单位为字符平均高度的1/8，由于系统字体的字符高度大致为宽度的两倍，所以虽然这种计算方法有些费解，但横向和纵向的数值在视觉上还是成比例的，但和以“像素”为单位在数值上肯定是不同的。如果读者一定要知道这个值换算成像素后是多少，那么可以用GetDialogBaseUnits函数来获取系统字体的高度和宽度再进行计算。

当一些英文版的软件在中文Windows上运行的时候，对话框中有些文本往往被砍掉了尾巴，原因就是这些程序是在英文Windows上调试的，文本框的尺寸是以英文Windows系统字符的大小来度量的，到了其他语言的Windows上后，系统字符的大小可能改变，对话框的大小也随着改变，结果就是原来刚好的宽度可能会变得不够，这也算是对话框尺寸度量方法的缺点吧！

使用文本编辑器直接书写对话框脚本定义不是很直观，所以在创建对话框资源时最好使用可视化的资源编辑器，如VC++或ResourceWorkshop等。

在子窗口控件的ID定义中有两个特殊的ID值——IDOK和IDCANCEL，在Resource.h中它们的值定义为1和2，IDOK是默认的“确定”ID，IDCANCEL是默认的“取消”ID。如果一个按钮的ID是IDOK，当焦点没有停留在其他按钮上的时候，在任何地方按下回车键就相当于按下了这个按钮，而按下Esc键的时候，就相当于按下了ID为IDCANCEL的按钮。

2、Tab停留位和组

对话框中可以定义多个子窗口控件，有的了窗口控件可以拥有输入焦点（如按钮、文本框与组合框等），有些则不能（如图标与文本等），当对话框中有多个允许拥有输入焦点的子窗口控件时（有WS_TABSTOP风格），用户可以用Tab键将输入焦点切换到下一个有WS_TABSTOP风格的子窗口控件上，也可以用Shift+Tab键切换到上一个，Tab键切换的顺序就叫做Tab停留位。

Tab停留位并不是系统根据子窗口控件的坐标位置自动排列的，而是按照子窗口控件在资源脚本文件中的定义顺序来排列的，所以读者在定义的时候最好根据子窗口控件的位置适当排列语句的先后，以免按动Tab键切换的时候焦点上下左右无规则的地跳来跳去。如果使用可视化的资源编辑器，那么菜单中一般会有“Tab停留位”菜单项，在编辑完成后也要进到这个菜单项中设置一下，资源编辑器会根据设置调整rc文件中定义语句的先后顺序。

对话框中往往有一些排列在一起的同类子窗口控件，如几个单选钮，几个单选钮之间的选中标记是互斥的，在对话框的其他地方可能又有一组互斥的单选钮用来代表其他功能，在对话框中规定所有的单选钮都是互斥的显然不现实，解决的方法就是将不同的子窗口控件“分组”，这就是“组”的含义。使用中可以选择一些子窗口控件定义WS_GROUP属性，两个有WS_GROUP属性的子窗口控件之间的所有子窗口控件同属同一组。

使用对话框

使用对话框的代码分为创建部分和对话框过程两个部分，完整代码如下所示：

                .386

                .model flat, stdcall

                option casemap :none

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; Include 文件定义

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

include         windows.inc

include         user32.inc

includelib      user32.lib

include         kernel32.inc

includelib      kernel32.lib

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; Equ 等值定义

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

ICO_MAIN        equ         1000h       ;图标

DLG_MAIN        equ         1           ;对话框

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; 数据段

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                .data?

hInstance       dd      ?

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; 代码段

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                .code

_ProcDlgMain    proc    uses ebx edi esi hWnd, wMsg, wParam, lParam

                mov     eax, wMsg

                .if     eax == WM_CLOSE

                        invoke EndDialog, hWnd, NULL

                .elseif eax == WM_INITDIALOG

                        invoke LoadIcon, hInstance, ICO_MAIN

                        invoke SendMessage, hWnd, WM_SETICON, ICON_BIG, eax

                .elseif eax == WM_COMMAND

                        mov     eax, wParam

                        .if     eax == IDOK

                                invoke EndDialog, hWnd, NULL

                        .endif

                .else

                        mov     eax, FALSE

                        ret

                .endif

                mov     eax, TRUE

                ret

_ProcDlgMain    endp

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

start:

                invoke GetModuleHandle, NULL

                mov     hInstance, eax

                invoke DialogBoxParam, hInstance, DLG_MAIN, NULL, offset _ProcDlgMain, NULL

                invoke ExitProcess, NULL

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                end     start

读者可以发现，相对于普通窗口的使用，对话框的使用显得特别简单，最明显的区别在于主程序中的一大堆代码不见了，换成了一个DialogBoxParam语句。

1、创建模态对话框

创建模态对话框的函数是DialogBoxParam，它的使用方法是：

       invoke     DialogBoxParam, hInstance, lpTemplateName, hWndParent, \

                     lpDialogFunc, dwInitParam

函数的各参数说明如下：

·hInstance和lpTemplateName——函数从hInstance参数指定的模块中装入lpTemplateName参数指定的对话框资源，然后显示对话框窗口。例子程序中的lpTemplateName参数用的就是我们定义的DLG_MAIN。

·hWndParent——对话框的父窗口，对话框关闭之前将无法切换到父窗口所属的其它窗口中，例子中用对话框做主窗口，所以父窗口句柄是NULL，在其他程序中使用时，这个参数设置为主窗口的句柄。

·lpDialogFunc——指定了对话框过程的地址，例子程序中是_ProcDlgMain。

·dwInitParam——当做WM_INITDIALOG消息的lParam传给对话框过程，读者可以用它来做自定义的用途。

要结束模态对话框，必须在对话框过程的WM_CLOSE消息中使用EndDialog函数：

       invoke     EndDialog, hDlg, dwResult

不能使用通常的DestroyWindow函数，参数中的hDlg就是对话框窗口的句柄，dwResult参数是退出时的返回值，这个值最后由DialogBoxParam函数返回到主程序中。

2、创建非模态对话框

创建非模态对话框的函数是CreateDialogParam，它的参数定义和DialogBoxParam一模一样：

       invoke     CreateDialogParam, hInstance, lpTemplateName, hWndParent, \

                                                 lpDialogFunc, dwInitParam

       mov        hDlg, eax

CreateDialogParam和DialogBoxParam在使用中有几个不同点：

·CreateDialogParam在创建对话框后，会根据对话框模板的风格是否定义了WS_VISIBLE来决定是否显示对话框窗口。如果定义了则显示，没有的话，则程序需要在以后自行调用ShowWindow来显示它；而DialogBoxParam函数不管是否定义了WS_VISIBLE风格都会显示对话框。

·CreateDialogParam在建立对话框窗口后直接返回，返回值是对话框窗口的句柄；而DialogBoxParam要在对话框关闭后才返回，返回值是EndDialog中的dwResult参数。

·在CreateDialogParam返回后，应用程序在自己的消息循环中获取对话框消息，所以如果要用非模态对话框做程序的主窗口，消息循环的代码还是要写的；而DialogBoxParam是使用Windows为它内建的消息循环。

·关闭非模态对话框使用DestroyWindow函数，注意在这里不要用EndDialog函数。

3、对话框过程

Windows在“对话框管理器”——也就是为对话框内建的窗口过程中处理对话框消息，在处理前会首先调用用户定义的对话框过程，程序可以在这里选择是否自行处理某些消息。读者在理解时可以把“对话框管理器”看成是对话框的“DefWindowProc”，凡是自己不想处理的消息都由它来处理。

和窗口过程一样，对话框过程是一个“回调”子程序，它由程序定义，Windows来调用，模态对话框和非模态对话框的对话框过程是一样的。

对话框过程和窗口过程的输入参数是一样的，也是：

       DialogProc     proc        hwndDlg, uMsg, wParam, lParam

在程序里面一般编写对话框过程的分支结构如下：

_ProcDlgMain        proc        uses ebx edi esi hWnd, wMsg, wParam, lParam

                            mov        eax, wMsg

                            .if           eax == WM_CLOSE

                                          ;模态对话框用EndDialog关闭

                                          ;非模态对话框用DestroyWindow关闭

                            .elseif      eax == WM_INITDIALOG

                                          ;初始化代码

                            .elseif      eax == WM_COMMAND

                                          ;子窗口控件发送的消息

                                          ;wParam的低16位为子窗口控件ID

                            .elseif      eax == WM_XXXX

                                          ;处理其他需要处理的消息

                            .else

                                          mov        eax, FALSE

                                          ret

                            .endif

                            mov        eax, TRUE

                            ret

_ProcDlgMain        endp

注意对话框过程和普通的窗口过程在使用上有以下区别：

·窗口过程对应于不同的消息有各种不同含义的返回值，而对话框过程返回BOOL类型的值，返回TRUE表示已经处理了某条消息，返回FALSE表示没有处理。“对话框管理器”代码会根据返回值决定是否继续处理某一条消息（唯一的例外是WM_INITDIALOG消息）。

·对于不处理的消息，不需要调用DefWindowProc来处理，这事情由“对话框管理器”来做。

“对话框管理器”不会把WM_CREATE消息转发给对话框过程，取而代之，它会以WM_INITDIALOG消息来调用对话框过程，程序可以在这里进行一些初始化的操作，WM_INITDIALOG消息的返回值有点特殊，如果程序想自行设置输入焦点，那么可以用SetFocus函数把输入焦点设置到需要的子窗口控件上，然后返回FALSE；如果返回TRUE的话，那么Windows会自动将输入焦点设置到第一个有WS_TABSTOP的子窗口控件上。

对话框过程在WM_COMMAND消息中处理子窗口控件发送的命令，当用户在对话框中按下了按钮，输入文字或选择复选框等操作时，子窗口控件会向对话框过程发送WM_COMMAND消息，wParam是子窗口控件的ID，如例子程序中处理“退出”按钮的消息，在里面用EndDialog函数关闭对话框。

对话框窗口的标题栏上默认没有定义图标，如果要像普通窗口一样显示一个图标，那么可以像例子程序中那样，在WM_INIDIALOG中用WM_SETICON消息来设置。

位图（Bitmap）是Windows操作系统存储图像的方式，图像中的每个像素对应存储器中的一个或多个数据位，如单色位图每个像素对应1位，16色位图每个像素对应4位，256色为8位，全彩色为24位等，所有的像素数据按照一行行的顺序排列在存储器中，每个像素对应的位数称为颜色深度。

位图的优越之处是操作的速度很快，计算机的屏幕显示是由硬件从视频缓冲区中的数据映射的，向视频缓冲区中拷贝数据就可以直接将图像显示在屏幕上，所以以位图的方式存储像素，显示图形的时间几乎就是向视频缓冲区拷贝数据的时间。

位图的不便之处一是尺寸问题：由于位图是不压缩的，它占用的空间很大，一个1024x768像素24位色的图像的大小为1024x768x3字节，达2.3MB；二是位图的缩放问题，读者都知道矢量和位图之间的关系，矢量图形（现在网上最流行的Flash就是矢量格式的）可以无限制缩放而不变形，因为它是根据矢量实时计算出像素数据的，而位图缩放后要对原来的像素数据进行插值计算，不可避免地会有失真。

在使用Windows的位图之前，必须搞清楚几个概念：位图、设备无关位图和位图文件。

单纯意义上的“位图”指的就是存放在内存中、可以马上使用的位图，它的颜色深度总是对应当前设备（如屏幕或打印机等）的颜色深度，不和具体的设备对应，位图数据是没有意义的，因为无法知道要把数据中的多少位解释成一个像素。

对于存放在磁盘上或别的地方的位图数据来说，它的颜色深度有可能和屏幕颜色深度不同，为了准确描述它的颜色信息，必须有像素数据的属性说明以及色彩表，在使用这个位图的时候，可以根据这些信息将像素数据转换到需要的颜色深度。色彩表和位图数据合在一起就叫做设备无关位图（DIB），因为它转换后可以用在不同颜色深度的设备上。Windows有函数专门用来处理DIB。使用DIB唯一的问题是当将高颜色数的DIB转换到低颜色数的设备上时，由于色彩只能被转换成设备所能表示的最相近的颜色，所以可能会有很大的颜色失真。

DIB可以存放在磁盘上的位图文件中，位图文件一般以bmp为扩展名，它的内容包括一个bitmap文件头和DIB数据，bitmap文件头可以用来验证整个文件的有效性。所以简单地讲，DIB是位图数据的超集，位图文件又是DIB的超集。

Windows支持的图形文件格式只有bmp，ico与cur等几种，可以广泛用在GDI操作中的只有bmp文件，其他格式文件如jpg与tif等都是不能直接应用的，要使用这些文件，必须在代码中将它们转换到位图格式以后才行，所以要编写一个仅支持bmp的图片浏览器是很简单的，而要支持其他格式麻烦就大了，仅jpg格式的解码就是个很复杂的问题！

在资源中定义位图

Windows对bmp文件的支持有两种方法，一种是打开bmp文件读入DIB部分的数据，然后用函数将DIB数据转换到位图数据；另一种方法就是在资源文件中用和ico，cur文件类似的方法定义位图资源，然后在程序中装入后使用。

在资源脚本文件中定义位图资源的语法是：

       位图ID          BITMAP        [DISCARDABLE]         位图文件名

在程序中可以用LoadBitmap函数装入位图资源：

       invoke     LoadBitmap, hInstance, lpBitmapName

       .if           eax

                     mov        hBitmap, eax

       .endif

LoadBitmap函数返回一个位图句柄，在程序退出的时候，位图句柄必须用DeleteObject函数释放。对位图资源的大部分操作涉及GDI的内容，以后再详细学习。

在不同应用程序之间的窗口中可以互发消息，方法是通过SendMessage或者PostMessage函数，它们的用法如下：

       invoke PostMessage, hWnd, Msg, wParam, lParam

       invoke SendMessage, hWnd, Msg, wParam, lParam

对于不同的Msg，wParam和lParam的含义是不同的，如对于WM_SETTEXT是：

       wParam = 0;                                             //未定义，必须为0

       lParam = (LPARAM)(LPCTSTR)lpsz;         //要设置的字符串地址

想一想就会发现一个问题：Windows中不同应用程序的地址空间是隔离的，全市程序1要用SendMessage调用程序2所属窗口的窗口过程，但程序2窗口过程的代码并不在程序1的地址空间中，那么SendMessage如何调用它呢？其实很简单，当程序1调用SendMessage函数的时候，Windows会先保存wParam和lParam参数并等待，等轮到程序2的时间片的时候再去调用它的窗口过程，并把保存的wParam和lParam参数发给它，等窗口过程返回的时候，Windows记下返回值并等待程序1，这样程序1看上去就像自己直接在调用程序2的窗口过程一样。

但又一个问题出现了：Windows在做“牵线红娘”的时候传递了wParam和lParam以及返回值，如果参数指向一个字符串呢，比如说上面的WM_SETTEXT消息中的lParam指向一个字符串，假设程序1中lParam指向字符串的地址为xxxxxxxx，把这个地址传给程序2的时候，程序2不可能访问到程序1的地址空间，在程序2中xxxxxxxx指向的可能是其他内容，也可能是不可访问的，这又该如何处理呢？

写一个源程序实验一下，用一个程序向另一个程序的窗口发送WM_SETTEXT消息，然后在另一个程序中将接收到的WM_SETTEXT消息的参数显示出来。先来打造接收程序，首先拷贝一份FirstWindows的代码，然后在窗口过程的分支中加上以下代码：

       .elseif      eax == WM_SETTEXT

                     invoke     wsprintf, addr szBuffer, addr szReceive, lParam, lParam

                     invoke     MessageBox, hWnd, offset szBuffer, addr szCaptionMain, MB_ok

同时在数据段中加上下列定义：

       szCaptionMain       db    ‘Receive Messag’,0

       szReceive              db    ‘Receive WM_SETTEXT message’,0dh,0ah

                                   db    ‘param: %08x’, 0dh, 0ah

                                   db    ‘text: “%s”, 0dh, 0ah, 0

在这里，要提及Win32 API中一个很常用的函数wsprintf，这是一个字符串格式化函数，可以将数值按指定格式翻译成字符串，类似于C语言中的printf函数，它的原型是这样的：

       int    wsprintf (

                     LPTSTR        lpOut,            //输出缓冲地址

                     LPCTSTR      lpFmt             //格式化串地址

                     …                                       //变量列表

       );

变量列表的数目由格式化字符串规定，wsprintf处理格式化字符串，遇到普通的字符则直接拷贝到输出，遇到%字符则代表有一个变量，%后面不同的字母表示不同的输出格式，如%d表示输出为整数，%x表示输出为16进制，%s表示输出字符串等。

%符号和表示格式的d，x和s等字母间可以用数字来指定输出时占用的位长，这时输出的位长不够时函数会用空格填齐。另外，表示位长的数字前可以加0来表示填齐时用“0”而非空格，如%08x表示输出为8位前面用0填齐的16进制数。

wsprintf是Win32 API中唯一一个参数数量不定的函数，使用wsprintf函数的时候，参数的数量取决于格式化字符串中用%号指定的数量，变量列表的数目和格式化串中的%格式一定要一一对应。这里szReceive中有两个%号定义，那么后面就要额外跟两个参数：

       invoke     wsprintf, addr szBuffer, addr szReceive, lParam, lParam

这条语句将lParam的数值以及lParam的字符串按照szReceive格式化串定义的格式转换，并将结果存放到szBuffer中，然后程序将szBuffer中的内容在一个消息框中显示出来：

       invoke     MessageBox, hWnd, offset szBuffer, addr szCaptionMain, MB_OK

执行程序写好了，现在写一个发送程序，如下所示：

                .386

                .model flat, stdcall

                option casemap:none

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

include         windows.inc

include         user32.inc

includelib      user32.lib

include         kernel32.inc

includelib      kernel32.lib

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                .data

hWnd            dd          ?

szBuffer        db          256 dup (?)

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                .const

szCaption       db          'SendMessage',0

szStart         db          'Press OK to start SendMessage, param:%08x!',0

szReturn        db          'SendMessage returned!',0

szDestClass     db          'MyClass',0

szText          db          'Text send to other windows',0

szNotFound      db          'Receive Message Window no found!',0

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                .code

start:

                invoke FindWindow,addr szDestClass, NULL

                .if     eax

                        mov hWnd,eax

                        invoke wsprintf, addr szBuffer, addr szStart, addr szText

                        invoke MessageBox, NULL, offset szBuffer, offset szCaption, MB_OK

                        invoke SendMessage, hWnd, WM_SETTEXT, 0, addr szText

                        invoke MessageBox, NULL, offset szReturn, offset szCaption, MB_OK

                .else

                        invoke MessageBox, NULL, offset szNotFound, offset szCaption, MB_OK

                .endif

                invoke ExitProcess, NULL

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

end start

在这个程序中首先用FindWindow函数找到接收窗口的窗口句柄，FindWindow函数的使用方法是：

       invoke     FindWindow, lpClassName, lpWindowName

       .if           eax

                     mov hWin, eax

       .endif

两个参数都指向字符串lpClassName指向需要寻找的窗口的窗口类，lpWindowName指向需要寻找窗口的窗口标题，如果目标窗口存在的话，函数的返回值是找到的窗口句柄，否则函数返回0。

用接收窗口的窗口类当做参数寻找窗口，如果没有找到则显示“Receive Message Window not found”，找到的话则把“Text send to other windows”字符串的地址当做WM_SETTEXT消息的参数用SendMessage发送给接收窗口。

好！，现在发送开始，首先执行Receive.exe，窗口出来了，然后执行Send.exe，屏幕上出现一个对话框：Press OK to start SendMessage, param:00402072，表示在Send程序中字符串的地址是00402072h，现在单击“确定”按钮执行SendMessage函数，单击后对话框消失，但接收程序显示出了一个对话框，内容为：

       Receive WM_SETTEXT message

       param: 0012fflc

       text: “Text send to other windows”

可见字符串是正确地传了过来，但地址却不是发送程序的00402072h，这是为何？

答案是Window做“红娘”做到底，它拷贝了WM_SETTEXT消息的lParam参数指向的字符串，并在接收程序的地址空间中开了一块内存放上这个字符串，然后把新的地址值当做lParam传给接收程序，毕竟在WM_SETTEXT消息中，lParam的数值是多少并不重要，重要的是它指向的字符串是否正确。

最后，单击接收程序中的“确定”按钮，发送程序马上弹出一个消息框并显示：SendMessage returned，这是SendMessage函数告诉我们：我回来了！

其实Windows在处理SendMessage和PostMessage的时候要检查消息的类型，并对不同的消息做不同的处理，当消息的参数是一个指针的时候，Windows要把指针指向的内容复制到缓冲区，以便在两个程序的地址空间中传递。

注意：在用户自定义的消息中（WM_USER等）不要在消息参数中传递指针，这只会引发非法访问内存，因为Windows不知道用户的意图，它只会把lParam和wParam当两个普通的数值传递，而不会帮用户把指针指向的内容复制到一个缓冲区中。

回想DOS时代的计算屏幕，在1990年Windows 3.0推出之前，计算机的屏幕一直使用文本模式，黑洞洞的底色上漂浮着白色的小字。对DOS程序来说，屏幕是唯一的，上面有光标表示输入字符的位置，程序运行后往屏幕输出一些信息，退出时输出的信息就留在了屏幕上，然后是第二个程序重复这个过程，当屏幕被写满的时候，整个屏幕上卷一行，最上面一行被去掉，然后程序在最底下新空出来的一行上继续输出。

对于一个单任务的操作系统，这种方式是很合理的，因为平时使用传真机或打字机就是用上卷的方式来容纳新的内容的。但是如果是多任务呢？两个程序同时往屏幕上写东西或者两个人同时往打字机上打字，那么谁都看不懂混在一起的是什么。DOS下的TSR（内存驻留）程序是多个程序同时使用一个屏幕的例子，但实质上这并不是多任务，而是TSR将别的程序暂时挂起，挂起的程序不可能在TSR执行期间再向屏幕输出内容，TSR在输出自己的内容之前必须保存屏幕上显示的内容，并在退出的时候把屏幕恢复原来的样子，否则挂起的程序并不知道屏幕已经被改变，在这个过程中，DOS不会去干预中间发生的一切。

Windows是多任务的操作系统，可以同时运行多个程序，同样，各个程序在屏幕上的显示不能互相干扰，而且，多个程序可以看成是“同时”运行的，在后台的程序也可能随时向屏幕输出内容，这中间的高度是由Windows完成的。Windows采用的方法是给程序一块矩形的屏幕空间，这就是窗口。应用程序通过Windows向属于自己的窗口显示信息，Windows判断该窗口是不是被别的窗口挡住，并把没有挡住的部分输出到屏幕上，这样屏幕上显示的东西就不会互相覆盖而乱套。对于应用程序来说，它只需认为窗口就是自己拥有的显示空间就可以了。

窗口和程序的关系

既然不同窗口的内容就是不同程序的输出，那么一个窗口就是一个程序吗？反过来，一个程序就是一个窗口吗？

答案是否定的，一个窗口不一定就是一个程序，它可能只是一个程序的一部分。一个程序可以建立多个顶层窗口，如Windows的桌面和任务栏都是顶层窗口，但它们都属于“文件管理器”进程，所以并不是一个窗口就是一个程序的代表。Windows的窗口采用层次结构，一个窗口中可以建立多个子窗口，如窗口中的状态栏，工具栏，对话框中的按钮，文本输入框与复选框等都是子窗口。子窗口中还可以建立下一级子窗口，如Word工具栏上的字体选择框。

反过来，运行的程序并非一定就是窗口，比如悄悄在后台运行的木马程序就不会显示一个窗口向用户报告它在干什么。在Windows NT下用“任务管理器”查看，进程的数量比屏幕上的窗口多得多，意味着很多的运行程序并没有显示窗口。如果一个程序不想和用户交互，它可以选择不建立窗口。

所以本章的标题“第一个窗口程序”，指学习编写第一个以标准的窗口为界面的程序，而不是泛指Windows程序。如果要写的Win32程序不是以窗口为界面的，如控制台程序等，就不一定采用本章中提及的以消息驱动的程序结构。

虽然以窗口为界面的程序并不是所有Windows程序的必须选择，但绝大部分的应用程序是以这种方式出现的，从操作系统的名称“Windows”就可以看出这一点，了解窗口程序就是相当于在了解Windows工作方式的基础。

窗口界面

大部分的窗口看上去都是大同小异。

典型的窗口，即Windows附带的写字板程序窗口。

窗口一般由屏幕上的矩形区域组成，不同的窗口可能包括一些相同的组成部分，如标题栏、菜单、工具栏、边框和状态栏等，每个部分都有自己固定的行为模式：

·窗口边框：窗口的外沿就是窗口边框，用鼠标按住边框并拖动可以调整窗口的大小。

·标题栏：窗口的最上面是标题栏，用鼠标按住标题栏拖动可以移动窗口，双击标题栏则将窗口最大化或从最大化的状态恢复。通过标题栏的颜色可以区分窗口是不是活动窗口，同时标题栏列出了应用程序的名称。

·菜单：标题栏下面是菜单，单击菜单会弹出各种功能选择。

·工具栏：菜单的下面是工具栏，工具栏上用图标的方式列出最常用的功能，相当于菜单的快捷方式。

·图标和最小化、最大化与关闭按钮：图标位于标题栏的左边，三个控制按钮则位于标题栏的右边。单击图标会弹出一个系统菜单，双击图标则相当于按下了关闭按钮。最小化、最大化按钮用来控制窗口的大小。

·状态栏：位于窗口的最下面，用来显示一些状态信息。

·客户区：窗口中间用来工作或输出的区域，叫做窗口的客户区，把窗口看做是一张白纸的话，客户区就是白纸中真正用来写东西的区域，程序在这里和用户进行交互。

·滚动条：如果客户区太小不足以显示全部内容，右边或底部可能还有滚动条，拖动它可以滚动窗口的客户区，以便看到其他的内容。

虽然大部分的窗口看上去都差不多，但并不是每个窗口都有这些东西，也许有的窗口就没有图标和最小化、最大化框，有的没有工具栏或状态栏，有的没有标题栏，而有的就干脆是个奇怪的形状，如Office帮助中助手，那些小狗小猫都些不折不扣的窗口，Windows的桌面和桌面下面的任务栏也都是窗口，就连屏幕保护的黑屏幕也是一个大小为整个屏幕、没有标题栏和边框的窗口！

一致的窗口形状和行为模式为Windows用户提供了一致的用户界面，几乎所有的窗口程序都在菜单的第一栏设置有关文件的操作和退出功能、最后一栏设置程序的帮助，相同的功能在工具栏上的图标也是大同小蒸发量的，用户可以不再像在DOS下那样，对不同的程序需要学习不同的界面，用户自从学会使用第一个软件起，就基本学会了所有Windows软件的使用模式，而且可以通过相似的菜单、工具栏等来发掘程序的新功能。窗口的菜单和客户区则是最个性化的东西，菜单随程序的不同而不同，而客户区则是窗口程序的输出区域，不同的程序在客户区内显示了不同的内容。

窗口程序是怎么工作的

窗口程序的运行模式

对程序员来说，要了解的不仅是用户可以看到的部分，还必须了解窗口底下的东西，了解用怎样的程序结构来实现窗口的行为模式。

DOS程序员熟悉的是顺序化的、按过程驱动的程序设计方法。程序有明显的开始、明显的过程和明显的结束，由程序运行的阶段来决定用户该做什么。而窗口程序是事件驱动的（再次提醒：这里是“窗口程序”，而不是“Windows程序”，因为和窗口有关的程序者事件驱动的，其他的Windows程序可能并不这样工作，如控制台程序的结构还是同DOS程序一样是顺序化的，但与窗口相关的Windows程序占了绝大多数，所以大部分的书籍中讲到Windows程序就认为是事件驱动的程序），用户可能随时发出各种消息，如操作的过程中觉得窗口不够大了，就马上会拖动边框，程序必须马上调整客户区的内容以适应新的窗口大小；用户觉得想先干别的事情，可能会把窗口最小化，关闭按钮也有可能随时被按下，这意味着程序要随时可以处理退出的请求。如果非要规定干活的时候不能移动窗口与调整大小，那么这些窗口就会呆在桌面上一动不动。

窗口程序在结构上和DOS程序有很大的不同，窗口程序实现大部分功能的代码应该呆在同一个模块——消息处理模块，这个模块可以随时应付所有类型的消息，只有这样才能随时响应用户的各种操作。

下面是地地道道的Win32汇编窗口程序：

FirstWindow源代码。

                .386

                .model flat,stdcall

                option casemap:none

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; Include 文件定义

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

include         windows.inc

include         gdi32.inc

includelib      gdi32.lib

include         user32.inc

includelib      user32.lib

include         kernel32.inc

includelib      kernel32.lib

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; 数据段

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                .data?

hInstance       dd      ?

hWinMain        dd      ?

                .const

szClassName     db      'MyClass',0

szCaptionMain   db      'My first Window!',0

szText          db      'Win32 Assembly, Simple and powerful!',0

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; 代码段

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                .code

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

; 窗口过程

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

_ProcWinMain    proc uses ebx edi esi, hWnd, uMsg, wParam, lParam

                local @stPs:PAINTSTRUCT

                local @stRect:RECT

                local @hDc

                mov eax,uMsg

;*************************************************************************

                .if     eax == WM_PAINT

                        invoke     BeginPaint,hWnd,addr @stPs

                        mov     @hDc,eax

                        invoke GetClientRect,hWnd,addr @stRect

                        invoke    DrawText,@hDc,addr szText,-1, \

                                addr @stRect, \

                                DT_SINGLELINE or DT_CENTER or DT_VCENTER

                        invoke     EndPaint, hWnd, addr @stPs

;***************************************************************************

                .elseif eax == WM_CLOSE

                        invoke     DestroyWindow,hWinMain

                        invoke     PostQuitMessage,NULL

;***************************************************************************

                .else

                        invoke     DefWindowProc,hWnd,uMsg,wParam,lParam

                        ret

                .endif

;***************************************************************************

                xor     eax,eax

                ret

_ProcWinMain    endp

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

_WinMain        proc

                local   @stWndClass:WNDCLASSEX

                local   @stMsg:MSG

                invoke     GetModuleHandle,NULL

                mov     hInstance,eax

                invoke     RtlZeroMemory,addr @stWndClass,sizeof @stWndClass

;**************************************************************************

; 注册窗口类

;**************************************************************************

                invoke     LoadCursor,0,IDC_ARROW

                mov     @stWndClass.hCursor,eax

                push    hInstance

                pop     @stWndClass.hInstance

                mov     @stWndClass.cbSize, sizeof WNDCLASSEX

                mov     @stWndClass.style, CS_HREDRAW or CS_VREDRAW

                mov     @stWndClass.lpfnWndProc, offset _ProcWinMain

                mov     @stWndClass.hbrBackground,COLOR_WINDOW + 1

                mov     @stWndClass.lpszClassName, offset szClassName

                invoke     RegisterClassEx, addr @stWndClass

;***************************************************************************

; 建立并显示窗口

;***************************************************************************

                invoke     CreateWindowEx, WS_EX_CLIENTEDGE, \

                        offset szClassName, offset szCaptionMain, \

                        WS_OVERLAPPEDWINDOW, \

                        100, 100, 600, 400, \

                        NULL, NULL, hInstance, NULL

                mov     hWinMain,eax

                invoke     ShowWindow,hWinMain,SW_SHOWNORMAL

                invoke     UpdateWindow,hWinMain

;**************************************************************************

; 消息循环

;**************************************************************************

                .while TRUE

                        invoke     GetMessage, addr @stMsg, NULL, 0, 0

                        .break     .if eax == 0

                        invoke     TranslateMessage, addr @stMsg

                        invoke     DispatchMessage, addr @stMsg

                .endw

                ret

_WinMain        endp

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

start:

                call    _WinMain

                invoke ExitProcess, NULL

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                end start

编译运行后，窗口出来了，对于这个窗口，用户可以拖动边框去改变大小、按标题栏上的按钮来最大化和最小化，当光标到边框的时候，会自动变成箭头，总之，这个窗口包括了一个典型窗口的所有特征。

接下来开始分析源代码，看了这三页多的源代码，第一个感觉是什么？是不是想撤退了？90%的人有同样的感觉，别急，过了这一关，Win32汇编的入门就成功了一半了，所以千万要挺住！有个振奋人心的消息是，这个程序是大部分窗口程序的模板，以后要写一个新的程序，把它拷贝过来再往中间添砖加瓦就是了，功夫一点都不白费。

先静下心来分析一下程序的结构，首先是注释，模式定义，include，.data数据段，.code代码段。

程序入口是start，然后执行了一下_WinMain子程序，完成后就是程序退出的函数ExitProcess，再看_WinMain的结构，前面是顺序下来的几个API调用：

GetMoudleHandle à RelZeroMemory à LoadCursor à RegisterClassEx à CreateWindowEx à ShowWindow à UpdateWindow

从名称上就能看出它们的用途，很明显，窗口是在CreateWindowEx处建立的，ShowWindow则是把窗口显示在屏幕上，这些代码是窗口的建立过程。

接下来，就是一个由3个API组成的循环了：

GetMessage à TranslateMessage à DispatchMessage

很明显，这是和消息有关的循环，因为API名称中都带有Message字样，如果退出这个循环，程序也就结束了，这个循环叫做消息循环。

设置_WinMain子程序并不是必须的，可以把_WinMain的所有代码放到主程序中，没有任何影响，之所以这样只是为将这里使用的变量定义成局部变量，这样可以方便移植。

看了程序的流程，似乎没有什么地方涉及窗口的行为，如改变大小和移动位置的处理等。

再看源程序，除了_WinMain，还有一个子程序_ProcWinMain，但除了在WNDCLASSEX结构的赋值中提到过它，好像就没有什么地方要用到这个子程序，起码在自己编写的源代码中没有任何一个地方调用过它。

再看ProWinMain，它是一个分支结构处理的子程序，功能是把参数uMsg取出来，根据不同的uMsg执行不同的代码，完了以后就退出了，中间也没有任何东西和主程序有关联。

第一个窗口程序就是由这么两个似乎是风马牛不相及的部分组成的，但它确实能工作，对于写惯了DOS汇编的程序员来说，这似乎不可理解。下面来看看这么一个陌生而奇怪的程序是如何工作的。

窗口程序的运行过程

在屏幕上显示一个窗口的过程一般有以下步骤，这就是主程序的结构流程：

1）得到应用程序的句柄（GetMoudleHandle）。

2）注册窗口类（RegisterClassEx）。在注册之前，要先填写RegisterClassEx的参数WNDCLASSEX结构。

3）建立窗口（CreateWindowEx）。

4）显示窗口（ShowWindow）。

5）刷新窗口客户区（UpdateWindow）。

6）进入无限的消息获取和处理的循环。首先获取消息（GetMessage），如果有消息到达，则将消息分派到回调函数处理（DispatchMessage），如果消息是WM_QUIT，则退出循环。

程序的另一半_ProcWinMain子程序是用来处理消息的，它就是窗口的回调函数（CallBack），也叫做窗口过程，之所以是回调函数是因为它是由Windows而不是我们自己调用的，我们调用DispatchMessage，而DispatchMessage再回过来调用窗口过程。

所有的用户操作都是通过消息来传给应用程序的，如用户按键，鼠标移动，选择了菜单和拖动了窗口等，应用程序中由窗口过程接收消息并处理，在例子程序中就是_ProcWinMain。窗口过程构造了一个分支结构，对应不同的消息执行不同的代码，所以一个应用程序中几乎所有的功能代码都集中在窗口过程里。

Windows在系统内部有一个系统消息队列，当输入设备有所动作的时候，如用户按动了键盘、移动了鼠标，按下或放开了鼠标等，Windows都会产生相应的记录放在系统消息队列里，每个记录中包含消息的类型、发生的位置（如鼠标在什么坐标移动）和发生的时间等信息。

同时，Windows为每个程序（严格地说是每个线程）维护一个消息队列，Windows检查系统消息队列里消息的发生位置，当位置位于某个应用程序的窗口范围内的时候，就把这个消息派送到应用程序的消息队列里。

当应用程序还没有来取消息的时候，消息就暂时保留在消息队里，当程序中的消息循环执行到GetMessage的时候，控制权转移到GetMessage所在的USER32.DLL中，USER32.DLL从程序消息队列中取出一条消息，然后把这条消息返回应用程序。

应用程序可以对这条消息进行预处理，如可以用TranslateMessage把基于键盘扫描码的按键消息转换成基于ASCII码的键盘消息，以后也会用到TranslateAccelerator把键盘快捷键转换成命令消息，但这个步骤不是必需的。

然后应用程序将处理这个消息，但方法不是自己直接调用窗口过程来完成，而是通过DispatchMessage间接调用窗口过程，Dispatch的英文含义是“分派”，之所以是“分派”，是因为一个程序可能建有不止一个窗口，不同的窗口消息必须分派给相应的窗口过程。当控制权转移到USER32.DLL中的DispatchMessage时，DispatchMessage找出消息对应窗口的窗口过程，然后把消息的具体信息当做参数来调用它，窗口过程根据消息找到对应的分支去处理，然后返回，这时控制权回到DispatchMessage，最后DispatchMessage函数返回应用程序。这样，一个循环就结束了，程序又开始新一轮的GetMessage。

窗口程序 à GetMessage(USER32.DLL) –> TranslateMessage(USER32.DLL) –> DispatchMessage(USER32.DLL) à 窗口过程 à USER32.DLL à 窗口程序

为什么要由Windows来调用窗口过程，程序取了消自以后自己处理不是更简便吗？事实上并非如此，如果程序自己处理消息的“分派”，就必须自己维护本程序所属窗口的列表，当程序建立的窗口不止一个的时候，这个工作就变得复杂起来；另一个原因是：别的程序也可能用SendMessage通过Windows直接调用你的窗口过程；第三个原因：Windows并不是把所有的消息都放进消息队列，有的消息是直接调用窗口过程处理的，如WM_SETCURSOR等实时性很强的消息，所以窗口过程必须开放给Windows。

应用程序之间也可以互发消息，PostMessage是把一个消息放到其他程序的消息队列中，目标程序收到了这个条消息就把它放入该程序的消息队列去处理；而SendMessage则越过消息队列直接调用目标程序的窗口过程，窗口过程返回以后才从SendMessage返回。

窗口过程是由Windows回调的，Windows又是怎么知道往哪里回调呢？答案是我们在调用RegisterClassEx函数的时候告诉了Windows。

Win32可执行文件的开发过程

在DOS下，生成一个可执行文件的步骤比较简单，用编译器将源程序编译为obj文件，再用链接器将obj文件链接成exe文件。

DOS可执行文件中的内容基本上是由源程序中所写的代码和数据定义转换而来的。

唯一的例外是带覆盖部分的exe文件，它在基本的exe文件的附加了一些自定义的数据，可执行部分的长度由文件头偏移0002h和0004h中的长度给出，后面就是附加上去的数据。这样，即使一个带覆盖的exe文件大小远远超过640KB，在DOS下也能运行。因为操作系统只装入真正的可执行部分，然后由程序自己去读取覆盖部分的数据。一些打包软件生成的奇大无比的自解压包就采用这种结构，可执行部分是解包代码，覆盖部分是被压缩的数据。DOS对可执行文件覆盖部分的数据格式并没有规定，它是程序员按自己的方式组织的。如果程序员愿意，也可以把这些数据单独放在另外一个文件中。

Win32可执行文件叫做PE文件。PE文件的基本结构和DOS可执行文件有很大的不同。它把程序中的不同部分分成各种节区（Section），其中可以有一个节区是放置各种资源的，如菜单、对话框、位图、光标、图标和声音等。虽然可以把资源部分理解成类似DOS可执行文件中的覆盖部分，但资源是Win32可执行文件的标准组成部分，而且是非常重要的组成部分。所以和DOS软件的开发过程相比，Win32软件的开发中多了一个创建资源文件的步骤。