【Windows】《深入浅出Windows API程序设计:编程基础篇》笔记-Chapter3-GDI绘图

Windows 2D 绘图 (GDI, GDI+, Direct2D) Windows 2D 绘图GDIGDI 函数GDI+GDI 和 GDI+ 的区别GDI+ 新特性Direct2D视觉效果demo GDI GDI 是 Graphics Device Interface 的缩写,含义是图形设备接口,它的主要任务是负责系统与绘图程序之间的信息交换,处理所有 Windows 程序的图形输出。 在 Windows 操作系统下,绝大多数具备图形界面的应用程序都离不开 GDI... 阅读详情

第3章 GDI绘图

GDI(Graphics Device Interface)是图形设备接口的英文缩写,处理Windows程序的图形和图像输出。程序员不需要关心硬件设备及设备驱动,就可以将应用程序的输出转换为硬件设备上的输出,实现应用程序与硬件设备的隔离,大大简化程序开发工作。在Windows操作系统中,图形界面应用程序通常离不开GDI,利用GDI所提供的众多函数可以方便地在屏幕、打印机以及其他输出设备上实现输出文本、图形等操作。本章知识点比较抽象,请耐心阅读。本章以后的内容都比较通俗易懂。

3.1 设备环境(DC)

设备无关性(也称设备独立性)是Windows的主要功能之一。应用程序可以在各种设备上进行绘制和打印输出,系统统一把所有外部设备都当作文件来看待,只要安装了它们的驱动程序,应用程序就可以像使用文件一样操纵、使用这些设备,GDI代表应用程序和设备驱动程序进行交互。为了实现设备无关性,引入了逻辑设备和物理设备这两个概念,在应用程序中,使用逻辑设备名称来请求使用某类设备,而系统在实际执行时,使用的是物理设备名称。设备无关性的支持包含在两个动态链接库中,第一个是GDI相关动态链接库,称为图形设备接口;第二个是设备驱动程序,设备驱动程序的名称取决于应用程序绘制输出的设备。GDI处理程序的绘图函数调用,将这些调用传递给设备驱动程序,设备驱动程序接收来自GDI的输入,将输入转换为设备命令,并将这些命令传递给对应的设备。

当程序在客户区中显示文本或图形时,我们通常称程序在“绘制”客户区。GDI在加载驱动程序后,准备设备进行绘制操作,例如选择线条颜色和宽度、画刷颜色和图案、字体名称、裁剪区域等。这些任务是通过创建和维护设备环境(DC)来完成的。DC是定义一组图形对象及其关联属性以及影响输出的图形模式的结构体。

与DC相关的部分图形对象及属性如表3.1所示。

表3.1

图形对象属性
画笔样式、宽度和颜色
画刷样式、颜色、图案和原点
字体字体名称、字体大小、字符宽度、字符高度、字符集等
位图大小(以字节为单位),尺寸(以像素为单位)、颜色格式、压缩方案等
路径形状
区域位置和尺寸

与大多数结构体不同,应用程序不能直接访问DC,而是通过调用各种函数间接地对DC结构进行操作。

Windows支持5种图形模式,允许应用程序指定颜色的混合方式、输出的位置、输出的缩放方式等。表3.2描述了存储在DC中的这些模式。

表3.2

图形模式描述
背景模式文本的背景色与现有窗口或屏幕颜色的混合方式等
绘图模式画笔、画刷的颜色与目标显示区域颜色的混合方式等
映射模式如何将图形输出从逻辑坐标映射到客户区、屏幕或打印机纸张
多边形填充模式如何使用画刷填充复杂区域的内部
拉伸模式当位图被放大或缩小时如何计算新位图

Windows有4种类型的DC,分别是显示设备DC、打印DC、内存DC(也称内存兼容DC)、信息DC,每种类型的DC都有特定的用途,如表3.3所述。

表3.3

DC类型描述
显示设备DC在显示器上进行绘图操作
打印DC在打印机或绘图仪上进行绘图操作
内存DC通常是在内存中的位图上进行绘图操作
信息DC获取设备环境信息

也就是说,通过设备环境,不仅可以在屏幕窗口进行绘图,也可以在打印机或绘图仪上进行绘图,还可以在内存中的位图上进行绘图。关于图形对象、图形模式以及各种DC类型,后面会分别进行详细介绍。

获取显示设备DC句柄

DC句柄是程序使用GDI函数的通行证,几乎所有的GDI绘图函数都需要一个DC句柄参数,有了DC句柄,便能随心所欲地绘制窗口客户区。

前面说过,当窗口客户区的部分或全部变为“无效”且必须“更新”时,例如改变窗口大小、最小化/最大化窗口、拖动窗口一部分到屏幕外再拖动回来时,应用程序将会获取到WM_PAINT消息。窗口过程的大部分绘图操作是在处理WM_PAINT消息期间进行的,可以通过调用BeginPaint函数来获取显示DC句柄。WM_PAINT消息的处理逻辑一般如下:

hdc = BeginPaint(hwnd, &ps);
// 绘图代码
EndPaint(hwnd, &ps);

BeginPaint函数的返回值就是需要更新区域的DC句柄hdc,BeginPaint返回的hdc对应的尺寸仅是无效区域,程序无法通过该句柄绘制到这个区域以外的地方。由于窗口过程每次接收到WM_PAINT消息时的无效区域可能不同,因此这个hdc值仅在当次WM_PAINT消息中有效,程序不应该保存它并把它,用在WM_PAINT消息以外的代码中。BeginPaint和EndPaint函数只能用在WM_PAINT消息中,因为只有这时才存在无效区域。BeginPaint函数还有一个作用就是把无效区域有效化,如果不调用BeginPaint,那么窗口的无效区域就一直不为空,系统会一直发送WM_PAINT消息。

窗口客户区中存在一个无效区域,这将导致Windows在应用程序的消息队列中放置一条WM_PAINT消息,即只有当程序客户区的一部分或全部无效时,窗口过程才会接收到WM_PATNT消息。Windows在内部为每个窗口都保存了一个绘制信息结构PAINTSTRUCT,这个结构保存着一个可以覆盖该无效区域的最小矩形的坐标和一些其他信息,这个最小矩形称为无效矩形。如果在窗口过程处理一条WM_PAINT消息之前,窗口客户区中又出现了另一个无效区域,那么Windows将计算出一个可以覆盖这两个无效区域的新的无效区域,并更新PAINTSTRUCT结构。Windows不会在消息队列中放置多条WM_PAINT消息。

WM_PAINT消息是一个低优先级的消息,Windows总是在消息循环为空的时候才把WM_PAINT消息放入消息队列。每当消息循环为空的时候,如果Windows发现存在一个无效区域,就会在程序的消息队列中放入一个WM_PAINT消息。前面说过“当程序窗口被首次创建时,整个客户区都是无效的”,因为此时应用程序尚未在该窗口上绘制任何东西。在WinMain中调用UpdateWindow函数时会发送第一条WM_PAINT消息,指示窗口过程在窗口客户区进行绘制,UpdateWindow函数将WM_PAINT消息直接发送到指定窗口的窗口过程,绕过应用程序的消息队列。现在大家应该明白,UpdateWindow函数只不过是让窗口过程尽快更新窗口,HelloWindows程序去掉UpdateWindow函数调用也可以正常运行。

如果应用程序在其他任何时间(例如在处理键盘或鼠标消息期间)需要进行绘制,可以调用GetDC或GetDCEx函数来获取显示DC句柄:

hdc = GetDC(hwnd);
// 绘图代码
ReleaseDC(hwnd, hdc);

GetDC函数返回的hdc对应指定窗口的整个客户区,通过GetDC函数返回的hdc可以在客户区的任何位置进行绘制操作,不存在无效矩形的概念,无效矩形和BeginPaint才是原配。当使用完毕时,必须调用ReleaseDC函数释放DC。对于用GetDC获取的hdc,Windows建议使用的范围限于单条消息内。当程序处理某条消息的时候,如果需要绘制客户区,可以调用GetDC函数获取hdc,但在消息返回前,必须调用ReleaseDC函数将它释放掉。如果在下一条消息中还需要用到hdc,那么可以重新调用GetDC函数获取。如果将GetDC的hwnd参数设置为NULL,那么函数获取的是整个屏幕的DC句柄。

现在我提出一个问题,相信读者是可以理解的,按下鼠标左键时将会产生WM_LBUTTONDOWN消息,鼠标在客户区中移动的时候会不断产生WM_MOUSEMOVE消息,这两个消息的lParam参数中都含有鼠标坐标信息。按住鼠标左键不放拖动鼠标会产生WM_LBUTTONDOWN消息和一系列WM_MOUSEMOVE消息,我们在窗口过程中处理WM_LBUTTONDOWN和WM_MOUSEMOVE消息,利用GetDC函数获取DC句柄进行绘图,连接WM_LBUTTONDOWN消息和一系列WM_MOUSEMOVE消息的这些坐标点就会形成一条线,但是当改变窗口大小、最小化然后最大化窗口、拖动窗口一部分到屏幕外再拖回来时,读者会发现这条线没有了,因为在需要重绘的时候Windows会使用指定的背景画刷擦除背景。如果希望这条线继续存在,就必须在WM_PAINT消息中重新绘制(可以事先保存好那些点)。如果可能,我们最好是在WM_PAINT消息中处理所有绘制工作。

GetWindowDC函数可以获取整个窗口的DC句柄,包括非客户区(例如标题栏、菜单和滚动条)。使用GetWindowDC函数返回的hdc可以在窗口的任何位置进行绘制,因为这个DC的原点是窗口的左上角,而不是窗口客户区的左上角,例如,程序可以使用GetWindowDC函数返回的hdc在窗口的标题栏上进行绘制,这时程序需要处理WM_NCPAINT(非客户区绘制)消息。

HDC GetWindowDC(_In_ HWND hWnd);

函数执行成功,返回值是指定窗口的DC句柄。同样的,完成绘制后必须调用ReleaseDC函数来释放DC。如果将参数hWnd参数设置为NULL,GetWindowDC函数获取的是整个屏幕的DC句柄。

Windows有4种类型的DC,关于其他类型DC句柄的获取,后面用到的时候再讲解。理论知识讲解太多实在乏味,接下来先实现一个输出(绘制)文本的示例,并实现滚动条功能。

3.2 绘制文本

GetSystemMetrics函数用于获取系统度量或系统配置信息,例如可以获取屏幕分辨率、全屏窗口客户区的宽度和高度、滚动条的宽度和高度等,该函数获取到的相关度量信息均以像素为单位:

int WINAPI GetSystemMetrics(_In_ int nIndex);

该函数只有一个参数,称之为索引,这个索引有95个标识符可以使用,可用的索引值及含义参见Chapter3\SystemMetrics\SystemMetrics\Metrics.h头文件,这是一个结构体数组,字段m_nIndex表示可用的索引值,字段m_pDesc表示含义。

例如GetSystemMetrics(SM_CXSCREEN)获取的是屏幕的宽度(CX表示 Count X,X轴像素数),SystemMetrics程序根据95个索引在客户区中输出95行,每行的格式类似下面的样子:

SM_CXSCREEN     屏幕的宽度     1366

通过TextOut函数输出METRICS结构数组的每个数组元素很简单。这里仅列出WM_PAINT消息的处理:

case WM_PAINT:
    hdc = BeginPaint(hwnd, &ps);
    for (int i = 0; i < NUMLINES; i++)
    {
        y = 18 * i; // 行间距
        TextOut(hdc,   0,     y,  METRICS[i].m_pLabel,   _tcslen(METRICS[i].m_pLabel));
        TextOut(hdc,   240,   y,  METRICS[i].m_pDesc,    _tcslen(METRICS[i].m_pDesc));
        TextOut(hdc,   760,   y,  szBuf,
            wsprintf(szBuf, TEXT("%d"), GetSystemMetrics(METRICS[i].m_nIndex)));
    }
    EndPaint(hwnd, &ps);
    return 0;

程序的运行效果与完整代码参见Chapter3\SystemMetrics项目。程序使用wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);把窗口背景设置为标准系统颜色(浅灰色),所以很容易发现文本其实是有背景色的,默认是白色背景;字体是系统字体(System字体,标题栏、菜单、对话框默认情况下使用系统字体);对于每一行的行间距以及每一列的距离,我们大体设置了一个数值,这并不准确;客户区一共输出了95行,但是由于屏幕分辨率的原因,无法完整显示出来,很明显程序需要一个垂直滚动条。

3.2.1 格式化文本

文本输出是程序客户区中最常见的图形输出类型,有一些函数可以格式化和绘制文本。格式化函数可以设置背景模式、背景颜色、对齐方式、文本颜色、字符间距等,这些都是DC的文本格式属性。背景模式不透明、背景颜色为白色、对齐方式为左对齐、文本颜色为黑色等都是默认的DC文本格式属性。

格式函数可以分为三类:获取或设置DC的文本格式属性的函数、获取字符宽度和高度的函数,以及获取字符串宽度和高度的函数。

1.文本格式属性

(1)文本对齐方式

SetTextAlign函数为指定的DC设置文本对齐方式:

UINT SetTextAlign(
    _In_ HDC  hdc,      // 设备环境句柄
    _In_ UINT fMode);   // 文本对齐方式

fMode参数指定文本对齐方式,可用的值及含义如表3.4所示。

表3.4

常量含义
TA_TOP起始点在文本边界矩形的上边缘
TA_BOTTOM起始点在文本边界矩形的下边缘
TA_BASELINE起始点在文本的基线上
TA_LEFT起始点在文本边界矩形的左边缘
TA_RIGHT起始点在文本边界矩形的右边缘
TA_CENTER起始点在文本边界矩形的中心(水平方向)
TA_UPDATECP使用当前位置作为起始点,当前位置在每次文本输出函数调用后会更新
TA_NOUPDATECP每次文本输出函数调用以后,当前位置不会更新

默认值为TA_LEFT | TA_TOP | TA_NOUPDATECP。

调用SetTextAlign函数可以改变TextOut、ExtTextOut、TabbedTextOut等函数中nXStart和nYStart参数表示的含义。使用TA_LEFT、TA_RIGHT和TA_CENTER标志会影响nXStart表示的水平坐标值,使用TA_TOP、TA_BOTTOM和TA_BASELINE标志会影响nYStart表示的垂直坐标值。例如在SetTextAlign函数中指定TA_RIGHT标志,那么TextOut函数的nXStart表示字符串中最后一个字符右侧的水平坐标。如果指定TA_TOP,则nYStart表示字符串中所有字符的最高点,即所有字符都在nYStart指定的位置之下;如果指定TA_BOTTOM则表示字符串中所有字符都会在nYStart指定的位置之上。

如果设置了TA_UPDATECP标志,Windows会忽略TextOut函数的nXStart和nYStart参数指定的值,而是将由先前调用的MoveToEx或LineTo函数(或其他一些可以改变当前位置的函数)指定的当前位置坐标值作为起始点。如果没有调用改变当前位置的函数,那么默认情况下当前位置的坐标为(0, 0),相对于客户区左上角;设置TA_UPDATECP标志以后,对TextOut函数的每次调用也会更新当前位置。例如,如果设置为TA_LEFT | TA_UPDATECP,TextOut函数返回后新的当前位置就是该字符串的结束位置,下次调用TextOut函数时就会从上一个字符串的结束位置开始绘制,有时候可能需要这个特性。

如果函数执行成功,则返回值是原来的文本对齐设置;如果函数执行失败,则返回值为GDI_ERROR。

大家可以把SystemMetrics程序的最后一个TextOut改为:

SetTextAlign(hdc, TA_RIGHT | TA_TOP);   // 设置最后一列右对齐
TextOut(hdc, 800, y, szBuf, wsprintf(szBuf, TEXT("%d"), GetSystemMetrics(METRICS[i].m_nIndex)));
SetTextAlign(hdc, TA_LEFT | TA_TOP);    // 设置回左对齐

将fMode参数设置为TA_RIGHT,那么TextOut的nXStart参数指定的就是字符串中最后一个字符右侧的X坐标,用截图工具测量一下,可以看到从客户区左侧到第三列结束正好是800逻辑单位(像素)。

可以通过调用GetTextAlign函数来获取指定DC的当前文本对齐设置:

UINT GetTextAlign(_In_ HDC hdc);

调用SetTextAlign函数的时候通常使用按位或运算符组合几个标志,调用GetTextAlign函数的时候可以使用按位“与”运算符检测返回值是否包含某标志。

(2)字符间距

可以通过调用SetTextCharacterExtra函数设置指定DC中文本输出的字符间距:

int SetTextCharacterExtra(
    HDC hdc,            // 设备环境句柄
    int nCharExtra);    // 字符间距,逻辑单位

默认字符间距值为0。如果函数执行成功,则返回值是原来的字符间距值;如果执行失败,则返回值为0x80000000。

大家可以在SystemMetrics程序的3个TextOut前调用SetTextCharacterExtra函数设置一下字符间距,看一下效果,例如:SetTextCharacterExtra(hdc, 5);。

可以通过调用GetTextCharacterExtra函数来获取指定DC的当前字符间距:

int GetTextCharacterExtra(HDC hdc);

(3)背景模式、背景颜色和文本颜色

可以通过调用SetTextColor函数设置绘制的文本颜色,以及在彩色打印机上绘制的文本颜色;可以通过调用SetBkColor函数设置每个字符后显示的颜色(也就是背景颜色);可以通过调用SetBkMode函数设置背景模式为透明或不透明。

COLORREF SetTextColor(
    HDC hdc,            // 设备环境句柄
    COLORREF crColor);  // 文本颜色值

如果函数执行成功,则返回原来的文本颜色值;如果函数执行失败,则返回值为CLR_INVALID。

COLORREF SetBkColor(
    HDC hdc,            // 设备环境句柄
    COLORREF crColor);  // 背景颜色值

如果函数执行成功,则返回原来的背景颜色值;如果函数执行失败,则返回值为CLR_INVALID。

int SetBkMode(
    HDC hdc,            // 设备环境句柄
    int iBkMode);       // 背景模式

iBkMode参数指定背景模式,可用的值只有两个:指定为OPAQUE表示不透明背景,指定为TRANSPARENT表示透明背景。如果函数执行成功,则返回原来的的背景模式;如果函数执行失败,则返回值为0。

COLORREF用于指定RGB颜色值,在windef.h头文件中定义如下:

typedef DWORD   COLORREF;
typedef DWORD   *LPCOLORREF;

COLORREF值的十六进制为“0x00BBGGRR”的形式,低位字节包含红色值,倒数第2字节包含绿色值,倒数第3字节包含蓝色值,高位字节必须为0,单字节的最大值为255。

要创建COLORREF颜色值,可以使用RGB宏分别指定红色、绿色、蓝色的值;要提取COLORREF颜色值中的的红色、绿色和蓝色值,可以分别使用GetRValue、GetGValue和GetBValue宏。这些宏在wingdi.h头文件中定义如下:

#define RGB(r,g,b)
    ((COLORREF)(((BYTE)(r)|((WORD)((BYTE)(g))<<8))|(((DWORD)(BYTE)(b))<<16)))
#define GetRValue(rgb)  (LOBYTE(rgb))
#define GetGValue(rgb)  (LOBYTE(((WORD)(rgb)) >> 8))
#define GetBValue(rgb)  (LOBYTE((rgb)>>16))

现在,我们在SystemMetrics程序的3个TextOut函数调用前面加上以下语句:

SetBkMode(hdc, TRANSPARENT);
SetTextColor(hdc, RGB(0, 0, 255));

可以看到背景模式是透明的,文本颜色为蓝色。

显示DC的默认文本颜色为黑色,默认背景颜色为白色,默认背景模式为不透明。程序可以通过调用GetTextColor函数获取DC的当前文本颜色,可以通过调用GetBkColor函数获取DC的当前背景颜色,可以通过调用GetBkMode函数获取DC的当前背景模式。

2.获取字符串的宽度和高度

GetCharWidth32函数可以获取指定DC当前字体中指定范围内的连续字符的宽度:

BOOL GetCharWidth32(
    _In_  HDC   hdc,        // 设备环境句柄
    _In_  UINT  iFirstChar, // 连续字符中的第一个字符
    _In_  UINT  iLastChar,  // 连续字符中的最后一个字符,不得位于指定的第一个字符之前
    _Out_ LPINT lpBuffer);  // 接收每个字符宽度的INT数组,字符宽度是逻辑单位

连续字符指的是ASCII值连续,例如将iFirstChar指定为A,iLastChar指定为Z。看下面的示例:

INT arrWidth[4];
TCHAR sz[8] = { 0 };
TCHAR szBuf[32] = { 0 };
GetCharWidth32(GetDC(hwnd), TEXT('你'), TEXT('佣'), arrWidth);
for (int i = TEXT('你'), j = 0; i <= TEXT('佣'); i++, j++)
{
    wsprintf(sz, TEXT("%c = %d\n"), i, arrWidth[j]);
    StringCchCat(szBuf, _countof(szBuf), sz);
}
MessageBox(hwnd, szBuf, TEXT("提示"), MB_OK);

“你”的码值为0x4F60,“佣”的码值为0x4F63,输出结果如原书图3.1所示有4个汉字,每个字符的宽度都是15。

可以把iFirstCha和iLastChar参数指定为相同的值,只获取一个字符的宽度。

GetTextExtentPoint32函数用于获取指定DC中一个字符串的宽度和高度值:

BOOL GetTextExtentPoint32(
    _In_  HDC     hdc,      // 设备环境句柄
    _In_  LPCTSTR lpString, // 字符串指针,不要求以零结尾,因为参数c可以指定字符串长度
    _In_  int     c,        // 字符串长度,可以使用_tcslen
    _Out_ LPSIZE  lpSize);  // 在这个SIZE结构中返回字符串的宽度和高度,逻辑单位

lpSize是一个指向SIZE结构的指针,在这个SIZE结构中返回字符串的宽度和高度。SIZE结构在windef.h头文件中定义如下:

typedef struct tagSIZE
{
    LONG        cx;
    LONG        cy;
} SIZE, *PSIZE, *LPSIZE;

以后对于函数返回值类型比较简单的情况,例如BOOL类型,没有特殊情况,我就不介绍其返回值了,但像GetMessage函数,虽然返回值类型是BOOL,我们还需要考虑返回值为−1(函数执行失败)的情况,而不能判断返回TRUE还是FALSE。另外,很多函数都有一个Ex扩展版本,大家可以把函数名输入VS,按F1键打开帮助文档查询用法,或者打开网页版MSDN进行查询,也可以安装一个离线版MSDN。

为了简洁起见,我们的程序可能对函数执行成功与否缺少必要的判断,这并不代表不需要通过函数的返回值判断函数执行是否成功。VS 2019提供了更多的源代码错误检查,如果发现函数中的参数不符合规定或者未初始化,会在该行语句下方显示一条波浪线,鼠标悬停在波浪线处会给出错误提示,我们可以根据提示修改源代码。另外,本书写作了多年,使用过不同版本的操作系统和VS,但是后期使用最新的操作系统和VS 2019对全书进行了修正。

前面说过:“WM_CREATE消息是窗口过程较早收到的消息之一,程序通常会在这里做一些初始化的工作”。对于SystemMetrics程序,我们可以在WM_CREATE消息中获取字符串高度,用于在TextOut函数中指定y坐标值:

HDC hdc;
PAINTSTRUCT ps;
TCHAR szBuf[10];
int y;
static SIZE size = { 0 };

