C++博客-梦中乐园-文章分类-Windows相关

windows xp 下删除.svn 文件夹

梦五 — Fri, 30 Mar 2012 11:17:00 GMT

可以通过将“Delete SVN Folders”操作添加到右击菜单中，然后在要删除.svn文件夹中右键点击“Delete SVN Folders”这个选项，即可删除这个文件夹下的所有.svn文件夹
方法如下：
建立一个文本文件，输入如下内容：
Windows Registry Editor Version 5.00
[HKEY_LOCAL_MACHINE\SOFTWARE\Classes\Folder\shell\DeleteSVN]
@="Delete SVN Folders"
[HKEY_LOCAL_MACHINE\SOFTWARE\Classes\Folder\shell\DeleteSVN\command]
@="cmd.exe /c \"TITLE Removing SVN Folders in %1 && COLOR 9A && FOR /r \"%1\" %%f IN (.svn) DO RD /s /q \"%%f\" \""
保存为后缀名为 .reg 的文件，名称自定。
双击运行 .reg 文件即可在右键菜单中添加“Delete SVN Folders” 选项。

梦五 2012-03-30 19:17 发表评论

VC6.0 设置 UNICODE 编译环境

梦五 — Wed, 07 Mar 2012 09:54:00 GMT

转自：http://www.cnblogs.com/mars9/archive/2011/09/21/2184158.html
VC++ 6.0支持Unicode编程，但默认的是ANSI，所以开发人员只需要稍微改变一下编写代码的习惯便可以轻松编写支持UNICODE的应用程序。　
　　 1. 安装完成后：需要把VC98\MFC\LIB下的MFC42U*.*手动拷贝到对应的安装目录下

　　 2. 为工程添加UNICODE和_UNICODE预处理选项：打开[工程]->[设置…]对话框，在C/C++标签对话框的“预处理程序定义”中去除_MBCS，加上_UNICODE,UNICODE。（注意中间用逗号隔开）.在没有定义UNICODE和_UNICODE前，所有函数和类型都默认使用ANSI的版本；在定义了UNICODE和_UNICODE之后，所有的MFC类和Windows API都变成了宽字节版本了。

　　 3. 设置程序入口点：因为MFC应用程序有针对Unicode专用的程序入口点，我们要设置entry point。否则就会出现连接错误。设置entry point的方法是：打开[工程]->[设置…]对话框，在Link页的Output类别的Entry Point里填上wWinMainCRTStartup。

　　 4. 使用ANSI/Unicode通用数据类型：微软提供了一些ANSI和Unicode兼容的通用数据类型，我们最常用的数据类型有_T ，TCHAR，LPTSTR,LPCTSTR。顺便说一下，LPCTSTR和const TCHAR*是完全等同的。其中L表示long指针，这是为了兼容Windows 3.1等16位操作系统遗留下来的，在Win32 中以及其它的32位操作系统中，long指针和near指针及far修饰符都是为了兼容的作用，没有实际意义。P（pointer）表示这是一个指针；C （const）表示是一个常量；T(_T宏)表示兼容ANSI和Unicode，STR（string）表示这个变量是一个字符串。综上可以看出， LPCTSTR表示一个指向常固定地址的可以根据一些宏定义改变语义的字符串。比如：TCHAR* szText=_T(“Hello!”);TCHAR szText[]=_T(“I Love You”);LPCTSTR lpszText=_T(“大家好！”);使用函数中的参数最好也要有变化，比如：MessageBox(_T(“你好”));　　其实，在上面的语句中，即使您不加_T宏，MessageBox函数也会自动把“你好”字符串进行强制转换。但我还是推荐您使用_T宏，以表示您有Unicode编码意识。

　　 5. 修改字符串运算问题　　一些字符串操作函数需要获取字符串的字符数(sizeof(szBuffer)/sizeof(TCHAR))，而另一些函数可能需要获取字符串的字节数sizeof(szBuffer)。您应该注意该问题并仔细分析字符串操作函数，以确定能够得到正确的结果。ANSI 操作函数以str开头，如strcpy()，strcat()，strlen()；Unicode操作函数以wcs开头，如wcscpy，wcscpy ()，wcslen()；ANSI/Unicode操作函数以_tcs开头 _tcscpy(C运行期库)；ANSI/Unicode操作函数以lstr开头 lstrcpy(Windows函数)；考虑ANSI和Unicode的兼容，我们需要使用以_tcs开头或lstr开头的通用字符串操作函数。

梦五 2012-03-07 17:54 发表评论

PeekMessage 函数

梦五 — Fri, 06 Jan 2012 13:43:00 GMT

PeekMessage 调用的一个例子：

PeekMessage(&msg,NULL,0,0,PM_REMOVE);

前面的4个参数（一个指向 MSG 结构的指针、一个窗口的句柄、两个值指示消息范围）与 GetMessage 的参数相同。
将第二、三、四个参数设置为 NULL 或 0时，表明我们想让 PeekMessage 返回程序中所有窗口的所有消息。

如果要将消息从消息队列中删除，则将 PeekMessage 的最后一个参数设置为 PM_REMOVE。
如果不希望删除消息，则将最后一个参数设置为 PM_NOREMOVE，这使得程序可以检查程序的消息队列中的下一个消息，而不实际删除它。

GetMessage 不将控制返回给程序，直到从程序的消息队列中获取消息，但是 PeekMessage 总是立刻返回，而不论一个消息是否出现。
当（应用程序的）消息队列中有一个消息时，PeekMessage 的返回值为 TRUE(非0)，并且将按通常方式处理消息。当队列中没有消息时，PeekMessage 返回 FALSE(0)。
考虑如下例子：

// 普通的消息循环
while( GetMessage(&msg,NULL,0,0) )
{
  TranslateMessage(&msg);
  DispatchMessage (&msg);
}
return msg.wParam;

// 等价于
while( TRUE )
{
  if( PeekMessage(&msg,NULL,0,0,PM_REMOVE) )
  {
    if(msg.message == WM_QUIT)
    {
      break;
    }
    TranslateMessage(&msg);
    DispatchMessage(&msg);
  }
  else
  {
    // Other program lines to do some work
  }
}
return msg.wParam;

如果 PeekMessage 的返回值为 TRUE,则消息按通常方式进行处理。如果返回值为 FALSE,则在将控制返回给Windows（操作系统）之前，还可以做一点工作（如显示另一个随机矩形）。

PeekMessage 不能从消息队列中删除 WM_PAINT 消息。
从队列中删除 WM_PAINT 消息的唯一方法是令窗口客户区的失效区域变得有效，这可以用 ValidateRect 和 ValidateRgn 或者 BeginPaint 和 EndPaint 对来完成。

不能使用如下所示的代码来清除消息队列中的所有消息：
while( PeekMessage(&msg,NULL,0,0,PM_REMOVE) );
这条语句从消息队列中删除 WM_PAINT 之外的所有消息。如果队列中有一个 WM_PAINT 消息，程序就会永远地陷在 while 循环中。

梦五 2012-01-06 21:43 发表评论

矩形、区域和剪裁

梦五 — Fri, 06 Jan 2012 13:09:00 GMT

Windows 包含了几种使用 RECT(矩形)结构和“区域”的绘图函数。
区域就是屏幕上的一块地方，它是矩形、多边形和椭圆的结合。

矩形函数：

函数	功能
FillRect(hdc,&rect,hBrush);	用指定画刷来填充矩形（直到但不包含 right 和 bottom 坐标），该函数不需要先将画刷选进设备描述表。
FrameRect(hdc,&rect,hBrush);	使用画刷画矩形框，但是不填充矩形。
InvertRect(hdc,&rect);	将矩形中所有像素反转，1转换成0，0转换成1。
SetRect(&rect,xLeft,yTop,xRight,yBottom);	将 RECT 结构的4个字段设置为特定值。
OffsetRect(&rect,x,y);	将矩形沿x轴和y轴移动几个单元。
InflateRect(&rect,x,y);	增减矩形的尺寸。
SetRectEmpty(&rect);	将矩形各字段设置为0。
CopyRect(&DestRect,&SrcRect);	将矩形复制给另一个矩形。
IntersectRect(&DestRect,&SrcRect1,&SrcRect2);	获取两个矩形的交集。
UnionRect(&DestRect,&SrcRect1,&SrcRect2);	获取两个矩形的并集。
bEmpty = IsRectEmpty(&rect);	确定矩形是否为空。
bInRect = PtInRect(&rect,point);	确定点是否在矩形内。

创建和绘制区域
区域是对显示器上一个范围的描述，这个范围是矩形、多边形和椭圆的组合。区域可以用于绘制和剪裁，通过将区域选进设备描述表，就可以用区域来进行剪裁（就是说，就可以将绘图的范围限制为客户区的一部分）。
与画笔、画刷和位图一样，区域是 GDI 对象，应该调用 DeleteObject 来删除创建的区域。

当创建一个区域时，Windows 返回一个该区域的句柄，类型为 HRGN。
最简单的区域是矩形，创建矩形区域的方法：
hRgn = CreateRectRgn(xLeft,yTop,xRight,yBottom);
或
hRgn = CreateRectRgnIndirect(&rect);

创建椭圆区域的方法：
hRgn = CreateEllipticRgn(xLeft,yTop,xRight,yBottom);
或
hRgn = CreateEllipticRgnIndirect(&rect);

创建圆角的矩形区域：CreateRoundRectRgn;

