消息映射、循环机制是Windows程序运行的基本方式。VC++ MFC 中有许多现成的消息句柄，可当我们需要完成其它的任务，需要自定义消息，就遇到了一些困难。在MFC ClassWizard中不允许添加用户自定义消息，所以我们必须在程序中添加相应代码，以便可以象处理其它消息一样处理自定义消息。通常的做法是采取以下步骤:
第一步:定义消息。
推荐用户自定义消息至少是WM_USER+100，因为很多新控件也要使用WM_USER消息。
第二步:实现消息处理函数。该函数使用WPRAM和LPARAM参数并返回LPESULT。
LPESULT CMainFrame::OnMyMessage(WPARAM wParam, LPARAM lParam)
{
// TODO: 处理用户自定义消息
...
return 0;
}
第三步:在类头文件的AFX_MSG块中说明消息处理函数:
class CMainFrame:public CMDIFrameWnd
{
...
// 一般消息映射函数
protected:
// {{AFX_MSG(CMainFrame)
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
afx_msg void OnTimer(UINT nIDEvent);
afx_msg LRESULT OnMyMessage(WPARAM wParam, LPARAM lParam);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
}
第四步:在用户类的消息块中，使用ON_MESSAGE宏指令将消息映射到消息处理函数中。
BEGIN_MESSAGE_MAP(CMainFrame, CMDIFrameWnd)
//{{AFX_MSG_MAP(CMainFrame)
ON_WM_CREATE()
ON_WM_TIMER()
ON_MESSAGE(WM_MY_MESSAGE, OnMyMessage)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
如果用户需要一个定义整个系统唯一的消息,可以调用SDK函数RegisterWindowMessage定义消息:
static UINT WM_MY_MESSAGE=RegisterWindowMessage("User");
并使用ON_REGISTERED_MESSAGE宏指令取代ON_MESSAGE宏指令,其余步骤同上。
当需要使用自定义消息时,可以在相应类中的函数中调用函数PostMessage或SendMessage发送消息PoseMessage(WM_MY_MESSAGE,O,O); 如果向其他进程发送消息可通过如下方法发送消息:
DWORD result;
SendMessageTimeout(wnd->m_hWnd, // 目标窗口
WM_MY_MESSAGE, // 消息
0, // WPARAM
0, // LPARAM
SMTO_ABORTIFHUNG |
SMTO_NORMAL,
TIMEOUT_INTERVAL,
&result);
以避免其它进程如果被阻塞而造成系统死等状态。
可是如果需要向其它类(如主框架、子窗口、视类、对话框、状态条、工具条或其他控件等)发送消息时,上述方法显得无能为力，而在编程过程中往往需要获取其它类中的某个识别信号,MFC框架给我们造成了种种限制,但是可以通过获取某个类的指针而向这个类发送消息，而自定义消息的各种动作则在这个类中定义，这样就可以自由自在的向其它类发送消息了。
下面举的例子叙述了向视类和框架类发送消息的方法：
在主框架类中向视类发送消息：
视类中定义消息：
ON_REGISTERED_MESSAGE(WM_MY_MESSAGE,OnMyMessage) //定义消息映射
视类定义消息处理函数：
// 消息处理函数
LRESULT CMessageView::OnMyMessage(WPARAM wParam, LPARAM lParam)
{
// TODO: 处理用户自定义消息
...
return 0;
}
//发送消息的测试函数
void CMainFrame::OnTest()
{
CView * active = GetActiveView();//获取当前视类指针
if(active != NULL)
active->PostMessage(WM_MY_MESSAGE,0,0);
}
在其它类中向视类发送消息：
//发送消息的测试函数
void CMainFrame::OnTest()
{
CMDIFrameWnd *pFrame;
CMDIChildWnd *pChild;
CView *pView;
//获取主窗口指针
pFrame =(CMDIFrameWnd*)AfxGetApp()->m_pMainWnd;
// 获取子窗口指针
pChild = (CMDIChildWnd *) pFrame->GetActiveFrame();
//获取视类指针
pView = pChild->GetActiveView();
if(pView != NULL)
pView->PostMessage(WM_MY_MESSAGE,0,0);//发送消息
}
其余步骤同上。
在视类中向主框架发送消息:
首先在主框架中定义相关的消息,方法同上,然后在发送消息的函数中添加代码如下
//发送消息的测试函数
void CMessageView::OnTest()
{
CFrameWnd * active = GetActiveFrame();//获取当前主窗口框架指针
if(active != this)
active->PostMessage(WM_MY_MESSAGE,0,0);
return 0;
}
在其它类中向不同的类发送消息可依次方法类推，这样我们的程序就可以的不受限制向其它类和进程发送消息，而避免了种种意想不到的风险。
下面一个例子程序为多文档程序里在一对话框中向视类发送消息,详述了发送自定义消息的具体过程。
第一步：在VC++中新建工程Message，所有ClassWizard步骤选项均为缺省,完成。
第二步：在主菜单中添加测试菜单为调出对话框，在框架类中建立相应函数OnTest()
第三步：在资源中建立对话框，通过ClassWizard添加新类TestDialog,添加测试按钮,
在对话框类中建立相应函数OnDialogTest()
//通过对话框按钮发送消息的函数
void TestDialog::OnDialogTest()
{
CMDIFrameWnd *pFrame;
CMDIChildWnd *pChild;
CView *pView;
//获取主窗口指针
pFrame =(CMDIFrameWnd*)AfxGetApp()->m_pMainWnd;
// 获取子窗口指针
pChild = (CMDIChildWnd *) pFrame->GetActiveFrame();
//获取视类指针
pView = pChild->GetActiveView();
if(active != NULL)
active->PostMessage(WM_MY_MESSAGE,0,0);//发送消息
}
在Message.h头文件中添加如下语句：
static UINT WM_MY_MESSAGE=RegisterWindowMessage("Message");
第四步:在视类中添加自定义消息:
在头文件MessageView.h中添加消息映射
protected:
//{{AFX_MSG(CMessageView)
//}}AFX_MSG
afx_msg LRESULT OnMyMessage(WPARAM wParam, LPARAM lParam); //此行为添加代码
DECLARE_MESSAGE_MAP()
在视类文件MessageView.cpp中的消息映射中添加自定义消息映射
BEGIN_MESSAGE_MAP(CMessageView, CView)
//{{AFX_MSG_MAP(CMessageView)
//}}AFX_MSG_MAP
// Standard printing commands
ON_REGISTERED_MESSAGE(WM_MY_MESSAGE,OnMyMessage) //此行添加代码定义唯一消息
END_MESSAGE_MAP()
添加相应的0消息处理函数
LRESULT CMessageView::OnMyMessage(WPARAM wParam, LPARAM lParam)
{
CRect rect;
GetClientRect(&rect);
InvalidateRect(&rect);
test=!test;
return 0;
}
在MessageView.h中添加布尔变量 public:BOOL test;
在视类构造函数中初始化 test变量:test=FALSE;
修改CMessageView::OnDraw()函数
void CMessageView::OnDraw(CDC* pDC)
{
CMessageDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
// 以下程序显示消息响应效果
if(test)
pDC->TextOut(0,0,"消息响应!");
}
第五步：显示测试对话框
在MainFrame类中包含对话框头文件：
#include "TestDialog.h";
OnTest()函数中添加代码
void CMainFrame::OnTest()
{
TestDialog dialog;
dialog.DoModal();
}
运行程序,在测试菜单打开对话框,点击测试按钮即可看到结果。
如果您计划通过Internet销售 MFC控件和ATL 控件，您应该将其打包成签署的小巧(Cabinet -CAB) 文件。签署文件确保用户下载您的控件时源代码是安全的。一个CAB文件包含一个您的控件及其安装信息(比如，都需要哪些动态链接库DLL和OCX一起安装)的压缩版本。
创建和签署CAB文件的工具包含于Visual C++ 5.0 光盘中的 CAB&SIGN 目录下面。 该目录下的公用程序在您安装Visual C++时并不会自动地一起安装，因此您必须将CAB&SIGN 目录下面的内容拷贝到您的硬盘驱动器中。
在签署文件之前，您需要有一个软件出版商证明书(Software Publisher Certificate)。您必须向证书发放机构(Certification Authority)申请自己的证书。利用CAB&SIGN目录下面的工具，您能够创建一个用于测试的测试证明书，但是该证明书不能用于签署发售的代码。有关申请软件出版商证明书的信息，请参考步骤 1 。
下面是创建签署CAB文件的步骤 :
1 获得一个软件出版商证明书 (您只需要这一次申请就可以永久使用)
2 创建 CAB 文件
3 签署您的文件
4 将签署过的 CAB文件嵌入一个Web页(可选项)获得一个软件出版商证明书
在签署文件之前，您需要有一个软件出版商证明书(SPC)。为此，您必须向证书发放机构(Certification Authority)提出申请。在申请过程中，您必须生成一个密匙对，并向证书发放机构提供证明信息，比如说您的名字、地址以及公共密匙。而且，您必须作出具有法律约束力的誓言：您不能也将不会发布您知道或者应该知道其中包含了病毒的软件，或者是恶意破坏用户的机器或代码。
有关如何得到软件出版商证明书更详尽的信息，请参考Signing Code with Microsoft's Authenticode。若要申请该证书，请参考 Digital Certificates for Authenticode ；若要创建一个测试证书来测试签署文件，请参考Making A Test Software Publisher Certificate.
证书发放机构生成一个符合工业标准X.509证书格式(包含版本3扩展)的软件出版商证明书 。该证书确定并且包含您的公共密匙，并以证书发放机构存档作为参考，把一个拷贝以电子邮件的方式返回给您。收到该证书之后，您应该在所有要发布的、用私人密匙签署的软件当中，包含一份该证书的拷贝。
获得一个软件出版商证明书
您可以使用Visual C++ 5.0 光盘中CAB&SIGN目录下的 MAKECERT和 CERT2SPC 公用程序，做一个测试软件出版商证明书。注意，该测试软件出版商证明书对真正的软件发布无效，但是能够被用来测试您代码的签署。
比如，要做一个私人密匙文件MYKEY.PVK 和一个公司证书CERT.CER，则运行公用程序MAKECERT，其命令如下:
C:\CAB&SIGN\MAKECERT
-u: MyKey
-n: CN = MySoftwareCompany
-k: MYKEY.PVK CERT.CER
MyKey 是您的密匙名，MySoftwareCompany 是您的公司名。注意公用程序 MAKECERT 在命令行选项中区分大小写，因此您必须使用小写的-u、-n以及-k；-n选项的值必须是大写的CN=。
做一个名为CERT.SPC测试软件出版商证明书，则运行公用程序CERT2SPC，命令如下:
C:\CAB&SIGN\CERT2SPC C:\CAB&SIGN\ROOT.CER CERT.CER CERT.SPC
注意CERT.SPC文件是利用您刚使用MAKECERT创建的CERT.CER文件以及CAB&SIGN目录下面的ROOT.CER文件创建的 。
创建一个 CAB文件
这一部分描述如何创建能在互连网上分派ATL和MFC组件的CAB文件。如果您要了解有关CAB文件的更多信息，请参考Cabinet文件参考书目(File Reference)，该文件位于平台软件开发工具包(Platform SDK，包含在Visual C++ 5.0联机文档中)的设置和系统管理服务(Setup and System Management Services)部分的\Setup API\Overview\Cabinet Files目录下面。
创建一个 CAB文件:
创建一个INF文件。
运行公共例程CABARC(在光盘上的CAB&SIGN目录中)。例如:
C:\CAB&SIGN\CABARC -s 6144
n MYCTL.CAB NEEDED1.DLL NEEDED2.DLL MYCTL.OCX MYCTL.INF
CABARC 创建了一个名为MYCTL.CAB的CAB文件。
您必须在您的源文件(INF、OCX以及DLL文件)目录下面运行CABARC。存档在CAB 文件中的文件需要在命令行列出，次序同它们在INF文件中的完全一致。在上例中，INF文件的列出次序是NEEDED1.DLL，然后 是NEEDED2.DLL，最后是MYCTL.OCX。
-s选项为代码签署保留空间。n 命令指定您想创建的是CAB文件。CABARC 命令和选项的说明可以查看，其方式是在命令行键入CABARC:
C:\CAB&SIGN\CABARC
创建一个INF文件
INF文件是一个文本文件，指定运行控件所需要下载或者呈交的文件(比如DLL或者其它OCX)。一个INF文件就捆绑了CAB压缩文件所有的必须文件。 缺省情况下，与现有硬盘中文件版本号相同的文件不被下载。要了解有关INF文件及其选项(包括如何创建独立于平台的INF文件)的详细情况，请参考万维网站Packaging Component Code for Automatic Download，或者参考平台软件开发工具包(Platform SDK，包含在Visual C++ 5.0联机文档中)的设置和系统管理服务(Setup and System Management Services)部分的\Setup API\Overview\INF Files目录下的内容。
作为示例，下面的INF是用来为ATL多边形控件创建一个CAB文件的。 您可以通过从Visual C++ 5.0光盘下载ATL POLYGON示例程序来创建POLYGON.DLL，并创建一个最小版本。创建该最小版本另外需要一个DLL即 ATL.DLL。ATL.DLL要先于POLYGON.DLL注册，因此首先把ATL.DLL 放置到INF当中。
; Sample INF file for POLYGON.DLL
[version]
; version signature (same for both NT and Win95) do not remove
signature="$CHICAGO$"
AdvancedINF=2.0
[Add.Code]
polygon.dll=polygon.dll
atl.dll=atl.dll
; needed DLL
[atl.dll]
file-win32-x86=thiscab
FileVersion=2，00，0，7024
DestDir=11
RegisterServer=yes
[polygon.dll]
file-win32-x86=thiscab
clsid={4CBBC676-507F-11D0-B98B-000000000000}
FileVersion=1，0，0，1
RegisterServer=yes
; end of INF file
该INF指定了系统需要安装特定版本的ATL.DLL。如果系统中还没有该文件，则需要从和该INF一起创建的CAB文件下载。"thiscab" 是一个关键字，意指包含该INF的CAB文件。您也可以从网上下载所需要的DLL文件，只要指定一个HTTP 网址即可，绝对路径或者相对路径都可以，比如:
file-win32-x86=http://www.mysite.com/mydir/NEEDED.DLL
关键字"file-win32-x86" 指定平台是 x86。
得到一个文件的版本号的过程是：在Windows NT或者Windows 95 Explorer中右键点击该文件；从弹出列表中选择Properties，然后在接着弹出的对话框中选择版本标签。有时，您可能需要在文件版本中插入一个额外的0 。比如，对话框中显示ATL.DLL的版本号是2.00.7024，在INF文件中则变为2，00，0，7024 。
"DestDir"指的是装载目录或者文件的地址: 11 指定为系统目录 WINDOWS/SYSTEM 或者 WINNT/SYSTEM32; 10 规定为窗口目录、WINDOWS或者WINNT。如果没有指定DestDir(典型情况)，则代码从固定的OCCACHE目录装载。
"clsid" 指的是要安装控件的CLSID。
创建 INF文件后，再运行CABARC公用程序(在Visual C++ 5.0光盘上的CAB&SIGN目录中)创建CAB文件。您必须在您的源文件目录下面运行CABARC。存档在CAB 文件中的文件需要在命令行列出，次序同它们在INF文件中完全一致。比如，从上面的INF文件为多边形控件做一个CAB文件，需要使用下面的命令 :
C:\CAB&SIGN\CABARC -s 6144 POLYGON.CAB ATL.DLL POLYGON.DLL POLYGON.INF
该CAB文件包含ATL.DLL和POLYGON.DLL的压缩版本，以及将它们展开到POLYGON.INF 文件所需要的信息。
有关创建一个下载MFC控件的CAB文件的示例，请参考MFC 4.2b Component Download Information.您需要包含在MFC控件中的DLL文件有MSVCRT.DLL，MFC42.DLL以及 OLEPRO32.DLL。
签署一个CAB文件
使用Code Signing Wizard签署一个CAB文件:
1. 运行公用程序 SIGNCODE (在Visual C++ 5.0光盘的CAB&SIGN 目录下)，启动Code Signing Wizard。
C:\CAB&SIGN\SIGNCODE
2. 在Code Signing Wizard对话框当中，点击Next前进到下一页。
3. 在您想签署那一个程序? 编辑框中，键入您想签署的CAB文件。
4.在您想在证书中使用什么名字? 编辑框中，键入您想在证书中使用的名字。
5. 点击Next，前进到下一页。
6. 在 您想将该程序签署在哪一个软件开发商证书下面? 编辑框中，键入软件开发商证书(SPC)文件名。
7. 在您要在该证书的哪一个文件中查找密码、密匙? 编辑框中，键入私人密匙(PVK)文件名。
8. 连续两次点击 Next前进到最后一页。
9.点击Sign，签署CAB 文件。您的文件将被数字化签署。
您可以不使用CAB文件直接签署您的DLL和OCX 。CAB文件的好处在于它是压缩的，而且，如果和INF文件一起使用，可以将所有必要代码捆绑在一起。
将签署过的 CAB文件嵌入一个Web页
ATL和MFC控件使用标签嵌入网页。在标签，您需要为该控件指定三个属性 :
ID - 控件名称
CLASSID - 控件的CLSID
CODEBASE - 下载控件的位置。CODEBASE 可以指向许多不同的文件类型。
CODEBASE可以直接指向一个OCX 文件或者DLL文件:
CODEBASE="http://www.mysite.com/mydir/polygon.dll#version=1，0，0，1"
因为这仅仅完成了DLL或OCX文件的下载和安装，任何必要的DLL支持必须已经装载到了客户机上。
如果您在CAB文件中包含了选项版本号，它应该指向要下载的控件。例如，如果POLYGON.DLL有一个版本号1，0，0，1，则CAB文件的版本号也必须是1，0，0，1:
CODEBASE="http://www.mysite.com/mydir/polygon.cab#version=1，0，0，1"
如果您没有包含选项版本号，则不能替换同一个组件(如果它们出现在客户机上的话)的老版本号。
映射（Map），又称为字典（Dictionary），是由关键字（Key）及其对应的元素值（Value）所组成的元素单元（Element）的表单式集合。
通常，对于Map而言，使用给定的Key，可以迅速地从单元集合中检索到相应的元素。因此，在需要对大量数据进行查找操作而查找的性能又占据重要地位的场合，Map无疑是一种较理想的容器。譬如，在MFC中，使用Map来实现HandleMaps（句柄映射），以及其他的一些内部数据结构。同时，MFC也提供了公共Map类。使用公共Map类，MFC程序员可以轻易地高效地根据自身的需求实现程序中自定义的映射。
通常，当一个Map对象被删除时，或者，当其中的元素被移除时，关键字和元素值也将被完全删除。
从数据结构的角度分析，有关Map的典型操作有：
1、向Map中插入具有给定关键字的元素单元。
2、在Map中查找具有给定关键字的元素单元。
3、在Map中删除具有给定关键字的元素单元。
4、枚举（遍历）Map中的所有元素单元。
MFC中的各种Map实现，都提供了实现上述操作的成员函数。为了方便讨论，我们以CMap为代表，进行讲解。
一旦你已经向Map中插入了一个关键字-元素值组合对(Key-Value pair)单元，就可以利用关键字访问Map，从而有效地检索、添加或者删除元素单元，也可以遍历Map中的所有单元。
对MFC中的CMap等，除了关键字访问方法之外，还有另一种不同的类型--POSITION，也可以作为访问元素单元的辅助方式，可以使用一个POSITION来"记住"一个元素单元或者对Map进行枚举操作。你可能认为这种使用POSITION实现的遍历等同于使用关键字来进行的Map遍历，事实上并非如此，确切的说，两种检索的等价性是不确定的。
MFC中的提供了基于模板的CMap类。利用CMap模板类，可以处理特定的数据类型，例如用户自定义的类或结构体等。同时，MFC也提供了基于指定数据类型的非模板类，其中包括：
类名关键字类型 元素值类型CMapWordToPtrWORDSVoid pointersCMapPtrToWordVoidpointers WORDSCMapPtrToPtrVoid pointersVoid pointersCMapWordToObWORDSObjectsCMapStringToObStringsObjectsCMapStringToPtrStringsVoid pointersCMapStringToStringStringsString
二、
使用Map的最大优势是它的快速查找的优秀性能，而取得最优性能的关键在于尽量使得在检索周期内所需进行的元素检查（比对）次数达到最少。顺序查找的性能是最差的，因为如果使用顺序查找算法在包含n个元素单元的Map中查找某个元素，可能（最坏情况下）需要进行n次独立的比较运算。
二元查找（折中查找）的性能表现要稍好一些，可是，一个不容忽视的问题是--二元查找要求待查序列为有序排列，这无疑会降低Map自身的操作灵活性。在我们的理解中，所谓的最佳算法应当是不论元素单元数目的多少，也不论元素是以什么顺序进行排列，查找过程都无需任何额外的比对操作，而能够仅仅通过简单的计算方法，就可以直接指向最终的相应元素的快速、高效算法。这听起来有些玄乎，但事实上，这种算法的确是有可能实现的（而且，我相信，Map可以做得到）。
在MFC的CMap及其相关的Map类中，只要对Map进行正确设置，Lookup函数通常能够一次到位的查找到任意元素，而很少需要进行两次或者三次以上的查找比对。
那么，这种高效的查找是如何实现的呢？
不失一般性，以MFC中的CMap模板类为例。在Map被创建之后（通常是恰恰在第一个元素被插入之前的瞬间），系统会为一个指向CAssoc结构体的指针数组的哈希表分配内存。MFC使用CAssoc结构体描述元素值和关键字的组合对。
CAssoc结构体描述如下：
struct CAssoc
{
CAssoc* pNext;
UINT nHashValue;
CString key;
CString value;
};
无论何时，只要有一个元素值-关键字单元被加入到Map中，就会随之创建一个新的CAssoc结构体，并根据单元中的关键字的实际值来计算出相应的哈希值。同时，拷贝一个指向CAssoc结构体的指针并将其插入到哈希表中索引值为i的位置中。其中，i的计算公式如下：
i=nHashValue%nHushTableSize
式中，nHashValue是由关键字Key的实际值计算出来的哈希值；nHashTableSize是哈希表中元素的数目（默认情况下，哈希表的大小为17）。
如果在哈希表中的索引值为i的位置已经容纳了一个CAssoc指针，那么MFC将建立一个单独的CAssoc结构体的链表（List）,链表中的第一个CAssoc结构体的地址被存储到哈希表中，而将第二个CAssoc结构体的地址存储到前一个CAssoc结构体的pNext域，以此类推。下图展示了哈希表的一种可能实现情况，在该哈希表中，共有10个元素，其中5个元素地址分别唯一的存储，另外5个分别存储在长度为2和3的两个链表中。
调用一个Map的Lookup()函数时，MFC根据输入的关键字的实际值计算相应的哈希值，然后使用前面提到的公式将哈希值转换为索引值，并从哈希表中的相应位置检索CAssoc指针。
理想情况下，该位置只包含一个CAssoc指针，而非CAssoc指针链表。如果事实情况真如同我们所期望的那样，单一地址对应单一CAssoc指针，那么，元素单元将能够被一次查找到位，并直接读出；如果从哈希表中检索到的是CAssoc链表的指针头地址，则MFC顺序比对链表元素CAssoc结构所包含的关键字，直至查找到正确结果。但是，正如我们先前所讨论的那样，只要正确设置Map，链表中的元素一般就不会超过三个，这就意味着，查找通常可以在三次元素比对操作之内完成。
在MFC的Map中，查找性能主要依赖于两个因素：
1、哈希表的大小
2、尽可能产生唯一哈希值的优异算法
哈希表的大小对于Map的查找性能而言，是非常重要的。举个简单的例子，如果有一个Map要容纳1000个元素单元，但是哈希表却只能提供17个存放CAssoc指针的空间，那么，即使是最佳情况，哈希表中的每个CAssoc链表中也将包含58或59个CAssoc结构体，自然，在这种情况下，查找性能将受到严重阻碍。
哈希算法亦是影响查找效率的重要因素之一。如果所使用的哈希算法只能产生少量的不同哈希值（从而也只能产生少量的不同的哈希表索引值），查找性能也同样将被降低。
优化Map查找性能的最有效途径是尽可能的增大哈希表以降低因索引值相同而产生冲突的可能。微软推荐将哈希表的大小设置为Map中所存储元素数目的110% ～120%，以使得Map的应用性能在内存消耗和查找效率之间取得相对平衡。
在MFC中，指定哈希表大小，可调用InitHashTable()函数：
map.InitHashTable(1200);
式中，假设Map中要存储1000个元素，按照微软公司的推荐，将哈希表的大小扩展到实际存储元素数目的120%，即设置Map大小为1200。
从统计学上考虑，实用奇数作为哈希表的大小也将有助于减少冲突的发生。因此，初始化一个存储1000个元素的哈希表的InitHashTable()函数可以如下形式使用：
map.InitHashTable(1201);
同时，在InitHashTable()函数的调用时机上，应该注意的是，该函数应当在map包含有任何元素之前使。如果map中已经包含了一个或者更多的元素，那么，重新改变map的大小，将会引发断言（Assertion）错误。
尽管MFC中所使用的哈希算法能够适应于大多数场合，但如果您真的有所需要，或者，只要你愿意，用户也可以使用自己的算法来取代原有的算法。对于一个输入的关键字的值，要计算出它的哈希值，MFC通常调用一个全局模板函数HashKey()，对于大多数数据类型而言，HashKey()函数是以下面的方式实现的：
AFX_INLINE UINT AFXAPI HashKey(ARG_KEY key)
{
file://一般情况的默认算法。
return ((UINT)(void*)(DWORD)key) >> 4;
}
但对于字符串而言，其具体的实现方式如下：
UINT AFXAPI HashKey(LPCWSTR key) // Unicode编码字符串
{
UINT nHash = 0;
while (*key)
nHash = (nHash<<5) + nHash + *key++;
return nHash;
}
UINT AFXAPI HashKey(LPCSTR key) file:// ANSI编码字符串
{
UINT nHash = 0;
while (*key)
nHash = (nHash<<5) + nHash + *key++;
return nHash;
}
要实现对应于特定数据类型的用户自定义哈希算法，您可以使用上述的字符串版本的HashKey()函数作为参考，写一个类似的特定类型的HashKey()函数。
有关MFC中的CMap类的概况，上面的文字段落中已经陆续提及，在此不再赘言。下面，列出CMap类的基本成员函数，并通过一个简短的程序片段来粗略地演示CMap类的使用方法。
构造函数：
CMap构造一个关键字和元素值映射的集合类。
操作：
Lookup通过给定的关键字查找相应的元素值。SetAt向Map中插入一个元素单元；若存在匹配键字，则替代之。operator []向Map中插入一个元素 -SetAt的子操作RemoveKey移除由关键字标示的元素单元RemoveAll移除Map中的所有元素单元GetStartPosition返回第一个元素单元的位置GetNextAssoc读取下一个元素单元GetHashTableSize返回哈希表的大小（元素单元的数目）InitHashTable初始化哈希表，并指定它的大小
状态：
GetCount返回Map中元素的数目IsEmpty检查Map是否为空（无元素单元）
应用实例如下：
CMap
file://初始化哈希表，并指定其大小（取奇数）
file://向myMap中添加元素单元。
for (int i=0;i < 200;i++)
myMap.SetAt( i, CPoint(i, i) );
file:// 删除实际值为偶数的关键字所对应的的元素单元。
POSITION pos = myMap.GetStartPosition();
int nKey;
CPoint pt;
while (pos != NULL)
{
myMap.GetNextAssoc( pos, nKey, pt );
if ((nKey%2) == 0)
myMap.RemoveKey( nKey );
}
#ifdef _DEBUG
afxDump.SetDepth( 1 );
afxDump << "myMap: " << &myMap << "\n";
#endif
在上面的应用程序片段中，我们可以了解有关CMap类的在通常情况下的使用方法。
1、首先我们使用CMap模板类来定义一个实例--myMap对象。
2、紧接着要做的是对myMap对象的哈希表的大小进行初始化设置。此时，应该先对myMap可能的容量需求进行估计，然后选择适当大小的奇数--或者，有可能的话，使用素数的效果会更好一些--来作为哈希表的初始值。
3、然后，向myMap中添加元素单元。
4、使用myMap进行数据映射、查找、遍历等操作。
5、调用myMap.RemoveAll()函数移除所有元素，释放myMap占用的内存空间。
CMap对应IMPLEMENT_SERIAL，从而支持用户对其元素进行串行化（Serialization）以及倾注（Dumping）操作。在对CMap的独立元素进行倾注操作时，应该注意的是，你必须将倾注环境（Dump Context）的深度设置为1或者更大的数字。
我试着用自已的话来表述线程的概念,还有很短时间里编的一个小示例程序（不知恰当不?,也不知能说得清不..),见笑了.
线程其实和标准的windows主程序(WinMain)没啥两样...主程序其实是一个特殊的线程,称为主线程而已，其实你完全可以把线程想象成和winmain一起**同时运行**，但是** 可以相互访问(即在一个地址空间) **的一些小的WinMain程序.它和主线程一样,里面可以创建窗口，获取消息,等等..
由于线程们在一个地址空间且同时运行，所以会造成一些麻烦。因为我们编程都要用别人的函数库，而他们的函数库里面往往会有很多静态或全局的状态或中间变量，有着很复杂的相互依赖关系，如果执行某个功能不串行化(所谓串行化,也就是只能等一个功能调用返回后，另一个线程才能调用，不可以同时调用)，就会造成大乱.这对线程来说，有术语称同步，windows为我们提供了很多同步的方法,MFC也提供了一些同步核心对象的类封装.对于某个功能调用库来说，叫线程安全.比如MFC的类库并不是线程安全的.
现在我举个刚刚自编的例子来简单说明这些概念。下面的一个对话框应用是多线程的.演示两个小动画:
(1)第一个动画由主线程的Timer来驱动，第二个动画由主线所创建的工作线程来驱动.分别显示在不同的位置.之所以我要加入Timer，也是为了形成线程驱动和timer驱动的对照,这是动画的两种驱动方式(还有在idle中驱动的)。
(2)这两个动画永远是不同的.也就是比如:一个是变哭，一个就会变笑，等那个变笑了，这个就变哭.动画图片来自于OICQ中的Face目录下,一般同样的头像会oicq会带三个图片(*-1.bmp,*-2.bmp,*-3.bmp),*-2.bmp是变灰的图片，我就取了1和3的图片来作动画.
这个程序的几个关键要注意的:
(1)主线程用PostThreadMessage和工作线程通信.工作线程用PeekMessage来取回消息。为了简单起见,我只用了一个WM_QUIT的消息来指示工作线程退出.
(2)主线程和工作线程同时调用了一个DisplayFace函数来进行动画显示.为了让两个动画一哭一笑做到不同，采用了CCriticalSection来进行同步.
示例如下:
(1)先用appwizards生成一个MFC的Dialog应用模板,假定对话框类为CTest01Dlg。
(2)再添入两个oicq的bmp文件到资源中去
(3)添加一个按钮(button)到对话框上.用作启动、停止动画的button
(4)用ClassWizard为button/onclick及dlg/ontimer生成事件响应函数，
(5)用Resource Symbol加入一个标识定义IDC_TIMER1
(6)在ClassView中为CTest01Dlg加入以下成员变量和成员函数
CriticalSection ccs;
CBitmap bm[2];
CWinThread* pMyThread;
static UINT MyThreadProc( LPVOID pParam);
void DisplayFace(CPoint r);
实现文件中加入相应代码(见下面)
(7)stdafx.h中加入#include
源代码如下,凡是我新加的代码周围都有注释包围，其它是ClassWizards自动写的:
// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but
// are changed infrequently
file://
#if !defined(AFX_STDAFX_H__5B92DAA8_FE27_4702_8037_A2538343E69D__INCLUDED_)
#define AFX_STDAFX_H__5B92DAA8_FE27_4702_8037_A2538343E69D__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers
#include // MFC core and standard components
#include // MFC extensions
#include // MFC support for Internet Explorer 4 Common Controls
file://加入头引用主要是CCriticalSection对象的定义.
#include
file://加入结束
#ifndef _AFX_NO_AFXCMN_SUPPORT
#include // MFC support for Windows Common Controls
#endif // _AFX_NO_AFXCMN_SUPPORT
file://{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_STDAFX_H__5B92DAA8_FE27_4702_8037_A2538343E69D__INCLUDED_)
// test01Dlg.h : header file
file://
#if !defined(AFX_TEST01DLG_H__F3780E23_CCFC_468C_A262_50FFF1D991BC__INCLUDED_)
#define AFX_TEST01DLG_H__F3780E23_CCFC_468C_A262_50FFF1D991BC__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
/////////////////////////////////////////////////////////////////////////////
// CTest01Dlg dialog
class CTest01Dlg : public CDialog
{
// Construction
public:
file://加入
CBitmap bm[2];
CCriticalSection ccs;
CWinThread* pMyThread;
static UINT MyThreadProc( LPVOID pParam);
void DisplayFace(CPoint r);
CTest01Dlg(CWnd* pParent = NULL); // standard constructor
file://加入结束
// Dialog Data
file://{{AFX_DATA(CTest01Dlg)
enum { IDD = IDD_TEST01_DIALOG };
// NOTE: the ClassWizard will add data members here
file://}}AFX_DATA
// ClassWizard generated virtual function overrides
file://{{AFX_VIRTUAL(CTest01Dlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
file://}}AFX_VIRTUAL
// Implementation
protected:
HICON m_hIcon;
// Generated message map functions
file://{{AFX_MSG(CTest01Dlg)
virtual BOOL OnInitDialog();
afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
afx_msg void OnPaint();
afx_msg HCURSOR OnQueryDragIcon();
afx_msg void OnButton1();
afx_msg void OnTimer(UINT nIDEvent);
file://}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
file://{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_TEST01DLG_H__F3780E23_CCFC_468C_A262_50FFF1D991BC__INCLUDED_)
// test01Dlg.cpp : implementation file
file://
#include "stdafx.h"
#include "test01.h"
#include "test01Dlg.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About
class CAboutDlg : public CDialog
{
public:
CAboutDlg();
// Dialog Data
file://{{AFX_DATA(CAboutDlg)
enum { IDD = IDD_ABOUTBOX };
file://}}AFX_DATA
// ClassWizard generated virtual function overrides
file://{{AFX_VIRTUAL(CAboutDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
file://}}AFX_VIRTUAL
// Implementation
protected:
file://{{AFX_MSG(CAboutDlg)
file://}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
file://{{AFX_DATA_INIT(CAboutDlg)
file://}}AFX_DATA_INIT
}
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
file://{{AFX_DATA_MAP(CAboutDlg)
file://}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
file://{{AFX_MSG_MAP(CAboutDlg)
// No message handlers
file://}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CTest01Dlg dialog
CTest01Dlg::CTest01Dlg(CWnd* pParent /*=NULL*/)
: CDialog(CTest01Dlg::IDD, pParent)
{
file://{{AFX_DATA_INIT(CTest01Dlg)
// NOTE: the ClassWizard will add member initialization here
file://}}AFX_DATA_INIT
// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
file://加入
pMyThread =NULL;
file://加入结束
}
void CTest01Dlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
file://{{AFX_DATA_MAP(CTest01Dlg)
// NOTE: the ClassWizard will add DDX and DDV calls here
file://}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CTest01Dlg, CDialog)
file://{{AFX_MSG_MAP(CTest01Dlg)
ON_WM_SYSCOMMAND()
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
ON_BN_CLICKED(IDC_BUTTON1, OnButton1)
ON_WM_TIMER()
file://}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CTest01Dlg message handlers
BOOL CTest01Dlg::OnInitDialog()
{
CDialog::OnInitDialog();
// Add "About..." menu item to system menu.
// IDM_ABOUTBOX must be in the system command range.
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
ASSERT(IDM_ABOUTBOX < 0xF000);
CMenu* pSysMenu = GetSystemMenu(FALSE);
if (pSysMenu != NULL)
{
CString strAboutMenu;
strAboutMenu.LoadString(IDS_ABOUTBOX);
if (!strAboutMenu.IsEmpty())
{
pSysMenu->AppendMenu(MF_SEPARATOR);
pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
}
}
// Set the icon for this dialog. The framework does this automatically
// when the application''s main window is not a dialog
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
// TODO: Add extra initialization here
file://加入
bm[0].LoadBitmap (IDB_BITMAP1);
bm[1].LoadBitmap (IDB_BITMAP3);
file://加入结束
return TRUE; // return TRUE unless you set the focus to a control
}
void CTest01Dlg::OnSysCommand(UINT nID, LPARAM lParam)
{
if ((nID & 0xFFF0) == IDM_ABOUTBOX)
{
CAboutDlg dlgAbout;
dlgAbout.DoModal();
}
else
{
CDialog::OnSysCommand(nID, lParam);
}
}
void CTest01Dlg::OnPaint()
{
if (IsIconic())
{
CPaintDC dc(this); // device context for painting
SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
// Center icon in client rectangle
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;
// Draw the icon
dc.DrawIcon(x, y, m_hIcon);
}
else
{
CDialog::OnPaint();
}
}
HCURSOR CTest01Dlg::OnQueryDragIcon()
{
return (HCURSOR) m_hIcon;
}
file://加入
void CTest01Dlg::OnButton1()
{
static BOOL bStarted=FALSE;
if (!bStarted){
SetTimer(IDC_TIMER1,500,NULL);
pMyThread=AfxBeginThread(MyThreadProc,this);
}else{
if (pMyThread){
pMyThread->PostThreadMessage (WM_QUIT,0,0);
::WaitForSingleObject(pMyThread->m_hThread ,INFINITE);
pMyThread=NULL;
}
KillTimer(IDC_TIMER1);
}
bStarted=!bStarted;
((CButton*)GetDlgItem(IDC_BUTTON1))->SetWindowText((bStarted?_T("停止"):_T("启动")));
}
void CTest01Dlg::OnTimer(UINT nIDEvent)
{
if (nIDEvent==IDC_TIMER1)
DisplayFace(CPoint(10,10));
CDialog::OnTimer(nIDEvent);
}
void CTest01Dlg::DisplayFace(CPoint p)
{
static int i=0;
ccs.Lock ();
BITMAP bmo;
bm
CClientDC dc(this);
CDC bmpDC;
bmpDC.CreateCompatibleDC (&dc);
bmpDC.SelectObject (&bm
dc.BitBlt (p.x ,p.y ,bmo.bmWidth,bmo.bmHeight,&bmpDC,0,0,SRCCOPY);
i++;
if (i==sizeof(bm)/sizeof(bm[0])) i=0;
ccs.Unlock ();
}
UINT CTest01Dlg::MyThreadProc(LPVOID pParam)
{
CTest01Dlg *me=(CTest01Dlg *)pParam;
MSG msg;
while(!PeekMessage(&msg,NULL,0,0,PM_NOREMOVE)){
me->DisplayFace (CPoint(100,10));
::Sleep (200);
}
return 0;
}
file://加入结束
p > Microsoft DirectX SDK是开发基于 Windows 平台游戏的一个软件开发工具，其功能主要包括在五个组件中 :DirectDraw DirectSound DirectPlay Direct3D和DirectInput,每个组件都具不中的功能：
DirectDraw使用直接写存技术加快游戏的动画速度；
DirectSound控制游戏声音的合成和播放；
DirectPlay使游戏具有网络多人游戏功能；
Direct3D让程序员更方便地开发三维游戏；
DirectInput使游戏支持更多的办入设备（现在只支持游戏杆，鼠标和键盘）。
可以说DirectX SDK提供了编写一个游戏 所必须的功能及基层函数，所以大多Windows游戏都使用了DirectX SDK.
MFC(Microsoft Foundation Class)类库是Microsoft Visual C++中提供的一个功能强大的 Windows 应用程序开发类， 使用这些类我们可以避免和繁琐的Windows API打交道，而且在 Visual C++中我们还可以利用ClassWizard 对MFC 类进行Windows 消息映射，所以如果能用MFC 类库来开发DirectX SDK的应用程序，至少有以下几个好处：
增加了程序的可读性，并且可以用VC++的 ClassView方便的管理所用的类；
增加程序代码的可重用性， 可以在原有的基础上开发出功能更强大的应用程序；
二 编写 DirectX SDK 应用程序基本框架
我们按下列步骤建立一个DirectX SDK 程序的基本框架：
1 用Visual C ++的MFC App Wizard (EXE) 生成一个基本对话框的工程文件，取名为DirectX，在向导第二步时取消About Box 的复选框，然后按Finish按钮。
2 删除在DirectX 工程目录中生成的DirectXDlg.H两个文件，并在Visual C++的File View中删除以上两个文件，按CTRL+W启动ClassWizard删除CdirectXDlg类，然后在ResourseView中删除IDD_DIRECTX_DIALOG.
3 建立两个文件DirectXWnd.H(这两个文件在本文的附录中，请注意不要删除有“//{”和“//}”之间的内容，否则将不能使用ClassWizard对窗口信息进行映射)，并把它们加入到工程中? 时工程中将加入一个基于CWnd的CdirectXWnd类，这是我们的DirectX应用程序的基类。CdirectXWnd类创建一个窗口并生成一个与该窗口相关联的DirectDraw对象lpDD，同时还生成一个显示平面（lpFrontBuffer）和一个显示缓冲平面（lpBackBuffer）,该类使用了几个虚函数，必要时其派生类可以覆盖这些函数。
4 打开DirectX.CPP,把 # include”DirectXDLG.h”改为 #include “DirectXWnd.H”然后把CdirectXApp::InitInstance()函数修改如下，其中黑体字为要增加的内容：
BOOL CdirectXApp::initlnstance()
{
#ifdef_AFXDLL
Enable3dControls();//Call this when using MFC in a shared DLL
#else
Enable3dConteolsStatic();//Call this when linking to MFC
Statically
#endif
CdirectXWnd *pWnd =new CdirectXWnd();
PWnd-$#@62;Create(“DirectXWnd Test”);
m-pMainWnd =pWnd;
pWnd-$#@62;UpdateWindow();
pWnd-$#@62;SetFocus();
if (pWnd-$#@62;initializeGame(640,480,8)= =FALSE){
pWnd-$#@62;DestroyWindow();
return FALSE;
}
MSG msg;
White(1)
{
if(PeekMessage(&msg,NULL,0,0,PM-NOREMOVE)) {
if( !GetMessage(&msg,NULL,0,0))
return msg.wParam;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else{
if (pWnd-$#@62;blsActive) {
pWnd-$#@62; UpdateFrame();
}
}
}
return TURE;
}
编译该程序并运行，可以看到出现一个黑色的屏幕窗口，按ESC或F12则可退出程序。至此我们的基本框架已经建立好了，虽然这个框架还比较简单，但我们可以在此基础上开发出更强大的应用框架。为了方便使用该框架，我们可以为该框架写一个Custom App Wizard,当然也可以不写，只要把该工程目录下的文件拷贝到另一个工程目录中即可。
三 测试框架
现在，我们按下列步骤写一个程序来测试这个框架：
1 把刚才创建的工程框架拷贝到一个新目录下，并打开。用Class View 创建一个基于CWnd的类CtestWnd,然后把CtestWnd.h和CtestWnd.CPP文件中的所有“CWnd”字符串替换为“CdirectXWnd”,并在CtestWnd.h文件头加入下列字符串：#include “DirectXWnd.h”.
2 打开DirectX.CPP文件，在文件头加入# include “TestWnd.h”,并把该文件中的所有”CdirectXWnd”字符串替换成”CtestWnd”并保存。
3 为CtestWnd类增加一个虚函数UpdateFrame(),这个函数覆盖了其基类CdirectXWnd的UpdateFrame():
void CtestWnd :: UpdateFrame()
{
staic int x= 0, dx =5;
staic int y =0, dy =5;
HDC hdc;
DDBL TFX ddbltfx;
HRESULT ddrval;
UpdateWindow();
Ddbltfx.swSize = sizedof(ddbltfx);
Ddbltfx.dwFillColor = 0;
Ddrval = lpBackBuffer -$#@62;Blt(
NULL ,//dest rect
NULL,//src surface
NULL,// src rect
DDBLT_COLORFILL |DDBLT_WAIT,
&ddbltfx);
if (ddrval ! = DD_OK)
{
msg(“ Fill failed ddrval =0x%081x”,ddrval);
return;
}
if (lpBackBuffer -$#@62;GetDC(&hdc) = =DD- OK)
{
if(x$#@60;0) dx=5;
if(x$#@62;590) dx= -5;
if (y$#@60;0) dy =5;
if ( y$#@62;430) dy = -5;
x += dx ; y + =dy;
Ellipse( hdc ,x,y,x+50,y+50);
LpBackBuffer -$#@62;ReleaseDC(hdc);
}
while(1)
{
HRESULT ddrval;
ddrva =lp FrontBuffer-$#@62;Flip(NULL,0);
if( ddrval = =DD_ OK)
{break;}
if (ddravl= =DDERR_SURFACELOST)
{
if(!CdirectXWnd::RestoreSurfaces())
{
break;
}
}
if (ddravl !=DDERR_WASSTILLDRAWING)
{
break;
}
}
}
4:编译并运行程序，屏幕上会出现一个白色球在移动
附录：
文件DirectXWnd.h
#if !defined(DIRECTXWND-H)
#define DIRECTXWND_H
//DirectXWnd.h:header file
#include$#@60;ddraw.h$#@62;
#pragma comment (lib,“ddraw。Lib”)//链接时加入ddraw.lib库
class CdirectXWnd: public CWnd
{
//Construction
public:
CDirectXWnd();
//Attributes
public:
BOOL blsActive; //应用程序是否激活
protected:
LPDERECTDRAW lpDD; //DirectDraw对象指针
LPDERECTDRAWSURFACE lpFrontBuffer;//DirectDraw主缓冲区
LPDERECTDRAWSURFACE lpBacdBuffer;//DirectDraw后备缓冲区
int nBufferCount; //后备缓冲区个数
//Operations
protected:
void Msg(LPSTR fmt,...);
public:
BOOL Create(LPCSTR lpszAppName); //创建窗体
//Overrides
virtual BOOL InitializeGame(UINT Gmodex,UINT GmodeY,UINT GBPP);
virtual BOOL CleanSurface();
virtual void UpdateFrame();
virtual BOOL RestoreSurfaces(void);
//{{AFX-VIRTUAL(CdirectXWnd)
//}}AFX_VIRTUAL
//Implementation
public:
virtual~CdirectXWnd();
//Generated message map functions
protected:
//{{AFX-MSG(CderectXWnd)
afx-msg void OnActivateApp(BOOL bActive, HTASK hTask);
//}}AFX-MSG
DECLARE-MESSAGE-MAP()
};
////////////////////////
//{{AFX-INSERT-LOCATION}}
#endif//!defined(DERECTXWND-H)
文件DirectXWnd.CPP
//DirectXWnd.cpp:implementation file
#include”stdafx.h”
#include”DirectX.h”
#include”DirectXWnd.h”
#ifdef-DEUG
#define new DEBUG-NEW
#undef THIS ？FILE
static char THIS ？FILE[]=--FILE--;
#endif
CDirectXWnd::CdirectWXnd()
{
lpDD=NULL;
lpFrontBuffer=NULL;
lpBackBuffer=NULL;
nBufferCount=0;
blsActive=TRUE;
}
CDirectXWnd::~CdirectXWnd()
{
if(lpDD){
CleanSurface();
lpDD-$#@62;Release();
lpDD=NULL;
}
}
BOOL CdirectXWnd::Create(LPCSTR IpszAppName)
{
CString className=AfxRegisterWndClass(CS-DBLCLKS,::LoadCursor(NULL,IDC-ARRWINDOW, className,IpszAppName,
WS-VISIBLE | WS-SYSMENU | WS-POPUP, 0, 0, GetSystemMetrics(SM-CXSCREEN), GetSystemMetrics(SM-CYSCREEN),NULL,NULL));
}
BOOL CdirectXWnd::InitializeGame(UINT GmodeX,UINT GModeY, UINT GBPP)
{
HRESULT ddrval;
ddrval=DirectDrawCreate(NULL,&lpDD,NULL);
if(ddrval!=DD-OK){
Msg(“DirectDrawCreate failed err=%d”, ddrval);
return FALSE;
}
ddral=lpDD-$#@62;SetCooperativeLevel(m-hWnd,DDSCL-EXCLUSIVE | DDSCL-FULLSCREEN);
if(ddrval!=DD-OK){
Msg(“SetCooperativeLevel failed err=%d”,ddrval);
return FALSE;
}
ddrval=lpDD_$#@62;SetDisplayMode(GmodeX,GmodeY,GBPP);
if(ddrval!-DD-OK)
{
Msg(“SetDisplayMode failed err=%d”,ddrval0;
return FALSE;
}
//check capabilites
DDCAPS ddcaps;
ddcaps.dwSize=sizeof(ddcaps);
ddrval=lpDD-$#@62;GetCaps(&ddcaps,NULL);
if(ddrval!=DD-OK){
Msg(“SetDisplayMode failed err=%d”,ddrval);
return FALSE;
}
if(ddcaps.dwCaps&DDCAPS_NOHARDWARE){
Msg(“No hardware support at all”);
}
//default to double buffered on 1mb, triple buffered
if(nBufferCount = =0){
if(ddcaps.dwVidMemTotal$#@60;=1024L*1024L*(GBPP/8)| |
GModeX$#@62;640){
NBufferCount =2;
}
else{
nBufferCount =3
}
}
DDSURFACEDESC ddsd;
: :ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize=sizeof(ddsd);
ddsd.dwFlags=DDSD_CAPS| DDSD_BACKBUFFERCOUNT;
ddsd.ddsCaps.dwCaps=DDSCAPS_PRIMARYSURFACE|
DDSCAPS_FLIP |DDSCAPS_COMPLEX;
ddsd.dwBackBufferCount=nBufferCount_1;
ddrval=lpDD_$#@62;CreateSurface(&ddsd,&lpFrontBuffer,NULL);
if(ddrval !=DD_OK){
Msg(“CreateSurface failed err=%d”,ddrval);
return FALSE;
}
DDSCAPS ddscaps;
ddscaps.dwCaps=DDSCAPS_BACKBUFFER;
ddrval=lpFrontBuffer_$#@62;GetAttachedSurface(&ddscaps,&lpBackBuffer);
if(ddrval !=DD_OK){
Msg(“GetAttachedsurface failed err=%d”,ddrval);
return FALSE;
}
return TRUE;
}
void CdirectXWnd: :Msg(LPSTR FMT, ...)
{
char buff[256];
va_list va;
lstrcpy(buff,”DirectxWnd:”);
va_start(va,fmt);
wvsprintf(&buff[lstrlen(buff)],fmt,va);
va_end(va);
lstrcat(buff,”/r/n”);
AfxMessageBox(buff);
}
//////////////////////////////
//Virtual Function
BOOL CdirectXWnd: :RestoreSurfaces()
{
HRESULT ddrval;
ddrval = lpFrontBuffer_$#@62;Restore();
if(ddrval !=DD_OK)
return FALSE;
return TRUE;
}
BOOL CDirectXWnd: :CleanSurface()
}
if(lpBackBuffer){
lpBackBuffer_$#@62;Release();
lpBackBuffer=NULL;
}
if(lpFrontBuffer){
lpFrontBuffer_$#@62;Release();
lpFrontBuffer=NULL;
}
return TRUE;
}
void CDirectSWnd: :UpdateFrame()
{
}
BEGIN_MESSAGE_MAP(CdirectXWnd,CWnd)
//{{AFX_MSG_MAP(CdirectXWnd)
ON_WM_KEYDOWN()
ON_WM_ACTIVATEAPP()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////
//CDirectXWnd message gandlers
void CDirectXWnd: :OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
switch(nChar)
{
case VK_ESCAPE:
case VK_F12:
PostMessage(WM_CLOSE);
break;
}
CWnd: :OnKeyDown(nChar, nRepCnt, nFlags);
}
void CdirectXWnd: :OnActivateApp(BOOL bActive,HTASK hTask){
CWnd: :OnActivateApp(bActive,hTask);
BlsActive=bActive;
}
--- 当我们提到动态菜单的实现时，我们通常的做法是使用GetMenu() 函数获取一个Cmenu 类指针，然后调用CMenu 类方法AppendMenu, InsertMenu, ModifyMenu, RemoveMenu 等。本文介绍一种更加简洁的方法，它利用MFC 的消息映像机制及CCmdUI 类方法来实现。
---- 首先，我们简要说说VC 中MFC 的消息映像。每个Windows 程序员大概都对以前使用的窗口函数WindowProc 记忆犹新，当我们面对各种消息时，我们别无他方，只能使用庞大而机械的switch-case 语句来实现不同的分支选择。在VC5.0 中使用V4.2 版的MFC 基本类库，你将告别switch-case 语句，代之以透明的消息映像。要在一个类中使用消息映像，在类声明中，必须显式的加入宏DECLARE_MESSAGE_MAP：
class CMyClass: public CBaseClass
{
DECLARE_MESSAGE_MAP()
}
---- 在类实现中，必须使用两个宏BEGIN_MESSAGE_MAP 和END_MESSAGE_MAP，BEGIN_MESSAGE_MAP 带两个参数：当前类和直接父类：
---- BEGIN_MESSAGE_MAP(CMyClass, CBaseClass)
---- // 消息映像项
---- ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
---- // 消息映像项
---- END_MESSAGE_MAP()
---- 消息映像项使用下列基本语法：
---- ON_MessageName(ID, ClassMethod)
---- MessageName 是需要处理的消息，ID 是发送消息的标识符，而ClassMethod 为处理此消息的类方法名。MessageName 是MFC 预定义的，可分为以下三种：
---- 命令消息
---- 子窗口通知消息
---- Windows 消息
---- 共一百多个，用户不必记住它们，因为消息映像可以很简单的利用ClassWizard 加入。处理一个消息的类方法ClassMethod 必须在类定义中声明，且有实现代码。其原型为：
---- Afx_msg return_type ClassMethod(paras table)
---- 类CCmdUI 专门（且仅仅）与ON_UPDATE_COMMAND_UI 消息映像宏配套使用，用于管理菜单（还有工具栏按扭等）的实时状态，如是否变灰，是否加选中标记等。
---- ON_UPDATE_COMMAND_UI 消息映像宏原型为：
---- ON_UPDATE_COMMAND_UI(Menu_Item_ID, Menu_Proc)
---- ON_UPDATE_COMMAND_UI 消息映像宏将一个菜单项（命令项）和一个更新处理过程联结，从而在适当的时机自动调用此更新处理过程来完成对菜单项状态的更新。
---- Menu_Item_ID 为菜单项的ID 号，Menu_Proc 为此菜单项的更新处理函数，? 为：
---- afx_msg void Menu_Proc (CCmdUI* pCmdUI)
---- 它带有一个CCmdUI 类指针，使用它可调用CCmdUI 的类方法。与菜单有关的类方法有：
Enable(BOOL) 使菜单项有效或无效
SetText(LPCTSTR) 设置菜单项的文本
SetCheck(int) 加上或去掉选中标记“X”
SetRadio(BOOL) 加上或去掉选中标记“.”
---- MenuProc 被调用的时机有以下几种情况：
---- 用鼠标选中包含该菜单项的菜单条
---- 用热键选中包含该菜单项的菜单条
---- 用快捷键选中与该菜单项在同一菜单条下的任一菜单项
---- 我们以下面菜单结构为例：
Test menu
Item One ID_ITEM_ONE Ctrl+1
Item Two ID_ITEM_TWO Ctrl+2
Popup Popup One ID_POPUP_ONE Ctrl+3
Popup Two ID_POPUP_TWO Ctrl+4
---- 当用鼠标左键点按Test menu 菜单条或按Alt+t 或按Ctrl+1/2/3/4 时，四个菜单项的更新处理过程MenuProc 都将被调用。
---- 当我们考察上面这个具有嵌套结构的菜单时，我们面临这样一个问题：菜单项Item One/Item Two 的更新函数和Popup One/Popup Two 的更新函数形式上是否一致？当Popup One 和Popup Two 都变灰时Popup 是否自动变灰？
---- 根据MFC 的内部机制，仅仅弹出菜单的第一项应附加一些代码，其余项的形式基本是一致的。也就是说在上例中，除菜单项Popup One 外，其他菜单项更新函数的代码基本一致，即根据条件，简单调用CCmdUI 类方法即可。菜单项Popup One 由于是弹出式菜单Popup 的第一项，它的更新函数在以下两种情况下都会被调用：
---- 当弹出式菜单（Popup）的菜单项（Popup One 和Popup Two）要被绘出时
---- 当此弹出式菜单即Popup 本身要被绘出时
---- 第一种情况很好理解，正如我们选中Test menu 而Item One 和Item Two 的更新函数会自动执行一样。第二种情况其实也很自然，因为Popup 和Item One/Item Two 不一样，它没有ID 号，不能添加消息映像项，那么它的状态如何更新呢？于是它的第一项的更新函数被调用，为了区分是不同的调用，它将CCmdUI 的类成员变量m_pSubMenu 设置为不同的值。在第一种情况下，m_pSubMenu 等于NULL, 第二种情况下，m_pSubMenu 不等于NULL。
---- 以下我们给出一个实际的编程范例。由于篇幅关系，我们仅仅给出一些关键的语句，其余的则一并略去。
---- 在头文件的类声明中：
BOOL m_bItemOne, m_bItemTwo, m_bPopupOne, m_bPopupTwo;
//用于决定各个菜单项的状态
protected:
afx_msg void OnUpdateMenuitemOne(CCmdUI* pCmdUI);
afx_msg void OnUpdateMenuitemTwo(CCmdUI* pCmdUI);
afx_msg void OnUpdatePopupOne(CCmdUI* pCmdUI);
afx_msg void OnUpdatePopupTwo(CCmdUI* pCmdUI);
//各菜单项的更新函数
DECLARE_MESSAGE_MAP()
在源文件中：
BEGIN_MESSAGE_MAP(CMyDoc, CDocument)
ON_UPDATE_COMMAND_UI (ID_ITEM_ONE,
OnUpdateMenuitemOne)
ON_UPDATE_COMMAND_UI (ID_ITEM_TWO,
OnUpdateMenuitemTwo)
ON_UPDATE_COMMAND_UI (ID_POPUP_ONE,
OnUpdatePopupOne)
ON_UPDATE_COMMAND_UI (ID_ POPUP_TWO,
OnUpdatePopupTwo)
END_MESSAGE_MAP()
void CMyApp::OnUpdatetMenuitemOne (CCmdUI* pCmdUI)
{
pCmdUI->Enable(m_bItemOne);
if(m_bItemOne) pCmdUI->SetText("Item One");
else pCmdUI->SetText("Item One is now disabled");
}
void CMyApp::OnUpdatetMenuitemTwo (CCmdUI* pCmdUI)
{
pCmdUI->Enable(m_bItemTwo);
if(m_bItemTwo) pCmdUI->SetText("Item Two");
else pCmdUI->SetText("Item Two is now disabled");
}
void CMyApp::OnUpdatePopupOne(CCmdUI* pCmdUI)
{
if (pCmdUI->m_pSubMenu != NULL)
{
BOOL b_Popup = m_bPopupOne || m_bPopupTwo;
pCmdUI->m_pMenu->EnableMenuItem(pCmdUI->m_nIndex,
MF_BYPOSITION |
(bEnable ? MF_ENABLED :
(MF_DISABLED | MF_GRAYED)));
return;
}
pCmdUI->Enable(m_bPopupOne);
}
void CMyApp::OnUpdatePopupTwo(CCmdUI* pCmdUI)
{
pCmdUI->Enable(m_bPopupTwo);
}