switch (uMsg)
{
case WM_CREATE:
    hdc = GetDC(hwnd);
    GetTextExtentPoint32(hdc, METRICS[0].m_pLabel, _tcslen(METRICS[0].m_pLabel), &size);
    ReleaseDC(hwnd, hdc);
    return 0;

case WM_PAINT:
    hdc = BeginPaint(hwnd, &ps);
    for (int i = 0; i < NUMLINES; i++)
    {
        y = size.cy * i;
        SetBkMode(hdc, TRANSPARENT);
        SetTextColor(hdc, RGB(0, 0, 255));
        TextOut(hdc,   0,     y,  METRICS[i].m_pLabel,   _tcslen(METRICS[i].m_pLabel));
        TextOut(hdc,   240,   y,  METRICS[i].m_pDesc,    _tcslen(METRICS[i].m_pDesc));
        TextOut(hdc,   760,   y,  szBuf,
            wsprintf(szBuf, TEXT("%d"), GetSystemMetrics(METRICS[i].m_nIndex)));
    }
    EndPaint(hwnd, &ps);
    return 0;

GetTextExtentPoint32函数适用于字符串中不包含制表符的情况,如果字符串中包含制表符,则应该调用GetTabbedTextExtent函数:

DWORD GetTabbedTextExtent(
    _In_        HDC     hDC,                        // 设备环境句柄
    _In_        LPCTSTR lpString,                   // 字符串指针,不要求以零结尾,因为nCount
                                                    // 指定字符串长度
    _In_        int     nCount,                     // 字符串长度,可以使用_tcslen
    _In_        int     nTabPositions,              // lpnTabStopPositions数组中元素的个数
    _In_opt_    const LPINT   lpnTabStopPositions); // 指向包含制表符位置的数组

如果将nTabPositions参数设置为0,并将lpnTabStopPositions参数设置为NULL,制表符会自动按平均字符宽度的8倍来扩展;如果将nTabPositions参数设置为1,则所有制表符按lpnTabStopPositions参数指向的数组中的第一个数组元素指定的距离来分隔。

如果函数执行成功,则返回值是字符串的宽度和高度(逻辑单位),高度值在高位字中,宽度值在低位字中;如果函数执行失败,则返回值为0。

HIWORD宏可以得到一个32位数的高16位;LOWORD宏可以得到一个32位数的低16位;HIBYTE宏可以得到一个16位数的高字节;LOBYTE宏可以得到一个16位数的低字节。类似的还有,MAKELONG宏可以将两个16位的数合成为一个32位的LONG型;MAKEWORD宏可以将两个8位的数合成为一个16位的WORD型,等等。这些宏在minwindef.h头文件中定义如下:

#define MAKEWORD(a, b)
    ((WORD)(((BYTE)(((DWORD_PTR)(a)) & 0xff)) | 
        ((WORD)((BYTE)(((DWORD_PTR)(b)) & 0xff))) << 8))
#define MAKELONG(a, b)
    ((LONG)(((WORD)(((DWORD_PTR)(a)) & 0xffff)) | 
        ((DWORD)((WORD)(((DWORD_PTR)(b)) & 0xffff))) << 16))

#define LOWORD(l)   ((WORD)(((DWORD_PTR)(l)) & 0xffff))
#define HIWORD(l)   ((WORD)((((DWORD_PTR)(l)) >> 16) & 0xffff))
#define LOBYTE(w)   ((BYTE)(((DWORD_PTR)(w)) & 0xff))
#define HIBYTE(w)   ((BYTE)((((DWORD_PTR)(w)) >> 8) & 0xff))
3.选择字体

系统提供了6种备用字体,前面说过“GetStockObject函数用于获取备用(或者说库存)画笔、画刷、字体等的句柄”,获取字体句柄以后,可以通过调用SelectObject函数把字体选入DC中,以后通过GDI函数进行文本绘制就会使用新的DC属性。一些备用字体如表3.5所示。

表3.5

值含义
ANSI_FIXED_FONT等宽系统字体
ANSI_VAR_FONT变宽系统字体
DEVICE_DEFAULT_FONT设备默认字体
OEM_FIXED_FONTOEM(原始设备制造商)等宽字体
SYSTEM_FONT系统字体,默认情况下使用系统字体绘制菜单、对话框控件和文本
SYSTEM_FIXED_FONT等宽系统字体

SelectObject函数可以把一个GDI对象选入指定的DC中:

HGDIOBJ SelectObject(
    _In_ HDC     hdc,       // 设备环境句柄
    _In_ HGDIOBJ hgdiobj);  // GDI对象句柄

函数执行成功,返回原来(也就是被替换掉的)对象的句柄。通常需要保存一下返回值,在用新对象完成绘制操作以后,应该再调用一次SelectObject函数,用原来的对象替换掉新对象,也就是恢复DC属性。

例如,我们通过SystemMetrics程序用OEM_FIXED_FONT字体输出文本看一下效果:

HGDIOBJ hFontOld;

switch (uMsg)
{
case WM_PAINT:
    hdc = BeginPaint(hwnd, &ps);
    SetBkMode(hdc, TRANSPARENT);
    SetTextColor(hdc, RGB(0, 0, 255));

    hFontOld = SelectObject(hdc, GetStockObject(OEM_FIXED_FONT));
    for (int i = 0; i < NUMLINES; i++)
    {
        y = 18 * i;
        TextOut(hdc,   0,     y,  METRICS[i].m_pLabel,  _tcslen(METRICS[i].m_pLabel));
        TextOut(hdc,   240,   y,  METRICS[i].m_pDesc,   _tcslen(METRICS[i].m_pDesc));
        TextOut(hdc,   760,   y,  szBuf,
            wsprintf(szBuf, TEXT("%d"), GetSystemMetrics(METRICS[i].m_nIndex)));
    }

    SelectObject(hdc, hFontOld);
    EndPaint(hwnd, &ps);
    return 0;

重新编译运行,效果稍微好看了一些,但是备用字体比较少,接下来我们学习创建自己喜欢的逻辑字体。

用CreateFont函数创建具有指定特征的逻辑字体:

HFONT CreateFont(
    _In_ int     nHeight,           // 字符高度,设置为0表示使用默认的字符高度
    _In_ int     nWidth,            // 字符宽度,通常设置为0,表示根据字符的高度来选择合适的字体
    _In_ int     nEscapement,       // 字符串的倾斜角度,以0.1度为单位,没有特殊需要一般设置为0
    _In_ int     nOrientation,      // 单个字符的倾斜角度,以0.1度为单位,通常这个字段会被忽略
    _In_ int     fnWeight,          // 字体粗细,如果设置为0,则使用默认粗细
    _In_ DWORD   fdwItalic,         // 是否斜体,设置为TRUE表示使用斜体
    _In_ DWORD   fdwUnderline,      // 是否有下划线,设置为TRUE表示使用下划线
    _In_ DWORD   fdwStrikeOut,      // 是否有删除线,设置为TRUE表示使用删除线
    _In_ DWORD   fdwCharSet,        // 字符集
    _In_ DWORD   fdwOutputPrecision,// 指定Windows通过字体的大小特征来匹配真实字体的方式
    _In_ DWORD   fdwClipPrecision,  // 指定裁剪方式,也就是当字符在显示区域以外时,如何只显示部分字符
    _In_ DWORD   fdwQuality,        // 指定如何将逻辑字体属性与实际物理字体属性匹配
    _In_ DWORD   fdwPitchAndFamily, // 指定字符间距和字体系列
    _In_ LPCTSTR lpszFace);         // 字体名称,字符串长度不得超过LF_FACESIZE(32)个字符
  • 前两个参数nHeight和nWidth均是逻辑单位。

  • 第5个参数fnWeight指定字体的粗细,字体的粗细在0~1000,400是正常粗细,700是粗体的,如果该参数设置为0,则使用默认粗细。wingdi.h头文件中定义了常量用于表示字体粗细,如表3.6所示。

表3.6

常量值
FW_DONTCARE0
FW_THIN100
FW_EXTRALIGHT200
FW_ULTRALIGHT200
FW_LIGHT300
FW_NORMAL400
FW_REGULAR400
FW_MEDIUM500
FW_SEMIBOLD600
FW_DEMIBOLD600
FW_BOLD700
FW_EXTRABOLD800
FW_ULTRABOLD800
FW_HEAVY900
FW_BLACK900
  • 第9个参数fdwCharSet指定字体的字符集,OEM_CHARSET表示OEM字符集,DEFAULT_CHARSET表示基于当前系统区域的字符集。一些可用的预定义值如表3.7所示。

表3.7

常量值含义
ANSI_CHARSET0ANSI(美国、西欧)
GB2312_CHARSET134简体中文
CHINESEBIG5_CHARSET136繁体中文
DEFAULT_CHARSET1默认字符集
OEM_CHARSET255原始设备制造商字符集
SYMBOL_CHARSET2标准符号
EASTEUROPE_CHARSET238东欧字符集
GREEK_CHARSET161希腊语字符集
MAC_CHARSET77Apple Macintosh
RUSSIAN_CHARSET204俄语字符集
  • 第10个参数fdwOutputPrecision指定输出精度,也就是指定实际获得的字体与所请求字体的高度、宽度、字符方向、转义、间距和字体类型匹配的程度,一般不使用这个参数。

  • 第12个参数fdwQuality指定如何将逻辑字体属性与实际物理字体属性匹配。值的含义如表3.8所示。

表3.8

值含义
ANTIALIASED_QUALITY如果字体支持,并且字体大小不太小或太大,则字体是抗锯齿的或平滑的
CLEARTYPE_QUALITY使用ClearType抗锯齿方法显示文本
DEFAULT_QUALITY字体的外观并不重要
DRAFT_QUALITY对于GDI光栅字体启用缩放,这意味着可以使用更多的字体大小,但质量可能更低
NONANTIALIASED_QUALITY字体不会消除锯齿
PROOF_QUALITY字体的字符质量比逻辑字体属性的精确匹配更重要。对于GDI光栅字体,禁用缩放,并选择最接近大小的字体,虽然使用PROOF_QUALITY时所选字体大小可能无法精确映射,但字体质量高,外观无变形
  • 第13个参数fdwPitchAndFamily指定字符间距和字体系列,最低两个位表示该字体是否是一个等宽字体(所有字符的宽度都相同)或是一个变宽字体。wingdi.h头文件中定义了表3.9所列的常量。

表3.9

常量值含义
DEFAULT_PITCH0默认间距
FIXED_PITCH1等宽
VARIABLE_PITCH2变宽

4~7位指定字体系列,值的含义如表3.10所示。

表3.10

常量值含义
FF_DONTCARE(0<<4)使用默认字体
FF_ROMAN(1<<4)具有可变笔画宽度和衬线的字体
FF_SWISS(2<<4)笔画宽度可变且不带衬线的字体
FF_MODERN(3<<4)具有恒定笔画宽度、带或不带衬线的字体
FF_SCRIPT(4<<4)字体看起来像手写,草书就是例子
FF_DECORATIVE(5<<4)古英语

CreateFont函数虽然参数比较多,但是除了字符高度、字符集和字体名称以外,其他参数通常均可以指定为0。HFONT是逻辑字体句柄类型,如果函数执行成功,则返回值是所创建逻辑字体的句柄;如果函数执行失败,则返回值为NULL。

当不再需要创建字体时,需要调用DeleteObject函数将其删除。DeleteObject函数用于删除创建的逻辑画笔、逻辑画刷、逻辑字体、位图、区域等,释放与对象相关联的所有系统资源,对象删除后,指定的句柄不再有效。

BOOL DeleteObject(_In_ HGDIOBJ hObject);    // GDI对象句柄

我们在SystemMetrics程序的3个TextOut前加上如下语句:

hFont = CreateFont(12, 0, 0, 0, 0, 0, 0, 0, GB2312_CHARSET, 0, 0, 0, 0, TEXT("宋体"));
hFontOld = (HFONT)SelectObject(hdc, hFont);

可以看到,字体美观了不少。

CreateFontIndirect函数的功能与CreateFont函数完全相同,不同的是CreateFontIndirect函数只需要一个LOGFONT结构参数:

HFONT CreateFontIndirect(_In_ const LOGFONT *lplf);

LOGFONT结构的字段与CreateFont函数的14个参数是一一对应的:

typedef struct tagLOGFONT {
    LONG  lfHeight;
    LONG  lfWidth;
    LONG  lfEscapement;
    LONG  lfOrientation;
    LONG  lfWeight;
    BYTE  lfItalic;
    BYTE  lfUnderline;
    BYTE  lfStrikeOut;
    BYTE  lfCharSet;
    BYTE  lfOutPrecision;
    BYTE  lfClipPrecision;
    BYTE  lfQuality;
    BYTE  lfPitchAndFamily;
    TCHAR lfFaceName[LF_FACESIZE];
} LOGFONT, *PLOGFONT;

EnumFontFamiliesEx函数可以根据提供的LOGFONT结构枚举系统中的字体:

int EnumFontFamiliesEx(
    _In_ HDC          hdc,                  // 设备环境句柄
    _In_ LPLOGFONT    lpLogfont,            // 指定字体特征的LOGFONT结构
    _In_ FONTENUMPROC lpEnumFontFamExProc,  // 回调函数
    _In_ LPARAM       lParam,               // 传递给回调函数的参数
         DWORD        dwFlags);             // 未使用,必须为0
  • 参数lpLogfont是指定字体特征的LOGFONT结构,函数只使用lfCharSet、lfFaceName和lfPitchAndFamily共3个字段,如表3.11所示。

表3.11

字段含义
lfCharSet如果设置为DEFAULT_CHARSET,函数将枚举所有字符集中指定名称的字体。如果有两种字体同名,则只枚举一种字体;如果设置为其他有效的字符集,则函数仅枚举指定字符集中的字体
lfFaceName如果设置为空字符串,则函数将在所有字体名称中枚举一种字体;如果设置为有效的字体名称,则函数将枚举具有指定名称的字体
lfPitchAndFamily必须设置为0

也就是说函数是基于字体名称或字符集或两者共同来枚举字体。

表3.12显示了lfCharSet和lfFaceName的各种值组合的结果。

表3.12

组合含义
lfCharSet = DEFAULT_CHARSET; lfFaceName = NULL枚举所有字符集中全部名称的字体,如果有两种字体同名,则只枚举一种字体
lfCharSet = DEFAULT_CHARSET; lfFaceName = 指定字体名称枚举所有字符集中指定名称的字体
lfCharSet = 指定字符集; lfFaceName = NULL枚举指定字符集中所有名称的字体
lfCharSet = 指定字符集; lfFaceName = 指定字体名称枚举指定字符集中指定名称的字体
  • 参数lpEnumFontFamExProc是EnumFontFamiliesEx函数的回调函数,对于枚举到的每个字体,都会调用一次这个回调函数。回调函数的格式如下:
int CALLBACK EnumFontFamExProc(
    const LOGFONT    *lpelfe,   // 有关字体逻辑属性信息的LOGFONT结构
    const TEXTMETRIC *lpntme,   // 有关字体物理属性信息的TEXTMETRIC结构
    DWORD      FontType,        // 字体类型,例如DEVICE_FONTTYPE、RASTER_
                                // FONTTYPE、TRUETYPE_FONTTYPE
    LPARAM     lParam);         // EnumFontFamiliesEx函数的lParam参数

如果需要继续枚举,则回调函数应返回非零;如果需要停止枚举,则返回0。

EnumFontFamiliesEx函数的返回值是最后一次回调函数调用返回的值。

系统会自动在DC中存储一组默认图形对象(没有默认位图或路径)及属性,程序可以通过创建一个新对象并将其选入DC中(调用SelectObject函数)来更改这些默认值。可以通过调用GetCurrentObject函数获取DC中指定图形对象(例如字体、画笔、画刷和位图)的句柄,可以通过调用GetObject函数获取DC中指定图形对象的属性。

4.获取字体的度量值

GetTextMetrics函数可以获取当前选定字体的度量值,该函数通常用于英文字体:

BOOL GetTextMetrics(
    _In_  HDC          hdc,     // 设备环境句柄
    _Out_ LPTEXTMETRIC lptm);   // 在这个TEXTMETRIC结构中返回字体度量值,逻辑单位

函数执行成功,在lptm指定的TEXTMETRIC结构中返回字体的信息。在wingdi.h头文件中TEXTMETRIC结构的定义如下:

typedef struct tagTEXTMETRIC {
    LONG  tmHeight;             // 字符高度(等于tmAscent + tmDescent)
    LONG  tmAscent;             // 字符基线以上的高度
    LONG  tmDescent;            // 字符基线以下的高度
    LONG  tmInternalLeading;    // 字符高度范围内的一部分顶部空间,可用于重音符号和其他音调符号
    LONG  tmExternalLeading;    // 在行之间添加的额外高度空间
    LONG  tmAveCharWidth;       // 字体中字符(小写字母)的平均宽度(通常定义为字母x的宽度)
    LONG  tmMaxCharWidth;       // 字体中最宽字符的宽度
    LONG  tmWeight;             // 字体的粗细
    LONG  tmOverhang;           // 添加到某些合成字体中的额外宽度
    LONG  tmDigitizedAspectX;
    LONG  tmDigitizedAspectY;
    TCHAR tmFirstChar;          // 字体中定义的第一个字符
    TCHAR tmLastChar;           // 字体中定义的最后一个字符
    TCHAR tmDefaultChar;        // 字体中所没有字符的替代字符
    TCHAR tmBreakChar;          // 单词之间的分隔字符,通常是空格
    BYTE  tmItalic;             // 字体为斜体时非零
    BYTE  tmUnderlined;         // 字体有下划线时非零
    BYTE  tmStruckOut;          // 字体有删除线时非零
    BYTE  tmPitchAndFamily;     // 字体间距(低4位)和字体系列(高4位)
    BYTE  tmCharSet;            // 字体的字符集
} TEXTMETRIC, *PTEXTMETRIC;

tmOverhang字段表示添加到某些合成字体中(例如粗体或斜体)的每个字符串的额外宽度,例如,GDI通过扩展每个字符的间距并用偏移量值重写字符串,使字符串变为粗体。

TEXTMETRIC结构虽然字段比较多,但是常用的也就是前面几个。字段tmHeight、tmAscent、tmDescent和tmInternalLeading之间的关系如原书图3.2所示。在图3.2中,字段tmExternalLeading没有表示出来。

对于等宽字体,大写字母宽度等于字符的平均宽度;对于变宽字体,大写字母宽度通常是字符平均宽度的1.5倍。对于变宽字体,TEXTMETRIC结构中的tmPitchAndFamily字段的低4位为1,对于等宽字体则为0。计算大写字母宽度的方式为cxCaps = (tm.tmPitchAndFamily & 1 ? 3 : 2) cxChar / 2;。

3.2.2 绘制文本函数

在选择了适当的字体和所需的文本格式选项后,可以通过调用相关函数来绘制字符或字符串,常用的文本绘制函数有DrawText、DrawTextEx、TextOut、ExtTextOut、PolyTextOut和TabbedTextOut等。当调用其中一个函数时,操作系统将此调用传递给GDI图形引擎,而GDI图形引擎又将调用传递给相应的设备驱动程序。其中ExtTextOut函数执行速度最快,该调用将快速转换为设备的ExtTextOut调用。但是,有时程序可能更适合调用其他函数,例如,要在指定的矩形区域范围内绘制文本,可以调用DrawText函数,要创建具有对齐列的多列文本,可以调用TabbedTextOut函数。

DrawText和DrawTextEx函数在指定的矩形内绘制文本:

int DrawText(
    _In_    HDC     hdc,                  // 设备环境句柄
    _Inout_ LPCTSTR lpchText,             // 字符串指针
    _In_    int     cchText,              // 字符串长度,以字符为单位
    _Inout_ LPRECT  lpRect,               // 所绘制的文本限定在这个矩形范围内
    _In_    UINT    uFormat);             // 绘制格式选项
int DrawTextEx(
    _In_     HDC              hdc,        // 设备环境句柄
    _Inout_  LPTSTR           lpchText,   // 字符串指针
    _In_     int              cchText,    // 字符串长度,以字符为单位
    _Inout_  LPRECT           lpRect,     // 所绘制的文本限定在这个矩形范围内
    _In_     UINT             uFormat,    // 绘制格式选项
    _In_opt_ LPDRAWTEXTPARAMS lpDTParams);// 指定扩展格式选项的DRAWTEXTPARAMS结构,可以为NULL
  • 参数cchText指定字符串的长度。如果lpchText参数指定的字符串是以零结尾的,那么cchText参数可以设置为−1,函数会自动计算字符个数;否则需要指定字符个数。

  • 参数uFormat指定格式化文本的方法,常用的值及含义如表3.13所示。

表3.13

常量含义
DT_TOP将文本对齐到矩形的顶部
DT_BOTTOM将文本对齐到矩形的底部,该标志仅与DT_SINGLELINE单行文本一起使用
DT_VCENTER文本在矩形内垂直居中,该标志仅与DT_SINGLELINE单行文本一起使用
DT_LEFT文本在矩形内左对齐
DT_RIGHT文本在矩形内右对齐
DT_CENTER文本在矩形内水平居中
DT_SINGLELINE在单行上显示文本,回车和换行符也不能打断行
DT_WORDBREAK如果一个单词超过矩形的边界,则自动断开到下一行
DT_EXPANDTABS展开制表符\t,每个制表符的默认字符数是8

DrawTextEx函数的lpDTParams参数是用于指定扩展格式选项的DRAWTEXTPARAMS结构,可为NULL:

typedef struct tagDRAWTEXTPARAMS
{
    UINT    cbSize;         // 该结构的大小
    int     iTabLength;     // 每个制表符的大小,单位等于平均字符宽度
    int     iLeftMargin;    // 左边距,逻辑单位
    int     iRightMargin;   // 右边距,逻辑单位
    UINT    uiLengthDrawn;  // 返回函数处理的字符个数,包括空格字符,不包括字符串结束标志
} DRAWTEXTPARAMS, FAR *LPDRAWTEXTPARAMS;

如果函数执行成功,则返回值是以逻辑单位表示的文本高度,如果指定了 DT_VCENTER 或DT_BOTTOM,则返回值是从lpRect→top到所绘制文本底部的偏移量;如果函数执行失败,则返回值为0。

下面使用DrawTextEx函数输出一个字符串看一下效果:

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    HDC hdc;
    PAINTSTRUCT ps;
    TCHAR szText[] = TEXT("For displayed text, if the end of a string does not fit in   
the rectangle, it is truncated and ellipses are added. If a word that is not at the end of   
the string goes beyond the limits of the rectangle, it is truncated without ellipses.");
    DRAWTEXTPARAMS dtp = { sizeof(DRAWTEXTPARAMS) };
    dtp.iLeftMargin = 10;
    dtp.iRightMargin = 10;
    RECT rect;

    switch (uMsg)
    {
    case WM_PAINT:
        hdc = BeginPaint(hwnd, &ps);
        SetBkMode(hdc, TRANSPARENT);
        SetTextColor(hdc, RGB(0, 0, 255));
        GetClientRect(hwnd, &rect);         // 获取客户区矩形尺寸
        DrawTextEx(hdc, szText, -1, &rect, DT_WORDBREAK, &dtp);
        EndPaint(hwnd, &ps);
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }

    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

GetClientRect函数用于获取客户区的矩形坐标:

BOOL WINAPI GetClientRect(
    _In_  HWND   hWnd,      // 窗口句柄
    _Out_ LPRECT lpRect);   // 在这个RECT中返回客户区的坐标,以像素为单位

参数lpRect指向的RECT结构返回客户区的左上角和右下角坐标。因为客户区坐标是相对于窗口客户区左上角的,所以获取到的左上角的坐标是(0, 0),即lpRect→right等于客户区宽度,lpRect→bottom等于客户区高度。

TabbedTextOut函数在指定位置绘制字符串,并将制表符扩展到制表符位置数组中指定的位置:

LONG TabbedTextOut(
    _In_       HDC     hDC,           // 设备环境句柄
    _In_       int     X,             // 字符串起点的X坐标,逻辑单位
    _In_       int     Y,             // 字符串起点的Y坐标,逻辑单位
    _In_       LPCTSTR lpString,      // 字符串指针,不要求以零结尾,参数nCount可以指定字符串长度
    _In_       int     nCount,        // 字符串长度,可以使用_tcslen
    _In_       int     nTabPositions, // lpnTabStopPositions数组中数组元素的个数
    _In_ const LPINT   lpnTabStopPositions, // 指向包含制表符位置的数组,逻辑单位
    _In_       int     nTabOrigin);   // 制表符开始位置的X坐标,逻辑单位,制表符的位置等于
                                      // nTabOrigin + lpnTabStopPositions[x]

如果将nTabPositions参数设置为0,并将lpnTabStopPositions参数设置为NULL,制表符将会按平均字符宽度的8倍来扩展;如果将nTabPositions参数设置为1,则所有制表符按lpnTabStopPositions指向的数组中的第一个数组元素指定的距离来分隔。

如果函数执行成功,则返回值是字符串的宽度和高度(逻辑单位),高度值在高位字中,宽度值在低位字中;如果函数执行失败,则返回值为0。看一个示例:

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    HDC hdc;
    PAINTSTRUCT ps;
    TCHAR szBuf[] = TEXT("姓名\t工作地点\t年龄");
    TCHAR szBuf2[] = TEXT("小王\t山东省济南市\t18");
    TCHAR szBuf3[] = TEXT("弗拉基米尔•弗拉基米罗维奇•科夫\t俄罗斯莫斯科\t68");
    INT nTabStopPositions[] = { 260, 370 };
    LONG lRet;

    switch (uMsg)
    {
    case WM_PAINT:
        hdc = BeginPaint(hwnd, &ps);
        SetBkMode(hdc, TRANSPARENT);
        SetTextColor(hdc, RGB(0, 0, 255));
        lRet = TabbedTextOut(hdc, 0, 0,     szBuf,  _tcslen(szBuf),  2, nTabStopPositions, 0);
        TabbedTextOut(hdc, 0, HIWORD(lRet), szBuf2, _tcslen(szBuf2), 2, nTabStopPositions, 0);
        TabbedTextOut(hdc, 0, HIWORD(lRet) * 2, szBuf3, _tcslen(szBuf3), 2, nTabStopPositions, 0);
        EndPaint(hwnd, &ps);
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }

    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

ExtTextOut函数和TextOut一样可以输出文本,另外,该函数可以指定一个矩形用于裁剪或作为背景。

BOOL ExtTextOut(
    _In_       HDC     hdc,         // 设备环境句柄
    _In_       int     X,           // 字符串的开始位置X坐标,相对于客户区左上角,逻辑单位
    _In_       int     Y,           // 字符串的开始位置Y坐标,相对于客户区左上角,逻辑单位
    _In_       UINT    fuOptions,   // 指定如何使用lprc参数指定的矩形,可以设置为0
    _In_ const RECT    *lprc,       // 指向可选RECT结构的指针,用于裁剪或作为背景,可为NULL
    _In_       LPCTSTR lpString,    // 要绘制的字符串,因为有cbCount参数指定长度,所以不要求以零结尾
    _In_       UINT    cbCount,     // lpString指向的字符串长度,可以使用_tcslen,不得超过8192
    _In_ const INT     *lpDx);      // 指向可选整型数组的指针,该数组指定相邻字符之间的间距
  • 参数fuOptions指定如何使用lprc参数定义的矩形,常用的值如表3.14所示。

表3.14

常量含义
ETO_CLIPPED文本将被裁剪到矩形范围内,就是说矩形范围以外的文本不会显示
ETO_OPAQUE使用当前背景色来填充矩形
  • 参数lpDx是指向可选数组的指针,该数组指定相邻字符之间的间距。如果设置为NULL,表示使用默认字符间距。

关于其他绘制文本函数的使用方法请自行参见MSDN。

3.2.3 加入标准滚动条

在窗口中加入一个标准滚动条比较简单,只需要在CreateWindowEx函数的dwStyle参数中指定WS_HSCROLL / WS_VSCROLL样式即可。WS_HSCROLL表示加入一个水平滚动条,WS_VSCROLL表示加入一个垂直滚动条。之所以叫标准滚动条,是因为与之对应的还有一个滚动条控件。滚动条控件是子窗口,可以出现在父窗口客户区的任何位置,后面会讲滚动条控件。

每个滚动条都有相应的“范围”和“位置”。滚动条的范围是一对整数,分别代表滚动条的最小值和最大值。位置是指滑块在范围中所处的值。当滑块在滚动条的最顶端(或最左)时,滑块的位置是范围的最小值;当滑块在滚动条的最底部(或最右)时,滑块的位置是范围的最大值。

标准滚动条的默认范围是0~100,滚动条控件的默认范围为空(最小值和最大值均为0)。通过调用SetScrollRange函数,可以把范围改成对程序更有意义的值:

BOOL SetScrollRange(
    _In_ HWND hWnd,     // 滚动条所在窗口的窗口句柄
    _In_ int  nBar,     // 指定要设置的滚动条
    _In_ int  nMinPos,  // 最小滚动位置
    _In_ int  nMaxPos,  // 最大滚动位置
    _In_ BOOL bRedraw); // 是否应该重新绘制滚动条以反映更改

参数nBar指定要设置的滚动条,该参数如表3.15所示。

表3.15

常量含义
SB_HORZ设置标准水平滚动条的范围
SB_VERT设置标准垂直滚动条的范围
SB_CTL设置滚动条控件的范围,这种情况下hWnd参数必须设置为滚动条控件的句柄

nMinPos和nMaxPos参数指定的值之间的差异不得大于MAXLONG(0X7FFFFFFF)。

SetScrollPos函数用于设置滑块在滚动条中的位置:

int SetScrollPos(
    _In_ HWND hWnd,     // 滚动条所属窗口的窗口句柄
    _In_ int  nBar,     // 指定要设置的滚动条,含义同SetScrollRange函数的nBar参数
    _In_ int  nPos,     // 滑块的新位置
    _In_ BOOL bRedraw); // 是否重新绘制滚动条以反映新的滑块位置

如果函数执行成功,则返回值是滑块的前一个位置;如果函数执行失败,则返回值为0。

1.WM_SIZE消息

在WinMain调用ShowWindow函数时、在窗口大小更改后、在窗口最小化到任务栏或从任务栏恢复时,Windows都会发送WM_SIZE消息到窗口过程。对一个消息的处理,依赖于其wParam和lParam参数的含义,每个消息的wParam和lParam参数的含义通常都不相同,这令初学者很困惑!我的建议是,不必刻意记忆不同消息的wParam和lParam参数的含义,用的时候打开帮助文档或查询MSDN即可。常用的消息并不是很多,用得多了,自然也就熟悉了。学习Windows程序设计,只需要有人把读者领进门,面对Windows这座巨大迷宫,以后读者还是要依靠MSDN。

  • WM_SIZE消息的wParam参数表示请求的大小调整类型,常用的值如表3.16所示。

表3.16

常量值含义
SIZE_RESTORED0窗口的大小已发生变化,包括从最小化或最大化恢复到原来的状态
SIZE_MINIMIZED1窗口已最小化
SIZE_MAXIMIZED2窗口已最大化
  • WM_SIZE消息的lParam参数表示窗口客户区的新尺寸,lParam的低位字指定客户区的新宽度,lParam的高位字指定客户区的新高度。通常这样使用lParam参数:
cxClient = LOWORD(lParam);    // 客户区的新宽度
cyClient = HIWORD(lParam);    // 客户区的新高度

随着窗口大小的改变,子窗口或子窗口控件通常也需要随之改变位置和大小,以适应新的客户区大小。例如,记事本程序客户区中用于编辑文本的部件就是一个编辑控件,如果窗口大小改变,程序就需要响应WM_SIZE消息,重新计算客户区大小,对编辑控件的大小作出改变。

窗口过程处理完WM_SIZE消息以后,应返回0。

如果不是在WM_SIZE消息中,可以通过调用GetClientRect函数获取客户区尺寸。

2.WM_HSCROLL消息

当窗口的标准水平滚动条中发生滚动事件时,窗口过程会收到WM_HSCROLL消息;当窗口的标准垂直滚动条中发生滚动事件时,窗口过程会收到WM_VSCROLL消息。

  • WM_HSCROLL消息的wParam参数表示滑块的当前位置和用户的滚动请求。wParam的低位字表示用户的滚动请求,值如表3.17所示。

表3.17

值含义
SB_LINELEFT向左滚动一个单位
SB_LINERIGHT向右滚动一个单位
SB_PAGELEFT向左滚动一页(一个客户区宽度)
SB_PAGERIGHT向右滚动一页(一个客户区宽度)
SB_THUMBPOSITION用户拖动滑块并已释放鼠标,wParam的高位字指示拖动操作结束时滑块的新位置
SB_THUMBTRACK用户正在拖动滑块,该消息会不断发送,直到用户释放鼠标,wParam的高位字实时指示滑块被拖动到的新位置
SB_LEFT滚动到最左侧,这个暂时用不到
SB_RIGHT滚动到最右侧,这个暂时用不到
SB_ENDSCROLL滚动已结束,通常不使用

如果wParam参数的低位字是SB_THUMBPOSITION或SB_THUMBTRACK,则wParam参数的高位字表示滑块的当前位置,在其他情况下无意义。

  • 如果消息是由滚动条控件发送的,则lParam参数是滚动条控件的句柄;如果消息是由标准滚动条发送的,则lParam参数为NULL。

窗口过程处理完WM_HSCROLL消息以后,应返回0。

3.WM_VSCROLL消息
  • WM_VSCROLL消息的wParam参数表示滑块的当前位置和用户的滚动请求。wParam的低位字表示用户的滚动请求,值如表3.18所示。

表3.18

值含义
SB_LINEDOWN向下滚动一个单位
SB_LINEUP向上滚动一个单位
SB_PAGEDOWN向下滚动一页(一个客户区高度)
SB_PAGEUP向上滚动一页(一个客户区高度)
SB_THUMBPOSITION用户拖动滑块并已释放鼠标,wParam的高位字指示拖动操作结束时滑块的新位置
SB_THUMBTRACK用户正在拖动滑块,该消息会不断发送,直到用户释放鼠标,wParam的高位字实时指示滑块被拖动到的新位置
SB_TOP滚动到最上部,这个暂时用不到
SB_BOTTOM滚动到最底部,这个暂时用不到
SB_ENDSCROLL滚动已结束,通常不使用

如果wParam参数的低位字是SB_THUMBPOSITION或SB_THUMBTRACK,则wParam参数的高位字表示滑块的当前位置,在其他情况下无意义。

  • 如果消息是由滚动条控件发送的,则lParam参数是滚动条控件的句柄;如果消息是由标准滚动条发送的,则lParam参数为NULL。

窗口过程处理完WM_VSCROLL消息以后,应返回0。

用户单击或拖动滚动条的不同位置时的滚动请求如原书图3.5所示。

当用户按住水平或垂直滑块进行滑动时,程序通常处理的是SB_THUMBTRACK请求,而不是SB_THUMBPOSITION请求,以便用户拖动过程中,客户区的内容可以实时发生改变。

是时候给SystemMetrics程序添加标准滚动条了,先添加一个垂直滚动条:

#include <Windows.h>
#include <tchar.h>
#include "Metrics.h"

const int NUMLINES = sizeof(METRICS) / sizeof(METRICS[0]);

// 函数声明,窗口过程
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    WNDCLASSEX wndclass;                      // RegisterClassEx函数用的WNDCLASSEX结构
    TCHAR szClassName[] = TEXT("MyWindow");   // RegisterClassEx函数注册的窗口类的名称
    TCHAR szAppName[] = TEXT("GetSystemMetrics");   // 窗口标题
    HWND hwnd;                    // CreateWindowEx函数创建的窗口的句柄
    MSG msg;                      // 消息循环所用的消息结构体

    wndclass.cbSize = sizeof(WNDCLASSEX);
    wndclass.style = CS_HREDRAW | CS_VREDRAW;
    wndclass.lpfnWndProc = WindowProc;
    wndclass.cbClsExtra = 0;
    wndclass.cbWndExtra = 0;
    wndclass.hInstance = hInstance;
    wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
    wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
    wndclass.lpszMenuName = NULL;
    wndclass.lpszClassName = szClassName;
    wndclass.hIconSm = NULL;
    RegisterClassEx(&wndclass);

    hwnd = CreateWindowEx(0, szClassName, szAppName, WS_OVERLAPPEDWINDOW | WS_VSCROLL,
        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance, NULL);

    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);

    while (GetMessage(&msg, NULL, 0, 0) != 0)
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return msg.wParam;
}

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    HDC hdc;
    PAINTSTRUCT ps;
    HFONT hFont, hFontOld;
    static BOOL IsCalcStr = TRUE;           // 只在第一次WM_PAINT中计算s_iCol1、s_iCol2、
                                            // s_iHeight
    static int s_iCol1, s_iCol2, s_iHeight; // 第一列、第二列字符串的最大宽度,字符串高度
    static int s_cxClient, s_cyClient;      // 客户区宽度、高度
    static int s_iVscrollPos;               // 垂直滚动条当前位置
    TCHAR szBuf[10];
    int y;

    switch (uMsg)
    {
    case WM_CREATE:
        // 设置垂直滚动条的范围和初始位置
        SetScrollRange(hwnd, SB_VERT, 0, NUMLINES - 1, FALSE);
        SetScrollPos(hwnd, SB_VERT, s_iVscrollPos, TRUE);
        return 0;

	case WM_SIZE:
        // 计算客户区宽度、高度,滚动条滚动一页的时候需要使用
        s_cxClient = LOWORD(lParam);
        s_cyClient = HIWORD(lParam);
        return 0;

    case WM_VSCROLL:
        switch (LOWORD(wParam))
        {
        case SB_LINEUP:
            s_iVscrollPos -= 1;
            break;
        case SB_LINEDOWN:
            s_iVscrollPos += 1;
            break;
        case SB_PAGEUP:
            s_iVscrollPos -= s_cyClient / s_iHeight;
            break;
        case SB_PAGEDOWN:
            s_iVscrollPos += s_cyClient / s_iHeight;
            break;
        case SB_THUMBTRACK:
            s_iVscrollPos = HIWORD(wParam);
            break;
        }
        s_iVscrollPos = min(s_iVscrollPos, NUMLINES - 1);
        s_iVscrollPos = max(0, s_iVscrollPos);
        if (s_iVscrollPos != GetScrollPos(hwnd, SB_VERT))
        {
            SetScrollPos(hwnd, SB_VERT, s_iVscrollPos, TRUE);
            //UpdateWindow(hwnd);               // 不可以,不存在无效区域不会生成WM_PAINT消息
            //InvalidateRect(hwnd, NULL, FALSE);// 不可以
            InvalidateRect(hwnd, NULL, TRUE);
        }
        return 0;

    case WM_PAINT:
        hdc = BeginPaint(hwnd, &ps);
        SetBkMode(hdc, TRANSPARENT);
        hFont = CreateFont(12, 0, 0, 0, 0, 0, 0, 0, GB2312_CHARSET, 0, 0, 0, 0, TEXT("宋体"));
        hFontOld = (HFONT)SelectObject(hdc, hFont);

        if (IsCalcStr)
        {
            SIZE size = { 0 };
            for (int i = 0; i < NUMLINES; i++)
            {
                GetTextExtentPoint32(hdc, METRICS[i].m_pLabel, _tcslen(METRICS[i].m_pLabel), &size);
                if (size.cx > s_iCol1)
                    s_iCol1 = size.cx;
                GetTextExtentPoint32(hdc, METRICS[i].m_pDesc, _tcslen(METRICS[i].m_pDesc), &size);
                if (size.cx > s_iCol2)
                    s_iCol2 = size.cx;
            }
            s_iHeight = size.cy + 2;    // 留一点行间距
            IsCalcStr = FALSE;
        }

        for (int i = 0; i < NUMLINES; i++)
        {
            y = s_iHeight * (i - s_iVscrollPos);
            TextOut(hdc, 0,                 y, METRICS[i].m_pLabel, _tcslen(METRICS[i].m_pLabel));
            TextOut(hdc, s_iCol1,           y, METRICS[i].m_pDesc,  _tcslen(METRICS[i].m_pDesc));
            TextOut(hdc, s_iCol1 + s_iCol2, y, szBuf,
                wsprintf(szBuf, TEXT("%d"), GetSystemMetrics(METRICS[i].m_nIndex)));
        }

        SelectObject(hdc, hFontOld);
        DeleteObject(hFont);
        EndPaint(hwnd, &ps);
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }

    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

程序中有几个变量被定义为静态变量。静态变量保存在全局数据区,而不是保存在堆栈中,不会因为WindowProc函数的退出而被销毁,下一次消息处理的时候还可以继续使用上次保存的值。也可以定义为全局变量,但是原则上还是少使用全局变量。

具体代码参见Chapter3\SystemMetrics2项目。编译运行,程序运行效果如原书图3.6所示。

程序需要初始化滚动条的范围和位置;处理滚动请求并更新滑块的位置,否则滑块会在用户松开鼠标以后回到原来的位置;并根据滚动条的变化更新客户区的内容。

在WM_CREATE消息中我们设置垂直滚动条的范围和初始位置,把垂直滚动条的范围设置为0~NUMLINES − 1,也就是总行数。然后把滑块初始位置设置为0,s_iVscrollPos是静态变量,系统会自动设置未初始化的静态变量初始值为0。如果滚动条的位置是0,则第一行文字显示在客户区的顶部;如果位置是其他值,则其他行会显示在顶部;如果位置是NUMLINES − 1,则最后一行显示在客户区的顶部。

看一下对WM_PAINT消息的处理。如果是第一次执行WM_PAINT,则需要分别计算出第一列和第二列中最宽的字符串,这个宽度用于TextOut函数的X坐标;对于每一行Y坐标的计算如下:

y = s_iHeight * (i - s_iVscrollPos);

令i = 0(也就是输出第一行)时,假设垂直滚动条向下滚动了2行,也就是s_iVscrollPos的值等于2。因为客户区左上角的坐标是(0, 0),所以第一行和第二行实际上是跑到了客户区上部,只不过在客户区以外的内容是不可见的。

再看一下对WM_VSCROLL消息的处理,我们分别处理了向上滚动一行SB_LINEUP、向下滚动一行SB_LINEDOWN、向上滚动一页SB_PAGEUP、向下滚动一页SB_PAGEDOWN和按住滑块拖动SB_THUMBTRACK的情况。然后需要对滑块新位置s_iVscrollPos进行合理范围的判断,否则s_iVscrollPos值会出现小于0或大于NUMLINES − 1的情况。虽然滑块新位置s_iVscrollPos值已经计算好了,但是滑块真正的位置还没有变化,我们应该判断一下s_iVscrollPos和滑块的当前位置这两个值是否相等,如果不相等,再调用SetScrollPos函数设置滑块位置。

去掉对InvalidateRect函数的调用,看一下会是什么现象,是不是存在滚动条可以正常工作,但是客户区内容没有随之滚动的情况?如果最小化程序窗口,再将窗口恢复到原先的尺寸,导致客户区无效重绘,那么是不是客户区内容就更新过来了呢?

InvalidateRect函数向指定窗口的更新区域添加一个无效矩形:

BOOL InvalidateRect(
    _In_       HWND hWnd,     // 窗口句柄
    _In_ const RECT *lpRect,  // 无效矩形,如果设置为NULL,表示整个客户区是无效矩形
    _In_       BOOL bErase);  // 是否擦除更新区域的背景

InvalidateRect函数会导致客户区出现一个无效区域。如果客户区存在无效区域,Windows会发送WM_PAINT消息到窗口过程。

这里不可以使用UpdateWindow,前面说过:当窗口客户区的部分或全部变为“无效”且必须“更新”时,窗口过程会收到WM_PAINT消息,这也就意味着客户区必须被重绘。调用UpdateWindow,Windows会检查客户区是否存在无效区域(或更新区域),如果存在,才会向窗口过程发送WM_PAINT消息。

InvalidateRect函数向指定窗口的更新区域添加一个无效矩形,该函数会导致客户区出现一个无效区域。如果客户区存在无效区域,Windows会发送WM_PAINT消息到窗口过程。但是WM_PAINT消息是一个低优先级的消息,Windows总是在消息循环为空的时候才把WM_PAINT放入其中。每当消息循环为空的时候,如果Windows发现存在一个无效区域,就会在程序的消息队列中放入一个WM_PAINT消息。

调用UpdateWindow函数,Windows会检查客户区是否存在无效区域。如果存在,就把WM_PAINT消息直接发送到指定窗口的窗口过程,绕过应用程序的消息队列,即UpdateWindow函数导致窗口过程WindowProc立即执行case WM_PAINT逻辑,所以可以在InvalidateRect函数调用以后紧接着调用UpdateWindow函数立即刷新客户区。

与InvalidateRect函数对应的,还有一个ValidateRect函数,该函数可以从指定窗口的更新区域中删除一个矩形区域:

BOOL ValidateRect(
    _In_       HWND hWnd,       // 窗口句柄
    _In_ const RECT *lpRect);   // 使之有效的矩形,如果设置为NULL,表示整个客户区变为有效

前面讲解获取显示DC句柄的时候,曾经提及,如果可能,我们最好是在WM_PAINT消息中处理绘制工作。SystemMetrics2程序就是这样,绕了个弯,没有在WM_VSCROLL消息中进行重绘,而是通过调用InvalidateRect函数生成一个无效区域进而生成WM_PAINT消息,在WM_PAINT消息中统一进行重绘。这不是舍近求远,而是一举两得。

在学习Windows以前,我以为滚动条是自动的,但实际上需要我们自己处理各种滚动请求并作出更新、重绘,可以理解,Windows程序设计本来就是比较底层的东西。

1.SetScrollInfo和GetScrollInfo函数

SystemMetrics2程序工作正常,但是滑块的大小不能反映一页内容占据总内容的比例。假设总内容总共是3页,那么滑块大小应该是滚动条长度的1/3才可以。实际上,SetScrollRange和SetScrollPos函数是Windows向后兼容Win16的产物,微软建议我们使用新函数SetScrollInfo。之所以介绍一些老函数,一方面是因为这些函数简单易用,很多资深的程序员还在使用;另一方面,本书的目标是既能做开发,又能做逆向,所以有些过时的东西我们还需要去了解。

SetScrollInfo函数具有SetScrollRange和SetScrollPos这两个函数的功能。SetScrollInfo函数用于设置滚动条的参数,包括滚动条的最小和最大滚动范围、页面大小以及滑块位置:

int SetScrollInfo(
    _In_ HWND          hwnd,    // 滚动条所属窗口的句柄,如果fnBar 指定为SB_CTL、则是滚动条控件句柄
    _In_ int           fnBar,   // 指定要设置的滚动条,含义同SetScrollRange函数的nBar参数
    _In_ LPCSCROLLINFO lpsi,    // 在这个SCROLLINFO结构中指定滚动条的参数
    _In_ BOOL          fRedraw);// 是否重新绘制滚动条以反映对滚动条的更改

除了lpsi参数,其他的我们都已了解。lpsi参数是一个指向SCROLLINFO结构的指针,在这个结构中指定滚动条的参数。在WinUser.h头文件中SCROLLINFO结构的定义如下:

typedef struct tagSCROLLINFO
{
    UINT    cbSize;     // 该结构的大小,sizeof( SCROLLINFO)
    UINT    fMask;      // 要设置或获取哪些滚动条参数
    int     nMin;       // 最小滚动位置
    int     nMax;       // 最大滚动位置
    UINT    nPage;      // 页面大小(客户区高度或宽度),滚动条使用这个字段确定滑块的适当大小
    int     nPos;       // 滑块的位置
    int     nTrackPos;  // 用户正在拖动滑块时的即时位置,可以在处理SB_THUMBTRACK请求时使用该字段
}   SCROLLINFO, FAR *LPSCROLLINFO;

fMask字段指定要设置(SetScrollInfo)或获取(GetScrollInfo)哪些滚动条参数,值如表3.19所示。

表3.19

常量含义
SIF_PAGEnPage字段包含页面大小信息
SIF_POSnPos字段包含滑块位置信息
SIF_RANGEnMin和nMax字段包含滚动范围的最小值和最大值
SIF_DISABLENOSCROLL在调用SetScrollInfo函数设置滚动条参数时,如果没有指定这个标志,并且客户区内容比较少,不需要滚动条滚动,那么系统会删除滚动条;如果指定了这个标志,那么系统仅是禁用滚动条而不是删除
SIF_TRACKPOSnTrackPos字段包含用户拖动滑块时滑块的即时位置
SIF_ALL`SIF_PAGE

调用SetScrollInfo函数设置滚动条参数的时候,只能使用前4个标志。把fMask字段设置为需要设置的标志,并在相应的字段中指定新的参数值,函数返回值是滑块的当前位置。

SetScrollInfo函数会对SCROLLINFO结构的nPage和nPos字段指定的值进行范围检查。nPage字段必须指定为0~nMax − nMin + 1的值;nPos字段必须指定为介于nMin~nMax − nPage + 1的值。假设一共有95行,我们把范围设置为0~94,一页可以显示35行,nPos字段最大值为94 − 35 + 1 = 60。如果nPos等于60,客户区显示61~95行,那么最后一行在最底部,而不是最顶部。如果上述字段的值超出范围,则函数会将其设置为刚好在范围内的值。

GetScrollInfo函数可以获取滚动条的参数,包括滚动条的最小和最大滚动范围、页面大小、滑块位置以及滑块即时位置(处理SB_THUMBTRACK请求时):

BOOL GetScrollInfo(
    _In_    HWND         hwnd,
    _In_    int          fnBar,
    _Inout_ LPSCROLLINFO lpsi);

调用GetScrollInfo函数获取滚动条参数时,SCROLLINFO.fMask字段只能使用SIF_PAGE、SIF_POS、SIF_RANGE和SIF_TRACKPOS这几个标志。为了简洁,通常直接指定为SIF_ALL标志。函数执行成功,会将指定的滚动条参数复制到SCROLLINFO结构的相关字段中。

在处理WM_HSCROLL / WM_VSCROLL消息时,对于SB_THUMBPOSITION / SB_THUMBTRACK滚动请求使用HIWORD(wParam)获取到的是16位位置数据,即说最大值为65535;而使用SetScrollInfo / GetScrollInfo可以设置 / 获取的范围是32位数据,因为SCROLLINFO结构的范围和位置参数都是int类型。

接下来,我们使用SetScrollInfo和GetScrollInfo函数改写SystemMetrics2项目。WinMain函数除了在CreateWindowEx函数调用中加了一个WS_HSCROLL样式以添加水平滚动条以外,没有任何变化。下面仅列出WindowProc窗口过程。

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    HDC hdc;
    PAINTSTRUCT ps;
    TEXTMETRIC tm;
    SCROLLINFO si;
    HFONT hFont, hFontOld;
    static int s_iCol1, s_iCol2, s_iCol3, s_iHeight; // 第1~3列字符串的最大宽度,字符串高度
    static int s_cxClient, s_cyClient;   // 客户区宽度、高度
    static int s_cxChar;                 // 平均字符宽度,用于水平滚动条滚动单位
    int iVertPos, iHorzPos;              // 垂直、水平滚动条的当前位置
    SIZE size = { 0 };
    int x, y;
    TCHAR szBuf[10];

    switch (uMsg)
    {
    case WM_CREATE:
        hdc = GetDC(hwnd);
        hFont = CreateFont(12, 0, 0, 0, 0, 0, 0, 0, GB2312_CHARSET, 0, 0, 0, 0, TEXT("宋体"));
        hFontOld = (HFONT)SelectObject(hdc, hFont);
        for (int i = 0; i < NUMLINES; i++)
        {
            GetTextExtentPoint32(hdc, METRICS[i].m_pLabel, _tcslen(METRICS[i].m_pLabel), 
                                 &size);
            if (size.cx > s_iCol1)
                s_iCol1 = size.cx;
            GetTextExtentPoint32(hdc, METRICS[i].m_pDesc, _tcslen(METRICS[i].m_pDesc), 
                                 &size);
            if (size.cx > s_iCol2)
                s_iCol2 = size.cx;
            GetTextExtentPoint32(hdc, szBuf,
                wsprintf(szBuf, TEXT("%d"), GetSystemMetrics(METRICS[i].m_nIndex)), &size);
            if (size.cx > s_iCol3)
                s_iCol3 = size.cx;
        }
        s_iHeight = size.cy + 2;

        GetTextMetrics(hdc, &tm);
        s_cxChar = tm.tmAveCharWidth;

        SelectObject(hdc, hFontOld);
        DeleteObject(hFont);
        ReleaseDC(hwnd, hdc);
        return 0;

    case WM_SIZE:
        // 客户区宽度、高度
        s_cxClient = LOWORD(lParam);
        s_cyClient = HIWORD(lParam);
        // 设置垂直滚动条的范围和页面大小
        si.cbSize = sizeof(SCROLLINFO);
        si.fMask = SIF_RANGE | SIF_PAGE;
        si.nMin = 0;
        si.nMax = NUMLINES - 1;
        si.nPage = s_cyClient / s_iHeight;
        SetScrollInfo(hwnd, SB_VERT, &si, TRUE);
        // 设置水平滚动条的范围和页面大小
        si.cbSize = sizeof(SCROLLINFO);
        si.fMask = SIF_RANGE | SIF_PAGE;
        si.nMin = 0;
        si.nMax = (s_iCol1 + s_iCol2 + s_iCol3) / s_cxChar - 1;
        si.nPage = s_cxClient / s_cxChar;
        SetScrollInfo(hwnd, SB_HORZ, &si, TRUE);
        return 0;

    case WM_VSCROLL:
        si.cbSize = sizeof(SCROLLINFO);
        si.fMask = SIF_ALL;
        GetScrollInfo(hwnd, SB_VERT, &si);
        iVertPos = si.nPos;
        switch (LOWORD(wParam))
        {
        case SB_LINEUP:
            si.nPos -= 1;
            break;
        case SB_LINEDOWN:
            si.nPos += 1;
            break;
        case SB_PAGEUP:
            si.nPos -= si.nPage;
            break;
        case SB_PAGEDOWN:
            si.nPos += si.nPage;
            break;
        case SB_THUMBTRACK:
            si.nPos = si.nTrackPos;
            break;
        }
        // 设置位置,然后获取位置,如果si.nPos越界,Windows不会设置
        si.cbSize = sizeof(SCROLLINFO);
        si.fMask = SIF_POS;
        SetScrollInfo(hwnd, SB_VERT, &si, TRUE);
        GetScrollInfo(hwnd, SB_VERT, &si);
        // 如果Windows更新了滚动条位置,我们更新客户区
        if (iVertPos != si.nPos)
            InvalidateRect(hwnd, NULL, TRUE);
        return 0;

    case WM_HSCROLL:
        si.cbSize = sizeof(SCROLLINFO);
        si.fMask = SIF_ALL;
        GetScrollInfo(hwnd, SB_HORZ, &si);
        iHorzPos = si.nPos;
        switch (LOWORD(wParam))
        {
        case SB_LINELEFT:
            si.nPos -= 1;
            break;
        case SB_LINERIGHT:
            si.nPos += 1;
            break;
        case SB_PAGELEFT:
            si.nPos -= si.nPage;
            break;
        case SB_PAGERIGHT:
            si.nPos += si.nPage;
            break;
        case SB_THUMBTRACK:
            si.nPos = si.nTrackPos;
            break;
        }
        // 设置位置,然后获取位置,如果si.nPos越界,Windows不会设置
        si.cbSize = sizeof(SCROLLINFO);
        si.fMask = SIF_POS;
        SetScrollInfo(hwnd, SB_HORZ, &si, TRUE);
        GetScrollInfo(hwnd, SB_HORZ, &si);
        // 如果Windows更新了滚动条位置,我们更新客户区
        if (iHorzPos != si.nPos)
            InvalidateRect(hwnd, NULL, TRUE);
        return 0;

    case WM_PAINT:
        hdc = BeginPaint(hwnd, &ps);
        // 获取垂直滚动条、水平滚动条位置
        si.cbSize = sizeof(SCROLLINFO);
        si.fMask = SIF_POS;
        GetScrollInfo(hwnd, SB_VERT, &si);
        iVertPos = si.nPos;

        si.cbSize = sizeof(SCROLLINFO);
        si.fMask = SIF_POS;
        GetScrollInfo(hwnd, SB_HORZ, &si);
        iHorzPos = si.nPos;

        SetBkMode(hdc, TRANSPARENT);
        hFont = CreateFont(12, 0, 0, 0, 0, 0, 0, 0, GB2312_CHARSET, 0, 0, 0, 0, TEXT("宋体"));
        hFontOld = (HFONT)SelectObject(hdc, hFont);
        for (int i = 0; i < NUMLINES; i++)
        {
          x = s_cxChar * (-iHorzPos);
          y = s_iHeight * (i - iVertPos);
          TextOut(hdc, x, y, METRICS[i].m_pLabel, _tcslen(METRICS[i].m_pLabel));
          TextOut(hdc, x + s_iCol1,          y, METRICS[i].m_pDesc,  _tcslen(METRICS[i]  
.m_pDesc));
          TextOut(hdc, x + s_iCol1 + s_iCol2, y, szBuf,
              wsprintf(szBuf, TEXT("%d"), GetSystemMetrics(METRICS[i].m_nIndex)));
        }

        SelectObject(hdc, hFontOld);
        DeleteObject(hFont);
        EndPaint(hwnd, &ps);
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }

    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

编译运行,可以发现,因为WM_SIZE消息中SetScrollInfo函数的SCROLLINFO结构的fMask字段没有指定SIF_DISABLENOSCROLL标志,所以在不需要水平滚动条的时候,水平滚动条是不显示的。完整代码参见Chapter3\SystemMetrics3项目。

SystemMetrics3程序最先执行的是WM_CREATE消息,然后是WM_SIZE和WM_PAINT。因为在WM_SIZE消息中需要使用s_iCol1、s_iCol2、s_iCol3、s_iHeight、s_cxChar这些变量,所以我们需要在WM_CREATE消息中提前获取这些值。

看一下WM_VSCROLL消息的处理,首先调用GetScrollInfo函数获取滚动以前的位置。然后根据滚动请求更新si.nPos的值,调用SetScrollInfo函数更新滚动条位置,再次调用GetScrollInfo函数看一下滚动条位置是否真的变化了,如果变化了,就调用InvalidateRect函数使整个客户区无效。为什么绕这么大一个弯呢?前面说过,SetScrollInfo函数会对SCROLLINFO结构的nPage和nPos字段指定的值进行范围检查。nPage字段必须指定为介于0~nMax − nMin + 1的值;nPos字段必须指定为介于nMin~nMax − max(nPage −1, 0)的值。如果任一值超出其范围,则函数将其设置为刚好在范围内的值。假设现在垂直滚动条滑块在位置0处,则向上滚动一个单位,执行SB_LINEUP请求,si.nPos的值变为−1,SetScrollInfo函数是不会向上滚动一个单位的,就是说滑块位置不会变化。

2.只刷新无效区域

前面的SystemMetrics2和SystemMetrics3程序,不管客户区是滚动了一行还是一页,都统统宣布整个客户区无效。如果刷新客户区的代码很麻烦且耗时的话,就会造成程序界面卡顿。前面曾多次提及无效区域的概念,发生滚动条滚动请求以后,我们可以仅让新出现的那些行无效,WM_PAINT只需要刷新这些行所占的区域即可,这样的逻辑无疑会更高效。当然了,对于代码逻辑很简单的情况,在当今强大的CPU面前,我们应该更注重代码简洁与易于理解。下面我们就只刷新无效区域,仅列出WindowProc中代码发生变化的几个消息:

case WM_VSCROLL:
    si.cbSize = sizeof(SCROLLINFO);
    si.fMask = SIF_ALL;
    GetScrollInfo(hwnd, SB_VERT, &si);
    iVertPos = si.nPos;
    switch (LOWORD(wParam))
    {
    case SB_LINEUP:
        si.nPos -= 1;
        break;
    case SB_LINEDOWN:
        si.nPos += 1;
        break;
    case SB_PAGEUP:
        si.nPos -= si.nPage;
        break;
    case SB_PAGEDOWN:
        si.nPos += si.nPage;
        break;
    case SB_THUMBTRACK:
        si.nPos = si.nTrackPos;
        break;
    }
    // 设置位置,然后获取位置。如果si.nPos越界,则Windows不会设置
    si.cbSize = sizeof(SCROLLINFO);
    si.fMask = SIF_POS;
    SetScrollInfo(hwnd, SB_VERT, &si, TRUE);
    GetScrollInfo(hwnd, SB_VERT, &si);
    // 如果Windows更新了滚动条位置,那么我们更新客户区
    if (iVertPos != si.nPos)
    {
        ScrollWindow(hwnd, 0, s_iHeight * (iVertPos - si.nPos), NULL, NULL);
		UpdateWindow(hwnd); 
    }
    return 0;

case WM_HSCROLL:
    si.cbSize = sizeof(SCROLLINFO);
    si.fMask = SIF_ALL;
    GetScrollInfo(hwnd, SB_HORZ, &si);
    iHorzPos = si.nPos;
    switch (LOWORD(wParam))
    {
    case SB_LINELEFT:
        si.nPos -= 1;
        break;
    case SB_LINERIGHT:
        si.nPos += 1;
        break;
    case SB_PAGELEFT:
        si.nPos -= si.nPage;
        break;
    case SB_PAGERIGHT:
        si.nPos += si.nPage;
        break;
    case SB_THUMBTRACK:
        si.nPos = si.nTrackPos;
        break;
    }
    // 设置位置,然后获取位置。如果si.nPos越界,则Windows不会设置
    si.cbSize = sizeof(SCROLLINFO);
    si.fMask = SIF_POS;
    SetScrollInfo(hwnd, SB_HORZ, &si, TRUE);
    GetScrollInfo(hwnd, SB_HORZ, &si);
    // 如果Windows更新了滚动条位置,那么我们更新客户区
    if (iHorzPos != si.nPos)
    {
        ScrollWindow(hwnd, s_cxChar * (iHorzPos - si.nPos), 0, NULL, NULL);
		UpdateWindow(hwnd); 
    }
    return 0;

case WM_PAINT:
    hdc = BeginPaint(hwnd, &ps);
    // 获取垂直滚动条、水平滚动条位置
    si.cbSize = sizeof(SCROLLINFO);
    si.fMask = SIF_POS | SIF_PAGE;
    GetScrollInfo(hwnd, SB_VERT, &si);
    iVertPos = si.nPos;
    si.cbSize = sizeof(SCROLLINFO);
    si.fMask = SIF_POS;
    GetScrollInfo(hwnd, SB_HORZ, &si);
    iHorzPos = si.nPos;

    SetBkMode(hdc, TRANSPARENT);
    hFont = CreateFont(12, 0, 0, 0, 0, 0, 0, 0, GB2312_CHARSET, 0, 0, 0, 0, TEXT("宋体"));
    hFontOld = (HFONT)SelectObject(hdc, hFont);

    // 获取无效区域
	nPaintBeg = max(0, iVertPos + ps.rcPaint.top / s_iHeight);
	nPaintEnd = min(NUMLINES - 1, iVertPos + ps.rcPaint.bottom / s_iHeight);
    for (int i = nPaintBeg; i <= nPaintEnd; i++)
    {
        x = s_cxChar * (-iHorzPos);
        y = s_iHeight * (i - iVertPos);
        TextOut(hdc, x,                     y, METRICS[i].m_pLabel, _tcslen(METRICS[i].
                m_pLabel));
        TextOut(hdc, x + s_iCol1,           y, METRICS[i].m_pDesc,  _tcslen(METRICS[i].
                m_pDesc));
        TextOut(hdc, x + s_iCol1 + s_iCol2, y, szBuf,
            wsprintf(szBuf, TEXT("%d"), GetSystemMetrics(METRICS[i].m_nIndex)));
    }

    SelectObject(hdc, hFontOld);
    DeleteObject(hFont);
    EndPaint(hwnd, &ps);
    return 0;

完整代码参见Chapter3\SystemMetrics4项目。读者可以在nPaintBeg = max(0, iVertPos + ps.rcPaint.top / s_iHeight);这一行按F9键设置断点,查看发生滚动事件时PAINTSTRUCT结构的无效矩形。

ScrollWindow函数滚动指定窗口的客户区:

BOOL ScrollWindow(
    _In_       HWND hWnd,         // 窗口句柄
    _In_       int  XAmount,      // 水平滚动的量
    _In_       int  YAmount,      // 垂直滚动的量
    _In_ const RECT *lpRect,      // 将要滚动的客户区部分的RECT结构设置为NULL,则滚动整个客户区
    _In_ const RECT *lpClipRect); // 裁剪矩形RECT结构,矩形外部的区域不会被绘制

lpRect和lpClipRect这两个参数挺有意思的,读者可以试着设置一下这两个参数看一看效果。

Windows会自动将新滚动出现的区域无效化,从而产生一条WM_PAINT消息,因此不需要调用InvalidateRect函数。

ScrollWindow函数有一个扩展版本ScrollWindowEx,功能更多,也是微软建议使用的,不过参数比较多,有点复杂,具体用法请参考MSDN。

3.根据客户区内容调整程序窗口大小

在我的1366 768分辨率的笔记本上,CreateWindowEx函数的宽度和高度参数指定为CW_USEDEFAULT,SystemMetrics4程序运行效果如原书图3.7所示。

可以看到客户区右边还有一大块空白,不是很美观。我们希望窗口宽度正好容纳3列文本,即根据3列文本的宽度之和计算窗口宽度,窗口宽度包括客户区宽度、滚动条宽度和边框宽度等,计算起来不是很方便。在WM_CREATE消息中s_cxChar = tm.tmAveCharWidth;语句的下面添加如下语句:

GetClientRect(hwnd, &rect);
rect.right = s_iCol1 + s_iCol2 + s_iCol3 + GetSystemMetrics(SM_CXVSCROLL);
AdjustWindowRectEx(&rect, GetWindowLongPtr(hwnd, GWL_STYLE),
    GetMenu(hwnd) != NULL, GetWindowLongPtr(hwnd, GWL_EXSTYLE));
SetWindowPos(hwnd, NULL, 0, 0, rect.right - rect.left, rect.bottom - rect.top,
    SWP_NOZORDER | SWP_NOMOVE);

窗口高度我们没有改变。首先通过调用GetClientRect函数获取客户区坐标,客户区坐标是相对于窗口客户区左上角的,因此获取到的左上角的坐标是(0,0),即rect.right等于客户区宽度,rect.bottom等于客户区高度;把客户区的宽度重新设置为三列文本宽度之和再加上垂直滚动条的宽度;为AdjustWindowRectEx函数指定窗口样式、扩展窗口样式以及是否有菜单栏,该函数可以根据客户区坐标计算窗口坐标,但是计算出的窗口坐标不包括滚动条,所以前面客户区的宽度我们又加上了一个垂直滚动条的宽度,需要注意的是,计算出来的窗口坐标是相对于客户区左上角的。窗口坐标的左上角并不是(0,0),所以窗口宽度等于rect.right−rect.left,窗口高度等于rect.bottom−rect.top;最后调用SetWindowPos函数设置窗口大小。

GetMenu函数获取指定窗口的菜单句柄,如果函数执行成功,则返回值是菜单的句柄;如果这个窗口没有菜单,则返回NULL,这个函数很简单。接下来介绍一下GetWindowLongPtr、AdjustWindowRectEx和SetWindowPos这3个函数。

要介绍GetWindowLongPtr函数,不得不先介绍一下SetWindowLongPtr函数。SetWindowLongPtr是SetWindowLong函数的升级版本,指针和句柄在32位Windows上为32位,在64位Windows上为64位。使用SetWindowLong函数设置指针或句柄只能设置32位的,要编写32位和64位版本兼容的代码,应该使用SetWindowLongPtr函数。如果编译为32位程序,则对SetWindowLongPtr函数的调用实际上还是调用SetWindowLong。SetWindowLongPtr函数设置窗口类中与每个窗口关联的额外内存的数据,或设置指定窗口的属性:

LONG_PTR WINAPI SetWindowLongPtr(
    _In_ HWND     hWnd,      // 窗口句柄
    _In_ int      nIndex,    // 要设置哪一项
    _In_ LONG_PTR dwNewLong);// 新值

参数nIndex指定要设置哪一项。WNDCLASSEX结构有一个cbWndExtra字段,该字段用于指定紧跟在窗口实例后面的附加数据字节数,用来存放自定义数据,即与每个窗口相关联的附加自定义数据,假设我们设置wndclass.cbWndExtra = 16,16字节可以存放2个__int64型数据或4个int型数据,nIndex参数指定为0、8分别表示要设置第1、2个__int64型数据。如果存放的是int型数据,则可以设置为0、4、8、12。如果要设置窗口的一些属性,值如表3.20所示。

表3.20

常量含义
GWL_EXSTYLE设置扩展窗口样式
GWL_STYLE设置窗口样式
GWLP_HINSTANCE设置应用程序的实例句柄
GWLP_ID设置窗口的ID,用于子窗口
GWLP_USERDATA设置与窗口关联的用户数据
GWLP_WNDPROC设置指向窗口过程的指针

如果函数执行成功,则返回值是指定偏移量处或窗口属性的先前值;如果函数执行失败,则返回值为0。

GetWindowLong和GetWindowLongPtr函数可以获取指定窗口的自定义数据或窗口的一些属性:

LONG_PTR WINAPI GetWindowLongPtr(
    _In_ HWND hWnd,     // 窗口句柄
    _In_ int  nIndex);  // 要获取哪一项

如果函数执行成功,则返回所请求的值;如果函数执行失败,则返回值为0。

AdjustWindowRectEx函数根据客户区的大小计算所需的窗口大小:

BOOL WINAPI AdjustWindowRectEx(
    _Inout_ LPRECT lpRect,      // 提供客户区坐标的RECT结构,函数在这个结构中返回所需的窗口坐标
    _In_    DWORD  dwStyle,     // 窗口的窗口样式
    _In_    BOOL   bMenu,       // 窗口是否有菜单
    _In_    DWORD  dwExStyle);  // 窗口的扩展窗口样式

SetWindowPos函数可以更改一个子窗口、顶级窗口的大小、位置和Z顺序,其中Z顺序是指窗口的前后顺序。假设桌面上有很多程序窗口,互相重叠覆盖,更改Z顺序可以确定哪个窗口在前或在后:

BOOL WINAPI SetWindowPos(
    _In_     HWND hWnd,             // 要调整大小、位置或Z顺序的窗口的窗口句柄
    _In_opt_ HWND hWndInsertAfter,  // 指定一个窗口句柄或一些预定义值
    _In_     int  X,                // 窗口新位置的X坐标,以像素为单位
    _In_     int  Y,                // 窗口新位置的Y坐标,以像素为单位
    _In_     int  cx,               // 窗口的新宽度,以像素为单位
    _In_     int  cy,               // 窗口的新高度,以像素为单位
 _In_     UINT uFlags);          // 窗口的大小和定位标志
  • 参数hWndInsertAfter指定一个窗口句柄,hWnd窗口将位于这个窗口之前,即hWndInsertAfter窗口作为定位窗口,可以设置为NULL。参数hWndInsertAfter也可以指定为表3.21所示的值。

表3.21

常量含义
HWND_TOP把窗口放置在Z顺序的顶部
HWND_BOTTOM把窗口放置在Z顺序的底部
HWND_TOPMOST窗口始终保持为最顶部的窗口,即使该窗口没有被激活
HWND_NOTOPMOST取消始终保持为最顶部的窗口
  • 参数X和Y指定窗口新位置的X和Y坐标。如果hWnd参数指定的窗口是顶级窗口,则相对于屏幕左上角;如果是子窗口,则相对于父窗口客户区的左上角。

  • 参数uFlags指定窗口的大小和定位标志,常用的值如表3.22所示。

表3.22

常量含义
SWP_NOZORDER维持当前Z序(忽略hWndInsertAfter参数)
SWP_NOMOVE维持当前位置(忽略X和Y参数)
SWP_NOSIZE维持当前尺寸(忽略cx和cy参数)
SWP_HIDEWINDOW隐藏窗口
SWP_SHOWWINDOW显示窗口

例如上面的示例使用SWP_NOZORDER | SWP_NOMOVE标志,表示忽略hWndInsertAfter、X和Y参数,保持Z顺序和窗口位置不变,仅改变窗口大小。有时候我们希望把一个窗口设置为始终保持为最顶部,可以这样使用:SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);。

MoveWindow函数可以更改一个子窗口、顶级窗口的位置和尺寸。实际上SetWindowPos函数具有MoveWindow的全部功能。MoveWindow函数通常用于设置子窗口:

BOOL WINAPI MoveWindow(
    _In_ HWND hWnd,     // 要调整大小、位置的窗口的窗口句柄
    _In_ int  X,        // 窗口新位置的X坐标,以像素为单位
    _In_ int  Y,        // 窗口新位置的Y坐标,以像素为单位
    _In_ int  nWidth,   // 窗口的新宽度,以像素为单位
    _In_ int  nHeight,  // 窗口的新高度,以像素为单位
    _In_ BOOL bRepaint);// 是否要重新绘制窗口,通常指定为TRUE

总结一下,窗口过程在什么时候会收到WM_PAINT消息。

  • 当程序窗口被首次创建时,整个客户区都是无效的,因为此时应用程序尚未在该窗口上绘制任何东西,此时窗口过程会收到第一条WM_PAINT消息。

  • 在调整程序窗口的尺寸时,客户区也会变为无效。我们把WNDCLASSEX结构的style字段设置为CS_HREDRAW | CS_VREDRAW,表示当程序窗口尺寸发生变化时,整个窗口客户区都应宣布无效,窗口过程会接收到一条WM_PAINT消息。

  • 如果先最小化程序窗口,然后将窗口恢复到原先的尺寸,那么Windows并不会保存原先客户区的内容,窗口过程接收到WM_PAINT消息后需要自行恢复客户区的内容。

  • 在屏幕中拖动程序窗口的全部或一部分到屏幕以外,然后又拖动回屏幕中的时候,窗口被标记为无效,窗口过程会收到一条WM_PAINT消息,并对客户区的内容进行重绘。

  • 程序调用InvalidateRect或InvalidateRgn函数向客户区添加无效区域,会生成WM_PAINT消息。

  • 程序调用ScrollWindow或ScrollDC函数滚动客户区。

InvalidateRgn和ScrollDC函数,以后用到的时候再解释。

还有一个问题,SystemMetrics程序不能使用键盘的Home、End和方向键进行滚动,标准滚动条的键盘接口需要我们自己去实现,不过相当简单,等学习了第4章以后再添加键盘接口。

3.2.4 保存设备环境

调用GetDC或BeginPaint函数以后,会返回一个DC句柄,DC的所有属性都被设定为默认值。如果程序需要使用非默认的DC属性,可以在获取到DC句柄以后设置相关DC属性;在调用ReleaseDC或EndPaint函数以后,系统将恢复DC属性的默认值,对属性所做的任何改变都会丢失。例如:

case WM_PAINT:
    hdc = BeginPaint(hwnd, &ps);
    // 设置设备环境属性
    // 绘制代码
    EndPaint(hwnd, &ps);
    return 0;

有没有办法在释放DC时保存对属性所做的更改,以便在下次调用GetDC或BeginPaint函数时这些属性仍然有效呢?还记得WNDCLASSEX结构的第2个字段style吗?这个字段指定窗口类样式,其中CS_OWNDC表示为窗口类的每个窗口分配唯一的DC。可以按如下方式设置style字段:

wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;

现在,每个基于这个窗口类创建的窗口都有它私有的专用DC。使用CS_OWNDC样式以后,只需要初始化DC属性一次,例如,在处理WM_CREATE消息时:

case WM_CREATE:
    hdc = GetDC(hwnd);
    // 设置设备环境属性
    ReleaseDC(hwnd, hdc);
    return 0;

在窗口的生命周期内,除非再次改变DC的属性值,原DC属性会一直有效。对于SystemMetrics程序,我们可以在WM_CREATE消息中设置背景模式和字体,这样一来就不需要每一次都在WM_PAINT消息中设置了。对于客户区需要大量绘图操作的情况,指定CS_OWNDC样式可以提高程序性能。

需要注意的是,指定CS_OWNDC样式仅影响通过GetDC和BeginPaint函数获取的DC句柄,通过其他函数(例如GetWindowDC)获取的DC是不受影响的。

有时候可能想改变某些DC属性,然后使用改变后的属性进行绘制,接着再恢复原来的DC属性,可以使用SaveDC和RestoreDC函数来保存和恢复DC状态。

SaveDC函数通过把DC属性压入DC堆栈来保存指定DC的当前状态:

int SaveDC(_In_ HDC hdc);   // 要保存其状态的设备环境句柄

如果函数执行成功,则返回值将标识保存的状态;如果函数执行失败,则返回值为0。

RestoreDC函数通过从DC堆栈中弹出状态信息来恢复DC到指定状态:

BOOL RestoreDC(
    _In_ HDC hdc,           // 要恢复其状态的设备环境句柄
    _In_ int nSavedDC);     // 要还原的保存状态

参数nSavedDC指定要还原的保存状态,可以指定为SaveDC函数的返回值,或者指定为负数,例如−1表示最近保存的状态,−2表示最近保存的状态的前一次。

同一状态不能多次恢复,恢复状态后保存的所有状态将被弹出销毁。另外还有一点需要注意,请看代码:

// 设置设备环境属性,然后保存
nDC1 = SaveDC(hdc);
// 再次设置设备环境属性,然后保存
nDC2 = SaveDC(hdc);
// …………
RestoreDC(hdc, nDC1);
// 使用状态1进行绘图
RestoreDC(hdc, nDC2);   // 恢复失败
// 使用状态2进行绘图

调用RestoreDC函数把DC状态恢复到nDC1,DC堆栈会弹出nDC1及以后压入堆栈的内容。

3.3 绘制直线和曲线

许多应用程序经常需要绘制直线和曲线,例如CAD和绘图程序会使用直线和曲线来绘制对象的轮廓、指定对象的中心,电子表格程序会使用直线和曲线绘制单元格、图表等。

3.3.1 绘制像素点

调用SetPixel函数可以将指定坐标处的像素设置为指定的颜色,GetPixel函数用于获取指定坐标处的像素COLORREF颜色值:

COLORREF SetPixel(_In_ HDC hdc, _In_ int X, _In_ int Y, _In_ COLORREF crColor);
COLORREF GetPixel(_In_ HDC hdc, _In_ int X, _In_ int Y);

GetPixel函数返回一个COLORREF颜色值,可以分别使用GetRValue、GetGValue和GetBValue宏提取COLORREF颜色值中的的红色、绿色和蓝色值。

SetPixel函数可以绘制任意复杂的图形,例如画一条线:

for (int i = 0; i < 100; i++)
    SetPixel(hdc, i, 10, RGB(255, 0, 0));

虽然绘制像素是最基本的绘图操作方法,但是在程序中一般很少使用SetPixel函数,因为它的开销很大,只适合用在需要绘制少量像素的地方。如果需要绘制一个线条或者一片区域,那么推荐使用后面介绍的画线函数或填充图形函数,因为这些函数是在驱动程序级别上完成的,用到了硬件加速功能。

我们也经常需要获取某个坐标处像素的颜色值,但是不应该通过GetPixel函数来获取一大块像素数据。如果需要分析一片区域的像素数据,可以把全部像素数据复制到内存中再进行处理。

3.3.2 绘制直线

常用的绘制直线的函数有LineTo、Polyline、PolylineTo和PolyPolyline。绘制直线的函数比较简单,LineTo函数从当前位置到指定的点之间绘制一条直线(线段);Polyline、PolylineTo函数通过连接指定数组中的点来绘制一系列线段;PolyPolyline函数相当于一次调用多个Polyline。

LineTo函数以当前位置为起点,以指定的点为终点,画一条线段:

BOOL LineTo(
    _In_ HDC hdc,   // 设备环境句柄
    _In_ int nXEnd, // 终点的X坐标,逻辑单位
    _In_ int nYEnd);// 终点的Y坐标,逻辑单位

函数执行成功,指定的终点(nXEnd,nYEnd)会被设置为新的当前位置。

当前位置作为某些GDI函数绘制的起点,DC中的默认当前位置是客户区坐标(0,0)处。以LineTo函数为例,如果没有设置当前位置,那么调用LineTo函数就会从客户区的左上角开始到指定的终点之间画一条线。

MoveToEx函数用于将当前位置更新为指定的点,并可以返回上一个当前位置:

BOOL MoveToEx(
    _In_        HDC     hdc,      // 设备环境句柄
    _In_        int     X,        // 新当前位置的X坐标,逻辑单位
    _In_        int     Y,        // 新当前位置的Y坐标,逻辑单位
    _Out_opt_   LPPOINT lpPoint); // 在这个POINT结构中返回上一个当前位置,可以
                                  // 设置为NULL

在调用需要使用当前位置的GDI函数进行绘制以前,通常需要先调用MoveToEx设置DC的当前位置。

Polyline函数通过连接指定数组中的点来绘制一系列线段:

BOOL Polyline(
    _In_       HDC   hdc,       // 设备环境句柄
    _In_ const POINT *lppt,     // 点结构数组,逻辑单位
    _In_       int   cPoints);  // lppt数组中点的个数,必须大于或等于2

需要注意的是,Polyline函数既不使用也不更新当前位置。

PolylineTo函数和Polyline函数功能相同:

BOOL PolylineTo(
    _In_       HDC   hdc,       // 设备环境句柄
    _In_ const POINT *lppt,     // 点结构数组,逻辑单位
    _In_       DWORD cCount);   // lppt数组中点的个数

唯一不同的是,PolylineTo函数会使用并更新当前位置。函数从当前位置到lppt参数指定数组中的第一个点绘制第一条线,然后从上一条线段的终点到lppt数组指定的下一点画第二条线,直到最后一个点。绘制结束时PolylineTo函数会将当前位置设置为最后一条线的终点。

PolyPolyline函数在功能上相当于调用了多个Polyline,就是说可以绘制多个一系列线段:

BOOL PolyPolyline(
    HDC         hdc,   // 设备环境句柄
    const POINT *apt,  // 点结构数组,逻辑单位。可以理解为是多个组,一个组可以画一系列线段
    const DWORD *asz,  // DWORD 类型数组,每个数组元素指定apt数组中每一个组有几个点
    DWORD       csz);  // 组的个数,也就是asz数组的数组元素个数,也就是画多个一系列线段

参数asz是一个DWORD类型的数组,分别指定apt数组中每一个组有几个点,每一个组的点个数必须大于或等于2。该函数既不使用也不更新当前位置。

可以看出只有带To的函数才使用和更新当前位置。

DC包含影响直线和曲线输出的一些属性,直线和曲线用到的属性包括当前位置、画笔样式、宽度和颜色、画刷样式和颜色等。

Windows使用当前画笔绘制直线和曲线,默认画笔是一个1像素宽的实心黑色画笔(BLACK_PEN)。可以通过调用GetStockObject函数获取系统的备用画笔,可用的备用画笔如表3.23所示。

表3.23

常量含义
BLACK_PEN黑色画笔(默认画笔)
WHITE_PEN白色画笔
NULL_PEN空画笔,表示什么也不画
DC_PENDC画笔,默认颜色为白色,可以使用SetDCPenColor函数更改颜色

我们还可以通过调用CreatePen / CreatePenIndirect函数来创建新的逻辑画笔。创建好画笔以后可以通过调用SelectObject函数将其选入DC中。

画线函数通常不使用画刷。默认画刷为纯白画刷(WHITE_BRUSH),可以通过调用GetStockObject函数获取系统的备用画刷。备用画刷在讲解注册窗口类的WNDCLASSEX结构时说过,有白色、黑色、灰色等几种;还可以通过调用CreateSolidBrush / CreateBrushIndirect函数来创建新的逻辑画刷。创建好画刷以后可以通过调用SelectObject函数将其选入DC中。

接下来看一下创建画笔的几个函数。

CreatePen / CreatePenIndirect函数创建具有指定样式、宽度和颜色的逻辑画笔:

HPEN CreatePen(
    _In_ int      fnPenStyle,// 画笔样式
    _In_ int      nWidth,    // 画笔宽度,逻辑单位
    _In_ COLORREF crColor);  // 画笔颜色,使用RGB宏
HPEN CreatePenIndirect(_In_ const LOGPEN *lplgpn);  // LOGPEN结构

参数fnPenStyle指定画笔样式,值如表3.24所示。

表3.24

常量含义
PS_SOLID实心画笔
PS_DASH划线
PS_DOT点线
PS_DASHDOT交替的划线和点线
PS_DASHDOTDOT交替的划线和双点线
PS_INSIDEFRAMEPS_SOLID和PS_INSIDEFRAME样式的画笔使用的都是实心线条,它们之间的区别是当画笔的宽度大于1像素,且使用区域绘画函数(例如绘制矩形)的时候,PS_SOLID样式的线条会居中画于边框线上;而PS_INSIDEFRAME样式的线条会全部画在边框线里面,画笔的宽度会向区域的内部扩展,所以它的名称是INSIDEFRAME
PS_NULL空,什么也不画

这几种样式的画笔效果如原书图3.8所示。

对于PS_DASH、PS_DOT、PS_DASHDOT和PS_DASHDOTDOT样式,如果指定的宽度nWidth大于1,那么会被替换为具有nWidth宽度的PS_SOLID样式的画笔,即这些样式的画笔只能是1像素宽。对于上述4种样式的画笔,划线和点线中间的空白默认是不透明、白色,可以通过调用SetBkMode和SetBkColor函数改变背景模式和背景颜色。

CreatePenIndirect函数的lplgpn参数是一个指向LOGPEN结构的指针,用于定义画笔的样式、宽度和颜色,LOGPEN结构在wingdi.h头文件中定义如下:

typedef struct tagLOGPEN
  {
    UINT        lopnStyle;
    POINT       lopnWidth;
    COLORREF    lopnColor;
  } LOGPEN, *PLOGPEN, NEAR *NPLOGPEN, FAR *LPLOGPEN;

这3个字段的含义和CreatePen函数的3个参数一一对应。

如果函数执行成功,则返回值是逻辑画笔的句柄,HPEN是画笔句柄类型;如果函数执行失败,则返回值为NULL。

再看一下创建画刷的几个函数。

CreateSolidBrush函数创建具有指定颜色的纯色逻辑画刷:

HBRUSH CreateSolidBrush(_In_ COLORREF crColor);  // COLORREF颜色值,使用RGB宏

函数执行成功,返回一个逻辑画刷句柄,HBRUSH是画刷句柄类型。

如果需要使用系统颜色画刷进行绘制,直接使用GetSysColorBrush即可,不需要使用CreateSolidBrush(GetSysColor(nIndex))创建画刷。因为GetSysColorBrush直接返回系统缓存的画刷,而不是创建新的画刷,不用的时候不需要调用DeleteObject函数将其删除:

COLORREF GetSysColor(_In_ int nIndex);      // nIndex指定为标准系统颜色,返回对应的COLORREF颜色值
HBRUSH GetSysColorBrush(_In_ int nIndex);   // nIndex指定为标准系统颜色,返回这个颜色的画刷句柄

CreateHatchBrush函数创建具有阴影样式的逻辑画刷:

HBRUSH CreateHatchBrush(
    _In_ int      fnStyle,  // 阴影样式
    _In_ COLORREF clrref);  // COLORREF颜色值

fnStyle指定阴影样式,可用的值如表3.25所示。

表3.25

常量含义
HS_BDIAGONAL从左到右看是向上45度的斜线
HS_CROSS水平和垂直交叉线
HS_DIAGCROSS45度交叉线
HS_FDIAGONAL从左到右看是向下45度的斜线
HS_HORIZONTAL水平线
HS_VERTICAL垂直线

这几种样式的阴影画刷效果如原书图3.9所示。

阴影中间的空白默认为不透明、白色,可以调用SetBkMode和SetBkColor函数改变背景模式和背景颜色。

CreatePatternBrush函数可以创建一个具有位图图案的逻辑画刷:

HBRUSH CreatePatternBrush(HBITMAP hbm); // 位图句柄

CreateBrushIndirect函数创建具有指定样式、颜色和图案的逻辑画刷:

HBRUSH CreateBrushIndirect(_In_ const LOGBRUSH *lplb);

CreateBrushIndirect函数具有前面所有函数的功能,而且也比较简单。参数lplb是一个指向LOGBRUSH结构的指针。LOGBRUSH结构在wingdi.h头文件中定义如下:

typedef struct tagLOGBRUSH
{
    UINT        lbStyle;    // 样式
    COLORREF    lbColor;    // 颜色
    ULONG_PTR   lbHatch;    // 图案
} LOGBRUSH, *PLOGBRUSH, NEAR *NPLOGBRUSH, FAR *LPLOGBRUSH;
  • lbStyle字段指定画刷样式,值如表3.26所示。

表3.26

常量含义
BS_DIBPATTERN、BS_DIBPATTERN8X8由设备无关位图(DIB)定义的图案画刷,lbHatch字段指定为DIB的句柄
BS_DIBPATTERNPT由设备无关位图(DIB)定义的图案画刷,lbHatch字段指定为DIB的句柄
BS_SOLID实心画刷
BS_HATCHED阴影画刷
BS_PATTERN、BS_PATTERN8X8由内存位图定义的图案画刷,lbHatch字段指定为内存位图的句柄
BS_HOLLOW、BS_NULL空画刷
  • lbColor字段指定画刷的颜色,通常用于BS_SOLID或BS_HATCHED样式的画刷。

  • lbHatch字段的含义取决于lbStyle定义的画刷样式。如果lbStyle字段指定为BS_HATCHED,则lbHatch字段指定阴影填充的线的方向,可用的值与CreateHatchBrush函数的fnStyle字段相同;如果lbStyle字段指定为BS_SOLID或BS_HOLLOW、BS_NULL,则忽略lbHatch字段。

当不再需要创建的逻辑画笔、画刷时,需要调用DeleteObject函数将其删除。

先练习一下这几个画线函数的用法。Line程序使用前面介绍的LineTo、Polyline、PolylineTo、PolyPolyline函数画线。程序运行效果如原书图3.10所示。

其中,Line程序使用PolyPolyline函数画了一个立方体,分为2组,第1组画了1~3,第2组画了①~⑥。Line.cpp源文件的内容如下所示:

#include <Windows.h>
#include <tchar.h>

// 函数声明,窗口过程
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM   
wParam, LPARAM lParam);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int   
nCmdShow)
{
    WNDCLASSEX wndclass;
    TCHAR szClassName[] = TEXT("MyWindow");
    TCHAR szAppName[] = TEXT("直线");
    HWND hwnd;
    MSG msg;

    wndclass.cbSize = sizeof(WNDCLASSEX);
    wndclass.style = CS_HREDRAW | CS_VREDRAW;
    wndclass.lpfnWndProc = WindowProc;
    wndclass.cbClsExtra = 0;
    wndclass.cbWndExtra = 0;
    wndclass.hInstance = hInstance;
    wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
    wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
    wndclass.lpszMenuName = NULL;
    wndclass.lpszClassName = szClassName;
    wndclass.hIconSm = NULL;
    RegisterClassEx(&wndclass);

    hwnd = CreateWindowEx(0, szClassName, szAppName, WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, 240, 300, NULL, NULL, hInstance, NULL);

    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);

    while (GetMessage(&msg, NULL, 0, 0) != 0)
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return msg.wParam;
}

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    HDC hdc;
	PAINTSTRUCT ps;

    POINT arrPtPolyPolyline[] = {                  // PolyPolyline函数的点
        110,60, 10,60, 60,10, 160,10,
        10,60, 10,160, 110,160, 110,60, 160,10, 160,110, 110,160,
        /*10,160, 60,110, 160,110,
        60,110, 60,10*/
    };
	DWORD arrGroup[] = { 4, 7 };

	POINT arrPtPolyline[] = { 10,220, 110,200, 210,220 };  // Polyline函数的点

    POINT arrPtPolylineTo[] = { 110,260, 210,240 };    // PolylineTo函数的点

    switch (uMsg)
    {
    case WM_PAINT:
    {
        hdc = BeginPaint(hwnd, &ps);
        SetBkMode(hdc, TRANSPARENT);
        // 宽度为3的红色实心画笔画立方体
        SelectObject(hdc, CreatePen(PS_SOLID, 3, RGB(255, 0, 0)));
        PolyPolyline(hdc, arrPtPolyPolyline, arrGroup, _countof(arrGroup));

        // 绿色划线画笔画1条线
        DeleteObject(SelectObject(hdc, CreatePen(PS_DASH, 1, RGB(0, 255, 0))));
        MoveToEx(hdc, 10, 180, NULL);
        LineTo(hdc, 210, 180);

        // 蓝色点线画笔画2条线
        DeleteObject(SelectObject(hdc, CreatePen(PS_DOT, 1, RGB(0, 0, 255))));
        Polyline(hdc, arrPtPolyline, _countof(arrPtPolyline));

        // 黑色点划线画笔画2条线
        DeleteObject(SelectObject(hdc, CreatePen(PS_DASHDOT, 1, RGB(0, 0, 0))));
        MoveToEx(hdc, 10, 240, NULL);
        PolylineTo(hdc, arrPtPolylineTo, _countof(arrPtPolylineTo));

        DeleteObject(SelectObject(hdc, GetStockObject(BLACK_PEN)));
        EndPaint(hwnd, &ps);
        return 0;
    }

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }

    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

具体代码参见Chapter3\Line项目。

使用GDI函数进行图形绘制的一般流程如下所示。

(1)获取DC句柄hdc。

(2)创建GDI对象,调用SelectObject函数把GDI对象选入DC以改变一些DC属性。

(3)调用GDI图形绘制函数在DC中进行绘图。

(4)删除创建的GDI对象,恢复DC的默认属性。

3.3.3 绘制曲线

常用的绘制曲线的函数有Arc、ArcTo、PolyBezier、PolyBezierTo,可以绘制直线和曲线组合的函数有AngleArc、PolyDraw。

Arc函数用于绘制椭圆弧线,就是椭圆(包括正圆形)边框的一部分:

BOOL Arc(
    _In_ HDC hdc,           // 设备环境句柄,以下单位均是逻辑单位
    _In_ int nLeftRect,     // 边界矩形左上角的X坐标
    _In_ int nTopRect,      // 边界矩形左上角的Y坐标
    _In_ int nRightRect,    // 边界矩形右下角的X坐标
    _In_ int nBottomRect,   // 边界矩形右下角的Y坐标
    _In_ int nXStartArc,    // 弧起点的X坐标
    _In_ int nYStartArc,    // 弧起点的Y坐标
    _In_ int nXEndArc,      // 弧终点的X坐标
    _In_ int nYEndArc);     // 弧终点的Y坐标

点(nLeftRect,nTopRect)和(nRightRect,nBottomRect)指定边界矩形,边界矩形内的椭圆定义了椭圆弧线的范围。将矩形中心到起点(nXStartArc,nYStartArc)与椭圆的相交点作为弧线的起点,矩形中心到终点(nXEndArc,nYEndArc)与椭圆的相交点作为弧线的终点,从弧线的起点到终点沿当前绘图方向绘制。如果起点和终点相同,则会绘制一个完整的椭圆形(内部不会填充)。具体请结合原书图3.11理解,其中的实心弧线就是Arc函数所画的弧线。

DC有一个当前绘图方向属性对Arc函数有影响。默认绘图方向是逆时针方向,可以通过调用GetArcDirection和SetArcDirection函数获取和设置DC的当前绘图方向。如果更改绘图方向为顺时针,那么原书图3.11中的椭圆弧线就会变为椭圆的虚线部分。

Arc函数既不使用也不更新当前位置。

ArcTo函数的参数和Arc完全相同,只不过ArcTo函数会从当前位置到弧线起点额外画一条线,而且会更新DC的当前位置为弧线终点。注意,这里的弧线起点不一定是函数中定义的起点,除非起点(nXStartArc,nYStartArc)正好定义为弧线起点,这里的弧线终点不一定是函数中定义的终点,除非终点(nXEndArc,nYEndArc)正好定义为弧线终点。原书图3.12中的实心直线和弧线就是ArcTo函数绘制的结果。

贝塞尔曲线(Bezier curve)又称贝兹曲线或贝济埃曲线,是应用于二维图形应用程序的数学不规则曲线,由法国数学家皮埃尔·贝塞尔(Pierre Bezier)发明,为计算机矢量图形学奠定了基础。我们在绘图工具上看到的钢笔工具就是用来绘制这种矢量曲线的。

PolyBezier函数可以绘制一条或多条贝塞尔曲线:

BOOL PolyBezier(
    HDC         hdc,    // 设备环境句柄
    const POINT *apt,   // 端点和控制点的点结构数组,逻辑单位
    DWORD       cpt);   // apt数组中点的个数

参数cpt指定apt数组中点的个数,该值必须是要绘制曲线个数的3倍以上,因为每个贝塞尔曲线需要2个控制点和1个端点。另外,贝塞尔曲线的开始还需要1个额外的起点。如果不明白,继续往下看。

PolyBezier函数使用apt参数指定的端点和控制点进行绘制。以第2点和第3点为控制点,从第1点到第4点绘制第一条曲线,就是说第一条曲线需要使用4个点;apt数组中的每个后续曲线需要提供3个点,以上一条曲线的终点为起点,后续2个点为控制点,后续第3个点为终点。

PolyBezier函数使用当前画笔绘制线条,该函数既不使用也不更新当前位置。

举例说明如下:

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
  HDC hdc;
  PAINTSTRUCT ps;
  POINT arrPoint[] = { 10,100, 100,10, 150,150, 200,50 };// 分别是曲线起点、控点1、控点2、
                                                         // 曲线终点

  switch (uMsg)
  {
  case WM_PAINT:
  {
      hdc = BeginPaint(hwnd, &ps);
      SetBkMode(hdc, TRANSPARENT);
      SelectObject(hdc, CreatePen(PS_SOLID, 2, RGB(0, 0, 0)));
      // 绘制贝塞尔曲线
      PolyBezier(hdc, arrPoint, _countof(arrPoint));

      DeleteObject(SelectObject(hdc, CreatePen(PS_DOT, 1, RGB(0, 0, 0))));
      // 曲线起点到控制点1画一条点线
      MoveToEx(hdc, arrPoint[0].x, arrPoint[0].y, NULL);
      LineTo(hdc, arrPoint[1].x, arrPoint[1].y);
      // 曲线终点到控制点2画一条点线
      MoveToEx(hdc, arrPoint[2].x, arrPoint[2].y, NULL);
      LineTo(hdc, arrPoint[3].x, arrPoint[3].y);

      DeleteObject(SelectObject(hdc, GetStockObject(BLACK_PEN)));
      EndPaint(hwnd, &ps);
      return 0;
  }

  case WM_DESTROY:
      PostQuitMessage(0);
      return 0;
  }

  return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

程序执行效果如原书图3.13所示。

PolyBezier函数只是画了一条曲线(图中的实心黑线)。绘制控制线是程序的责任,一般的绘图程序通常是鼠标按住控制点1或2拖动可以调整曲线的形状。这个实现起来很简单,只需要处理鼠标按下、松开和鼠标移动消息,然后重新计算控制点坐标,再次调用PolyBezier函数即可(曲线的起点和终点坐标通常不会再改变)。读者学习了第4章之后,完全可以根据自己的意愿实现实用的贝塞尔曲线。为了精简篇幅,以后很多示例程序我可能不列出完整源代码,上例中没有列出WinMain函数,因为WinMain函数和以前相同。

PolyBezierTo函数的参数和PolyBezier完全相同。PolyBezierTo函数从当前位置到apt数组提供的第3个点绘制一条贝塞尔曲线,使用第1、2个点作为控制点;对于每个后续曲线,函数也是需要3个点,使用前一条曲线的终点作为下一条曲线的起点。PolyBezierTo函数将当前位置设置为最后一条贝塞尔曲线的终点。

AngleArc函数绘制一条直线和一条弧线(一个正圆形边框的一部分)。直线从当前位置绘制到弧线的开头,弧线沿着指定半径和圆心的圆的边框线逆时针绘制(不受当前绘图方向影响)。弧线的长度由给定的起始角度和扫描角度决定。

BOOL AngleArc(
HDC   hdc,          // 设备环境句柄
int   x,            // 圆心的X坐标,逻辑单位
int   y,            // 圆心的Y坐标,逻辑单位
DWORD r,            // 圆的半径,逻辑单位
FLOAT StartAngle,   // 相对于X轴的起始角度,单位是度
FLOAT SweepAngle);  // 扫描角度,即相对于起始角度StartAngle的角度,单位是度

AngleArc函数会将当前位置设置为弧线的终点。

例如下面的代码:

MoveToEx(hdc, 250, 50, NULL);             // 设置当前位置
AngleArc(hdc, 150, 150, 100, 0, 270);     // 调用AngleArc函数进行绘制

// 绘制参考点线
SelectObject(hdc, CreatePen(PS_DOT, 1, RGB(0, 0, 0)));
MoveToEx(hdc, 150, 150, NULL);
LineTo(hdc, 270, 150);
MoveToEx(hdc, 150, 150, NULL);
LineTo(hdc, 150, 270);

DeleteObject(SelectObject(hdc, GetStockObject(BLACK_PEN)));

程序执行效果如原书图3.14所示。

PolyDraw函数绘制一组直线和贝塞尔曲线,该函数可以用来代替对MoveToEx、LineTo和PolyBezierTo函数的连续调用,以绘制一系列图形,即使形成了闭合图形其内部也不会填充:

BOOL PolyDraw(
    HDC         hdc,  // 设备环境句柄
    const POINT *apt, // 点结构数组,包含每条直线的端点以及每条贝塞尔曲线的端点和控制点
    const BYTE  *aj,  // 一个数组,每个数组元素指定如何使用apt数组中对应的每个点
    int         cpt); // apt数组中点的个数

参数aj中的每个数组元素指定如何使用apt数组中对应的每个点,该参数如表3.27所示。

表3.27

常量含义
PT_MOVETO从该点开始绘制,该点将成为新的当前位置
PT_LINETO从当前位置到该点绘制一条直线,然后该点将成为新的当前位置
PT_BEZIERTO该点是贝塞尔曲线的控制点或端点。PT_BEZIERTO类型总是以3个一组出现,当前位置作为贝塞尔曲线的起点,前2个点是控制点,第3个点是终点,终点会变为新的当前位置

PT_LINETO或PT_BEZIERTO还可以和PT_CLOSEFIGURE标志一起使用,即PT_LINETO | PT_CLOSEFIGURE或PT_BEZIERTO | PT_CLOSEFIGURE,表示绘制完直线或贝塞尔曲线以后,直线或贝塞尔曲线的终点和最近使用PT_MOVETO的点之间会画一条线,形成一个封闭区域,但其内部不会被填充。

还是上面的PolyBezier函数的示例,我们可以改写为:

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    HDC hdc;
    PAINTSTRUCT ps;
    POINT arrPoint[] = { 10,100, 100,10, 150,150, 200,50,
        10,100, 100,10, 150,150, 200,50 };          // 这4个点用于绘制控制线
    BYTE arrFlag[] = { PT_MOVETO, PT_BEZIERTO, PT_BEZIERTO, PT_BEZIERTO,
        PT_MOVETO, PT_LINETO, PT_MOVETO, PT_LINETO };

    switch (uMsg)
    {
    case WM_PAINT:
        hdc = BeginPaint(hwnd, &ps);
        PolyDraw(hdc, arrPoint, arrFlag, _countof(arrPoint));
        EndPaint(hwnd, &ps);
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }

    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

效果是一样的,只不过是贝塞尔曲线和控制线都是实心黑线,不能分别控制其样式。

3.4 填充图形

填充图形,也叫填充形状。有许多应用程序会用到填充图形,例如电子表格程序使用填充图形来绘制图表。填充图形使用当前画笔绘制边框线,使用当前画刷绘制内部的填充色。常见的填充图形如表3.28所示。

表3.28

填充图形所用函数效果图
直角矩形Rectangle
圆角矩形RoundRect
椭圆Ellipse
弦形或者说弓形Chord
饼形Pie
多边形Polygon
多个多边形PolyPolygon

默认的DC使用1像素的黑色实心画笔和白色画刷,所以这些填充图形的边框线是1像素的实心黑线,内部填充为白色。为了能看出填充图形的内部填充颜色,本节程序指定WNDCLASSEX结构的hbrBackground字段为COLOR_BTNFACE + 1(浅灰色窗口背景)。

Rectangle函数用于绘制一个直角矩形,该函数既不使用也不更新当前位置:

BOOL Rectangle(
    _In_ HDC hdc,           // 设备环境句柄
    _In_ int nLeftRect,     // 矩形左上角的X坐标,逻辑单位
    _In_ int nTopRect,      // 矩形左上角的Y坐标,逻辑单位
    _In_ int nRightRect,    // 矩形右下角的X坐标,逻辑单位
    _In_ int nBottomRect);  // 矩形右下角的Y坐标,逻辑单位

RoundRect函数绘制一个圆角矩形,该函数既不使用也不更新当前位置:

BOOL RoundRect(
    _In_ HDC hdc,           // 设备环境句柄
    _In_ int nLeftRect,     // 矩形左上角的X坐标,逻辑单位
    _In_ int nTopRect,      // 矩形左上角的Y坐标,逻辑单位
    _In_ int nRightRect,    // 矩形右下角的X坐标,逻辑单位
    _In_ int nBottomRect,   // 矩形右下角的Y坐标,逻辑单位
    _In_ int nWidth,        // 用于绘制圆角的椭圆的宽度,逻辑单位
    _In_ int nHeight);      // 用于绘制圆角的椭圆的高度,逻辑单位

可以把圆角矩形的圆角想象成是一个较小的椭圆,如原书图3.15所示。

这个小椭圆的宽度是nWidth,高度是nHeight,可以想象成Windows将这个小椭圆分成了4个象限,4个圆角分别是该小椭圆的一个象限。当nWidth和nHeight的值较大时,对应的圆角显得比较明显;如果nWidth的值等于nLeftRect与nRightRect的差,并且nHeight的值等于nTopRect与nBottomRect的差,那么RoundRect函数画出来的就是一个椭圆,而不是一个圆角矩形。图3.15中在圆角矩形的长边上的那部分圆角和短边上的那部分圆角是相同大小的,因为使用了相同的nWidth和nHeight值,也可以把这两个参数指定为不同的值,实现不同的效果。

Ellipse函数在指定的边界矩形内绘制椭圆,函数参数和Rectangle完全相同,该函数既不使用也不更新当前位置:

BOOL Ellipse(
    _In_ HDC hdc,           // 设备环境句柄
    _In_ int nLeftRect,     // 矩形左上角的X坐标,逻辑单位
    _In_ int nTopRect,      // 矩形左上角的Y坐标,逻辑单位
    _In_ int nRightRect,    // 矩形右下角的X坐标,逻辑单位
    _In_ int nBottomRect);  // 矩形右下角的Y坐标,逻辑单位

Chord函数绘制一个弦形,由一个椭圆和一条直线的交点界定的区域,该函数既不使用也不更新当前位置:

BOOL Chord(
    _In_ HDC hdc,           // 设备环境句柄
    _In_ int nLeftRect,     // 边界矩形左上角的X坐标,逻辑单位
    _In_ int nTopRect,      // 边界矩形左上角的Y坐标,逻辑单位
    _In_ int nRightRect,    // 边界矩形右下角的X坐标,逻辑单位
    _In_ int nBottomRect,   // 边界矩形右下角的Y坐标,逻辑单位
    _In_ int nXRadial1,     // 弦起点的径向端点的X坐标,逻辑单位
    _In_ int nYRadial1,     // 弦起点的径向端点的Y坐标,逻辑单位
    _In_ int nXRadial2,     // 弦终点的径向端点的X坐标,逻辑单位
    _In_ int nYRadial2);    // 弦终点的径向端点的Y坐标,逻辑单位

弦形曲线部分的绘制和Arc函数类似,只不过Chord函数会闭合曲线的两个端点。点(nLeftRect,nTopRect)和(nRightRect,nBottomRect)指定边界矩形,边界矩形内的椭圆定义了弦形的曲线。矩形中心到起点(nXRadial1, nYRadial1)与椭圆的相交点作为弦形曲线的起点,矩形中心到终点(nXRadial2,nYRadial2)与椭圆的相交点作为弦形曲线的终点,从弦形曲线的起点到终点沿当前绘图方向绘制,然后在弦形曲线的起点和终点之间绘制一条直线来闭合弦形。如果起点和终点相同,则会绘制一个完整的椭圆形。具体请结合原书图3.16理解。

DC有一个当前绘图方向属性对Chord函数有影响,默认绘图方向是逆时针方向,可以调用GetChordDirection和SetChordDirection函数获取和设置DC的当前绘图方向。

Pie函数绘制一个饼形,该函数的参数和Chord完全相同,只不过闭合方式不同,该函数既不使用也不更新当前位置:

BOOL Pie(
    _In_ HDC hdc,           // 设备环境句柄
    _In_ int nLeftRect,     // 边界矩形左上角的X坐标,逻辑单位
    _In_ int nTopRect,      // 边界矩形左上角的Y坐标,逻辑单位
    _In_ int nRightRect,    // 边界矩形右下角的X坐标,逻辑单位
    _In_ int nBottomRect,   // 边界矩形右下角的Y坐标,逻辑单位
    _In_ int nXRadial1,     // 饼形起点的径向端点的X坐标,逻辑单位
    _In_ int nYRadial1,     // 饼形起点的径向端点的Y坐标,逻辑单位
    _In_ int nXRadial2,     // 饼形终点的径向端点的X坐标,逻辑单位
    _In_ int nYRadial2);    // 饼形终点的径向端点的Y坐标,逻辑单位

点(nLeftRect,nTopRect)和(nRightRect,nBottomRect)指定边界矩形,边界矩形内的椭圆定义了饼形的曲线。矩形中心到起点(nXRadial1,nYRadial1)与椭圆的相交点作为饼形曲线的起点,矩形中心到终点(nXRadial2,nYRadial2)与椭圆的相交点作为饼形曲线的终点,从饼形曲线的起点到终点沿当前绘图方向绘制,然后在矩形中心到饼形曲线的起点和终点之间分别绘制一条直线来闭合饼形。具体结合原书图3.17理解。

可以看到,函数Arc、Chord和Pie都使用同样的参数。同样,Pie函数会受当前绘图方向的影响。

Polygon函数与Polyline有点类似,该函数通过连接指定数组中的点来绘制一条或多条直线。如果数组中的最后一个点与第一个点不同,则会额外绘制一条线连接最后一个点与第—个点(Polyline函数不会这么做),形成一个多边形,内部会被填充。该函数既不使用也不更新当前位置:

BOOL Polygon(
    _In_       HDC   hdc,       // 设备环境句柄
    _In_ const POINT *lpPoints, // 点结构数组,逻辑单位
    _In_       int   nCount);   // lpPoints数组中点的个数,必须大于或等于2

参数nCount指定lpPoints数组中点的个数,必须大于或等于2。如果只是指定了2个点,那么仅绘制一条直线。大家测试一下,把Line程序对Polyline函数的调用改为Polygon,会发现(10,220),(110,200),(210,220)这3个点会形成一个多边形,内部会被填充。

有一个问题,请看代码,我们绘制两个五角形:

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    HDC hdc;
    PAINTSTRUCT ps;
    POINT arrPt[] =  { 0,  40, 100,40, 20, 100, 50, 0, 80, 100 };
    POINT arrPt2[] = { 120,40, 220,40, 140,100, 170,0, 200,100 };
    // X坐标相对于arrPt右移120

    switch (uMsg)
    {
    case WM_PAINT:
        hdc = BeginPaint(hwnd, &ps);
        Polygon(hdc, arrPt, _countof(arrPt));

        // 设置多边形填充模式为WINDING
        SetPolyFillMode(hdc, WINDING);
        Polygon(hdc, arrPt2, _countof(arrPt2));
        EndPaint(hwnd, &ps);
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }

    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

程序运行效果如原书图3.18所示。

为了方便大家识别,我把5个点的先后顺序标识出来了。可以看到,默认情况下五角形内部那个五边形不会被填充;设置多边形填充模式为WINDING以后,五角形内部那个五边形会被填充。

在填充复杂的重叠多边形的情况下,例如上面的五角形,不同的多边形填充模式可能会导致内部填充方式的不同。SetPolyFillMode函数为多边形填充函数设置多边形填充模式:

int SetPolyFillMode(
    _In_ HDC hdc,           // 设备环境
    _In_ int iPolyFillMode);// 新的多边形填充模式

参数iPolyFillMode指定新的多边形填充模式,该参数如表3.29所示。

表3.29

常量含义
ALTERNATE交替模式,默认值。对于ALTERNATE填充模式,要判断一个封闭区域是否被填充,可以想象从这个封闭区域中的一个点向外部无穷远处水平或垂直画一条射线,只有该射线穿越奇数条边框线时,封闭区域才会被填充
WINDING缠绕模式。WINDING模式在大多数情况下会填充所有封闭区域,但是也有例外。在WINDING模式下,要确定一个区域是否应该被填充,同样可以假想从区域内的一个点画一条伸向外部无穷远处的水平或垂直射线,如果射线穿越奇数条边框线,则区域被填充,这和ALTERNATE模式相同。如果射线穿越偶数条边框线,还要考虑到边框线的绘制方向。在被穿越的偶数条边框线中,不同方向的边框线(相对于射线的方向)的数目如果相等,则区域不会被填充;不同方向的边框线(相对于射线的方向)的数目如果不相等,则区域会被填充

为了让大家理解多边形填充模式,再看一种更复杂的情况,原书图3.19中的箭头表示画线的方向。

WINDING模式和ALTERNATE模式都会填充号码为1~3的3个封闭的L型区域。两个更小的内部区域号码为4和5,在ALTERNATE模式下不被填充。但是在WINDING模式下,号码为5的区域会被填充,这是因为从区域的内部到达图形的外部会穿越两条相同方向的边框线;号码为4的区域不会被填充,这是因为射线会穿越两条边框线,但是这两条边框线的绘制方向相反。

PolyPolygon函数在功能上相当于调用了多个Polygon,就是说绘制一系列多边形,该函数既不使用也不更新当前位置:

BOOL PolyPolygon(
    _In_       HDC   hdc,           // 设备环境句柄
    _In_ const POINT *lpPoints,     // 点结构数组,逻辑单位。可理解为是多个组,一个组画一个多边形
    _In_ const INT   *lpPolyCounts, // 整型数组
    _In_       int   nCount);       // 组的个数,也就是lpPolyCounts的数组元素个数,即几个多边形

参数lpPolyCounts是一个整型数组,每个数组元素用于指定每一个组分别有几个点,每一个组的点个数必须大于或等于2。每个多边形都会通过从最后一个顶点到第一个顶点绘制一条直线来自动闭合多边形,该函数同样受多边形填充模式影响。PolyPolygon在功能上等同于下面的代码:

for (int i = 0, iGroup = 0; i < nCount; i++)
{
    Polygon(hdc, lpPoints + iGroup, lpPolyCounts[i]);
    iGroup += lpPolyCounts[i];
}

举个小例子,画一个三菱车标,不过,我提供的坐标可能不是很精确:

POINT arrPoint[] = { 50,66, 66,33, 50,0, 33,33, 
    50,66, 17,66, 0,100, 33,100, 
    50,66, 83,66, 100,100, 66,100 };
INT arrPolyCounts[] = { 4, 4, 4 };
// …………
PolyPolygon(hdc, arrPoint, arrPolyCounts, _countof(arrPolyCounts));

程序运行效果就是本节一开始列出的常见填充图形函数表中PolyPolygon函数的效果图。

可以看到,上面的函数都既不使用也不更新当前位置;填充图形使用当前画笔绘制边框线,使用当前画刷绘制内部的填充色。前面已经学习过创建逻辑画笔和逻辑画刷,我们可以创建各种不同样式、宽度和颜色的画笔,然后使用SelectObject函数将其选入DC中用于绘制边框线;可以创建各种不同颜色、阴影样式或图案的画刷,然后使用SelectObject函数将其选入DC中用于填充图形内部。

一些矩形操作函数

在GDI编程中经常使用矩形,以下矩形函数在实际开发中可能会用到。矩形的坐标值使用有符号整数,矩形右侧的坐标值必须大于左侧的坐标值。同样,矩形底部的坐标值必须大于顶部的坐标值。下面的所有矩形函数都使用逻辑单位。

SetRect函数设置指定矩形的坐标;CopyRect函数将一个矩形的坐标复制给另一个矩形,设置rect2 = rect1;SetRectEmpty函数用于把一个矩形的所有坐标都设置为0;IsRectEmpty函数判断一个矩形的大小是否为0,即右侧的坐标是否小于或等于左侧的坐标,或底部的坐标是否小于或等于顶部的坐标,或同时小于或等于;EqualRect函数判断两个矩形是否相同,即两个矩形的左上角和右下角坐标是否都相同,若两个矩形的尺寸大小相同是不可以的,必须是坐标完全相同。

BOOL SetRect(
    _Out_ LPRECT lprc,              // 要设置的矩形的RECT结构的指针
    _In_  int    xLeft,             // 指定矩形左上角的新X坐标
    _In_  int    yTop,              // 指定矩形左上角的新Y坐标
    _In_  int    xRight,            // 指定矩形右下角的新X坐标
    _In_  int    yBottom);          // 指定矩形右下角的新Y坐标
BOOL CopyRect(
    _Out_       LPRECT lprcDst,     // 目标矩形的RECT结构的指针
    _In_  const RECT   *lprcSrc);   // 源矩形的RECT结构的指针
BOOL SetRectEmpty(
    _Out_ LPRECT lprc);             // 要设置的矩形的RECT结构的指针
BOOL IsRectEmpty(
    _In_ const RECT *lprc);         // 要判断的矩形的RECT结构的指针
BOOL EqualRect(
    _In_ const RECT *lprc1,         // 第一个矩形的RECT结构的指针
    _In_ const RECT *lprc2);        // 第二个矩形的RECT结构的指针

InflateRect函数增加或减小一个矩形的宽度或高度,也可以同时增加或减小宽度和高度:

BOOL InflateRect(
    _Inout_ LPRECT lprc,    // 要设置的矩形的RECT结构的指针
    _In_    int    dx,      // 增加或减少矩形宽度的量,设置为负可以减小宽度
    _In_    int    dy);     // 增加或减少矩形高度的量,设置为负可以减小高度

Inflate的字面意思是膨胀,该函数在矩形的左侧和右侧各添加dx单位,在顶部和底部各添加dy单位:

RECT rect = { 10, 10, 110, 110 }; // 矩形大小100  100
// …………
InflateRect(&rect, 100, 100);     // 变为rect = { -90, -90, 210, 210 }矩形大小300  300
InflateRect(&rect, -150, -150);   // 变为rect = { 60, 60, 60, 60 }矩形大小0  0

OffsetRect函数将矩形移动一定的量,大小不会改变:

BOOL OffsetRect(
    LPRECT lprc,    // 要移动的矩形的RECT结构的指针
    int    dx,      // 向左或向右移动的量,设置为负值可以向左移动
    int    dy);     // 向上或向下移动的量,设置为负值可以向上移动

为了帮助理解,请看代码:

RECT rect = { 10, 10, 110, 110 };
// ......
OffsetRect(&rect, 10, 20);    // rect = { 20,  30,  120, 130 }  100  100
OffsetRect(&rect, -50, -50);  // rect = { -30, -20, 70,  80  }  100  100

PtInRect函数用于判断一个点是否位于指定的矩形内,这个函数经常使用:

BOOL PtInRect(
    const RECT *lprc,   // 矩形的RECT结构的指针
    POINT      pt);     // 点结构

IntersectRect函数计算两个源矩形的交集,并将交集矩形的坐标放入目标矩形参数:

BOOL IntersectRect(
    LPRECT     lprcDst,     // 目标矩形的RECT结构的指针
    const RECT *lprcSrc1,   // 源矩形1的RECT结构的指针
    const RECT *lprcSrc2);  // 源矩形2的RECT结构的指针

如果两个源矩形不相交,则将一个空矩形(所有坐标都设置为0)放置到目标矩形中,如原书图3.20所示。

UnionRect函数计算两个源矩形的并集,结果如原书图3.21所示:

BOOL UnionRect(
    LPRECT     lprcDst,     // 目标矩形的RECT结构的指针
    const RECT *lprcSrc1,   // 源矩形1的RECT结构的指针
    const RECT *lprcSrc2);  // 源矩形2的RECT结构的指针

源矩形1和源矩形2的并集就是实心黑线范围的大矩形,并集的结果是包含两个源矩形的最小矩形,而不会是一个不规则的形状。

SubtractRect函数从一个矩形中减去另一个矩形:

BOOL SubtractRect(
    LPRECT     lprcDst,     // 存放相减结果的矩形的RECT结构的指针
    const RECT *lprcSrc1,   // 源矩形1的RECT结构的指针,函数从该结构中减去
                            // lprcSrc2指向的矩形
    const RECT *lprcSrc2);  // 源矩形2的RECT结构的指针

有一点需要注意,请看图3.22。

图中粗边框的矩形为源矩形1,细边框的矩形为源矩形2,左图中源矩形1减源矩形2的结果还是源矩形1;右图中源矩形1减源矩形2的结果则是阴影填充那个小矩形,即无法只减去一个小角,和UnionRect函数的道理相同,结果不会是一个不规则形状。

FillRect函数使用指定的画刷填充矩形;FrameRect函数使用指定的画刷绘制矩形的边框,一般都是使用画笔绘制边框线,使用画刷绘制边框线比较少见;InvertRect函数通过对矩形每个像素的颜色值执行逻辑非运算来反转矩形的边框和内部填充颜色,对同一个矩形调用InvertRect两次又会还原为以前的颜色。

int FillRect(
    HDC        hDC,     // 设备环境句柄
    const RECT *lprc,   // 要填充的矩形的RECT结构的指针
    HBRUSH     hbr);    // 用于填充矩形的逻辑画刷句柄,或标准系统颜色,例如
                        // (HBRUSH)(COLOR_BTNFACE + 1)
int FrameRect(
    HDC        hDC,     // 设备环境句柄
    const RECT *lprc,   // 要绘制边框线的矩形的RECT结构的指针
    HBRUSH     hbr);    // 用于绘制边框线的画刷句柄
BOOL InvertRect(
    HDC        hDC,     // 设备环境句柄
    const RECT *lprc);  // 要反转颜色的矩形的RECT结构的指针

3.5 逻辑坐标与设备坐标

坐标空间是一个二维笛卡尔坐标系,通过使用相互垂直的两个参考轴来定位二维对象。系统中有四层坐标空间:世界、页面、设备和物理设备(客户区、桌面或打印纸页面),如表3.30所示。

表3.30

坐标空间描述
世界坐标空间可选,用作图形对象变换的起始坐标空间,可以对图形对象进行平移、缩放、旋转、剪切(倾斜、变形)和反射(镜像)。世界坐标空间高223单位,宽223单位
页面坐标空间用作世界坐标空间之后的下一个坐标空间,或图形变换的起始坐标空间,该坐标空间可以设置映射模式。页面坐标空间也是高223单位,宽223单位
设备坐标空间用作页面坐标空间之后的下一个坐标空间,该坐标空间只允许平移操作,这样可以确保设备坐标空间的原点映射到物理设备坐标空间中的正确位置。设备坐标空间高227个单位,宽227个单位
物理设备坐标空间图形对象变换的最终(输出)空间,通常指应用程序窗口的客户区,也可以是整个桌面、全窗口(整个程序窗口,包括标题栏、菜单栏、客户区、边框等)或一页打印机或绘图仪纸张,具体取决于获取的是哪一种DC

本节的话题比较抽象,但是相信读者通过阅读已经掌握了不少。世界坐标空间是可选的,所以只是简要介绍一下,页面坐标空间、设备坐标空间以及映射模式是需要我们学习的。

世界坐标空间和页面坐标空间都称为逻辑坐标空间,这两种坐标空间配合使用,为应用程序提供与设备无关的单位,如毫米和英寸。系统使用变换技术将一个矩形区域从一个坐标空间复制(或映射)到下一个坐标空间,直到输出全部显示在物理设备上,变换是一种改变对象大小、方向和形状的算法。一些工程或机械绘图类程序使用像素作为绘图单位是不合适的,因为像素的大小因设备而异(例如一个手机屏幕分辨率可能高达2560 1440,而一个14寸笔记本才1366 768,高分屏14寸笔记本可能是1920 1080),所以这类程序一般使用与设备无关的单位(例如毫米、英寸)。这类程序通常也使用变换技术,例如CAD程序的旋转对象、缩放图形或创建透视图等功能。

3.5.1 世界坐标空间到页面坐标空间的变换

DC默认运行在兼容图形模式下。兼容图形模式只支持一种逻辑坐标空间,即页面坐标空间,而不支持世界坐标空间。如果应用程序需要支持世界坐标空间,就必须调用SetGraphicsMode(hdc, GM_ADVANCED)函数改变DC的图形模式为高级图形模式,这样一来,DC就支持两层逻辑坐标空间:世界坐标空间和页面坐标空间以及两种坐标空间之间的变换矩阵。世界坐标空间到页面坐标空间的变换支持平移、缩放、旋转、剪切(倾斜、变形)和反射(镜像)等功能,这都是通过调用SetWorldTransform函数实现的。调用该函数以后,映射将从世界坐标空间开始;否则,映射将从页面坐标空间开始。

SetWorldTransform函数为指定的DC设置世界坐标空间和页面坐标空间之间的二维线性变换,该函数使用的是逻辑单位:

BOOL SetWorldTransform(
    _In_       HDC   hdc,       // 设备环境句柄
    _In_ const XFORM *lpXform); // 包含变换数据的XFORM结构的指针

参数lpXform是一个指向XFORM结构的指针,包含世界坐标空间到页面坐标空间变换的数据,XFORM结构在wingdi.h头文件中定义如下:

typedef struct  tagXFORM
{
    FLOAT   eM11;
    FLOAT   eM12;
    FLOAT   eM21;
    FLOAT   eM22;
    FLOAT   eDx;
    FLOAT   eDy;
} XFORM, *PXFORM, FAR *LPXFORM;

这6个字段构成了一个2 3矩阵,不同的操作需要设置不同的字段,如表3.31所示。

表3.31

操作eM11eM12eM21eM22eDxeDy算法
相等100100x’ = x, y’ = y
平移1001dxdyx’ = x + dx, y’ = y + dy
缩放mx00my00x’ = mx x, y’ = my y
旋转cos(t)sin(t)−sin(t)cos(t)00x’ = cos(t) x − sin(t) y, y’ = sin(t) x + cos(t) y; 逆时针旋转t度
剪切1s0100x’ = x + s y, y’ = y; x’与y成一定的比例
反射−100−100x’ = −x, y’ = −y

接下来让我们看一下不同变换的效果。对于WorldPage程序,读者分别用NORMAL、TRANSLATE、SCALE、ROTATE、SHEAR、REFLECT为参数调用TransformAndDraw函数,看一下相等、平移、缩放、旋转、剪切、反射的效果,在学习了页面坐标空间到设备坐标空间的变换以后就可以读懂本程序。具体代码参见Chapter3\WorldPage项目。

3.5.2 页面坐标空间到设备坐标空间的变换

页面坐标空间到设备坐标空间的变换决定了与DC关联的所有图形输出的映射模式。映射模式指定用于绘图操作的逻辑单位的大小。Windows提供了8种映射模式,如表3.32所示。

表3.32

映射模式逻辑单位X、Y轴正方向
MM_TEXT页面空间中的每个逻辑单位都映射到一个像素,也就是说,根本不执行缩放,这种映射模式下的页面空间相当于设备空间X坐标轴从左向右增加
Y坐标轴从上到下增加
MM_HIENGLISH页面空间中的每个逻辑单位映射到设备空间中的0.001英寸X坐标轴从左向右增加
Y坐标轴从下到上增加
MM_LOENGLISH页面空间中的每个逻辑单位映射到设备空间中的0.01英寸X坐标轴从左向右增加
Y坐标轴从下到上增加
MM_HIMETRIC页面空间中的每个逻辑单位映射到设备空间中的0.01毫米X坐标轴从左向右增加
Y坐标轴从下到上增加
MM_LOMETRIC页面空间中的每个逻辑单位映射到设备空间中的0.1毫米X坐标轴从左向右增加
Y坐标轴从下到上增加
MM_TWIPS页面空间中的每个逻辑单位映射到一个点的二十分之一(1/1440英寸)X坐标轴从左向右增加
Y坐标轴从下到上增加
MM_ISOTROPIC页面空间中的每个逻辑单位映射到设备空间中应用程序定义的单元坐标轴总是等量缩放
坐标轴的方向由应用程序指定
MM_ANISOTROPIC页面空间中的每个逻辑单位映射到设备空间中应用程序定义的单元坐标轴不一定等量缩放
坐标轴的方向由应用程序指定

单词METRIC(公制)和ENGLISH(英制)指的是两种比较通用的测量系统,LO和HI是低(Low)和高(High),指的是精度的高低。在排版中,一个点是一个基本测量单位,大约为1/72英寸,但是在图形程序设计中,通常假定它正好是1/72英寸,—个Twip是1/20点,也就是1/1440英寸。ISOTROPIC和ANISOTROPIC的意思分别是各向同性和各向异性。

前6种映射模式属于系统预定义映射模式,MM_ISOTROPIC和MM_ANISOTROPIC属于程序自定义映射模式。在6种预定义的映射模式中,一种依赖于设备(MM_TEXT),其余(MM_HIENGLISH、MM_LOENGLISH、MM_HIMETRIC、MM_LOMETRIC、MM_TWIPS)称为度量映射模式,度量映射模式独立于设备,即与设备无关。

在6种预定义的映射模式中,X坐标轴都是从左向右增加;除了MM_TEXT映射模式Y坐标轴从上到下增加以外,其余5种的Y坐标轴都是从下到上增加。

要设置映射模式,需要调用SetMapMode函数;调用GetMapMode函数可以获取DC的当前映射模式:

int SetMapMode(
    _In_ HDC hdc,               // 设备环境句柄
    _In_ int fnMapMode);        // 8种映射模式之一
int GetMapMode(_In_ HDC hdc);   // 设备环境句柄

前面曾多次提到过逻辑坐标和逻辑单位的概念,默认的页面坐标空间到设备坐标空间变换的映射模式是MM_TEXT。1个逻辑单位就等于1像素,X坐标轴从左向右增加,Y坐标轴从上到下增加,这种映射模式直接映射到设备的坐标系。回忆一下HelloWindows程序输出文本的那句TextOut调用:TextOut(hdc, 10, 10, szStr, _tcslen(szStr));,文本起始于距离客户区左上角向右10像素、向下10像素处。

如果设置为MM_LOENGLISH映射模式,每个逻辑单位将映射为设备坐标空间中的0.01英寸(1英寸≈2.54厘米):

SetMapMode(hdc, MM_LOENGLISH);
TextOut(hdc, 100, -100, szStr, _tcslen(szStr));

文本起始于距离客户区左上角向右1英寸,向下1英寸处;Y坐标使用负值,因为在MM_LOENGLISH映射模式下,Y坐标轴从下到上增加。

如果不需要实现一些变换效果,大部分Windows程序可能不需要调用SetGraphicsMode(hdc, GM_ADVANCED)启用世界坐标空间,也不需要MM_TEXT以外的映射模式,因为以像素为单位操作起来很方便。有些程序可能需要与设备无关的映射模式(例如度量映射模式MM_HIENGLISH、MM_LOENGLISH、MM_HIMETRIC、MM_LOMETRIC、MM_TWIPS),假设电子表格程序提供图表功能,如果希望每个饼图的直径为2英寸,那么可以使用MM_LOENGLISH映射模式并调用绘图函数来绘制图表,这样一来图表的直径在任何显示器或打印机上都是一致的,前面说过像素的大小因设备而异。

几乎所有需要一个DC句柄hdc参数的GDI函数,都是使用逻辑单位。具体一个逻辑单位映射为多少像素或度量单位,取决于映射模式。也有个别不需要DC句柄的函数,例如创建画笔的CreatePen函数也是使用逻辑单位。

1.设备坐标系统

讲到这里,不得不说明设备坐标空间到物理设备坐标空间的变换问题。设备坐标空间到物理设备坐标空间的变换是由Windows控制的,没有设置设备坐标空间到物理设备坐标空间变换的函数,也没有获取相关数据的函数,这种变换的唯一目的是确保设备坐标空间的原点映射到物理设备上的适当位置。设备坐标空间到物理设备坐标空间(客户区、桌面或打印机纸张)的变换始终是一对一映射,它确保无论程序窗口在桌面上移动到何处,图形输出都可以正确显示在应用程序的窗口中。本书认为设备坐标空间近似等于物理设备坐标空间。

映射模式是DC的一种属性,只有当使用以DC句柄作为参数的GDI函数时,才存在映射模式的概念,因此几乎所有的非GDI函数都使用设备坐标。

在图形对象最终输出之前,Windows会把在GDI函数中指定的逻辑坐标转换为设备坐标。

在Windows中有3种设备坐标系统:屏幕坐标、全窗口坐标和客户区坐标。注意,在所有的设备坐标系统中,都是以像素为单位,水平方向上X值从左向右增加,垂直方向上Y值从上往下增加。

  • 屏幕坐标:很多函数的操作都是相对于屏幕的,比如创建一个程序窗口的CreateWindowEx函数,获取一个窗口位置、大小的GetWindowRect函数,获取光标位置的GetCursorPos函数,MSG结构的pt字段(消息发生时的光标位置)等,都是使用屏幕坐标。

  • 全窗口坐标:全窗口坐标在Windows中用得不多,调用GetWindowDC函数获取的DC的原点是窗口的左上角而非客户区左上角。

  • 客户区坐标:这是最常使用的设备坐标系统,调用GetDC或BeginPaint函数获取的DC的原点是客户区左上角。

可以调用ClientToScreen函数把客户区坐标转换为屏幕坐标,调用ScreenToClient函数把屏幕坐标转换为客户区坐标:

BOOL ClientToScreen(
    _In_    HWND    hWnd,    // 窗口句柄
    _Inout_ LPPOINT lpPoint);// 要转换的客户区坐标的点结构,函数返回后屏幕坐标将被复制到该结构中
BOOL ScreenToClient(
    _In_ HWND    hWnd,       // 窗口句柄
    _Inout_ LPPOINT lpPoint);// 要转换的屏幕坐标的点结构,函数返回后客户区坐标将被复制到该结构中

GetWindowRect函数获取指定窗口的尺寸,尺寸以屏幕坐标表示,相对于屏幕左上角:

BOOL WINAPI GetWindowRect(
    _In_  HWND   hWnd,       // 窗口句柄
    _Out_ LPRECT lpRect);    // 接收窗口左上角和右下角屏幕坐标的RECT结构

全窗口坐标是相对于一个程序窗口的。如果想将一组点从相对于一个窗口的坐标空间转换(映射)到相对于另一个窗口的坐标空间,则可以调用MapWindowPoints函数:

int MapWindowPoints(
    _In_    HWND    hWndFrom,
    _In_    HWND    hWndTo,
    _Inout_ LPPOINT lpPoints,   // 指向POINT结构数组的指针,其中包含要转换的点
    _In_    UINT    cPoints);   // lpPoints参数指向的数组中POINT结构的数量

MapWindowPoints函数将相对于hWndFrom指定的程序窗口的一组坐标点转换到相对于hWndTo指定的程序窗口的一组坐标点。hWndFrom和hWndTo参数如果设置为NULL或HWND_DESKTOP,则表示桌面句柄。

2.窗口和视口

映射模式定义了Windows如何将GDI函数中指定的逻辑坐标映射到设备坐标,这里的设备坐标系统取决于获取DC句柄所用的函数。

到目前为止,本书中“窗口”一词恐怕是出现次数最多的,读者都明白窗口的含义,但是本节讨论的窗口却是另外的含义。窗口指的是页面坐标空间的逻辑坐标系,窗口以逻辑坐标表示(可能是像素、毫米、英寸等);视口指的是设备坐标空间的设备坐标系,视口以设备坐标(像素)表示。窗口和视口分别由原点、水平(X)范围和垂直(Y)范围组成,即窗口原点、窗口水平范围、窗口垂直范围、视口原点、视口水平范围、视口垂直范围、系统根据窗口和视口的原点、范围来进行页面坐标空间到设备坐标空间的变换。系统将窗口原点映射到视口原点,窗口范围映射到视口范围,如原书的图3.23所示。

视口指的是设备坐标空间的设备坐标系,通常是客户区坐标,也可以是屏幕坐标或全窗口坐标,这取决于获取DC句柄所用的函数。

对于所有的映射模式,Windows使用下面的公式将窗口(逻辑)坐标转换为视口(设备)坐标:

xViewport = (xWindow - xWinOrg)  xViewExt / xWinExt + xViewOrg;
yViewport = (yWindow - yWinOrg)  yViewExt / yWinExt + yViewOrg;

其中,点(xWindow, yWindow)是一个待转换的窗口逻辑点坐标,是逻辑单位;点(xViewport, yViewport)是转换以后的视口设备点坐标,是设备单位,大多数情况下是客户区坐标。点(xWinOrg, yWinOrg)是逻辑坐标系下的窗口原点,点(xViewOrg, yViewOrg)是设备坐标系下的视口原点,在默认情况下这两个点都被设置为(0,0),但是可以改变它们。(xWinExt, yWinExt)是逻辑坐标系下的窗口范围;(xViewExt, yViewExt)是设备坐标系下的视口范围。在大多数的映射模式中,范围是由映射方式所隐含的,不能改变,每个范围本身并没有多大意义,但是可以看到逻辑单位转换为设备单位的换算因子是视口范围和窗口范围的比例。窗口原点和视口原点都可以改变,但不变的是窗口原点(xWinOrg, yWinOrg),它总是会被映射到视口原点(xViewOrg, yViewOrg)。

如果窗口和视口的原点都停留在它们的默认值(0,0)上,则公式可以简化如下:

xViewport = xWindow  xViewExt / xWinExt;
yViewport = yWindow  yViewExt / yWinExt;

为了加深理解,先介绍几个函数,然后举一个例子。GetWindowExtEx函数可以获取指定DC的当前窗口的X范围和Y范围,GetViewportExtEx函数可以获取指定DC的当前视口的X范围和Y范围:

BOOL GetWindowExtEx(
    _In_  HDC    hdc,       // 设备环境句柄
    _Out_ LPSIZE lpSize);   // 接收窗口X范围和Y范围的SIZE结构的指针,逻辑单位
BOOL GetViewportExtEx(
    _In_  HDC    hdc,       // 设备环境句柄
    _Out_ LPSIZE lpSize);   // 接收视口X范围和Y范围的SIZE结构的指针,设备单位

GetDeviceCaps函数可以获取一些设备信息:

int GetDeviceCaps(
    _In_ HDC hdc,           // 设备环境句柄
    _In_ int nIndex);       // 索引

参数nIndex指定索引,可用的索引值有37个,常用的值及含义如表3.33所示。

表3.33

常量含义
HORZRES屏幕的宽度(像素),对于打印机则是页面可打印区域的宽度
VERTRES屏幕的高度(像素),对于打印机则是页面可打印区域的高度
HORZSIZE屏幕的物理宽度(毫米)
VERTSIZE屏幕的物理高度(毫米)
LOGPIXELSX沿屏幕宽度每逻辑英寸的像素数
LOGPIXELSY沿屏幕高度每逻辑英寸的像素数
PLANES颜色平面数
BITSPIXEL每个像素的相邻颜色位数

我的笔记本是14英寸1366 768分辨率,设置映射模式为MM_LOENGLISH,看一看窗口范围和视口范围:

// 获取设备信息
nHorzRes = GetDeviceCaps(hdc, HORZRES);     // 1366像素
nVertRes = GetDeviceCaps(hdc, VERTRES);     // 768像素
nHorzSize = GetDeviceCaps(hdc, HORZSIZE);   // 309毫米
nVertSize = GetDeviceCaps(hdc, VERTSIZE);   // 174毫米

SetMapMode(hdc, MM_LOENGLISH);
GetWindowExtEx(hdc, &size);                 // { cx=1217 cy=685 }
GetViewportExtEx(hdc, &size);               // { cx=1366 cy=-768 }
  • GetWindowExtEx函数获取的窗口的X范围和Y范围分别是1217和685个0.01英寸,1英寸(in)≈25.4毫米(mm):

309 100 / 25.4 = 1216.535个0.01英寸

174 100 / 25.4 = 685.039个0.01英寸

可知,当使用MM_LOENGLISH映射模式时,Windows将xViewExt设置为水平像素数,xWinExt表示以0.01英寸为单位被xViewExt像素占据的长度,它们的比例(xViewExt / xWinExt)表示每0.01英寸的像素数。为了提高转换性能,比例因子表示为整数,而不是浮点数。

  • GetViewportExtEx函数获取的视口的X范围和Y范围分别是1366像素和−768像素,−768表示Y逻辑坐标轴从下到上增加。

下面的公式可以将视口(设备)坐标转换为窗口(逻辑)坐标:

xWindow = (xViewport - xViewOrg)  xWinExt / xViewExt + xWinOrg;
yWindow = (yViewport - yViewOrg)  yWinExt / yViewExt + yWinOrg;

Windows提供了两个函数在设备坐标与逻辑坐标之间转换。DPtoLP函数将设备坐标转换为逻辑坐标,LPtoDP函数将逻辑坐标转换为设备坐标:

BOOL DPtoLP(
    _In_    HDC     hdc,        // 设备环境句柄
    _Inout_ LPPOINT lpPoints,   // 点结构数组的指针,将转换每个点结构中包含的X和Y坐标
    _In_    int     nCount);    // 点结构的个数
BOOL LPtoDP(
    _In_    HDC     hdc,
    _Inout_ LPPOINT lpPoints,
    _In_    int     nCount);

例如:

SetMapMode(hdc, MM_LOENGLISH);
GetClientRect(hwnd, &rect);     // {LT(0, 0) RB(384, 261)   [384 x 261]}
DPtoLP(hdc, (LPPOINT)&rect, 2); // {LT(0, 0) RB(342, -233)  [342 x -233]}
TextOut(hdc, rect.right / 2, rect.bottom / 2, TEXT("映射模式"),_tcslen(TEXT ("映射模式")));

文本会从客户区中间开始输出。GetClientRect函数获取的客户区大小为[384 261],经过DPtoLP函数转换以后变为[342 −233],−233的负号大家应该懂了,但是客户区矩形尺寸怎么发生变化了呢?因为一个是设备单位,一个是逻辑单位。

前面说过,在所有的设备坐标系统中,都是以像素为单位。水平方向上X值从左向右增加,垂直方向上Y值从上往下增加。虽然已经设置为MM_LOENGLISH映射模式,GetClientRect函数获取的设备坐标(客户区坐标)还是水平方向上X值从左向右增加,垂直方向上Y值从上往下增加;转换为逻辑坐标以后则是水平方向上X值从左向右增加,垂直方向上Y值从下往上增加。

3.默认的MM_TEXT映射模式

默认的页面坐标空间到设备坐标空间变换的映射模式是MM_TEXT,1个逻辑单位映射为1像素,正X在右边,正Y在下面,这种映射模式直接映射到设备的坐标系。在MM_TEXT映射模式下,默认的窗口、视口原点和范围如下:

窗口原点:(0, 0) 可以改变
视口原点:(0, 0) 可以改变
窗口范围:(1, 1) 不可改变
视口范围:(1, 1) 不可改变

窗口和视口范围都设置为1,不可改变,即创建一对一映射,在逻辑坐标和设备坐标之间没有执行缩放;窗口原点和视口原点可以改变,即逻辑坐标到设备坐标的变换支持平移。

MM_TEXT称为文本映射模式,这是因为坐标轴的方向与文本读写类似,我们读文本的顺序是从左到右、从上到下,MM_TEXT以同样的方式定义坐标轴上值的增长方向,如原书的图3.24所示。

前面给出的窗口(逻辑)坐标转换为视口(设备)坐标的公式可以简化为以下形式:

xViewport = xWindow - xWinOrg + xViewOrg;
yViewport = yWindow - yWinOrg + yViewOrg;

MM_TEXT映射模式下的窗口原点和视口原点都可以改变,可以通过SetWindowOrgEx函数和SetViewportOrgEx函数来改变窗口原点和视口原点。SetWindowOrgEx函数把指定的窗口逻辑坐标点映射到视口原点(0,0),然后逻辑点(0,0)不再指向客户区左上角;SetViewportOrgEx函数把指定的视口设备坐标点映射到窗口原点(0,0),然后逻辑点(0,0)不再指向客户区左上角。

BOOL SetWindowOrgEx(
    _In_  HDC     hdc,      // 设备环境句柄
    _In_  int     X,        // 新窗口原点的X坐标,逻辑单位
    _In_  int     Y,        // 新窗口原点的Y坐标,逻辑单位
    _Out_ LPPOINT lpPoint); // 在这个POINT结构中返回窗口的上一个原点
BOOL SetViewportOrgEx(
    _In_  HDC     hdc,      // 设备环境句柄
    _In_  int     X,        // 新视口原点的X坐标,设备单位
    _In_  int     Y,        // 新视口原点的Y坐标,设备单位
    _Out_ LPPOINT lpPoint); // 在这个POINT结构中返回视口的上一个原点

换句话说,如果将窗口原点改为(xWinOrg, yWinOrg),逻辑点(xWinOrg, yWinOrg)将会被映射到设备点(0,0),即客户区左上角;如果将视口原点改为(xViewOrg, yViewOrg),那么逻辑点(0,0)将会被映射到设备点(xViewOrg, yViewOrg)。窗口原点始终会映射到视口原点。

SetWindowOrgEx和SetViewportOrgEx函数的作用是平移坐标轴,这两个函数只使用一个即可,应该尽量避免两个函数同时使用。不管怎么调用SetWindowOrgEx或SetViewportOrgEx函数改变窗口或视口原点,设备点(0,0)始终是客户区左上角,但是GDI图形输出函数使用的是逻辑坐标。

举个例子,假设客户区宽度为cxClient像素,高度为cyClient像素,如果想定义逻辑点(0,0)为客户区的中心,可以这样:

SetViewportOrgEx(hdc, cxClient / 2, cyClient / 2, NULL);

SetViewportOrgEx函数的X、Y参数均是设备单位,上面的函数调用表示将逻辑点(0,0)映射到设备点(cxClient/2, cyClient/2)。现在的逻辑坐标系(是说逻辑坐标)如原书的图3.25所示。

逻辑X轴的范围是−cxClient/2~cxClient/2,逻辑Y轴的范围是−cyClient/2~cyClient/2,客户区右下角的逻辑坐标为(cxClient/2, cyClient/2)。如果想在客户区的左上角,也就是设备坐标点(0,0)处开始显示文本,则需要使用负的逻辑坐标:

TextOut(hdc, -cxClient / 2, -cyClient / 2, TEXT("Hello MM_TEXT"), _tcslen(TEXT("Hello MM_TEXT")));

因为使用设备单位比较方便,所以我个人倾向于使用SetViewportOrgEx函数,当然可以通过调用SetWindowOrgEx函数取得相同的效果,把逻辑点(−cxClient/2, −cyClient/2)映射到视口原点(0,0),也就是客户区的左上角:

SetWindowOrgEx(hdc, -cxClient / 2, -cyClient / 2, NULL); // MM_TEXT映射模式下1个逻辑单位
 // 就是1像素

SetViewportOrgEx函数的X、Y参数均是逻辑单位,但是在MM_TEXT映射模式下1个逻辑单位映射为1像素,默认的页面坐标空间到设备坐标空间变换的映射模式就是MM_TEXT。如果需要使用MM_TEXT映射模式,则不需要调用SetMapMode(hdc, MM_TEXT);。

SetWindowOrgEx和SetViewportOrgEx函数的作用是平移坐标轴,响应滚动条滚动请求的时候,可以通过调用这两个函数达到滚动客户区内容的目的。打开SystemMetrics2项目,在WM_PAINT消息中是这样根据垂直滚动条的当前位置输出文本的:

for (int i = 0; i < NUMLINES; i++)
{
    y = s_iHeight * (i - s_iVscrollPos);
    // 输出文本
}

调用SetWindowOrgEx函数也可以获得同样的效果:

SetWindowOrgEx(hdc, 0, s_iHeight * s_iVscrollPos, NULL);
for (int i = 0; i < NUMLINES; i++)
{
    y = s_iHeight * i;
    // 输出文本
}
4.度量映射模式

在6种系统预定义的映射模式中,MM_TEXT依赖于设备,其余5种(MM_HIENGLISH、MM_LOENGLISH、MM_HIMETRIC、MM_LOMETRIC、MM_TWIPS)称为度量映射模式,度量映射模式提供了与设备无关的逻辑单位。MM_TEXT映射模式Y坐标轴从上到下增加,度量映射模式的Y坐标轴都是从下到上增加的。有些程序可能需要与设备无关的度量映射模式,例如CAD程序通常以毫米为单位。

这5种映射模式按照从低精度到高精度依次如表3.34所示。为了对照,最后一列以毫米(mm)为单位表示了该逻辑单位的大小。

表3.34

映射模式逻辑单位毫米
MM_LOENGLISH0.01in0.254
MM_LOMETRIC0.1mm0.1
MM_HIENGLISH0.001in0.0254
MM_TWIPS1/1400in0.0176
MM_HIMETRIC0.01mm0.01

默认情况下,这5种映射模式的窗口和视口的原点及范围如下所示:

窗口原点:(0, 0) 可以改变
视口原点:(0, 0) 可以改变
窗口范围:(?, ?) 不可改变
视口范围:(?, ?) 不可改变

在讲解窗口和视口的时候,我用14英寸1366 768分辨率的笔记本,设置映射模式为MM_LOENGLISH做了测试,当时的窗口范围是{ cx=1217 cy=685 },视口范围是{ cx=1366 cy=−768 },比例xViewExt / xWinExt表示每0.01英寸的像素数。现在我说,这5种映射模式的窗口范围和视口范围取决于哪种映射模式和设备分辨率是多少,相信大家可以理解这句话。范围本身并不重要,只有把它们表达为一个比值时才有意义,逻辑单位转换为设备单位的换算因子是视口范围和窗口范围的比例。

在我的计算机上我一一测试每种映射模式的窗口范围,视口范围当然都是{ cx=1366 cy=−768 },如表3.35所示。

表3.35

映射模式窗口范围视口范围
MM_LOENGLISH{ cx=1217 cy=685 }个0.01in{ cx=1366 cy=−768 }
MM_LOMETRIC{ cx=3090 cy=1740 }个0.1mm{ cx=1366 cy=−768 }
MM_HIENGLISH{ cx=12165 cy=6850 }个0.001 in{ cx=1366 cy=−768 }
MM_TWIPS{ cx=17518 cy=9865 }个1/1400 in{ cx=1366 cy=−768 }
MM_HIMETRIC{ cx=30900 cy=17400 }个0.01mm{ cx=1366 cy=−768 }
MM_TEXT{ cx=1 cy=1 }{ cx=1 cy=1 }

在这里只需知道视口范围Y值前面的负号是什么意思,表示Y逻辑坐标轴从下到上增加。除此之外,这5种映射模式的用法和MM_TEXT没有多大不同。和MM_TEXT一样,窗口原点和视口原点可以改变,即逻辑坐标到设备坐标的变换支持平移。

当改变为5种映射模式之一时,逻辑坐标系统如原书的图3.26所示。

如果需要在客户区显示图形对象,只能使用负的Y坐标值,例如:

SetMapMode(hdc, MM_LOENGLISH);
TextOut(hdc, 100, -100, TEXT("Hello"), _tcslen(TEXT("Hello")));

文本将显示在距离客户区左上角右边和下面各1英寸的地方。

再例如,在距离客户区左上角1/4~3/4的区域画一个椭圆:

SetMapMode(hdc, MM_LOENGLISH);
GetClientRect(hwnd, &rect);     // {LT(0, 0) RB(384, 261)  [384 x 261]}
DPtoLP(hdc, (LPPOINT)&rect, 2); // {LT(0, 0) RB(342, -233)  [342 x -233]}
Ellipse(hdc, rect.right / 4, rect.bottom / 4, rect.right * 3 / 4, rect.bottom * 3 / 4);

对于这5种映射模式,DPtoLP函数为我们提供了很大的便利。

5.自定义映射模式

MM_ISOTROPIC和MM_ANISOTROPIC属于程序自定义的映射模式,对于6种预定义的映射模式(MM_TEXT、MM_HIENGLISH、MM_LOENGLISH、MM_HIMETRIC、MM_LOMETRIC和MM_TWIPS),当调用SetMapMode函数设置为其中一种映射模式时,系统将设置其窗口范围和视口范围,这两个范围不能改变。其他两种映射模式(MM_ISOTROPIC和MM_ANISOTROPIC)要求我们自己指定范围,这是通过调用SetWindowExtEx和SetViewportExtEx函数来实现的,对于MM_ISOTROPIC映射模式,在调用SetViewportExtEx之前通常先调用SetWindowExtEx。

SetWindowExtEx函数设置DC的窗口水平和垂直范围,SetViewportExtEx设置DC的视口水平和垂直范围:

BOOL SetWindowExtEx(
    _In_  HDC    hdc,       // 设备环境句柄
    _In_  int    nXExtent,  // 窗口的水平范围,逻辑单位
    _In_  int    nYExtent,  // 窗口的垂直范围,逻辑单位
    _Out_ LPSIZE lpSize);   // 在这个SIZE结构中返回以前的窗口范围,可以设置为NULL
BOOL SetViewportExtEx(
    _In_  HDC    hdc,       // 设备环境句柄
    _In_  int    nXExtent,  // 视口的水平范围,设备单位
    _In_  int    nYExtent,  // 视口的垂直范围,逻辑单位
    _Out_ LPSIZE lpSize);   // 在这个SIZE结构中返回以前的视口范围,可以设置为NULL

MM_ISOTROPIC映射模式可以确保X方向和Y方向的逻辑单位相同,而MM_ANISOTROPIC映射模式则允许X方向和Y方向的逻辑单位不同。逻辑单位相同的意思是两个轴上的逻辑单位表示相等的物理距离。

(1)MM_ISOTROPIC映射模式

MM_ISOTROPIC映射模式可以确保X方向和Y方向的逻辑单位相同的含义。请看代码:

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    HDC hdc;
    PAINTSTRUCT ps;
    RECT rect;
    SIZE size;

    switch (uMsg)
    {
    case WM_PAINT:
        hdc = BeginPaint(hwnd, &ps);
        // 设置映射模式为MM_ISOTROPIC
        SetMapMode(hdc, MM_ISOTROPIC);

        // 窗口范围设置为(100, 100)
        SetWindowExtEx(hdc, 100, 100, &size);   // size返回{ cx=3090 cy=1740}
        // 视口范围设置为客户区的宽度和高度
        GetClientRect(hwnd, &rect);  // {LT(0, 0) RB(384, 261)  [384 x 261]}
        SetViewportExtEx(hdc, rect.right, rect.bottom, &size);  // size返回{cx=1366 cy=-768 }

        // 获取窗口范围和视口范围
        GetWindowExtEx(hdc, &size);     // {cx=100 cy=100 }
        GetViewportExtEx(hdc, &size);   // {cx=261 cy=261 }

        // 画一个和客户区宽度或高度相同大小的圆
        Ellipse(hdc, 0, 0, 100, 100);
        EndPaint(hwnd, &ps);
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }

    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

我们调用SetWindowExtEx函数把窗口的水平范围和垂直范围都设置为100逻辑单位;调用SetViewportExtEx函数把视口的水平范围和垂直范围设置为客户区的宽度和高度,此处为[384 261],没有使用−261,这说明我们希望逻辑坐标和MM_TEXT一样,X坐标轴从左向右增加,Y坐标轴从上到下增加。通常,在调用SetWindowExtEx函数时,要把窗口范围设置为期望得到的逻辑窗口的逻辑大小;而在调用SetViewportExtEx函数时,则把视口范围设置为客户区的实际宽度和高度。

调用SetWindowExtEx函数以后在size参数中返回原窗口范围为{ cx=3090 cy=1740 },调用SetViewportExtEx函数以后在size参数中返回原视口范围为{ cx=1366 cy=−768 }。在讲解度量映射模式的时候,我曾经在我的计算机上一一测试每种度量映射模式的窗口和视口范围,可以看出当设置映射模式为MM_ISOTROPIC时,Windows使用与MM_LOMETRIC映射模式相同的窗口和视口范围,不过不要依赖这一事实。

设置好窗口范围和视口范围以后,我们调用GetWindowExtEx和GetViewportExtEx函数分别获取窗口范围和视口范围,窗口范围还是我们设置的{ cx=100 cy=100 },视口范围变为{ cx=261 cy=261 },即Windows取客户区宽度和高度中较小的一个。Windows之所以会调整它们的值,是为了让X和Y坐标轴上的逻辑单位表示相同的物理尺寸。当Windows调整这些范围时,它必须让逻辑窗口可以容纳在对应的物理视口之内,这就有可能导致X轴或Y轴的一部分客户区落在逻辑窗口的外面。

有什么意义呢?现在我们随意拖拉调整程序窗口的宽度或高度,程序都会在客户区的左上角显示一个直径为客户区宽度或高度的正圆。请读者把映射模式设置为MM_ANISOTROPIC,看一看又会是什么现象。

上面的圆形总是位于客户区的左上角,我们希望不管窗口大小如何调整,圆形总是位于客户区的中心,可以实现一个四象限二维笛卡儿坐标系。逻辑点(0,0)位于客户区的中心,4个方向的轴可以任意缩放,X轴向右增加,Y轴向上增加。可以使用下面的代码:

case WM_PAINT:
    hdc = BeginPaint(hwnd, &ps);
    // 设置映射模式为MM_ISOTROPIC
    SetMapMode(hdc, MM_ISOTROPIC);

    // 窗口范围设置为(100, 100)
    SetWindowExtEx(hdc, 100, 100, &size);
    // 视口范围设置为客户区的宽度和高度
    GetClientRect(hwnd, &rect);
    SetViewportExtEx(hdc, rect.right, -rect.bottom, &size);     // -rect.bottom

    // 设置视口原点
    SetViewportOrgEx(hdc, rect.right / 2, rect.bottom / 2, NULL);

    // 画一个和客户区宽度或高度相同大小的圆
    Ellipse(hdc, -50, 50, 50, -50);
    EndPaint(hwnd, &ps);
    return 0;

如果客户区的宽度大于高度,那么逻辑坐标如原书的图3.27所示。如果客户区的高度大于宽度,那么逻辑坐标如原书的图3.28所示。

但是,在窗口或视口的范围中,Windows并没有实现裁剪。当调用GDI函数时,仍然可以随意使用小于−50或大于50的逻辑X和Y值。

(2)MM_ANISOTROPIC映射模式

Windows不会对使用MM_ANISOTROPIC映射模式设置的窗口和视口范围做任何调整,该模式允许X方向和Y方向的逻辑单位不同。再看一下前面MM_ISOTROPIC映射模式画圆的部分代码:

// 窗口范围设置为(100, 100)
SetWindowExtEx(hdc, 100, 100, &size);
// 视口范围设置为客户区的宽度和高度
GetClientRect(hwnd, &rect);
SetViewportExtEx(hdc, rect.right, -rect.bottom, &size);     // -rect.bottom
// 设置视口原点
SetViewportOrgEx(hdc, rect.right / 2, rect.bottom / 2, NULL);

使用MM_ISOTROPIC映射模式,上面的代码会导致X轴或Y轴的一部分客户区落在逻辑窗口的外面;而使用MM_ANISOTROPIC映射模式,不管客户区的尺寸如何调整,窗口范围(100,100)总是覆盖整个客户区的宽度和高度,如果客户区不是正方形的,那么X和Y轴的每个逻辑单位会有不同的物理尺寸。

学习了这么多,读者应该明白一个函数是使用逻辑单位还是设备单位。几乎所有GDI函数,需要一个DC句柄hdc参数的函数,以及操作GDI图形对象的函数,它们都是使用逻辑单位。具体一个逻辑单位映射为多少像素或度量单位,取决于映射模式。此外,与屏幕、窗口或者客户区有关的函数都是使用设备单位。对于API函数的讲解,我以后不再刻意指出使用什么单位。

3.6 扩展画笔

ExtCreatePen函数可以创建扩展画笔,该函数创建具有指定样式、宽度和画笔属性的装饰画笔或几何画笔。ExtCreatePen函数比较复杂,如果没有特别需求,使用前面的CreatePen / CreatePenIndirect函数即可。ExtCreatePen函数创建的装饰画笔宽度只能是1(解释为设备单位,像素),只能是纯色。而几何画笔可以有任意宽度,可以有画笔的任何属性,例如阴影和图案样式。几何画笔用于绘制具有独特端点或连接点样式的线条以及宽度超过1像素的线条,也用于需要可缩放线条的应用程序(因为画笔宽度是逻辑单位):

HPEN ExtCreatePen(
    _In_       DWORD    dwPenStyle,  // 类型、样式、端点和连接点属性的组合
    _In_       DWORD    dwWidth,     // 画笔宽度,逻辑单位
    _In_ const LOGBRUSH *lplb,       // 指向LOGBRUSH结构的指针
    _In_       DWORD    dwStyleCount,// 下面lpStyle数组的数组元素个数
 _In_ const DWORD    *lpStyle);   // DWORD类型的数组

参数dwPenStyle是画笔类型、样式、端点和连接点属性的组合。

(1)画笔类型如表3.36所示。

表3.36

常量含义
PS_COSMETIC装饰画笔
PS_GEOMETRIC几何画笔

(2)画笔样式如表3.37所示。

表3.37

|
| 常量 | 含义 |
| PS_ALTERNATE | 用于PS_COSMETIC装饰画笔类型,指定该样式以后每隔一个像素设置一次,即看上去像点线,只能是PS_SOLID样式(无法使用其他画笔样式,例如PS_DASH、PS_DOT等) |
| PS_USERSTYLE | 使用(用户提供的)lpStyle数组提供的样式 |
| PS_SOLID | 含义同CreatePen函数的fnPenStyle参数 |
| PS_DASH | 含义同CreatePen函数的fnPenStyle参数 |
| PS_DOT | 含义同CreatePen函数的fnPenStyle参数 |
| PS_DASHDOT | 含义同CreatePen函数的fnPenStyle参数 |
| PS_DASHDOTDOT | 含义同CreatePen函数的fnPenStyle参数 |
| PS_NULL | 含义同CreatePen函数的fnPenStyle参数 |
| PS_INSIDEFRAME | 含义同CreatePen函数的fnPenStyle参数 |

(3)使用CreatePen函数创建的画笔,端点和连接点总是圆滑的;而使用ExtCreatePen函数创建的画笔,端点和连接点可以有其他选择。端点指的是一条线的两端,端点样式仅适用于几何画笔,值如表3.38所示。

表3.38

常量含义
PS_ENDCAP_ROUND端点是圆形的
PS_ENDCAP_SQUARE端点是方形的
PS_ENDCAP_FLAT端点是平的

(4)连接点指的是线与线之间的连接处,连接点样式仅适用于几何画笔,值如表3.39所示。

表3.39

常量含义
PS_JOIN_BEVEL斜截,将连接点的末端切断
PS_JOIN_MITER斜接,将连接点的末端处理为尖头
PS_JOIN_ROUND连接点的末端是圆的

让我们看一下不同端点、连接点样式的效果。这些在实际开发中会遇到,所以不妨了解一下:

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    HDC hdc;
    PAINTSTRUCT ps;
    HPEN hPen;
    LOGBRUSH logBrush;
    int arrEnd[] = { PS_ENDCAP_ROUND , PS_ENDCAP_SQUARE , PS_ENDCAP_FLAT };
    int arrJoin[] = { PS_JOIN_BEVEL , PS_JOIN_MITER , PS_JOIN_ROUND };
    POINT arrPoint[] = { 50,50, 100,200, 150,50 };

    switch (uMsg)
    {
    case WM_PAINT:
    {
        hdc = BeginPaint(hwnd, &ps);
        logBrush.lbStyle = BS_SOLID;
        logBrush.lbColor = RGB(0, 0, 0);
        logBrush.lbHatch = 0;
        for (int i = 0; i < 3; i++)
        {
            // 画黑色40宽的粗线,几何画笔
            hPen = ExtCreatePen(PS_GEOMETRIC | PS_SOLID | arrEnd[i] | arrJoin[i], 40,   
&logBrush, 0, NULL);
            SelectObject(hdc, hPen);
            for (int j = 0; j < _countof(arrPoint); j++)
            {
                if (i > 0)
                    arrPoint[j].x += 150;
            }
            Polyline(hdc, arrPoint, _countof(arrPoint));

            // 画白色细线作为对比
            DeleteObject(SelectObject(hdc, GetStockObject(WHITE_PEN)));
            Polyline(hdc, arrPoint, _countof(arrPoint));
            SelectObject(hdc, GetStockObject(BLACK_PEN));
        }
        EndPaint(hwnd, &ps);
        return 0;
    }

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }

    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

程序执行效果如原书的图3.29所示。

完整代码参见Chapter3\ExtCreatePen项目。只有设置为粗线的时候才能看出效果,为了形成对比,我在粗线内部又画了同样尺寸的1像素的白线。

  • 参数dwWidth指定画笔宽度,是逻辑单位。如果dwPenStyle参数指定了PS_COSMETIC装饰画笔类型,则宽度必须设置为1;如果dwPenStyle参数指定了PS_GEOMETRIC几何画笔类型,宽度可以随意指定(逻辑单位)。

  • 参数lplb是一个指向LOGBRUSH结构的指针,使用画刷结构指定画笔属性。如果dwPenStyle参数指定了PS_COSMETIC类型,则lplb->lbColor字段指定画笔的颜色,lplb->lbStyle字段必须设置为BS_SOLID;如果dwPenStyle参数指定了PS_GEOMETRIC类型,则可以使用所有字段指定画笔的属性。关于LOGBRUSH结构,参见CreateBrushIndirect函数的lplb参数的解释。

几何画笔可以使用位图图案,下面的代码用到了资源文件。添加资源我们还没有讲解,大家可以先不做测试:

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    HDC hdc;
    PAINTSTRUCT ps;
    HPEN hPen;
    LOGBRUSH logBrush;

    switch (uMsg)
    {
    case WM_PAINT:
    {
        hdc = BeginPaint(hwnd, &ps);
        logBrush.lbStyle = BS_PATTERN;      // 位图图案画刷
        // LoadBitmap用于加载一副苹果图标的位图,这个函数后面再讲
        logBrush.lbHatch = (ULONG_PTR)LoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_APPLE));

        hPen = ExtCreatePen(PS_GEOMETRIC, 100, &logBrush, 0, NULL);
        SelectObject(hdc, hPen);
        MoveToEx(hdc, 70, 70, NULL);
        LineTo(hdc, 470, 70);

        DeleteObject(SelectObject(hdc, GetStockObject(BLACK_PEN)));
        MoveToEx(hdc, 70, 70, NULL);
        LineTo(hdc, 470, 70);
        EndPaint(hwnd, &ps);
        return 0;
    }

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }

    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

程序运行效果如原书的图3.30所示。

完整代码参见Chapter3\ExtCreatePen2项目。程序用位图画刷创建了一个几何画笔,为了形成对比,粗线中间是一条黑色细线。ExtCreatePen函数可以创建各种风格各异的几何画笔。

  • 参数dwStyleCount指定lpStyle数组的数组元素个数,最大为16。如果dwPenStyle参数没有指定PS_USERSTYLE样式,则该参数必须为0。

  • 参数lpStyle是一个指向DWORD类型数组的指针,该参数用于PS_USERSTYLE样式。如果dwPenStyle参数没有指定PS_USERSTYLE样式,该参数可以设置为NULL。第一个值指定第一个短划线的长度,第二个值指定第一个空格的长度,以此类推。如果在绘制线条时超出了lpStyle数组,指针将重置为数组的开头。如果dwStyleCount为偶数,破折号和空格的模式将再次重复;如果dwStyleCount是奇数,则当指针重置时模式将反转—— lpStyle的第一个元素现在引用空格,第二个元素引用破折号。

3.7 区域

区域是与DC关联的图形对象之一,区域就是一个矩形、圆角矩形、椭圆或多边形以及两个或多个以上的图形组合起来的形状,可以对区域内部进行填充、绘制区域边框线、用于执行命中测试(测试光标位置)等。可以调用表3.40所示的函数创建特定形状的区域。

表3.40

形状所用函数
矩形区域CreateRectRgn、CreateRectRgnIndirect、SetRectRgn
圆角矩形区域CreateRoundRectRgn
椭圆区域CreateEllipticRgn、CreateEllipticRgnIndirect
多边形区域CreatePolygonRgn、CreatePolyPolygonRgn

(1)矩形区域:

HRGN CreateRectRgn(int x1, int y1, int x2, int y2); // 指定矩形区域左上角的X、Y,右下角的X、Y
 // 坐标
HRGN CreateRectRgnIndirect(const RECT *lprect);     // 通过一个RECT结构指定矩形区域

(2)圆角矩形区域:

// w、h指定创建圆角的那个小椭圆的宽度、高度
HRGN CreateRoundRectRgn(int x1, int y1, int x2, int y2, int w, int h);

(3)椭圆区域:

HRGN CreateEllipticRgn(int x1, int y1, int x2, int y2);
HRGN CreateEllipticRgnIndirect(const RECT *lprect);

(4)多边形区域:

HRGN CreatePolygonRgn(const POINT *pptl, int cPoint, int iMode); // iMode参数同
                                                                 //SetPolyFillMode的参数
HRGN CreatePolyPolygonRgn(const POINT *pptl, const INT *pc, int cPoly, int iMode);

以上这些函数的用法和Rectangle、RoundRect、Ellipse、Polygon、PolyPolygon函数的用法类似,在此不再详细解释。HRGN是区域句柄类型,每个区域创建函数都返回一个标识新区域的句柄。

当不再需要创建的区域时,可调用DeleteObject函数将其删除。

CombineRgn函数可以按指定的组合模式组合两个区域,并将结果存储在第三个区域中:

int CombineRgn(
    _In_ HRGN hrgnDest,         // 两个区域组合的结果区域句柄
    _In_ HRGN hrgnSrc1,         // 第一个区域的句柄
    _In_ HRGN hrgnSrc2,         // 第二个区域的句柄
    _In_ int  fnCombineMode);   // 组合模式

参数fnCombineMode指定组合模式是表3.41所示的效果之一。在表3.41最后一列中,矩形区域是hrgnSrc1,圆形区域是hrgnSrc2,阴影部分是组合的结果hrgnDest。

表3.41

常量含义效果图
RGN_AND新区域是两个区域的共同部分
RGN_COPY新区域是hrgnSrc1中的区域
RGN_DIFF新区域是hrgnSrc1区域减去hrgnSrc2中的部分
RGN_OR新区域是两个区域的叠加
RGN_XOR新区域是两个区域的叠加除去共同部分

该函数把hrgnSrc1和hrgnSrc2两个区域组合起来放入hrgnDest指定的区域中,但hrgnDest必须是一个已经存在的区域句柄(哪怕是创建一个空区域),在函数执行后,hrgnDest中原来的区域会被破坏并替换成新组合的区域。hrgnDest和hrgnSrc1这两个参数可以使用同一个句柄,这样就相当于把hrgnSrc2组合到hrgnSrc1中去。

返回值表明了结果区域hrgnDest的类型,值如表3.42所示。

表3.42

常量含义
SIMPLEREGION新区域是一个简单形状,例如矩形
COMPLEXREGION新区域是一个复杂形状
NULLREGION新区域是空区域
ERROR函数执行出错

FillRgn和PaintRgn函数都可以填充区域。FillRgn函数使用指定的画刷和当前多边形填充模式来填充区域,PaintRgn函数使用当前画刷和当前多边形填充模式来填充区域(该函数没有画刷句柄参数):

BOOL FillRgn(
    _In_ HDC    hdc,        // 设备环境句柄
    _In_ HRGN   hrgn,       // 要填充的区域的句柄
    _In_ HBRUSH hbr);       // 用于填充区域的画刷的句柄
BOOL PaintRgn(
    _In_ HDC  hdc,          // 设备环境句柄
    _In_ HRGN hrgn);        // 要填充的区域的句柄

FrameRgn函数使用指定的画刷绘制一个区域的边框:

BOOL FrameRgn(
    _In_ HDC    hdc,        // 设备环境句柄
    _In_ HRGN   hrgn,       // 区域句柄
    _In_ HBRUSH hbr,        // 用于绘制边框的画刷的句柄
    _In_ int    nWidth,     // 画刷的宽度
    _In_ int    nHeight);   // 画刷的高度

关于nWidth和nHeight参数的理解参见原书的图3.31,它显示了对一个组合区域调用FrameRgn(hdc, hRgn, (HBRUSH)GetStockObject(BLACK_BRUSH), 10, 1);的结果。

调用InvertRgn函数可以反转区域内的颜色,例如使白色像素变黑,黑色像素变白:

BOOL InvertRgn(_In_ HDC  hdc, _In_ HRGN hrgn);

例如,对原书的图3.31调用InvertRgn函数的结果如原书的图3.32所示。

通过调用GetRgnBox函数可以获取一个区域的边界矩形尺寸。如果区域是矩形,则函数返回区域的矩形尺寸;如果区域是椭圆,则函数返回可以界定椭圆区域的最小矩形的尺寸;如果区域是多边形,则函数返回可以界定整个多边形的最小矩形的尺寸。代码如下:

int GetRgnBox(_In_  HRGN   hrgn, _Out_ LPRECT lprc); // lprc是接收边界矩形尺寸的RECT结构的指针

函数的返回值同CombineRgn函数的返回值,即SIMPLEREGION、COMPLEXREGION、NULLREGION或ERROR。

OffsetRgn函数可以将区域移动一定的量,大小不会改变:

int OffsetRgn(
    _In_ HRGN hrgn,         // 要移动的区域的句柄
    _In_ int  nXOffset,     // 向左或向右移动的量,设置为负值可以向左移动
    _In_ int  nYOffset);    // 向上或向下移动的量,设置为负值可以向上移动

函数的返回值同CombineRgn函数的返回值,即SIMPLEREGION、COMPLEXREGION、NULLREGION或ERROR。

EqualRgn函数用于比较两个区域是否相同,两个区域相同是指大小和形状都相同(坐标可以不同):

BOOL EqualRgn(HRGN hrgn1, HRGN hrgn2);

PtInRegion函数可以判断指定的点是否在一个区域内:

BOOL PtInRegion(
    _In_ HRGN hrgn, // 区域句柄
    _In_ int  X,    // 点的X坐标
    _In_ int  Y);   // 点的Y坐标

前面说过,区域可以用于执行命中测试(测试光标位置),可以通过处理各种鼠标消息来获取光标坐标,例如鼠标左键按下WM_LBUTTONDOWN、鼠标左键抬起WM_LBUTTONUP、鼠标右键按下WM_RBUTTONDOWN、鼠标右键抬起WM_RBUTTONUP、鼠标移动WM_MOUSEMOVE等,这些消息的lParam参数包含光标的坐标信息。我们可以利用PtInRegion函数测试鼠标光标是否位于区域内,然后执行相应的操作。

SelectClipRgn函数用于把指定区域作为DC的当前裁剪区域,以后仅在裁剪区域边界内的图形输出时才会显示;要删除DC的裁剪区域,调用SelectClipRgn(hdc, NULL)即可。

int SelectClipRgn(
    _In_ HDC  hdc,      // 设备环境句柄
    _In_ HRGN hrgn);    // 区域句柄

下面的代码绘制了一个和客户区大小相同的黑色矩形,但是只有椭圆区域内的部分才会显示:

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    HDC hdc;
    PAINTSTRUCT ps;
    HRGN hRgn;
    RECT rect;

    switch (uMsg)
    {
    case WM_PAINT:
        hdc = BeginPaint(hwnd, &ps);
        hRgn = CreateEllipticRgn(50, 50, 350, 250);
        SelectClipRgn(hdc, hRgn);

        // 绘制一个和客户区大小相同的黑色矩形
        GetClientRect(hwnd, &rect);
        SelectObject(hdc, GetStockObject(BLACK_BRUSH));
        Rectangle(hdc, 0, 0, rect.right, rect.bottom);
        SelectObject(hdc, GetStockObject(WHITE_BRUSH));
        EndPaint(hwnd, &ps);
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }

    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

讲解了这么多对区域的操作,区域有什么用呢?先举一个例子吧,SetWindowRgn函数用于设置一个窗口的窗口区域,窗口区域决定了窗口中允许绘图的区域,位于窗口区域之外的任何部分都不会显示:

int SetWindowRgn(
    _In_ HWND hWnd,     // 设置这个窗口的窗口区域
    _In_ HRGN hRgn,     // 将窗口的窗口区域设置为该区域
    _In_ BOOL bRedraw); // 设置窗口区域后是否重新绘制窗口,通常设为TRUE

需要注意的是,窗口区域hRgn的坐标相对于窗口的左上角,而不是客户区的左上角。有Set…函数,通常就有相应的Get…函数,要获取窗口的窗口区域句柄,可以调用GetWindowRgn函数。

假设我用CreateWindowEx函数创建了一个400像素 300像素的窗口,处理WM_CREATE消息:

case WM_CREATE:
    hRgn = CreateEllipticRgn(50, 50, 350, 250);
    SetWindowRgn(hwnd, hRgn, TRUE);
    return 0;

设置窗口区域为距离程序窗口左上角(50,50)到右下角(350,250)的椭圆范围内,运行程序可以看到显示为一个300 200的椭圆形,通过设置窗口区域可以实现各种奇形怪状的程序窗口。但是现在标题栏不见了,无法拖动窗口,“关闭”按钮也不可见。这些问题通过后面的学习都可以解决,现在可以通过按下Alt + F4组合键,或者任务栏右键关闭程序。

3.8 路径

路径也是与DC关联的图形对象之一,系统会自动在DC中存储一组默认的图形对象(例如画笔、画刷、字体)及属性,但是没有默认路径。

要创建路径并将其选入DC中,首先需要调用BeginPath(hdc)函数表示开始创建路径,然后调用绘图函数进行绘制,这相当于向路径中添加点,最后调用EndPath(hdc)函数来结束路径的创建。可用的绘图函数包括绘制直线的MoveToEx、LineTo、Polyline、PolylineTo、PolyPolyline,绘制曲线的Arc、ArcTo、PolyBezier、PolyBezierTo、AngleArc、PolyDraw,绘制填充图形的Rectangle、RoundRect、Ellipse、Chord、Pie、Polygon、PolyPolygon,绘制文本的TextOut、ExtTextOut,闭合路径中绘制的图形的CloseFigure,等等。

先看一下CloseFigure函数的作用,用于闭合路径中绘制的图形,我依次调用了:

BeginPath(hdc);
MoveToEx(hdc, 50, 50, NULL);
LineTo(hdc, 150, 80);
LineTo(hdc, 50, 110);
CloseFigure(hdc);

Rectangle(hdc, 160, 50, 250, 110);
EndPath(hdc);

StrokePath(hdc);    // 绘制路径的轮廓

从原书的图3.33可以看到CloseFigure(hdc)的作用就是画了箭头所指的直线来闭合图形。

调用BeginPath函数时,如果以前在DC中已经选了一个路径,则系统会删除老路径。调用EndPath函数以后,系统会把新路径选入DC,然后程序可通过以下方式之一对新路径进行操作。

  • 绘制路径的轮廓或者边框(使用当前画笔)。

  • 填充路径的内部(使用当前画刷)。

  • 绘制路径轮廓并填充路径的内部。

  • 将路径转换为裁剪路径。

  • 将路径转换为区域。

  • 将路径中的每条曲线转换为一系列线段来展平路径(FlattenPath函数)。

  • 获取组成路径的直线和曲线的坐标(GetPath函数)。

可以通过调用StrokePath函数使用当前画笔来绘制路径的轮廓,通过调用FillPath函数使用当前画刷来填充路径的内部,通过调用StrokeAndFillPath函数使用当前画笔、画刷来绘制路径的轮廓并填充路径的内部。填充路径时,系统使用DC的当前填充模式,可以通过调用SetPolyFillMode函数来设置新的填充模式。创建路径时可以使用任何绘图函数,各种图形形状构成了一个复杂的路径,这是以前介绍的单一绘图函数无法实现的:

BOOL StrokePath(_In_ HDC hdc);
BOOL FillPath(_In_ HDC hdc);
BOOL StrokeAndFillPath(HDC hdc);

请注意,调用这3个函数的任意一个以后,当前路径将从DC中删除。如果路径需要用于其他用途,则不要调用上述函数。FillPath函数会自动闭合当前路径中没有闭合的图形,然后使用当前画刷、多边形填充模式填充路径的内部;StrokeAndFillPath函数会自动闭合当前路径中没有闭合的图形,然后使用当前画笔绘制路径的轮廓,使用当前画刷、多边形填充模式填充路径的内部;StrokePath函数则不会自动闭合当前路径中没有闭合的图形。看一个示例,不同函数调用的结果如原书的图3.34所示:

case WM_PAINT:
    hdc = BeginPaint(hwnd, &ps);
    BeginPath(hdc);
    MoveToEx(hdc, 50, 50, NULL);
    LineTo(hdc, 150, 80);
    LineTo(hdc, 50, 110);
    Rectangle(hdc, 160, 50, 250, 110);
    EndPath(hdc);

    SelectObject(hdc, CreatePen(PS_SOLID, 2, RGB(0, 0, 0)));
    SelectObject(hdc, CreateSolidBrush(RGB(180, 180, 180)));
    StrokePath(hdc);
    //FillPath(hdc);
    //StrokeAndFillPath(hdc);
EndPaint(hwnd, &ps);
    DeleteObject(SelectObject(hdc, GetStockObject(BLACK_PEN)));
    DeleteObject(SelectObject(hdc, GetStockObject(WHITE_BRUSH)));
    return 0;

如果使用TextOut函数输出文本,然后调用StrokePath函数,可以制作镂空文本。当然,字体需要设置大一点。如果使用阴影或位图图案画刷等,那么可以制作各种炫丽的文字效果。

调用SelectClipPath函数可以把当前路径作为DC的裁剪区域,以后仅在路径边界内的图形输出才会显示:

BOOL SelectClipPath(_In_ HDC hdc, _In_ int iMode);  // iMode指定当前裁剪区域和当前路径的组合方式

参数iMode指定当前裁剪区域和当前路径的组合方式,默认情况下当前裁剪区域指的是整个客户区,该参数可以指定为RGN_AND、RGN_COPY、RGN_DIFF、RGN_OR、RGN_XOR中的一个,这些常量的含义和组合区域函数CombineRgn的fnCombineMode参数含义相同:

case WM_PAINT:
    hdc = BeginPaint(hwnd, &ps);
    // 创建路径
    BeginPath(hdc);
    MoveToEx(hdc, 50, 50, NULL);
    LineTo(hdc, 150, 80);
    LineTo(hdc, 50, 110);
    CloseFigure(hdc);
    Rectangle(hdc, 160, 50, 250, 110);
    EndPath(hdc);

    // 把当前路径作为设备环境的裁剪区域
    SelectClipPath(hdc, RGN_COPY);

    // 绘制一个和客户区大小相同的黑色矩形
    GetClientRect(hwnd, &rect);
    SelectObject(hdc, GetStockObject(BLACK_BRUSH));
    Rectangle(hdc, 0, 0, rect.right, rect.bottom);
    EndPaint(hwnd, &ps);
    return 0;

和客户区大小相同的黑色矩形仅在路径边界内的部分才会显示。

裁剪区域也是DC的图形对象之一,裁剪可以将输出限制在指定的区域或路径内。SelectClipRgn函数可以把指定区域作为DC的当前裁剪区域,SelectClipPath函数可以把当前路径作为DC的裁剪区域。

另外,调用BeginPaint函数以后会在lpPaint参数指定的PAINTSTRUCT结构中返回需要重绘的区域,这个区域叫作无效区域。使用由BeginPaint函数返回的DC句柄,是无法在无效区域以外的区域进行绘制的,这个无效区域也就是裁剪区域。

可以通过调用PathToRegion函数将当前路径转换为区域,然后进行各种区域的操作:

HRGN PathToRegion(_In_ HDC hdc);

将路径转换为区域以后,系统将从DC中删除当前路径。

3.9 绘图模式

绘图模式,也称光栅操作,用于定义画笔、画刷的颜色与目标显示区域颜色的混合方式。例如,调用LineTo函数画一条线,最终显示的颜色是由画笔的颜色和显示区域的颜色共同控制的,根据DC所选择的绘图模式,将画笔的像素颜色和目标显示区域的像素颜色执行某种位运算,这就是光栅操作(Raster Operation,ROP)。因为只涉及两个对象的像素颜色的运算,即画笔或画刷与目标显示区域,因此也称为二元光栅操作(ROP2)。

Windows定义了16种ROP2运算码,在默认的DC属性中,绘图模式是R2_COPYPEN,意思是Windows只是简单地将画笔或画刷像素的颜色复制到目标显示区域像素上。

例如,设置画笔 / 画刷颜色(PB)为1100,设置目标区域颜色(DES)为1010,依据位运算规则得到的运算结果如表3.43所示。

表3.43

位运算规则运算结果绘图模式常量
00000R2_BLACK
11111R2_WHITE
~Des0101R2_NOT
PB ^ Des0110R2_XORPEN
~(PB ^ Des)1001R2_NOTXORPEN
Des1010R2_NOP
PBDes1110
~(PBDes)0001
PB1100R2_COPYPEN(默认)
~PB0011R2_NOTCOPYPEN
PB & Des1000R2_MASKPEN
~(PB & Des)0111R2_NOTMASKPEN
~PB & Des0010R2_MASKNOTPEN
PB & ~Des0100R2_MASKPENNOT
~PBD1011
PB~Des1101

表3.43中运算符有按位取反、异或、或、与,说明了画笔 / 画刷颜色值(PB)的每个颜色位如何与目标显示区域颜色值(Des)的每个颜色位进行运算得到最终显示的颜色。

前面几种ROP2运算码是比较常见的。R2_BLACK表示不管画笔 / 画刷和目标区域的颜色是什么,绘制出来的总是黑色;R2_WHITE表示不管画笔 / 画刷和目标区域的颜色是什么,绘制出来的总是白色;R2_N0T表示将目标区域的颜色取反来确定绘制的颜色,而不管画笔 / 画刷的颜色;R2_XORPEN绘图模式挺有意思,设置为该模式以后就会用PB^Des计算出来的颜色绘图,再设置一次该模式,在同一个地方进行绘图结果是PB ^ (PB^Des),异或操作两次会复原,PB ^ (PB^Des)的结果就是Des,第二次的绘图相当于擦除了第一次的绘图痕迹;R2_N0TC0PYPEN表示将画笔 / 画刷的颜色位取反来进行绘图。

可以通过调用SetROP2(hdc, iRop2Mode);函数设置一种新的绘图模式,函数执行成功,则返回先前的绘图模式。如果要获取DC的当前绘图模式,则可以调用GetROP2(hdc)函数,函数返回当前的绘图模式。后面会有一个用到R2_N0T绘图模式的示例。

C++ MFC/BCG编程(五):Windows绘图引擎、图形设备接口GDI、设备描述表DC Windows环境下二维绘图引擎有多种选择:GDI、GDI+、Direct2D、Direct3D、OpenGL、Vulkan等。GDI作为微软原生的二维绘图引擎,有微软的全力支持,作为操作系统核心层效率方面不用担心。 阅读详情

相关推荐

《Windows API每日一练》4.1 GDI绘图

尽管一些图形语言并不允许使用像素坐标,但是 Windows GDI允许使用任何一种坐标系统(可以使用其他依据物理测量得到的坐标系统),所以你可以使用虚拟坐标系统来保证程序与硬件独立,也可以使用设备坐标系统来完全迎合硬件的需求。◆可被填充的封闭区域。这个画刷可以是纯色的,或者是使用某种填充模式(如一系列水平的、垂直的或者倾斜的图案),还可以是在水平或垂直方向不停重复的位图图像。1.设备上下文(Device Context,DC):设备上下文是GDI的核心概念,它是一个数据结构,包含了在设备中绘图的所有信息。

bcdaren的博客 790

深入浅出 Windows API 程序设计 学习笔记

(1)注册窗⼝类(RegisterClassEx),在注册之前,要先填写 RegisterClassEx函数的参数WNDCLASSEX结构的各个字段。(2)创建窗⼝(CreateWindowEx)。(3)显⽰窗⼝(ShowWindow)、刷新窗⼝客户区 (UpdateWindow)。(4)进⼊⽆限的消息获取、分发的循环:获取消息 (GetMessage),转换消息(TranslateMessage),将消息分发 到回调函数WindowProc进⾏处理(DispatchMessage)。

weixin_51930086的博客 900

Qt自带绘图与GDI+绘图方式比较_gdi+实时绘制qt(2)

2、GDI+是Windows操作系统中的图形设备接口,它提供了一套用于绘制图形的API,包括了图形渲染、图形变换、图形剪切、图形填充等功能,使开发者可以快速地开发出各种类型的图形应用程序。1、Qt是一个跨平台的C++应用程序框架,它提供了一套用于GUI编程的类库,包括了绘图、网络、XML、数据库、多线程等模块,使开发者可以快速地开发出高质量的跨平台应用程序。Qt提供了一套用于绘图的类库,包括了QPainter、QPen、QBrush等类,使开发者可以快速地进行图形绘制。

qq_17136213的博客 918

深入浅出Windows API程序设计

有人有买书吗?怎么样。

qq_44599646的博客 351

利用C++和Windows API在桌面实现绘图功能

本文还有配套的精品资源,点击获取 简介:本文章介绍如何使用C++和Windows API中的GDI/GDI+库,实现在计算机桌面上进行图形绘制操作,包括创建窗口、设备上下文获取、线条、圆形和文本绘制以及颜色样式的应用。将深入探讨窗口创建、消息处理、绘图操作、资源释放以及GDI+的扩展使用等关键步骤,以实现一个完整的桌面绘图程序。 1. 使用C++进行编程 1.1...

weixin_29155599的博客 3414

全面掌握GDI绘图技术的Win32App程序

本文还有配套的精品资源,点击获取 简介:GDI是Windows操作系统的图形设备接口,为开发者提供在显示器或打印机上高效生成图形的API。本文介绍了一个基于GDI技术的简单画图应用程序"Win32App",涵盖了从基础概念到绘图流程,再到内存位图与双缓冲技术的全面内容。通过本程序,用户可以绘制基本图形并设置颜色,实现如点、线、椭圆和矩形的绘制,并能够清屏。同时,本文还提供了...

weixin_31163455的博客 1449

Windows API程序设计(窗口创建)

目的 1.了解 windows操作系统应用程序开发的基本概念,win32 API函数、消息与事件驱动; 2.掌握WinMain函数的基本框架,窗口定义、窗口创建、消息循环及窗口过程函数; 创建一个Win32应用程序的步骤: 1.定义 WinMain 函数; 2.设计窗口类 WNDCLASS; 3.注册窗口类; 4.创建窗口; 5.显示并更新窗口; 6.编写消息循环; 7.编写窗口过程调用函数; #include <windows.h> #include <stdio.h> LRES

weixin_44439920的博客 1150

Windows GDI计算器编程实战教程

图形设备接口(GDI)是Windows操作系统中用于图形和渲染输出的核心组件。GDI提供了一组API,使得程序员能够不直接与硬件设备交互,而是通过软件抽象层实现图形绘制。GDI的主要功能包括但不限于基本图形绘制、文本渲染、颜色管理以及位图操作等。它使得开发者能够创建和管理图形对象(如线条、形状、位图和字体)并将它们输出到显示设备、打印机或其他图形输出设备。

weixin_31860973的博客 878

Qt使用GDI绘图(仅Windows平台)

绘图引擎 Windows环境下二维绘图引擎有多种选择:GDI、GDI+、DirectDraw、Qt/QPainter、Agg、Cairo、skia、Direct2D、Direct3D、OpenGL等。 GDI:微软原生的二维绘图引擎。 优点:微软的全力支持,作为操作系统核心层效率方面不用担心,支持多种开发框架(含语言):WinSDK、MFC、Delphi等。 缺点:不是面向C++对象组织的......

$firecat利白的代码足迹$ 9404

掌握Windows GDI编程:从基础到实践

图形设备接口(GDI,Graphics Device Interface)是Windows操作系统中用于图形渲染的一个重要组件。GDI的设计理念是抽象化,它为程序员提供了一套设备无关的API(应用程序编程接口),使他们能够在不同的输出设备上呈现统一的图形和文本。无论是在显示器上、打印机上还是其他任何图形设备上,GDI都保证了内容的一致性与可移植性。GDI(Graphics Device Interface)API函数是Windows图形系统的重要组成部分,它们允许程序员与硬件无关地进行图形处理和输出。

weixin_28235889的博客 531

Windows程序设计(第五版pdf代码)深入浅出MFC

Windows程序设计(第五版pdf代码)深入浅出MFC,包含了3部分内容,分别是windows程序设计第五版pdf中文高清,和代码,深入浅出MFCpdf中文,比较全面的学习windos开发的全部资料了,免费分享!和别人十一分没多大差别

深入浅出Windows API程序设计 核心编程篇-配套资源-源代码

百度网盘分享链接【深入浅出Windows API程序设计 核心编程篇-配套资源-源代码】

Windows API 编程.pdf

Windows API 编程.pdf 这是一本很好的书

Windows编程日志7——GDI编程基础

Windows GDI编程基础摘要 GDI(Graphics Device Interface)是Windows的传统绘图系统,提供设备无关的2D绘图功能。核心概念包括: HDC(设备上下文):代表绘图目标,如屏幕、打印机或内存位图 GDI对象:包括HPEN(画笔)、HBRUSH(画刷)、HBITMAP(位图)和HFONT(字体) 绘制流程:在WM_PAINT消息中通过BeginPaint/EndPaint获取和释放HDC GDI优势在于设备兼容性好、简单业务实现方便,但存在性能局限,现代应用推荐使用Dir

charlie114514191的博客 1624

深入浅出MFC完整电子版

给书是深入浅出MFC书籍电子版本,是Visual C++入门学习一本必备的书籍。

《竹林蹊径——深入浅出Windows内核驱动开发》

这是《竹林蹊径--深入浅出Windows内核驱动开发》的三章试读内容,算是官方发布吧。内容是:第二章(64位编程)、第六章(内核C++)、附录2(虚拟机调试)。 本书由China-pub首发,目前在当当和淘宝上都有卖。价格低至7.5折,比较实惠。大家先下载试读版本看看,也可以去书店逛逛,看看书写的如何。相关网址如下: China-Pub: http://www.china-pub.com/197674 当当:http://product.dangdang.com/product.aspx?product_id=21020856

上一篇: 【Windows】《深入浅出Windows API程序设计:编程基础篇》笔记-Chapter2-Windows窗口程序
下一篇: 【Windows】《深入浅出Windows API程序设计:编程基础篇》笔记-Chapter4-键盘与鼠标
江湖人称菠萝包
博客等级 码龄10年 762粉丝 314原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值