创建多边形区域的方法：
hRgn = CreatePolygonRgn(&point,iCount,iPolyFillMode);
创建多个多边形区域：CreatePolyPolygonRgn;

合成区域：
iRgnType = CombineRgn(hDestRgn,hSrcRgn1,hSrcRgn2,iCombine);
这一函数将两个源区域（hSrcRgn1 和 hSrcRgn2）组合起来并用句柄 hDestRgn 指向合成的目标区域。这三个区域句柄必须是有效的，但是 hDestRgn 所指向的原来的区域被破坏掉了（当你使用这个函数时，可能要让 hDestRgn 在初始时指向一个小的矩形区域）。
iCombine 参数说明 hSrcRgn1 和 hSrcRgn2 如何组合：

iCombine 值	新区域
RGN_AND	两个源区域的公共部分
RGN_OR	两个源区域的全部
RGN_XOR	两个源区域的全部除去公共部分
RGN_DIEF	hSrcRgn1 不在 hSrcRgn2 中的部分
RGN_COPY	hSrcRgn1 的全部（忽略hSrcRgn2）

从 CombineRgn 返回的 iRgnType 值是下列之一：
NULLREGION，表示得到一个空区域；
SIMPLEREGION，表示得到一个简单的矩形、椭圆或者多边形；
COMPLEXREGION，表示多个矩形、椭圆或多边形的组合；
ERROR，表示出错了。

删除区域：
DeleteObject(hRgn);

矩形与区域的剪裁：
区域也在剪裁中扮演了一个角色。InvalidateRect 函数使显示的一个矩形区域失效，并产生一个 WM_PAINT 消息。
InvalidateRect(hwnd,NULL,TRUE);
清空客户区，并产生一个 WM_PAINT 消息（在应用程序的消息队列中，最终由 Windows 调用应用程序的窗口过程函数来处理。）

可以通过调用 GetUpdateRect 来获取失效矩形的坐标，并且可以使用 ValidateRect 函数使客户区的矩形有效。
当接收到一个 WM_PAINT 消息时，无效矩形的坐标可以从 PAINTSTRUCT 结构中得到，该结构是用 BeginPaint 函数填充的。这个无效矩形还定义了一个“剪裁区域”，不能在剪裁区域外绘图。

Windows 有两个作用于区域而不是矩形的函数，它们类似于InvalidateRect 和 ValidateRect:
InvalidateRgn(hwnd,hRgn,bErase);
和
ValidateRgn(hwnd,hRgn);

当接收到一个由无效矩形引起的 WM_PAINT 消息时，剪裁区域不一定是矩形。

可以使用以下两个函数把区域选进设备描述表：
SelectObject(hdc,hRgn);
或
SelectClipRgn(hdc,hRgn);
通过将一个区域选进设备描述表来创建自己的剪裁区域，这个剪裁区域使用设备坐标。

GDI(图形设备接口)为剪裁区域建立一份副本，所以在将它选进设备描述表之后，用户可以删除它。

几个对剪裁区域进行操作的函数：
ExcludeClipRect 用于将一个矩形从剪裁区域里排除掉。
IntersectClipRect 用于创建一个新的剪裁区域，它是前一个剪裁区域与一个矩形的交集。
OffsetClipRgn 用于将剪裁区域移动到客户区的另一部分。

梦五 2012-01-06 21:09 发表评论

窗口和视口

梦五 — Fri, 06 Jan 2012 07:48:00 GMT

“窗口”和“视口”这两个词用得并不恰当。在其他图形界面语言中，视口通常包含有剪裁区域的意思，并且，我们以及用窗口来指程序在屏幕上占据的区域。
在这里的讨论中，我们必须把关于这些词的先入之见抛到一边。

映射方式用于定义从“窗口”（逻辑坐标）到“视口”（设备坐标）的映射。

“视口”是基于设备坐标（像素）的。
通常，视口和客户区相同，但是，如果你已经用 GetWindowDC 或 CreateDC 获取了一个设备描述表，则视口也可以是整窗口坐标或者屏幕坐标。
点(0,0)是客户区（或者整个窗口或屏幕）的左上角，x的值向右增加，y的值向下增加。

“窗口”是基于逻辑坐标的，逻辑坐标可以是像素、mm、英寸，或者你想要的任何其他单位。您在 GDI 绘图函数中指定逻辑窗口坐标。

对于所有的映射方式，Windows 都用下面两个公式来将窗口（逻辑）坐标转化为视口（设备）坐标：
xViewport = (xWindow - xWinOrg) *(xViewExt/xWinExt) + xViewOrg

yViewPort = (yWindow - yWinOrg) * (yViewExt/yWinExt) + yViewOrg
其中，(xWindow,yWindow)是带转换的逻辑点，(xViewport,yViewport)是转换后的设备坐标点，更像客户区坐标。(xWinOrg,yWinOrg)是逻辑坐标的窗口原点；(xViewOrg,yViewOrg)是设备坐标的视口原点。在默认的设备描述表中，这两个点均被设置为(0,0)，但是他们可以改变。

设备点与逻辑点相互转换的函数：

// 设备点转换为逻辑点
DPtoLP(hdc,pPoints,iNumber);

// 将逻辑点转换为设备点
LPtoDP(hdc,pPoints,iNumber);

// pPoints是一个指向 POINT 结构数组的指针，而 iNumber 是要转换的点的个数。

// 将 GetClientRect(它总是使用设备单位)获取的客户区大小转换为逻辑坐标
GetClientRect(hwnd,&rect);
DPtoLP(hdc,(POINT)&rect,2);

Windows 提供了函数 SetViewportOrgEx 和 SetWindowOrgEx，用来改变视口和窗口的原点。

可以使用下面两个函数来获取当前视口和窗口的原点：
GetViewportOrgEx(hdc,&pt);
GetWindowOrgEx (hdc,&pt);

梦五 2012-01-06 15:48 发表评论

设备坐标和逻辑坐标

梦五 — Fri, 06 Jan 2012 03:15:00 GMT

Windows 对所有消息（如 WM_MOVE,WM_SIZE 和 WM_MOUSEMOVE），对所有非 GDI 函数，甚至对一些 GDI 函数，永远使用设备坐标。

由于映射方式是一种设备描述表属性，所以，只有对需要设备描述表句柄作参数的 GDI 函数，映射方式才会起作用。

Windows 将 GDI 函数中指定的逻辑坐标映射为设备坐标。

所有设备坐标系都以像素为单位，水平轴（即x轴）上的值从左到右递增，垂直轴（即y轴）上的值从上到下递增。
设备坐标系包括：“屏幕坐标”、“整窗口坐标”和“客户区坐标”。

屏幕坐标：
当我们使用整个屏幕时，就根据“屏幕坐标”进行操作。屏幕的左上角为(0,0)点，屏幕坐标用在 WM_MOVE 消息（对于非子窗口）以及下列 Windows 函数中：CreateWindow 和 MoveWindow（都是对于非子窗口）、GetMessagePos,GetCursorPos,SetCursorPos,GetWindowRect，以及 WindowFromPoint(这不是全部函数的列表)。
如果以 DISPLAY 为参数调用 CreateDC ，以获取整个屏幕的设备描述表，则默认情况下 GDI 调用中指定的逻辑坐标将被映射为屏幕坐标。

整窗口坐标：
“整窗口坐标”以程序的整个窗口为基准，如标题栏、菜单、滚动条和窗口框都包括在内。而对于普通窗口，点(0,0)是缩放边框的左上角。
整窗口坐标在 Windows 中极少使用，但是如果用 GetWindowDC 获取设备描述表，GDI 函数中的逻辑坐标就会转换为客户区坐标。

客户区坐标系：
点(0,0)是客户区的左上角。当使用 GetDC 或 BeginPaint 获取设备描述表时，GDI 函数中的逻辑坐标就会默认地转换为客户区坐标。

设备坐标系之间的转换：
用函数 ClientToScreen 和 ScreenToClient 可以将客户区坐标转换为屏幕坐标，或者反过来，将屏幕坐标转换为客户区坐标。
可以使用 GetWindowRect 函数获取屏幕坐标下的整个窗口的位置和大小。

梦五 2012-01-06 11:15 发表评论

GDI 映射方式

梦五 — Thu, 05 Jan 2012 16:23:00 GMT

在默认情况下，程序都是相对于客户区的左上角，以像素为单位绘图的。

“映射方式”是一种几乎影响任何客户区绘图的设备描述表属性。
另外有4种设备描述表属性——窗口原点、视口原点、窗口范围和视口范围——与映射方式密切相关。

GDI 绘图函数中需要的传入的坐标值使用的都是一种“逻辑单位”。Windows 必须将逻辑单位转换为“设备单位”，即像素。这种转换方式由映射方式、窗口和视口原点，以及窗口和视口的范围所控制的。

Windows 定义了8种映射方式：

		增加值
映射方式	逻辑单位	X值	Y值
MM_TEXT	像素	右	下
MM_LOMETRIC	0.1 mm	右	上
MM_HIMETRIC	0.01 mm	右	上
MM_LOENGLISH	0.01 in.	右	上
MM_HIENGLISH	0.001 in.	右	上
MM_TWIPS	1/1440 in.	右	上
MM_ISOTROPIC	任意(x = y)	可选	可选
MM_ANISOTROPIC	任意(x != y)	可选	可选

设置映射方式：
SetMapMode(hdc,iMapMode);
iMapMode 是8个映射方式标识符之一。

获取当前的映射方式：
iMapMode = GetMapMode(hdc);

