VC添加自定义消息
http://blog.csdn.net/jinnee_cumtb/article/details/4524375VC的ClassWizard不允许增加用户自定义消息，所以你必须手工进行添加。当你添加了自定义的消息以后，ClassWizard就可以像处理其它消息一样处理你定义的消息了。
一、VC6添加自定义消息
1、定义消息。在Windows中，所有的消息都用一个特定的整数值来表示，为了避免自定义消息与已存在的其他消息发生冲突，应该利用Windows提供 的一个常量：WM_USER，小于这个常量的是系统保留的。即用户自定义的消息至少为WM_USER+1，注意最后表示的消息的数值不要超过 0x7FFF。在开发Windows95应用程序时，Microsoft推荐用户自定义消息至少是WM_USER+100，因为很多新控件也要使用 WM_USER消息。
#define UM_PROGRESS WM_USER + 100
2、在类头文件的AFX_MSG块中声明消息处理函数：
class CMainFrame:public CFrameWnd{
protected:
//{{AFX_MSG(CMainFrame)
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
afx_msg void OnTimer(UINT nIDEvent);
afx_msg LRESULT OnProgress(WPARAM wParam, LPARAM lParam);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
3、在类的实现文件中，使用ON_MESSAGE宏指令将消息映射到消息处理表中。
BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
//{{AFX_MSG_MAP(CMainFrame)
ON_WM_CREATE()
ON_WM_TIMER()
ON_MESSAGE(UM_PROGRESS, OnProgress)//注意这条语句的后面没有分号
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
4、实现消息处理函数。该函数使用WPRAM和LPARAM参数并返回LPESULT。
LPESULT CMainFrame::OnProgress(WPARAM wParam,LPARAM lParam){
CRect rect;
m_wndStatusBar.GetItemRect(2,&rect); //获得窗格区域
//创建进度栏，注意第三个参数为CWnd* pParentWnd，根据情况选择父窗体
m_progress.Create(WS_CHILD|WS_VISIBLE|PBS_VERTICAL,rect,this,123);
m_progress.SetPos(50);
return 0;
}
5、在适当的时候发送自定义消息，进行消息处理。需要注意使用SendMessage还是PostMessage进行处理：SendMessage是消息处理完毕后再返回；而PostMessage则是把消息放到消息队列后立即返回。
SendMessage(UM_PROGRESS);
PostMessage(UM_PROGRESS);
如果用户需要整个系统唯一的消息，可以调用SDK函数RegisterWindowMessage并使用ON_REGISTER_MESSAGE宏指令取代ON_MESSAGE宏指令，其余步骤同上。
二、VC2003添加自定义消息
在VC2003中添加自定义消息和VC6基本一致。需要注意的是VC6处理的消息可以没有参数，但VC2003消息处理的函数必须带有两个参数 wParam和lParam，并且其返回值类型为LRESULT。这里，还有另一种方法可以实现地定义消息的处理(VC6和VC2003均适用)：
1、定义消息：#define UM_PROGRESS WM_USER + 100
2、重载CMainFrame的DefWindowProc函数，然后添加对用户自定义消息处理：
LRESULT CMainFrame::DefWindowProc(UINT message, WPARAM wParam,
LPARAM lParam){
switch(message){
case UM_PROGRESS:{
//通过指定资源ID获得相应的索引
int index = m_wndStatusBar.CommandToIndex(IDS_PROGRESS);
CRect rect;
m_wndStatusBar.GetItemRect(index,&rect);
m_progress.Create(WS_CHILD|WS_VISIBLE,rect, &m_wndStatusBar
,123);
m_progress.SetPos(50);
break;
}
default:
break;
}
return CFrameWnd::DefWindowProc(message, wParam, lParam);
}
========
自定义消息
http://www.cnblogs.com/xydblog/archive/2014/02/25/3566266.html一、实现过程
1. 使用宏定义消息ID，例如:
#define WM_OCRRESULT (WM_USER+101)
其中WM_USER为系统消息和用户自定义消息的分界线，小于WM_USER的消息被系统所占用，如：WM_LBUTTONDOWN消息，大于WM_USER的消息为用户自定义消息；
2. 在类声明AFX_MSG块中声明消息响应函数的原型，例如:
afx_msg void OnOcrResult(WPARAM wParam, LPARAM lParam); 函数可以有返回值，也可以无返回值； 函数原型可以有参数，也可以无参数，如果无参数，经常导致在debug下正常运行，release下程序就奔溃了。
复制代码
class CDlgOCRMain : public CDialog
{
protected:
// Generated message map functions
//{{AFX_MSG(CDlgOCRMain)
virtual BOOL OnInitDialog();
afx_msg void OnDestroy();
afx_msg void OnSize(UINT nType, int cx, int cy);
afx_msg BOOL OnEraseBkgnd(CDC *pDC);
afx_msg void OnPaint();
afx_msg void OnOcrResult(WPARAM wParam, LPARAM lParam);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
}
3. 在用户类的消息块中，使用ON_MESSAGE宏指令将消息映射到消
息处理函数中，格式为：ON_MESSAGE(MsgID,MsgFun)
注意：ON_MESSAGE一定要放到AFX_MSG_MAP之后，END_MESSAGE_MAP()之前
BEGIN_MESSAGE_MAP(CDlgOCRMain, CDialog)
//{{AFX_MSG_MAP(CDlgOCRMain)
ON_WM_DESTROY()
ON_WM_SIZE()
ON_WM_ERASEBKGND()
ON_WM_PAINT()
//}}AFX_MSG_MAP
ON_MESSAGE(WM_OCRRESULT, OnOcrResult)
END_MESSAGE_MAP()
4. 实现消息处理函数
void CDlgOCRMain::OnOcrResult(WPARAM wParam, LPARAM lParam)
{
//........................
}
二、自定义消息出错
如果我们消息响应函数原型为: afx_msg void OnXXXX(); 则在经常导致在debug下正常运行，release下程序就奔溃了。
解决方法：
将afx_msg void OnXXXX()改为afx_msg void OnXXXX(WPARAM wParam, LPARAM lParam)；
原因：
当有自定义的消息产生时，系统会调用自定义消息处理函数，系统想当然的认为这个函数有两个参数，分别是WPARAM wParam和LPARAM lParam。系统在调用函数时，会把这两个参数压栈。 然而函数自身并没有参数。在release优化的情况下，在返回上一级函数时，依据的是这个函数的自动变量，参数等信息，于是这两个参数被系统留了下来，也就是说参数仍然保存在栈中，这样就产生了冲突，所以程序就崩溃了。
在debug下，每调用一个函数时，系统会把当前函数在堆栈中的位置保存在一个寄存器中（SP），当函数执行完毕后返回上一级函数时，SP指针返回到函数调用前SP指针指向的位置。也就是说保证了入栈和出栈的一致性。
========
VC/MFC中如何自定义消息
定义一个自定义消息号：const UINT WM_MYMESSAGE = WM_USER + n; // 自定义消息一般大于WM_USER，然后就可以为该消息添加映射了。
afx_msg LRESULT OnMyMessage ( WPARAM wParam, LPARAM lParam );
ON_MESSAGE ( WM_MYMESSAGE, OnMyMessage )
LRESULT cxx::OnMyMessage ( WPARAM wParma, LPARAM lParam )
{
...
}
如果该消息不需要返回值，也不需要参数，那么可以使用宏ON_MESSAGE_VOID来映射
afx_msg void OnMyMessage ();
ON_MESSAGE_VOID ( WM_MYMESSAGE, OnMyMessage )
void cxx::OnMyMessage ()
{
...
}
复杂全面版本：
消息映射、循环机制是Windows程序运行的基本方式。VC++ MFC 中有许多现成的消息句柄，可当我们需要完成其它的任务，需要自定义消息，就遇到了一些困难。在MFC ClassWizard中不允许添加用户自定义消息，所以我们必须在程序中添加相应代码，以便可以象处理其它消息一样处理自定义消息。通常的做法是采取以下步骤:
第一步:定义消息。
推荐用户自定义消息至少是WM_USER+100，因为很多新控件也要使用WM_USER消息。
#define WM_MY_MESSAGE (WM_USER+100)
第二步:实现消息处理函数。该函数使用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();
}
运行程序,在测试菜单打开对话框,点击测试按钮即可看到结果。
========
MFC中自定义消息
http://blog.csdn.net/qihailong123456/article/details/6777112这篇技术文章不是讨论经典的MFC中的消息工作机理的，讨论消息工作原理、方式和路径的文章在网上和书本中
随处可见。网上众多的讨论都是关于如何响应并进行用户自定义消息映射的；网上还有一些文章介绍如何在自定
义类中响应Windows消息，在本文中都简略叙述。但是，网上大部分的文章没用透彻阐述如何在用户自定义类中
响应自定义消息这一通用方法。
问题定义如下：用户自定义一个类，这个类不一定要有界面（完全可以是不可视的），要求自定义的类可以响应
某个自定义消息。
首先能够响应消息的类必须都从CCmdTarget类中派生，因为只有以这个类中提供了消息的框架和处理机制，而
CWnd类也派生与此类。CWinApp类、CDocument类、CDocTemplate类等都是CCmdTarget的派生类，即子类；而
CFrameWnd类、CView类、CDialog类等都是从CWnd中派生的，其实也是CCmdTarget的子孙，所以都能够响应消息
，但是响应消息的种类不太相同。
那么，如果自己定义的类要求响应命令消息（就是WM_COMMAND，也就是一些菜单、工具栏中的消息，包括快捷键
，这类消息处理的机制与其他以WM_开头的消息处理机制不同，它具有一条层次明确的消息流动路径），那么自
定义的类可以从CCmdTarget中派生。由于CWnd窗体类派生于CCmdTarget父类，那么从CWnd中派生的类也可以理所
应当的响应命令消息。这种命令消息无论是往已有的一些诸如CWinApp类中还是自定义的类中添加都是一件非常
容易的事情，只需用向导即可，在此不再叙述。
如果用户自定义的类要求响应普通的Windows消息（也就是以WM_开头，除了WM_COMMAND以外的消息，这类消息在
WM_USER以下的是系统消息，WM_USER以上的可以由用户自己定义），那就要求自定义的类必须从CWnd中派生。这
是由于此类消息的处理机制决定的，这类消息没有命令消息那条繁琐的流动路径，而是消息发出者直接发给对应
CWnd的窗体句柄，由CWnd负责消息的响应。所以这类消息必须同一个CWnd类对应，更精确的说必须与一个HWND类
型的窗体句柄相对应。这样得出一个重要的结论，就是从CCmdTarget中派生而没有从CWnd派生的类没有处理此类
消息的能力。
综上所述，就是为什么命令消息可以放到大部分类中处理，包括CWinThread、CWinApp、CDocument、CView、
CFrameWnd或是自定义的类中，而普通Windows消息和用户自定义的消息只能放到CFrameWnd和CView等派生与CWnd
中的类中处理。
由此可见，我们自定义的类要想响应自定义消息就只能从CWnd中派生（当然不响应任何消息的类可以从CObject
中派生）。先来看看如何自定义消息：
在.h中做的工作：
第一步要声明消息：
#define WM_MYMSG WM_USER+8
第二步要在类声明中声明消息映射：
DECLARE_MESSAGE_MAP()
第三步要在类声明中定义消息处理函数：
afx_msg LRESULT MyMsgHandler(WPARAM,LPARAM);
在.cpp中做的工作：
第四步要实现消息映射:
BEGIN_MESSAGE_MAP(CMainFrame, CMDIFrameWnd)
ON_MESSAGE(WM_MYMSG,OnMyMsgHandler)
END_MESSAGE_MAP()
第五步要实现消息处理函数（当然可以不实现）：
LRESULT CMainFrame::OnMyMsgHandler(WPARAM w,LPARAM l)
{
AfxMessageBox("Hello,World!");
return 0;
}
在引发或发出消息的地方只用写上：
::SendMessge(::AfxGetMainWnd()->m_hWnd,WM_MYMSG,0,0);
到此，自定义消息完毕，这是好多网上文章都写的东西。大家会发现上面代码是在CMainFrame类中实现的，但是
如果要用自定义类，就没有那么简单了。显然把第四步与第五步的CMainFrame换成自定义的类名（这里我用
CMyTestObject来代表自定义类）是不能正常工作的。原因在于在发送消息的SendMessage函数中的第一个参数是
要响应消息对应的HWND类型的窗体句柄，而CMyTestObject类中的m_hWnd中在没有调用CWnd::Create之前是没有
任何意义的，也就是没有调用CWnd::Create或CWnd::CreateEx函数时，CWnd不对应任何窗体，消息处理不能正常
运作。
所以，又一个重要的结论，在自定义类能够处理任何消息之前一定要确保m_hWnd关联到一个窗体，即便这个窗体
是不可见的。那么有人说，在自定义类的构造函数中调用Create函数就行了，不错，当然也可以在别处调用，只
要确保在消息发送之前。但是，Create的调用很有说法，要注意两个地方，第一个参数是类的名称，我建议最好
设为NULL；第五个参数是父窗体对象的指针，这个函数指定的对象一定要存在，我建议最好为整个程序的主窗体
。还有很多人问第六个参数的意义，这个参数关系不大，是子窗体ID，用于传给父窗体记录以便识别。如下是我
的自定义类的构造函数：
CMyTestObject::CMyTestObject()
{
CWnd::Create(NULL,"MyTestObject",WS_CHILD,CRect(0,0,0,0),::AfxGetMainWnd(),1234);
} //一定要在生成主窗体后使用，在主窗体完成OnCreate消息的处理后
CMyTestObject::CMyTestObject(CWnd *pParent)
{
CWnd::Create(NULL,"MyTestObject",WS_CHILD,CRect(0,0,0,0),pParent,1234);
}
不能如下调用Create，因为此时CMyTestObject不关联任何窗体，所以this中的m_hWnd无效：
CWnd::Create(NULL,"MyTestObject",WS_CHILD,CRect(0,0,0,0),this,1234);
这时上面四、五两步修改成：
BEGIN_MESSAGE_MAP(CMyTestObject, CWnd)
ON_MESSAGE(WM_MYMSG，OnMyMsgHandler)
END_MESSAGE_MAP()
LRESULT CMyTestObject::OnMyMsgHandler(WPARAM w,LPARAM l)
{
AfxMessageBox("My Messge Handler in My Self-Custom Class!");
return 0;
}
在类外部发出消息：
CMyTestObject *test=new CMyTestObject();
::SendMessage(test->m_hWnd,WM_MYMSG,0,0);
在类内部某个成员函数（方法）中发出消息：
::SendMessage(m_hWnd,WM_MYMSG,0,0);
最后一个问题便是容易产生警告错误的窗体回收，自定义的类要显式调用窗体销毁，析构函数如下：
CMyTestObject::~CMyTestObject()
{
CWnd::DestroyWindow();
}
========
vc中SendMessage自定义消息函数用法实例
http://www.jb51.net/article/56565.htm这篇文章主要介绍了vc中SendMessage自定义消息函数用法,以实例实行详细讲述了SendMessage的定义、原理与用法,具有一定的实用价值,需要的朋友可以参考下
..本文实例讲述了vc中SendMessage自定义消息函数用法，分享给大家供大家参考。具体如下：
SendMessage的基本结构如下：
复制代码 代码如下:SendMessage(
HWND hWnd, //消息传递的目标窗口或线程的句柄。
UINT Msg, //消息类别（这里可以是一些系统消息，也可以是自己定义，下文具体介绍，）
WPARAM wParam, //参数1 （WPARAM 其实是与UINT是同种类型的，
//在vc编译器中右键有个“转到WPARAM的定义”的选项可以查看。
LPARAM lParam); //参数2
其中一些参数的由来如下：
//typedef unsigned int UINT;
//typedef UINT WPARAM;
//typedef LONG LPARAM;
//typedef LONG LRESULT;
例如可以用以下语句：
复制代码 代码如下:::SendMessage(this->m_hWnd, WM_MY_DOSOME, (WPARAM) 0, (LPARAM) 0);
这里我发送的消息是本窗体接收的，所以句柄用：this->m_hWnd
这里的消息类别WM_MY_DOSOME就是我自定义的，
在接收消息的窗体或线程所在的头文件里：
复制代码 代码如下:#define WM_MY_DOSOME WM_USER+1 // do something
当然你还可以定义更多如：
复制代码 代码如下:#define WM_DOOTHER WM_USER+2 // do other
表示要做一些事情。
到这里，可能大家还是对消息类别有点模糊，不要担心，下面很快就讲到。
我们发了一个消息出去,那么接收方要能识别这个消息是干什么，就是通过消息类别来区分，并且开始去做这个消息对应要处理的事情。如下：
一、编写一个事情：
我们在接收窗体里定义一个这样的事情（过程），
复制代码 代码如下:afx_msg LRESULT DoSomeThing(WPARAM iParam1,LPARAM iParam2)
{
MessageBox("收到消息了，我要开始做一些事情了。","收到",MB_OK);
//可以运用iParam1，iParam2 来做一些事情。
return 0;
}
这个事情有3点大家要注意，非常重要：
1. 使用了afx_msg，并且要将afx_msg LRESULT DoSomeThing(WPARAM iParam1,LPARAM iParam2)
改写到头文件的
//{{AFX_MSG
//。。。改写到这里，颜色会变成灰的。这一点非常重要。
//}}AFX_MSG
2. 参数有2个，WPARAM iParam1,LPARAM iParam2，哪怕没有东西传进来也要写，不然会吃苦头的，vc里不会提醒你少写了一个，
但一些莫名奇妙的事情会发生。
3. 类型用 LRESULT，完了要return 0;
二、让接收方知道什么时候做这个事情：
我们在
复制代码 代码如下://{{AFX_MSG_MAP
//。。。这里写上
ON_MESSAGE(WM_MY_DOSOME,DoSomeThing)
//如果还有其他消息就再写一个
ON_MESSAGE(WM_DOOTHER,DoOther)
//}}AFX_MSG_MAP
到这里，当你用SendMessage，发了一个WM_MY_DOSOME类型的消息过来的时候，接收方就会去做DoSomeThing(WPARAM iParam1,LPARAM iParam2)
发了一个WM_DOOTHER类型的消息过来的时候，接收方就会去做DoOther(WPARAM iParam1,LPARAM iParam2)当然，这里DoOther我还没有定义。
这样就是一个完整的消息发送与接受过程，这里没有详细讲参数，iParam1，因为还没有用到很复杂的情况，
在头文件里：
复制代码 代码如下:#define WM_MYMSG WM_USER+5 //自定义一个消息
afx_msg void OnMyMessage(WPARAM wParam, LPARAM lParam); //自定义消息的处理函数声明
在.cpp文件里：
复制代码 代码如下:ON_MESSAGE(WM_MYMSG, OnMyMessage)
//利用ON_MESSAGE()宏在自定义消息与其处理函数间建立映射关系
void CModelessDlg::OnMyMessage(WPARAM wParam, LPARAM lParam)
//从lParam中取出CString对象的指针,并将字符串内容在IDC_MSGEDIT中显示出来
{
CString *str;
str=(CString *)lParam;
SetDlgItemText(IDC_EDIT,*str);
}
按下按钮发送消息
复制代码 代码如下:void CModelessDlg::OnMsgBTN()
{
CString str= "自定义消息被触发了！";
SendMessage(WM_MYMSG, 0, (LPARAM) &str);
//给ModelessDlg自己发一个自定义的消息
}
希望本文所述对大家的VC程序设计有所帮助。
========