默认映射方式为 MM_TEXT。在这种方式下，逻辑单位与物理单位（也叫设备单位）相同，这样就可以直接以像素为单位进行操作。
示例：

// MM_TEXT 映射方式下：
TextOut(hdc,8,16,TEXT("Hello"),5);
// 文本从距离客户区左端8像素、上端16像素的位置处开始。

// MM_LOENGLISH 映射方式下：
TextOut(hdc,50,-100,TEXT("Hello"),5);
// 文本从距离客户区左端0.5英寸、上端1英寸的位置处开始。

梦五 2012-01-06 00:23 发表评论

绘制填充区域

梦五 — Thu, 05 Jan 2012 08:57:00 GMT

Windows 中7个用来画带边缘的填充图形的函数如下表所示：

函数	图形
Rectangle	直角矩形
Ellipse	椭圆
RoundRect	圆角矩形
Chord	椭圆周上的弧，两端以弦连接
Pie	椭圆上的饼图
Polygon	多边形
PolyPolygon	多个多边形

Windows 用设备描述表中选择的当前画笔来画图形的边界框，边界框还使用当前背景方式、背景色彩和绘图方式，这跟 Windows 画线时一样。
图形以当前设备描述表中选择的刷子来填充。默认情况下，使用现有对象，这意味着图形内部将画为白色。

Windows 定义了6种现有刷子：
WHITE_BRUSH,LTGRAY_BRUSH,GRAY_BRUSH,DKGRAY_BRUSH,BLACK_BRUSH 和 NULL_BRUSH(也叫 HELLOW_BRUSH).
可以将任何一种现有画刷选入设备描述表中，就和选择画笔一样。

Windows 将 HBRUSH 定义为刷子的句柄。

刷子的获取和选入：

// 定义一个刷子句柄变量
HBRUSH hBrush;

// 获取 GRAY_BRUSH 的句柄
hBrush = GetStockObject(GRAY_BRUSH);

// 选进设备描述表
SelectObject(hdc,hBrush);

// 现在如果要画上表中的任一个图形，则其内部为灰色。

/* ------------------------------------------*/

// 如果想画一个没有边界框的图形，可以将 NULL_PEN 选进设备描述表：
SelectObject(hdc,GetStockObject(NULL_PEN));

// 如果想画出图形的边界框，但不填充内部，则将 NULL_BRUSH 选进设备描述表：
SelectObject(hdc,GetStockObject(NULL_BRUSH));

对于 Polygon 和 PolyPolygon 函数，Windows 使用定义在设备描述表中的当前画刷来填充这个带边界的区域。至于填充内部的方式，则取决于多边形填充方式，可以用SetPolyFillMode 函数来设置：

SetPolyFillMode(hdc,iMode);

默认情况下，多边形填充方式是 ALTERNATE，但是可以将它设置为 WINDING。

用画刷填充内部：
Rectangle,RoundRect,Ellipse,Chord,Pie,Polygon 和 PolyPolygon 图形的内部是用选进设备描述表的当前画刷（也成为“模式”）来填充的。
画刷是一个 8 * 8 的位图，它水平和垂直地重复使用来填充内部区域。

逻辑画刷：
与逻辑画笔一样，逻辑画刷也是 GDI 对象。创建的所有画刷都必须被删除，但是当它还在设备描述表中时不能将其删除。

Windows 有5个函数可以用来创建逻辑画刷，然后就可使用 SelectObject 将画刷选进设备描述表。
创建逻辑画刷的第一个函数：
hBrush = CreateSolidBrush(crColor);
函数中的 Solid 并不是指画刷为纯色。在将画刷选入设备描述表中时，Windows 创建一个抖动色的位图，并为画刷使用该位图。

可以使用由水平、垂直或者倾斜的线组成的“影线标记(hatch marks)”来创建画刷，第二个函数为创建影线画刷的函数：
hBrush = CreateHatchBrush(iHatchStyle,crColor);
iHatchStyle 参数描述影线标记的外观，有6种可用的影线标记风格：HS_HORIZONTAL,HS_BDIAGONAL,HS_VERTICAL,HS_CROSS,HS_FDIAGONAL,HS_DIAGCROSS;
crColor 参数是影线的色彩，在将画刷选进设备描述表时，Windows 将这种色彩转换为与之最相近的纯色。影线之间的区域根据设备描述表中定义的背景方式和背景色来着色。如果背景方式为 OPAQUE，则用背景色（它也被转换为纯色）来填充线之间的空间。在这种情况下，影线和填充线都不能是抖动色。如果背景方式为 TRANSPARENT，则 Windows 只画出影线，不填充它们之间的区域。

第三、第四个函数：
CreatePatternBrush 和 CreateDIBPatternBrushPt
创建基于位图的画刷。

第5个函数：
hBrush = CreateBrushIndirect(&logbrush);
变量 logbrush 是一个类型为 LOGBRUSH（“逻辑画刷”）的结构。

和画笔一样，用 SelectObject 将画刷选进设备描述表，用 DeleteObject 删除画刷，用GetObject 来获取逻辑画刷的信息：

// 将画刷选进设备描述表
SelectObject(hdc,hBrush);

// 删除所创建的画刷
DeleteObject(hBrush);

// 获取画刷的信息
GetObject(hBrush,sizeof(LOGBRUSH),(LPVOID)&logbrush);

注意：不要删除当前选进设备描述表的画刷。

梦五 2012-01-05 16:57 发表评论

绘图方式

梦五 — Thu, 05 Jan 2012 08:34:00 GMT

设备描述表中定义的绘图方式也影响显示器上所画线的外观。

当 Windows 使用画笔来画线时，它实际上执行画笔像素与目标位置处原来像素之间的某种按位布尔运算。像素间的按位布尔运算叫做“光栅运算”，简记为“ROP”。由于画一条直线只涉及两种像素（画笔和目标），因此这种运算又称为“二元光栅运算”，简记为“ROP2”。

Windows 定义了16种 ROP2 代码，表示 Windows 组合画笔像素和目标像素的方式。在默认设备描述表中，绘图方式定义为 R2_COPYPEN，这意味着 Windows 只是将画笔像素复制到目标像素。

可以通过以下调用在设备描述表中设置新的绘图模式：

// iDrawMode 参数是预定义的绘图模式的值之一
SetROP2(hdc,iDrawMode);

可以用 GetROP2 函数来获取设备描述表中当前绘图方式：

iDrawMode = GetROP2(hdc);

梦五 2012-01-05 16:34 发表评论

画笔

梦五 — Wed, 04 Jan 2012 08:22:00 GMT

1. 当调用画线函数时，Windows 使用设备描述表中当前选中的“画笔”来画线。

2. 画笔决定线的色彩、宽度和线型，线型可以是实线、点划线或者虚线，默认设备描述表中画笔为 BLACK_PEN。不管映射方式什么，这种画笔都画出一个象素宽的黑色实线来。

3. Windows 提供的三种现有画笔：BLACK_PEN,WHITE_PEN 和 NULL_PEN.NULL_PEN 什么都不画。可以自己定制画笔。

4. Windows 程序使用句柄来引用画笔。画笔句柄的类型为 HPEN类型。

5. 调用 GetStockObject 函数可以获得现有画笔的句柄；调用 SelectObject 函数将画笔选进设备描述表，SelectObject 的返回值是此调用前设备描述表中的画笔句柄，即，SelectObject 将返回设备描述表中上一次选择的画笔句柄。

// 假设想使用名为 WHITE_PEN 的现有画笔，可以如下获取画笔的句柄

HPEN hPen;

hPen = GetStockObject(WHITE_PEN);

// 将画笔选进设备描述表
SelectObject(hdc,hPen);

当前的画笔是白色，在这个调用后，你画的线将使用 WHITE_PEN，直到i你将另外一个画笔选进设备描述表或者释放设备描述表句柄为止。

6. 创建自己的画笔，通常是：
使用函数 CreatePen 或 CreatePenIndirect 创建一个“逻辑画笔”（这仅仅是对画笔的描述），这些函数返回逻辑画笔的句柄；然后，调用 SelectObject 将画笔选进设备描述表，现在可以使用新的画笔来画线了。
在任何时候，都只能有一种画笔选进设备描述表。在释放设备描述表（或者选择了另一种画笔到设备描述表中）之后，就可以调用 DeleteObject 来删除所创建的逻辑画笔了。在删除后，该画笔的句柄就不再有效了。

7. 逻辑画笔是一种“GDI（图形设备接口）”对象；程序员可以创建六种的 GDI 对象：画笔、刷子、位图、区域、字体和调色板。
    除了调色板之外，这些对象都是通过 SelectObject 选进设备描述表的。

8. 使用 GDI 对象应该遵守的三条规则：
    最后要删除自己创建的所有 GDI 对象；
    当 GDI 对象正在一个有效的设备描述表中时，不要删除它；
    不要删除现有对象。

9. 如果有一个画笔的句柄，就可以通过调用 GetObject 获取 LOGPEN 结构各个成员的值：

GetObject(hPen,sizeof(LOGPEN),(LPVOID)&logpen);

10. 如果需要当前选进设备描述表的画笔句柄，可以调用：

hPen = GetCurrentObject(hdc,OBJ_PEN);

11. 使用点式画笔和虚线画笔时，点和虚线之间的空隙问题。
空隙的着色取决于设备描述表的两个属性——背景模式和背景颜色。
默认的背景模式为 OPAQUE，在这种方式下，Windows 使用背景色来填充空隙，默认的背景色为白色。
可以通过调用 SetBkColor(hdc,crColor); 来改变 Windows 用来填充空隙的背景色。
通过调用 GetBkColor 来获取设备描述表中定义的当前背景色。
通过将背景模式转换为 TRANSPARENT，可以阻止 Windows 填充空隙：SetBkMode(hdc,TRANSPARENT); 此后，Windows 将忽略背景色，并且不填充空隙，可以通过 GetBkMode 来获取当前背景模式（TRANSPARENT 或者 OPAQUE）。

梦五 2012-01-04 16:22 发表评论

设备描述表（二）

梦五 — Sat, 31 Dec 2011 07:01:00 GMT

Windows 使用设备描述表来保存控制 GDI 函数在显示器上如何操作的“属性”。例如，在使用 TextOut 函数显示文本时，程序员不必指定文本的色彩和字体，Windows 从设备描述表获取这个信息。

程序获取一个设备描述表句柄时，Windows 用默认值设置所有的属性。

1. Windows 98 支持的设备描述表属性，程序可以改变或者获取任何一种属性。

设备描述表属性	默认值	修改该值的函数	获取该值的函数
Mapping Mode	MM_TEXT	SetMapMode	GetMapMode
Window Orign	(0,0)	SetWindowOrgEx	GetWindowOrgEx
Window Orign	(0,0)	OffsetWindowOrgEx	GetWindowOrgEx
Viewport Orign	(0,0)	SetViewportOrgEx	GetViewportOrgEx
Viewport Orign	(0,0)	OffsetViewportOrgEx	GetViewportOrgEx
Window Extents	(1,1)	SetWindowExtEx	GetWindowExtEx
		SetMapMode
		ScaleWindowExtEx
Viewport Extents	(1,1)	SetViewportExtEx	GetViewportExtEx
		SetMapMode
		ScaleViewportExtEx
Pen	BLACK_PEN	SelectObject	SelectObject
Brush	WHITE_BRUSH	SelectObject	SelectObject
Font	SYSEMT_FONT	SelectObject	SelectObject
Bitmap	None	SelectObject	SelectObject
Current Position	(0,0)	MoveToEx	GetCurrentPositionEx
		LineTo
		PolylineTo
		PolyBezierTo
Background Mode	OPAQUE	SetBkMode	GetBkMode
Background Color	White	SetBkColor	GetBkColor
TextColor	Black	SetTextColor	GetTextColor
Drawing Mode	R2_COPYPEN	SetROP2	GetROP2
Stretching Mode	BLACKONWHITE	SetStretchBltMode	SetStretchBltMode
Polygon Fill Mode	ALTERNATE	SetPolyFillMode	GetPolyFillMode
Intercharacter	0	SetTextCharacterExtra	GetTextCharacterExtra
Spacing
Brush Origin	(0,0)	SetBrushOrgEx	GetBrushOrgEx
Clipping Region	None	SelectObject	GetClipBox
		SelectClipRgn
		IntersectClipRgn
		OffsetClipRgn
		ExcludeClipRect
		SelectClipPath

2. 保存设备描述表
通常，在您调用 GetDC 或 BeginPaint 时，Windows 用默认值创建一个新的设备描述表句柄，您对属性所做的一切改变在设备描述表用 ReleaseDC 或 EndPaint 调用释放时，都会丢失。
如果您的程序需要使用非默认的设备描述表属性，则您必须在每次获取设备描述表句柄时初始化设备描述表：

case WM_PAINT:
  hdc = BeginPaint(hwnd,&ps);
  [initialize device context attributes]
  [paint client area of window]
  EndPaint(hwnd,&ps);
  return 0;

虽然通常情况下这种方法已经很令人满意了，但是您还可能想要在释放设备描述表之后，仍然保存程序中对设备描述表属性所做的改变，以便在下一次调用 GetDC 和 BeginPaint 时，它们仍然能够起作用。
为此，可在登陆（注册）窗口类时，将 CS_OWNDC 标志包含为窗口类的一部分：

wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;

现在基于这个窗口类所创建的每个窗口都将拥有自己的设备描述表，它一直存在，直到窗口被删除。如果使用了 CS_OWNDC 风格，就只需初始化设备描述表一次，可以在处理 WM_CREATE 消息期间完成这一操作：

case WM_CREATE:
  hdc = GetDC(hwnd);
  [initialize device context attributes]
  ReleaseDC(hwnd,hdc);

这些属性在改变之前一直有效。
CS_OWNDC 风格只影响 GetDC 和 BeginPaint 获得的设备描述表，不影响其他函数（如 GetWindowDC）获得的设备描述表。
即使使用了 CS_OWNDC，您仍然应该在退出窗口过程之前释放设备描述表。

在某些情况下，您可能想改变某些设备描述表属性，用改变后的属性进行绘图，然后恢复原来的设备描述表。要简化这一过程可以像下面这样做：

// 保存设备描述表的状态
idSaved = SaveDC(hdc);

// now,可以改变一些属性，在想要回到调用 SaveDC 前存在的设备描述表时，调用：
RestoreDC(hdc,idSaved);

// 可以在调用 RestoreDC 之前调用 SaveDC 数次

RestoreDC 和 SaveDC 的另一种使用方式：

// 调用 SaveDC 时，不需要保存返回值：
SaveDC(hdc);

// 然后，您可以更改某些属性并再次调用 SaveDC,要将设备描述表恢复到一个已经保存的状态，调用：
RestoreDC(hdc,-1);

// 这就将设备描述表恢复到最近由 SaveDC 函数保存的状态中

梦五 2011-12-31 15:01 发表评论

锁的使用：一些有用的窍门和技巧

梦五 — Thu, 29 Dec 2011 16:50:00 GMT

1. 以原子方式操作一组对象时使用一个锁。

2. 同时访问多个逻辑资源。
必须在代码中的任何地方以完全相同的顺序来获得资源的锁。

3. 不要长时间占用锁。
如果一个锁被长时间占用，那么其他线程可能会进入等待状态，这会影响到应用程序的性能。
我们可以用下面这个技巧来把花在关键段中的时间降至最低。

// 下面的代码会在 WM_SOMEMSG 消息被发送到另一个窗口之前阻止其他线程修改 g_s 的值

SOMESTRUCT g_s;
CRITICAL_SECTION g_cs;

DWORD WINAPI SomeThread(PVOID pvParam)
{
  EnterCriticalSection(&g_cs);

  // Send a message to a window
  SendMessage(hWndSomeWnd,WM_SOMEMSG,&g_s,0);

  LeaveCriticalSection(&g_cs);
  return 0;
}

我们不可能知道窗口过程(Window procedure)需要多长时间来处理 WM_SOMEMSG 消息，可能只需要几微妙，也可能需要几年。在这段时间内，其他线程都无法得到 g_s 的访问权。把前述代码写成下面这种形式会更好。

SOMESTRUCT g_s;
CRITICAL_SECTION g_cs;

DWORD WINAPI SomeThread(PVOID pvParam)
{
  EnterCriticalSection(&g_cs);

  SOMESTRUCT sTemp = g_s;

  LeaveCriticalSection(&g_cs);

  // Send a message to a window
  SendMessage(hWndSomeWnd,WM_SOMEMSG,&sTemp,0);

  return 0;
}

这个技巧假设窗口过程只需读取结构的“快照”就已经足够了，它同时还假设窗口过程不需要修改结构中的成员。

梦五 2011-12-30 00:50 发表评论

用户模式下的线程同步（三）—— 高级线程同步

梦五 — Wed, 28 Dec 2011 07:49:00 GMT

2. 旋转锁

// 旋转锁伪代码

// Global variable indicating whether a shared resource is in use or not
BOOL g_fResourceInUse = FALSE;

void Func1(){
  // Wait to access the resource.
  while( InterlockedExchange(&g_fResourceInUse,TRUE) == TRUE )
  {
    sleep(0);
  }

  // Access the resource


  // We no longer need to access the resource.
  InterlockedExchange(&g_fResourceInUse,FALSE);
}

while 循环不停地运行，把 g_fResourceInUse 的值设为 TRUE 并检查原来的值是否为 TRUE。如果原来的值为 FALSE，那说明资源尚未被使用，于是调用线程立刻就能将它设为“使用中”，然后退出循环。如果原来的值是 TRUE，那说明有其他的线程正在使用该资源，于是 while 循环会继续执行。

对那些用到旋转锁的线程来说，我们可能想要（调用 SetProcessPriorityBoost 或 SetThreadPriorityBoost 来）禁用线程优先级提升（thread priority boosting）。
在单 CPU 的机器上应该避免使用旋转锁。如果一个线程不停地循环，那么这不仅会浪费宝贵的 CPU 时间，而且会阻止其他线程改变锁的值。
旋转锁假定被保护的资源始终只会被占用一小段时间。与切换到内核模式然后等待相比，在这种情况下以循环的方式进行等待的效率会更高。

当线程试图进入一个关键段，但这个关键段正被另一个线程占用的时候，函数会立即把调用线程切换到等待状态。这意味着线程必须从用户模式切换到内核模式（大约1000个ＣＰＵ周期），这个切换的开销非常大。

3. 关键段和旋转锁
为了提高关键段的性能，Microsoft 把旋转锁合并到了关键段中。因此，当调用 EnterCriticalSection 的时候，它会用一个旋转锁不断地循环，尝试在一段时间内获得对资源的访问权。只有当尝试失败的时候，线程才会切换到内核模式并进入等待状态。

为了在使用关键段的时候同时使用旋转锁，我们必须调用下面的函数来初始化关键段：

BOOL InitializeCriticalSectionAndSpinCount(PCRITICAL_SECTION pcs,DWORD dwSpinCount);
// pcs,关键段结构的地址
// dwSpinCount,旋转锁循环的次数

在把线程切换到等待状态之前，函数会先尝试用旋转锁来获得对资源的访问权。这个值可以是从0到0x00FFFFFF之间的任何一个值。
如果我们在单处理器的机器上调用这个函数，那么函数会忽略 dwSpinCount 参数，因此次数总是为0。

我们可以调用下面的函数来改变关键段的旋转次数：

DWORD SetCriticalSectionSpinCount(PCRITICAL_SECTION pcs,DWORD dwSpinCount);
// 如果主机只有一个单处理器，函数会忽略 dwSpinCount　参数

我们应该总是在使用关键段的时候同时使用旋转锁，因为这样做不会损失任何东西。
用来保护进程堆的关键段所使用的旋转次数大约是4000。

4. Slim 读/写锁
SRWLock 的目的和关键段相同：对一个资源进行保护，不让其他线程访问它。但是，与关键段不同的是，SRWLock 允许我们区分那些想要读取资源的线程（读取者线程）和想要更新资源的值的线程（写入者线程）。

提供的功能：
让所有的读取者线程在同一时刻访问共享资源应该是可行的，这是因为仅仅读取资源的值并不存在破坏数据的风险。
只有当写入者线程想要对资源进行更新的时候才需要进行同步。在这种情况下，写入者线程应该独占对资源的访问权：任何其他线程，无论是读取者线程还是写入者线程，都不允许访问资源。

使用 SRWLock：
首先，分配一个 SRWLOCK 结构并用 InitializeSRWLock 函数对它进行初始化：

VOID InitializeSRWLock(PSRWLOCK SRWLock);

一旦 SRWLock 的初始化完成之后，写入者线程就可以调用 AcquireSRWLockExclusive,将 SRWLock 对象的地址作为参数传入，以尝试获得对被保护的资源的独占访问权。

VOID AequireSRWLockExclusive(PSRWLOCK SRWLock);

完成对资源的更新之后，应该调用 ReleaseSRWLockExclusive，并将　SRWLOCK 对象的地址作为参数传入，这样就解除了对资源的锁定。

VOID ReleaseSRWLockExclusive(PSRWLOCK SRWLock);

对于读取者线程来说同样有两个类似的步骤：

VOID AcquireSRWLockShared(PSRWLOCK SRWLock);

VOID ReleaseSRWLockShared(PSRWLOCK SRWLock);

如果锁已经被占用，那么调用 AcquireSRWLock(Shared/Exclusive) 会阻塞调用线程。
不能递归地获得 SRWLOCK。即，一个线程不能为了多次写入资源而多次锁定资源，然后再多次调用 ReleaseSRWLock* 来释放对资源的锁定。
不存在用来删除或销毁 SRWLOCK 的函数，系统会自动执行清理工作。

5. 条件变量
有时我们想让线程以原子方式把锁释放并将自己阻塞，直到某一个条件成立为止。要实现这样的线程同步是比较复杂的。
Windows 通过 SleepConditionVariableCS 或 SleepConditionVariableSRW 函数，通过了一种条件变量，来帮助我们简化这种情形下所需的工作。

BOOL SleepConditionVariableCS(PCONDITION_VARIABLE pConditionVariable,PCRITICAL_SECTION pCriticalSection,DWORD dwMilliseconds);

BOOL SleepConditionVariableSRW(PCONDITION_VARIABLE pConditionVariable,PSRWLOCK pSRWLock,DWORD dwMilliseconds,ULONG Flags);

参数 pConditionVariable 指向一个已初始化的条件变量，调用线程正在等待该条件变量。

第二个参数是一个指向关键段或者 SRWLock 的指针，该关键段或 SRWLock 用来同步对共享资源的访问。

参数 dwMilliseconds 表示我们希望线程花多少时间（可以设成INFINITE）来等待条件变量被触发。

第二个函数中的 Flags 参数用来指定一旦条件变量被触发，我们希望线程以何种方式来得到锁：对写入者线程来说，应该传入0，表示希望独占对资源的访问；对读取者线程来说，应该传入 CONDITION_VARIABLE_LOCKMODE_SHARED，表示希望共享对资源的访问。

当指定的时间用完的时候，如果条件变量尚未被触发，函数会返回 FALSE，否则函数会返回 TRUE。注意，当函数返回FALSE的时候，线程显然并没有得到锁或关键段。

当另一个线程检测到相应的条件已经满足的时候，比如存在一个元素可以让读取者线程读取，或者有足够的空间让写入者线程插入新的元素，它会调用 WakeConditionVariable 或 WakeAllConditionVariable，这样阻塞在 Sleep* 函数中的线程就会被唤醒。

VOID WakeConditionVariable(PCONDITION_VARIABLE ConditionVariable);

当我们调用 WakeConditionVariable 的时候，会使一个在　SleepConditionVariable* 函数中等待同一个条件变量被触发的线程得到锁并返回。当这个线程释放同一个锁的时候，不会唤醒其他正在等待同一个条件变量的线程。

VOID WakeAllConditionVariable(PCONDITION_VARIABLE ConditionVariable);
当调用 WakeAllConditionVariable 的时候，会使一个或几个在 SleepConditionVariable* 函数中等待这个条件变量被触发的线程得到对资源的访问权并返回。
唤醒多个线程是可以的，因为我们确信如果我们请求独占对资源的访问，那么同一时刻必定只有一个写入者线程得到锁，如果我们传给 Flag 参数的是 CONDITION_VARIABLE_LOCKMODE_SHARED，那么在同一时刻可以允许多个读取者线程得到锁。

总结：
如果希望应用程序中得到最佳性能，那么首先应该尝试不要共享数据，然后依次使用 volatile 读取，volatile 写入，Interlocked API，SRWLock 以及关键段。当且仅当所有这些都不能满足要求的时候，再使用内核对象。

梦五 2011-12-28 15:49 发表评论

用户模式下的线程同步（二）—— 高级线程同步

梦五 — Mon, 26 Dec 2011 16:30:00 GMT

概述：浪费CPU时间是件非常糟糕的事情，所以在实现用户模式下的线程同步时，我们需要一种机制，它既能让线程等待共享资源的访问权，又不会浪费CPU时间。

实现原理：
当线程想要访问一个共享资源或者想要得到一些“特殊事件”的通知时，线程必须调用操作系统的一个函数，并将线程正在等待的东西作为参数传入。如果操作系统检测到资源已经可供使用了，或者特殊事件已经发生了，那么这个函数会立即返回，这样线程将仍然保持可调度状态。（线程可能并不会立即运行，它是可调度的，系统会根据一定的规则来给它分配CPU时间。）

如果无法取得对资源的访问权，或者特殊事件尚未发生，那么系统会将线程切换到等待状态，使线程变得不可调度，从而避免了让线程浪费CPU时间。当线程在等待的时候，系统会充当它的代理。系统会记住线程想要访问什么资源，当资源可供使用的时候，它会自动将线程唤醒——线程的执行与特殊事件是同步的。

1. 关键段
关键段（critical section）是一小段代码，它在执行之前需要独占对一些共享资源的访问权。这种方式可以让多行代码以“原子方式”来对资源进行操控。
这里的原子方式，指的是代码知道除了当前线程之外，没有其他任何线程会同时访问该资源。
当然，系统仍然可以暂停当前线程去调度其他线程。但是，在当前线程离开关键段之前，系统是不会去调度任何想要访问同一资源的其他线程的。

定义关键段类型的变量：

// 定义一个 CRITICAL_SECTION 类型的变量
CRITICAL_SECTION cs;

当我们有一个资源要让多个线程访问的时候，应该创建一个 CRITICAL_SECTION 结构。
一个比喻：一个 CRITICAL_SECTION 结构就像是飞机上的一个卫生间，而马桶则是我们想要保护的数据。由于卫生间很小，因此在同一时刻只允许一个人（线程）在卫生间（关键段）内使用马桶（被保护的资源）。

关键段的最大缺点在于它们无法用来在多个进程之间对线程进行同步。

关键段细节：
使用 CRITICAL_SECTION 结构的两个必要条件：
第一个条件是所有想要访问共享资源的线程必须知道用来保护资源的 CRITICAL_SECTION 结构的地址。
第二个条件是在任何线程试图访问被保护的资源之前，必须对 CRITICAL_SECTION 结构的内部成员进行初始化。

下面的函数用来对结构进行初始化：

VOID InitializeCriticalSection(PCRITICAL_SECTION pcs);

在调用 EnterCriticalSection 之前必须调用这个函数。

当知道线程将不再需要访问共享资源的时候，我们应该调用下面的函数来清理 CRITICAL_SECTION结构：

VOID DeleteCriticalSection(PCRITICAL_SECTION pcs);

在对共享资源进行访问之前，必须在代码中先调用下面的函数：

VOID EnterCriticalSection(PCRITICAL_SECTION pcs);

EnterCriticalSection 会检查（CRITICAL_SECTION）结构中的成员变量，这些变量表示是否有线程正在访问资源，以及那个线程正在访问资源。
EnterCriticalSection 会执行下面的测试：
如果没有线程正在访问资源，那么 EnterCriticalSection 会更新成员变量，以表示调用线程已经获准对资源的访问，并立即返回，这样线程就可以继续执行（访问资源）。

如果成员变量表示调用线程已经获准访问资源，那么 EnterCriticalSection 会更新变量，以表示调用线程被获准访问的次数，并立即返回，这样线程就可以继续执行。这种情况非常少见，只有当线程在调用 LeaveCriticalSection 之前连续调用 EnterCriticalSection 两次以上才会发生。

如果成员变量表示有一个（调用线程之外的其他）线程已经获准访问资源，那么 EnterCriticalSection 会使用一个事件内核对象来把调用线程切换到等待状态。系统会记住这个线程想要访问这个资源，一旦当前正在访问资源的线程调用了 LeaveCriticalSection，系统会自动更新 CRITICAL_SECTION 的成员变量并将等待中的线程切换到可调度状态。

EnterCriticalSection 的内部并不怎么复杂，它只不过是执行了一些简单的测试。这个函数的价值在于它能够以原子方式执行所有这些测试。

TryEnterCriticalSection 函数：
TryEnterCriticalSection 从来不会让调用线程进入等待状态。它会通过返回值来表示调用线程是否获准访问资源。因此，如果 TryEnterCriticalSection 发现资源正在被其他线程访问，那么它会返回 FALSE。其他情况下，它会返回 TRUE。

通过使用这个函数，线程可以快速地检查它是否能够访问某个共享资源。如果不能访问共享资源，那么它可以继续做些其他的事情，而不用等待。如果 TryEnterCriticalSection 返回 TRUE，那么 CRITICAL_SECTION 的成员变量已经更新过了，以表示该线程正在访问资源。因此，每个返回值为 TRUE 的 TryEnterCriticalSection 调用必须有一个对应的 LeaveCriticalSection。

可以使用 TryEnterCriticalSection 函数来代替 EnterCriticalSection。

在代码完成对共享资源的访问后，应该调用下面的函数：

VOID LeaveCriticalSection(PCRITICAL_SECTION pcs);

LeaveCriticalSection 会检查结构内部的成员变量并将计数器减1，该计数器用来表示调用线程获准访问共享资源的次数。如果计数器大于0，LeaveCriticalSection 会直接返回，不执行任何其他操作。
如果计数器变成了0，LeaveCriticalSection 会更新成员变量，以表示没有任何线程正在访问被保护的资源。它同时会检查有没有其他线程由于调用了 EnterCriticalSection 而处于等待状态。如果至少有一个线程处于等待状态，那么函数会更新成员变量，把其中一个处于等待状态的线程切换回可调度状态。
与 EnterCriticalSection 相似，LeaveCriticalSection 会以原子方式执行所有的测试和更新操作。但是，LeaveCriticalSection 从来不会把线程切换到等待状态，它总是立即返回。

梦五 2011-12-27 00:30 发表评论

volatile 关键字

梦五 — Mon, 26 Dec 2011 14:58:00 GMT

volatile 类型限定符告诉编译器被它修饰的变量可能会被应用程序之外的其他东西修改，比如操作系统、硬件或者一个并发执行的线程。
确切地说，volatile 限定符告诉编译器不要对这个变量（被 volatile 修饰的变量）进行任何形式的优化，而是始终从变量在内存中的位置读取变量的值。

如果不给变量加上 volatile 限定符，编译器可能会对 C++ 代码进行优化。在这个优化中，编译器把变量的值载入到 CPU 寄存器中，这个操作只需要进行一次。然后它只对 CPU 寄存器中的值进行引用，与每次都从变量所在的内存地址取得变量的值并进行使用相比，优化操作能够得到更好的性能。

给一个结构加 volatile 限定符等于给结构中所有的成员都加 volatile 限定符，这样可以确保任何一个成员始终都是从内存中读取的。

如果传一个变量的地址给函数，那么函数必须从内存中读取它的值，编译器的优化程序不会对此产生影响。

备注：
volatile: 易变的（英文注释）。

梦五 2011-12-26 22:58 发表评论

图形设备接口

梦五 — Tue, 20 Dec 2011 03:34:00 GMT

图形设备接口（GDI:Graphics Device Interface）是 Windows 的子系统，负责在视频显示器和打印机上显示图形。

GDI 的主要目的之一是支持与设备无关的图形。

图形输出设备分为两大类：光栅设备和矢量设备。
光栅设备以点模式来表示图像，这类设备包括视频显示适配器，点阵打印机和激光打印机。
矢量设备使用线来绘制图像，通常局限于绘图仪。

梦五 2011-12-20 11:34 发表评论

“进队消息” 与 “不进队消息”

梦五 — Tue, 20 Dec 2011 03:14:00 GMT

Windows 给窗口发送消息，意味着 Windows 调用窗口过程。但是，Windows程序也有一个消息循环，它调用 GetMessage 从消息队列中取出消息，并且调用 DiapatchMessage 将消息发送给窗口过程。

消息能够被分为“进队的” 和 “不进队的”。
进队的消息是由 Windows 放入程序消息队列中。在程序的消息循环中，重新返回并分配给窗口过程。
不进队的消息在 Windows 调用窗口时直接送给窗口过程。
即，进队的消息被“发送”给消息队列，而不进队的消息则“发送”给窗口过程。

在任何情况下，窗口过程都将获得窗口所有的消息——包括进队的和不进队的。窗口过程是窗口的“消息中心”。

进队消息基本上是用户输入的结果，以击键（如 WM_KEYDOWN 和 WM_KEYUP 消息）、击键产生的字符（WM_CHAR）、鼠标移动（WM_MOUSEMOVE）和鼠标键（WM_LBUTTONDOWN）的形式给出。进队消息还包括时钟消息（WM_TIMER）、刷新消息（WM_PAINT）和退出消息（WM_QUIT）。

不进队消息则是其他消息。在许多情况下，不进队消息来自调用特定的 Windows 函数。例如，当 WinMain 调用 CreateWindow 时，Windows 将给窗口过程发送一个 WM_CREATE 消息。当 WinMain 调用 ShowWindow 时，Windows 将给窗口过程发送 WM_SIZE 和 WM_SHOWWINDOW 消息。当 WinMain 调用 UpdateWindow 时，Windows 将给窗口过程发送 WM_PAINT 消息。
键盘或鼠标输入时发出的进队消息信息，也能在不进队消息中出现。

梦五 2011-12-20 11:14 发表评论

Scroll Bar（滚动条）

梦五 — Sat, 17 Dec 2011 13:39:00 GMT

Windows（操作系统）对滚动条的处理：
处理所有滚动条鼠标事件；
当用户在滚动条内单击鼠标时，提供一种“反相视频”闪烁；
当用户在滚动条内拖动滚动框时，移动滚动框；
为包含滚动条窗口的窗口过程发送滚动条消息。

程序员对于滚动条应该完成的工作：
初始化滚动条的范围和位置；
处理窗口过程的滚动条消息；
更新滚动条内滚动框的位置；
更改客户区的内容以响应对滚动条的更改。

滚动条消息（WM_VSCROLL 和 WM_HSCROLL）：
在用鼠标单击滚动条或者拖动滚动框时，Windows 给窗口过程发送 WM_VSCROLL（供上下移动）和 WM_HSCROLL（供左右移动）消息。
在滚动条上的每个鼠标动作都至少产生两个消息，一个在按下鼠标键时产生，一个在释放键时产生。

wParam 和 lParam 消息参数：
与所有的消息一样，WM_VSCROLL 和 WM_HSCROLL 也带有 wParam 和 lParam 消息参数。对于来自作为窗口的一部分而创建的滚动条消息，可以忽略 lParam；它只用于作为子窗口而创建的滚动条（通常在对话框内）。

wParam 消息参数：
wParam 消息参数被分为一个低位字和一个高位字。低位字是一个数值，它指出了鼠标对滚动条进行的操作。这个数值被看作一个“通知码”。
通知码的值由以SB（代表"scroll bar"（滚动条））开头的标识符定义。

通知码：
SB_LINEUP              // 按下垂直滚动条的顶部按钮
SB_LINEDOWN         // 按下垂直滚动条的底部按钮
SB_LINELEFT            // 按下水平滚动条的左部按钮
SB_LINERIGHT          // 按下水平滚动条的右部按钮
SB_ENDSCROLL        // 释放滚动条上的鼠标光标
SB_PAGEUP              // 按下垂直滚动条上滚动框与顶部按钮之间的空白位置
SB_PAGEDOWN        // 按下垂直滚动条上滚动框与底部按钮之间的空白位置
SB_PAGELEFT           // 按下水平滚动条上滚动框与左部按钮之间的空白位置
SB_PAGERIGHT         // 按下水平滚动条上滚动框与右部按钮之间的空白位置
SB_THUMBTRACK      // 按下滚动条上的滚动框
SB_THUMBPOSITION // 释放滚动框上的鼠标按钮

其他通知码（对于作为应用程序窗口一部分而创建的滚动条来说，以下这些通知码永远不会接收到）：
SB_TOP             // 滚动框被移到了最顶部
SB_BOTTOM      // 滚动框被移到了最底部
SB_LEFT          // 滚动框被移到了最左部
SB_RIGHT         // 滚动框被移动了最右部

SB_THUMBTRACK 和 SB_THUMBPOSITION：
当 wParam 的低位字是 SB_THUMBTRACK 时，wParam的高位字是用户在拖动滚动框时的当前位置。该位置位于滚动条范围的最小值和最大值之间。
当 wParam 的低位字是 SB_THUMBPOSITION 时，wParam的高位字是用户释放鼠标键后滚动框的最终位置。
对于其他的滚动条操作，wParam 的高位字应该被忽略。

梦五 2011-12-17 21:39 发表评论

设备描述表（一）

梦五 — Fri, 16 Dec 2011 03:25:00 GMT

设备描述表（简称为“DC”）实际上是 GDI（图形设备接口）内部保存的数据结构。设备描述表与特定的显示设备（如视频显示器或打印机）相关。

在窗口的客户区域显示文本和图形需要设备描述表句柄。
当您想在一个图像输出设备（诸如屏幕或者打印机）上绘图时，您首先必须获得一个设备描述表（或者DC）的句柄。将句柄返回给程序时，Windows 就给了您使用设备的权限。然后您在 GDI 中将这个句柄作为一个参数，向 Windows 标识您想在其上进行绘图的设备。

设备描述表中的有些值是图形化的“属性”，这些属性定义了一些GDI绘图函数工作情况的特殊内容。例如，对于 TextOut(hdc,x,y,psText,iLength),设备描述表的属性确定了文本的颜色、文本的背景色、TextOut函数的 x 坐标和 y 坐标映射到窗口的客户区的方式，以及显示文本时 Windows 使用的字体。

当程序需要绘图时，它必须先获取设备描述表句柄。在获取了该句柄后，Windows 用默认的属性值填充内部设备描述表结构。
可以通过调用不同的 GDI 函数改变这些默认值。
利用其它的 GDI 函数可以获取这些属性的当前值。
还有其它的 GDI 函数能够在窗口的客户区真正地绘图。

当程序在客户区绘图完毕后，它必须释放设备描述表句柄。句柄被释放后就不再有效，且不能再被使用。

程序必须在处理单个消息期间获取和释放句柄。

除了调用 CreateDC 函数创建的设备描述表之外，程序不能在两个消息之间保存其它设备描述表句柄。

Windows 应用程序一般使用两种方法来获取窗口客户区中的设备描述表句柄，以备在屏幕上绘图。
方法一：
在处理 WM_PAINT 消息时，使用这种方法。它涉及 BeginPaint 和 EndPaint两个函数。

hdc = BeginPaint(hwnd,&ps);
[other program lines]
EndPaint(hwnd,&ps);

BeginPaint 函数包含一个类型为 PAINTSTRUCT 结构的变量ps,该结构的hdc字段是 BeginPaint 返回的设备描述表句柄。PAINTSTRUCT 结构又包含一个名为 rcPaint 的 RECT （矩形）结构，rcPaint 定义一个包围窗口客户区无效范围的矩形。使用从 BeginPaint 获得的设备描述表句柄，只能在这个区域内绘图。BeginPaint 调用使该区域有效。

方法二：
调用 GetDC 来获取句柄，ReleaseDC 来释放句柄。

hdc = GetDC(hwnd);
[other program lines]
ReleaseDC(hwnd,hdc);

这个设备描述表句柄适用于窗口句柄为 hwnd 的客户区。
GetDC 和 ReleaseDC 不使客户区中任何可能的无效区域变成有效。

Windows 程序还可以获取适用于整个窗口（而不仅限于窗口的客户区）的设备描述表句柄：

hdc = GetWindowDC(hwnd);
[other program lines]
ReleaseDC(hwnd,hdc);

这个设备描述表除了客户区之外，还包括窗口的标题栏、菜单、滚动条和框架（frame）。GetWindowDC 函数很少使用，如果想尝试用一用它，则必须捕获 WM_NCPAINT（“非客户区绘制”）消息，Windows 使用该消息在窗口的非客户区上绘图。

获取设备描述表句柄更通用的函数调用。
BeginPaint、GetDC 和 GetWindowDC 获得的设备描述表都与视频显示器上的某个特定窗口相关。获取设备描述表句柄的另一个更通用的函数是 CreateDC:

hdc = CreateDC(pszDirver,pszDevice,pszOutput,pData);
[other program lines]
DeleteDC(hdc);

例如，可以通过下面的调用来获取整个屏幕的设备描述表句柄：
hdc = CreateDC(TEXT("DISPLAY"),NULL,NULL,NULL);

获取一个“信息描述表”的句柄：
有时候只是需要获取关于某设备描述表的一些信息而并不进行任何绘画，在这种情况下，可以使用 CreateIC 来获取一个“信息描述表”的句柄，其参数与 CreateDC 函数相同：
hdc = CreateIC(TEXT("DISPLAY"),NULL,NULL,NULL);
不能用这个信息环境句柄往设备上写东西。

当使用位图时，获取一个“内存设备描述表”有时是有用的：

hdcMem = CreateCompatibleDC(hdc);
[other program lines]
DeleteDC(hdcMem);
可以将位图选进内存设备描述表，然后使用GDI函数在位图上绘画。

元文件是以二进制形式存储的 GDI 命令的集合。元文件主要用于通过剪切板传输矢量图形表示。
可以通过获取元文件设备描述表来创建元文件：

hdcMeta = CreateMetaFile(pszFilename);
[other program lines]
hmf = CloseMetaFile(hdcMeta);

在元文件设备描述表有效期间，任何用 hdcMeta 所做的 GDI 调用都变成元文件的一部分而不会显示。在调用 CloseMetaFile 之后，设备描述表句柄变为无效，函数返回一个指向元文件(hmf)的句柄。

窗口的设备描述表定义了一个剪取区域。
对于从 GetDC 获取的设备描述表句柄，默认的剪取区域是整个窗口客户区；而对于从 BeginPaint 获取的设备描述表句柄，默认的剪取区域则为窗口客户区中的无效区域。
Windows 不会在剪取区域之外的任何位置显示字符串。

获取设备描述表信息：
一个设备描述表通常是指一个物理显示设备，如视频显示器和打印机。通常需要获取有关该设备的信息，其中包括显示器的显示尺寸（单位为像素或者物理度量）和色彩范围。
可以通过调用 GetDeviceCaps（“获取设备能力”）函数来获取这些信息：

iValue = GetDeviceCaps(hdc,iIndex);

梦五 2011-12-16 11:25 发表评论

WM_PAINT 消息

梦五 — Fri, 16 Dec 2011 02:54:00 GMT

第一个 WM_PAINT 消息：
大多数 Windows 程序在 WinMain 中进入消息循环之前的初始化期间都要调用函数 UpdateWindow。Windows（操作系统）利用这个机会给窗口过程发送第一个WM_PAINT消息。这个消息通知窗口过程：必须绘制客户区。

在发生下面几种事件之一时，窗口过程会接收到一个WM_PAINT消息：
在用户移动窗口或显示窗口时，窗口中先前被隐藏的区域重新可见；
用户改变窗口的大小（如果窗口类风格具有　CS_HREDRAW 和　CS_VERDRAW 位设置）；
程序使用 ScrollWindow 或 ScrollDC 函数滚动客户区的一部分；
程序使用 InvalidateRect 或 InvalidateRgn 函数显示产生　WM_PAINT 消息。

在某些情况下，客户区的一部分被临时覆盖，Windows 试图保存一个显示区域，并在以后恢复它，但这并不总是能成功的。下面的情况下，Windows 可能会发送 WM_PAINT 消息：
Windows 擦除覆盖了部分窗口的对话框或消息框；
菜单下拉出来，然后被释放；
显示工具提示。

在某些情况下，Windows 总是保存它所覆盖的显示区域，然后恢复它。这些情况是：
鼠标光标穿越客户区；
图标拖过客户区。

梦五 2011-12-16 10:54 发表评论

消息循环

梦五 — Thu, 15 Dec 2011 08:06:00 GMT

1. Windows（操作系统）为当前运行的每个Windows程序维护一个“消息队列”。在发生输入事件（用户用鼠标和键盘向窗口输入数据）之后，Windows（操作系统）将事件转换为一个“消息”，并将消息放入程序的消息队列中。

2. 程序通过执行一块被称为“消息循环”的代码从消息队列中取出消息：

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

msg变量是类型为MSG的结构，类型MSG在WINUSER.H中定义如下：

typedef struct tagMSG
{
  HWND     hwnd;
  UINT     message;
  WPARAM   wParam;
  LPARAM   lParam;
  DWORD    time;
  POINT    pt;
}MSG,*PMSG;

POINT数据类型也是一个结构，在WINDEF.H中定义如下：

typedef struct tagPOINT
{
LONG x;
LONG y;
}POINT,*PPOINT;

3. 消息循环以GetMessage调用开始，它从消息队列中取出一个消息：GetMessage(&msg,NULL,0,0);
这一调用传给Windows（操作系统）一个指向名为msg的MSG结构的指针。第二、第三和第四个参数设置为NULL或者0，表示程序接收它自己创建的所有窗口的所有消息。
Windows 用从消息队列中取出的下一个消息来填充消息结构的各个域，结构的各个域包括：

hwnd    消息发向的窗口的句柄。
message    消息标识符。这是一个数值，用以标识消息。
wParam    一个32位的"message parameter（消息参数）"，其含义和数值根据消息的不同而不同。
lParam    一个32位的消息参数，其值与消息有关。
time    消息放入消息队列中的时间。
pt    消息放入消息队列时的鼠标坐标。

只要从消息队列中取出消息的message域不为WM_QUIT（其值为0x0012）,GetMessage就返回一个非零值。WM_QUIT消息将导致GetMessage返回0。

4. 语句TranslateMessage(&msg);将msg结构传给Windows（操作系统），进行一些键盘转换。

5. 语句DispatchMessage(&msg);又将msg结构回传给Windows。然后，Windows 将该消息发送给适当的窗口过程，让它进行处理。这也就是说，Windows将调用窗口过程。
处理完消息后，窗口过程返回到Windows（操作系统）。此时Windows还停留在DispatchMessage调用中。在结束DispatchMessage调用的处理后，Windows回到程序，并且接着从下一个GetMessage调用开始消息循环。

梦五 2011-12-15 16:06 发表评论

Windows 窗口

梦五 — Thu, 15 Dec 2011 07:32:00 GMT

在Windows中，“窗口”一词有确切的含义。一个窗口就是屏幕上的一个矩形区域，它接受用户的输入，并以文本或图形的格式显示输出内容。

窗口以“消息”的形式接收窗口的输入，窗口也用消息与其他窗口通讯。

当用户改变窗口的大小时，Windows(操作系统)给程序发送一条消息指出新窗口的大小。然后程序就可以调整窗口中的内容，以反映大小的变化。

所谓“Windows给程序发送消息”，是指Windows调用程序中的一个函数，该函数的参数描述了这个特定消息。这种位于Windows程序中的函数被称为“窗口过程”。

程序创建的每一个窗口都有相关的窗口过程。这个窗口过程是一个函数，既可以在程序中，也可以在动态连接库中。Windows通过调用窗口过程来给窗口发送消息。窗口过程根据此消息进行处理，然后将控制返回给Windows。

窗口通常是在“窗口类”的基础上创建的。窗口类标识了处理窗口消息的窗口过程。
可以在单个窗口类的基础上创建多个窗口。
窗口类定义了窗口过程和基于此类创建的窗口的其他一些特征。在创建窗口时，要定义一些窗口所独有的特征。

Windows程序开始执行后，Windows（操作系统）为该程序创建一个“消息队列”。这个消息队列用来存放该程序可能创建的各种不同窗口的消息。程序中有一小段代码，叫做“消息循环”，用来从消息队列中取出消息，并且将它们发送给相应的窗口过程。有些消息直接发送给窗口过程，不用放入消息队列中。

Windows 中的每个窗口都有一个句柄，程序用句柄来引用窗口。

关键字：窗口，窗口类，窗口过程，消息队列，消息循环和窗口消息。

梦五 2011-12-15 15:32 发表评论

Windows句柄

梦五 — Thu, 15 Dec 2011 02:45:00 GMT

句柄是一个数（通常为32位），它代表一个对象。
程序几乎总是通过调用Windows函数获取句柄。程序在其他Windows函数中使用这个句柄，以引用它代表的对象。
句柄的实际值对程序来说是无关紧要的。但是，向您的程序提供句柄的Windows模块知道如何使用它来引用相应的对象。

标识符含义

HINSTANCE                                          实例（程序自身）句柄
HWND                                                 窗口句柄
HDC                                                    设备描述表句柄
HICON                                                 图标句柄
HCURSOR                                            鼠标指针句柄
HBRUSH                                              图形刷句柄

梦五 2011-12-15 10:45 发表评论

Windows标识符前缀

梦五 — Thu, 15 Dec 2011 02:31:00 GMT

前缀类别

CS                                       类风格选项
CW                                      创建窗口选项
DT                                       绘制文本选项
IDI                                       图标ID号
IDC                                      光标ID号
MB                                       消息框选项
SND                                     声音选项
WM                                      窗口消息
WS                                      窗口风格

梦五 2011-12-15 10:31 发表评论

Windows函数简明描述

梦五 — Thu, 15 Dec 2011 02:20:00 GMT

LoadIcon 加载图标供程序使用
LoadCursor 加载鼠标指针供程序使用
GetStockObject 获取一个图象对象，如获取绘制窗口背景的刷子
RegisterClass 为程序窗口注册窗口类
MessageBox 显示消息框
CreateWindow 根据窗口类创建一个窗口
ShowWindow 在屏幕上显示窗口
UpdateWindow 指示窗口刷新自身
GetMessage 从消息队列中获取消息
TranslateMessage 转换某些键盘消息
DispatchMessage 将消息发送给窗口过程
PlaySound 播放一个声音文件
BeginPaint 开始窗口绘制
GetClientRect 获取窗口客户区的尺寸
DrawText 显示文本串
EndPaint 结束窗口绘制
PostQuitMessage 在消息队列中插入一条“退出”消息
DefWindowProc 执行默认的消息处理

梦五 2011-12-15 10:20 发表评论

WINDOWS头文件

梦五 — Tue, 13 Dec 2011 03:27:00 GMT

WINDEF.H 基本类型定义；
WINNT.H 支持Unicode的类型定义；
WINBASE.H 内核函数；
WINUSER.H 用户接口函数；
WINGDI.H 图形设备接口函数。

梦五 2011-12-13 11:27 发表评论

术语

梦五 — Tue, 13 Dec 2011 03:22:00 GMT

API：应用程序编程接口
EMS：扩充内存
DLL：动态链接库
GDI：图形设备接口
GUI：图形用户界面
MFC：Microsoft基础类库

梦五 2011-12-13 11:22 发表评论

用户模式下的线程同步（一）——Interlocked系列函数

梦五 — Mon, 12 Dec 2011 02:10:00 GMT

1. 原子访问：Interlocked系列函数——Interlocked系列函数会以原子方式来操控一个值。

// 传一个长整形变量的地址和另一个增量值，函数就会保证递增操作是以原子方式进行的。
LONG InterlockedExchangeAdd(PLONG volatile plAddend,LONG lIncrement);

LONGLONG InterlockedExchangeAdd64(PLONGLONG volatile pllAddend,LONGLONG llIncrement);

//InterlockedIncrement函数以原子方式给一个值加1。
LONG InterlockedIncrement(IN PLONG Addend);

//InterlockedExchange和InterlockedExchangePointer会把第一个参数所指向的内存地址的当前值，以原子方式替换为第二个参数指定的值。
LONG InterlockedExchange(OUT PLONG Target,IN LONG Value);

LONGLONG InterlockedExchange64(PLONGLONG volatile plTarget,LONGLONG lValue);

PVOID InterlockedExchangePointer(PVOID* volatile ppvTarget,PVOID pvValue);
//这两个函数都会返回原来的值。

// InterlockedCompareExchange和InterlockedCompareExchangePointer函数以原子方式执行一个测试和设置操作。
PVOID InterlockedCompareExchange(PLONG plDestination,LONG lExchange,LONG lComparand);

PVOID InterlockedCompareExchangePointer(PVOID* ppvDestination,PVOID pvExchange,PVOID pvComparand);

注意：我们必须确保传给这些函数的变量地址是经过对齐的，否则这些函数可能会失败。
C运行库提供了一个_aligned_malloc函数，我们可以使用这个函数来分配一块对齐过的内存：

void * _aligned_malloc(size_t size,size_t alignment);
// size表示要分配的字节数。
// alignment表示要对齐到的字节边界，传给alignment参数的值必须是２的整数幂次方

Interlocked单向链表函数——对Interlocked单向链表的栈进行操作，栈中的每个操作，比如入栈或出栈，必定是以原子方式进行的。
InitializeSListHead    // 创建一个空栈
InterlockedPushEntrySList // 在栈顶添加一个元素
InterlockedPopEntrySList    // 移除位于栈顶的元素并将它返回
InterlockedFlushSList     // 清空栈
QueryDepthSList    // 返回栈中元素的数量

梦五 2011-12-12 10:10 发表评论

进程优先级 and 线程相对优先级

梦五 — Tue, 29 Nov 2011 02:06:00 GMT

进程都属于某个优先级类，另外可以指定进程中线程的相对线程优先级。
Windows支持6个优先级类（priority class）:idle,below normal,normal,above normal,high 和 real-time.

进程优先级类解释：
real-time(实时)：此进程中的线程必须立即响应事件，执行实时任务。此进程中的线程还会抢占操作系统的组件的CPU时间。使用该优先级类需要极为小心。

high(高)：此进程中的线程必须立即响应事件，执行实时任务。任务管理器运行在这一级，因此用户可以通过它结束失控的进程。

above normal(高于标准)：此进程中的线程运行在 normal 和 high 优先级类之间。

normal(标准)：此进程中的线程无需特殊的调度。

below normal(低于标准)：此进程中的线程运行在 normal　和　idle　优先级类之间。

idle(低)：此进程中的线程在系统空闲时运行。屏幕保护程序、后台实用程序和统计数据收集软件通常使用该进程。

normal是最常用的优先级类，为99%的应用程序所使用。

Windows支持7个相对线程优先级：idle,lowest,below normal,normal,above normal,highest 和 time-critical.
这些优先级是相对于进程优先级的。

相对线程优先级解释：
time-critical：对于real-time优先级类，线程运行在31上；所有其他优先级运行在15.

highest：线程运行在高于normal之上两个级别.

above normal：线程运行在高于normal之上一个级别.

normal：线程运行在进程normal级别上.

below normal：线程运行在低于normal之下一个级别.

lowest：线程运行在低于normal之下两个级别.

idle：对于real-time优先级类，线程运行在16;所有其他优先级运行在1.

大多数线程使用normal线程优先级。

线程优先级是相对于进程优先级的。如果改变进程优先级，线程的相对优先级不变，但是优先级值将变化。

进程永远无法调度，能调度的是线程。进程优先级是　Microsoft　提出的一个抽象概念，有助于用户无需了解调度程序的内部工作机理。

梦五 2011-11-29 10:06 发表评论