mfc 消息映射的实现-stug1980-ChinaUnix博客

stug1980

首页　| 　博文目录　| 　关于我

stug1980

博客访问： 198327
博文数量： 264
博客积分： 6010
博客等级：准将
技术积分： 2740
用户组：普通用户
注册时间： 2009-06-03 13:25

文章分类

全部博文（264）

未分配的博文（264）

文章存档

2011年（1）

2009年（263）

我的朋友

相关博文

mfc 消息映射的实现

分类： C/C++

2009-06-04 15:04:39

Windows消息概述
　　Windows应用程序的输入由Windows系统以消息的形式发送给应用程序的窗口。这些窗口通过窗口过程来接收和处理消息，然后把控制返还给Windows。0 Q2 J+ r, F! O9 j+ F
　　消息的分类
6 }  g" |- D  i$ j3 g  m' I1 d
　　队列消息和非队列消息 9 Z4 `$ V+ z* j/ T
　　从消息的发送途径上看，消息分两种：队列消息和非队列消息。队列消息送到系统消息队列，然后到线程消息队列；非队列消息直接送给目的窗口过程。
　　这里，对消息队列阐述如下：4 h' b5 u3 u9 g8 `; u
　　Windows维护一个系统消息队列（System message queue），每个GUI线程有一个线程消息队列（Thread message queue）。
　　鼠标、键盘事件由鼠标或键盘驱动程序转换成输入消息并把消息放进系统消息队列，例如WM_MOUSEMOVE、WM_LBUTTONUP、WM_KEYDOWN、WM_CHAR等等。Windows每次从系统消息队列移走一个消息，确定它是送给哪个窗口的和这个窗口是由哪个线程创建的，然后，把它放进窗口创建线程的线程消息队列。线程消息队列接收送给该线程所创建窗口的消息。线程从消息队列取出消息，通过Windows把它送给适当的窗口过程来处理。
　　除了键盘、鼠标消息以外，队列消息还有WM_PAINT、WM_TIMER和WM_QUIT。* u8 W" t  }+ ]% Y6 J0 x
　　这些队列消息以外的绝大多数消息是非队列消息。, T9 P; @0 k* \$ i0 U0 N. a: {
' z+ R) `, P# _& I
　　系统消息和应用程序消息
　　从消息的来源来看，可以分为：系统定义的消息和应用程序定义的消息。' ]' R+ L1 r8 O# I& T3 |# @  u5 E
　　系统消息ID的范围是从0到WM_USER-1，或0X80000到0XBFFFF；应用程序消息从WM_USER（0X0400）到0X7FFF，或0XC000到0XFFFF；WM_USER到0X7FFF范围的消息由应用程序自己使用；0XC000到0XFFFF范围的消息用来和其他应用程序通信，为了ID的唯一性，使用::RegisterWindowMessage来得到该范围的消息ID。
　　消息结构和消息处理
　　消息的结构 $ K$ _; D1 W! G) ?3 g) D
　　为了从消息队列获取消息信息，需要使用MSG结构。例如，::GetMessage函数（从消息队列得到消息并从队列中移走）和:eekMessage函数(从消息队列得到消息但是可以不移走)都使用了该结构来保存获得的消息信息。+ k" L" B: D2 G9 }' V
　　MSG结构的定义如下：* |5 c" t: G- H" D- ?2 a$ A
　　typedef struct tagMSG { // msg
　　HWND hwnd; ! P3 b: u/ L; ~" W  I. n
　　UINT message; ! m  `5 X  Q) O2 j9 R8 W5 K
　　WPARAM wParam;
　　LPARAM lParam;
　　DWORD time;
　　POINT pt;
　　} MSG; , V7 F1 {7 L7 `: U( Y. `+ G9 @
　　该结构包括了六个成员，用来描述消息的有关属性：; |. u1 Z7 F) V* S( m7 d/ y% ]
　　接收消息的窗口句柄、消息标识（ID）、第一个消息参数、第二个消息参数、消息产生的时间、消息产生时鼠标的位置。
& m3 I: X% P! e) C
　　应用程序通过窗口过程来处理消息
　　如前所述，每个“窗口类”都要登记一个如下形式的窗口过程：. b  N# g6 u/ D& P
　　LRESULT CALLBACK MainWndProc (7 C# Y- K3 L+ M% g* s* t6 S
　　HWND hwnd,// 窗口句柄, l8 Z6 Q8 z6 [% x8 m
　　UINT msg,// 消息标识
　　WPARAM wParam,//消息参数1
　　LPARAM lParam//消息参数24 G1 E$ d! k! c5 \9 j
　　)
　　应用程序通过窗口过程来处理消息：非队列消息由Windows直接送给目的窗口的窗口过程，队列消息由:ispatchMessage等派发给目的窗口的窗口过程。窗口过程被调用时，接受四个参数：% M1 s4 ?' R! s; S  x9 k8 t
　　a window handle（窗口句柄）；" e# [% c% r* G( f5 }; w6 ~
　　a message identifier（消息标识）；" `1 R2 g: ~" ]
　　two 32-bit values called message parameters（两个32位的消息参数）；( Z8 W% V3 i- Y/ `$ y' h! Y
　　需要的话，窗口过程用::GetMessageTime获取消息产生的时间，用::GetMessagePos获取消息产生时鼠标光标所在的位置。7 e: D5 h& e) C
　　在窗口过程里，用switch/case分支处理语句来识别和处理消息。0 u3 D7 G8 {9 F; f& M( F

　　应用程序通过消息循环来获得对消息的处理 : {$ G; L+ E( w6 }' t1 t
　　每个GDI应用程序在主窗口创建之后，都会进入消息循环，接受用户输入、解释和处理消息。3 E* l$ F% [% j5 I  G2 b+ J
　　消息循环的结构如下：, A' n9 V) @' u( C* ^
　　while (GetMessage(&msg, (HWND) NULL, 0, 0)) {//从消息队列得到消息4 X1 B5 F, F+ l: ?
　　if (hwndDlgModeless == (HWND) NULL || ! C9 j7 v5 R6 D7 i: b
　　!IsDialogMessage(hwndDlgModeless, &msg) && 9 t  K* b; U3 s) l$ a
　　!TranslateAccelerator(hwndMain, haccel, &msg)) { 4 H9 w$ V& s' E9 ?9 t) G7 |- S( y
　　TranslateMessage(&msg);
　　DispatchMessage(&msg); //发送消息2 \# V+ _8 C' u1 S& b1 R4 X
　　}
　　}
　　消息循环从消息队列中得到消息，如果不是快捷键消息或者对话框消息，就进行消息转换和派发，让目的窗口的窗口过程来处理。% [( U  y- I  t) d; ~& B
　　当得到消息WM_QUIT，或者::GetMessage出错时，退出消息循环。; A) t* d- C. p. l; ]! f
- V+ Q* L+ A* V8 t
　　MFC消息处理
　　使用MFC框架编程时，消息发送和处理的本质也如上所述。但是，有一点需要强调的是，所有的MFC窗口都使用同一窗口过程，程序员不必去设计和实现自己的窗口过程，而是通过MFC提供的一套消息映射机制来处理消息。因此，MFC简化了程序员编程时处理消息的复杂性。
　　所谓消息映射，简单地讲，就是让程序员指定要某个MFC类（有消息处理能力的类）处理某个消息。MFC提供了工具ClassWizard来帮助实现消息映射，在处理消息的类中添加一些有关消息映射的内容和处理消息的成员函数。程序员将完成消息处理函数，实现所希望的消息处理能力。- {& z9 h4 J& V  N3 n
　　如果派生类要覆盖基类的消息处理函数，就用ClassWizard在派生类中添加一个消息映射条目，用同样的原型定义一个函数，然后实现该函数。这个函数覆盖派生类的任何基类的同名处理函数。
　　下面几节将分析MFC的消息机制的实现原理和消息处理的过程。为此，首先要分析ClassWizard实现消息映射的内幕，然后讨论MFC的窗口过程，分析MFC窗口过程是如何实现消息处理的。
　　消息映射的定义和实现 : o& S* `* A" j8 K
　　MFC处理的三类消息 / d8 ^5 c' B0 Q  d
. E1 ^! {* x1 d' a+ C/ d" b' m2 {
　　根据处理函数和处理过程的不同，MFC主要处理三类消息：& G7 C: ~" A( M3 Z; T! ^
　　Windows消息，前缀以“WM_”打头，WM_COMMAND例外。Windows消息直接送给MFC窗口过程处理，窗口过程调用对应的消息处理函数。一般，由窗口对象来处理这类消息，也就是说，这类消息处理函数一般是MFC窗口类的成员函数。 8 Y) I6 v$ |* ?
　　控制通知消息，是控制子窗口送给父窗口的WM_COMMAND通知消息。窗口过程调用对应的消息处理函数。一般，由窗口对象来处理这类消息，也就是说，这类消息处理函数一般是MFC窗口类的成员函数。 ' S' B/ R& ]) W+ a9 s( E
　　需要指出的是，Win32使用新的WM_NOFITY来处理复杂的通知消息。WM_COMMAND类型的通知消息仅仅能传递一个控制窗口句柄(lparam)、控制窗ID和通知代码(wparam)。WM_NOTIFY能传递任意复杂的信息。7 h7 J; J# A- Z/ x' ^
　　命令消息，这是来自菜单、工具条按钮、加速键等用户接口对象的WM_COMMAND通知消息，属于应用程序自己定义的消息。通过消息映射机制，MFC 框架把命令按一定的路径分发给多种类型的对象（具备消息处理能力）处理，如文档、窗口、应用程序、文档模板等对象。能处理消息映射的类必须从 CCmdTarget类派生。
　　在讨论了消息的分类之后，应该是讨论各类消息如何处理的时候了。但是，要知道怎么处理消息，首先要知道如何映射消息。+ d: j7 H9 a4 M' j' _0 |% V3 l; i
　　MFC消息映射的实现方法 # _% |7 {8 l, ^$ x2 A
　　MFC使用ClassWizard帮助实现消息映射，它在源码中添加一些消息映射的内容，并声明和实现消息处理函数。现在来分析这些被添加的内容。1 q" Q5 g* h, ?& @) ]6 T2 i! o* K
　　在类的定义（头文件）里，它增加了消息处理函数声明，并添加一行声明消息映射的宏DECLARE_MESSAGE_MAP。
　　在类的实现（实现文件）里，实现消息处理函数，并使用IMPLEMENT_MESSAGE_MAP宏实现消息映射。一般情况下，这些声明和实现是由MFC的ClassWizard自动来维护的。看一个例子：
　　在AppWizard产生的应用程序类的源码中，应用程序类的定义（头文件）包含了类似如下的代码：; o+ r$ I  P/ ~+ |) ?
　　//{{AFX_MSG(CTttApp)
　　afx_msg void OnAppAbout();
　　//}}AFX_MSG6 m1 x4 x8 D6 Z9 A8 }5 x( s
　　DECLARE_MESSAGE_MAP()6 Q3 H6 D2 {$ {2 h8 _; L
　　应用程序类的实现文件中包含了类似如下的代码：
　　BEGIN_MESSAGE_MAP(CTApp, CWinApp)) c" j( [2 M: i# Y
　　//{{AFX_MSG_MAP(CTttApp)
　　ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
　　//}}AFX_MSG_MAP
　　END_MESSAGE_MAP()- ?4 M5 p: `4 e" m* p
　　头文件里是消息映射和消息处理函数的声明，实现文件里是消息映射的实现和消息处理函数的实现。它表示让应用程序对象处理命令消息ID_APP_ABOUT，消息处理函数是OnAppAbout。
　　为什么这样做之后就完成了一个消息映射？这些声明和实现到底作了些什么呢？接着，将讨论这些问题。. Q# @) c+ c* N! z1 @% s* ?

　　在声明与实现的内部 1 J- ?0 k! w% t
　　DECLARE_MESSAGE_MAP宏：
　　首先，看DECLARE_MESSAGE_MAP宏的内容：
　　#ifdef _AFXDLL
　　#define DECLARE_MESSAGE_MAP() 0 ^1 J5 p$ P  {' a( U0 x9 F3 Y
　　private:
　　static const AFX_MSGMAP_ENTRY _messageEntries[];
　　protected:
　　static AFX_DATA const AFX_MSGMAP messageMap;
　　static const AFX_MSGMAP* PASCAL _GetBaseMessageMap();
　　virtual const AFX_MSGMAP* GetMessageMap() const; 9 v) ]5 S  k: D# t1 X+ w
　　#else
　　#define DECLARE_MESSAGE_MAP() ; a3 l$ c: w& X. X/ b: Y
　　private: ! l! d+ L3 I! u" `8 Y; y) S; V
　　static const AFX_MSGMAP_ENTRY _messageEntries[]; % L0 m3 c" V$ G- d2 p9 {7 k$ b) i
　　protected:
　　static AFX_DATA const AFX_MSGMAP messageMap;   }$ X: u. ?& E" x
　　virtual const AFX_MSGMAP* GetMessageMap() const; . r6 e: v1 F/ [7 h# a
　　#endif+ Z7 A4 n/ S% X) L
　　DECLARE_MESSAGE_MAP定义了两个版本，分别用于静态或者动态链接到MFC DLL的情形。

　　BEGIN_MESSAE_MAP宏 ! u+ q+ W0 k& i0 p  R  T
　　然后，看BEGIN_MESSAE_MAP宏的内容：
　　#ifdef _AFXDLL
　　#define BEGIN_MESSAGE_MAP(theClass, baseClass)
　　const AFX_MSGMAP* PASCAL theClass::_GetBaseMessageMap()
　　{ return &baseClass::messageMap; }
　　const AFX_MSGMAP* theClass::GetMessageMap() const
　　{ return &theClass::messageMap; } ! q' ?7 J& B5 j
　　AFX_DATADEF const AFX_MSGMAP theClass::messageMap =
　　{ &theClass::_GetBaseMessageMap, &theClass::_messageEntries[0] }; 5 G, i  W! x! d" U
　　const AFX_MSGMAP_ENTRY theClass::_messageEntries[] = . k% D, `2 E4 w( {' D( m
　　{ 6 U' T' N' Q) A! D+ _# T3 w
　　#else4 I  N4 k8 H6 Z( i) q8 `
　　#define BEGIN_MESSAGE_MAP(theClass, baseClass)
　　const AFX_MSGMAP* theClass::GetMessageMap() const 2 c' F8 N0 M0 s, @* R
　　{ return &theClass::messageMap; }
　　AFX_DATADEF const AFX_MSGMAP theClass::messageMap = , [! ?: K3 ]. ~; R( U
　　{ &baseClass::messageMap, &theClass::_messageEntries[0] };
　　const AFX_MSGMAP_ENTRY theClass::_messageEntries[] = / e$ c/ U; f% H! w8 ?/ P- d" _
　　{ 1 W) _* H. l' v3 c; ]8 |9 ]$ [- P8 g
　　#endif
　　#define END_MESSAGE_MAP() 6 E- F- t) d- Z1 a9 @# S; {
　　{0, 0, 0, 0, AfxSig_end, (AFX_PMSG)0 } 4 r* M! K+ r) k2 \( w8 a
　　}; # C. V" z9 a7 T6 p3 @0 k
　　对应地，BEGIN_MESSAGE_MAP定义了两个版本，分别用于静态或者动态链接到MFC DLL的情形。END_MESSAGE_MAP相对简单，就只有一种定义。

　　ON_COMMAND宏
　　最后，看ON_COMMAND宏的内容：
　　#define ON_COMMAND(id, memberFxn) , I* O7 N) o+ s( E; a6 T, z+ G
　　{. h6 T# A7 e& x0 @( b6 o* C8 g( T
　　WM_COMMAND,
　　CN_COMMAND,4 n5 O/ Z5 _( A% m: q6 F& w2 h$ j
　　(WORD)id,$ S! e, ~- u7 z* [
　　(WORD)id,
　　AfxSig_vv,) `1 ^( c+ I8 c6 [3 F  B5 w* X9 O
　　(AFX_PMSG)memberFxn
　　}；5 J0 a5 ~4 Y8 x, M) o; F+ `7 z
　　消息映射声明的解释 ' z$ B, o9 X& C8 g9 K6 u& ]. E" c
　　在清楚了有关宏的定义之后，现在来分析它们的作用和功能。
　　消息映射声明的实质是给所在类添加几个静态成员变量和静态或虚拟函数，当然它们是与消息映射相关的变量和函数。
　　成员变量 ' F8 T% E6 J. ~: l5 x0 F/ w+ _6 |) N7 @
　　有两个成员变量被添加，第一个是_messageEntries，第二个是messageMap。/ W( H; h- E9 \0 I7 ?5 r
　　第一个成员变量的声明：
　　AFX_MSGMAP_ENTRY _messageEntries[]5 |% {+ E0 F6 G# `' M& ^; W
　　这是一个AFX_MSGMAP_ENTRY 类型的数组变量，是一个静态成员变量，用来容纳类的消息映射条目。一个消息映射条目可以用AFX_MSGMAP_ENTRY结构来描述。8 ^* |7 e1 e" I& n8 R6 d
　　AFX_MSGMAP_ENTRY结构的定义如下：/ P4 x0 \" U1 x! d2 p! j
　　struct AFX_MSGMAP_ENTRY
　　{, |$ H+ A7 n# L( g+ Z5 p0 A
　　//Windows消息ID
　　UINT nMessage;
　　//控制消息的通知码% v; L/ d# [/ Y% V" z; P" p
　　UINT nCode;
　　//Windows Control的ID% F6 W" W3 c" y# e3 N0 j/ g9 Q: P
　　UINT nID;  u3 p1 ?) j+ Z: H" n
　　//如果是一定范围的消息被映射，则nLastID指定其范围0 L+ N0 {/ ^6 T$ ^7 c; P1 x$ b
　　UINT nLastID;
　　UINT nSig;//消息的动作标识: S" V. u+ N! j
　　//响应消息时应执行的函数(routine to call (or special value))! ?- k. t- L( p% A# N: L
　　AFX_PMSG pfn;
　　};
　　从上述结构可以看出，每条映射有两部分的内容：第一部分是关于消息ID的，包括前四个域；第二部分是关于消息对应的执行函数，包括后两个域。
　　在上述结构的六个域中，pfn是一个指向CCmdTarger成员函数的指针。函数指针的类型定义如下：
　　typedef void (AFX_MSG_CALL CCmdTarget::*AFX_PMSG)(void);
　　当使用一条或者多条消息映射条目初始化消息映射数组时，各种不同类型的消息函数都被转换成这样的类型：不接收参数，也不返回参数的类型。因为所有可以有消息映射的类都是从CCmdTarge派生的，所以可以实现这样的转换。
　　nSig是一个标识变量，用来标识不同原型的消息处理函数，每一个不同原型的消息处理函数对应一个不同的nSig。在消息分发时，MFC内部根据nSig把消息派发给对应的成员函数处理，实际上，就是根据nSig的值把pfn还原成相应类型的消息处理函数并执行它。
　　第二个成员变量的声明 / i+ f0 p6 i0 o9 g
　　AFX_MSGMAP messageMap;
　　这是一个AFX_MSGMAP类型的静态成员变量，从其类型名称和变量名称可以猜出，它是一个包含了消息映射信息的变量。的确，它把消息映射的信息（消息映射数组）和相关函数打包在一起，也就是说，得到了一个消息处理类的该变量，就得到了它全部的消息映射数据和功能。AFX_MSGMAP结构的定义如下：
　　struct AFX_MSGMAP
　　{& p5 b! z3 x" s+ o! [5 f
　　//得到基类的消息映射入口地址的数据或者函数( m8 I& T6 ~' N0 R) s; C
　　#ifdef _AFXDLL- D" y: r2 C5 Q4 u( ~  g: [/ ?0 C
　　//pfnGetBaseMap指向_GetBaseMessageMap函数* W% v( z( ~0 L6 A5 Y3 L3 K9 k
　　const AFX_MSGMAP* (PASCAL* pfnGetBaseMap)();/ \  w0 [) B' v+ D5 l
　　#else
　　//pBaseMap保存基类消息映射入口_messageEntries的地址" S  n( |( ]# k5 y& W. l
　　const AFX_MSGMAP* pBaseMap;
　　#endif& ^2 g% A% O( `8 E) q
　　//lpEntries保存消息映射入口_messageEntries的地址2 O% B, Q9 ]9 r: {
　　const AFX_MSGMAP_ENTRY* lpEntries;
　　};
　　从上面的定义可以看出，通过messageMap可以得到类的消息映射数组_messageEntries和函数_GetBaseMessageMap的地址（不使用MFC DLL时，是基类消息映射数组的地址）。0 t# P, J: D' }% p
　　成员函数 / J& x+ h' b& {+ `
　　_GetBaseMessageMap()
　　用来得到基类消息映射的函数。* C; @% F# Z5 I: f* L! r$ e5 S
　　GetMessageMap()
　　用来得到自身消息映射的函数。5 u6 K% A4 |7 m7 g" X- _
　　消息映射实现的解释
　　消息映射实现的实质是初始化声明中定义的静态成员函数_messageEntries和messageMap，实现所声明的静态或虚拟函数GetMessageMap、_GetBaseMessageMap。4 H8 W8 ?# u4 p' J8 P- T8 u
　　这样，在进入WinMain函数之前，每个可以响应消息的MFC类都生成了一个消息映射表，程序运行时通过查询该表判断是否需要响应某条消息。" V9 i9 l) L9 [
　　对消息映射入口表(消息映射数组)的初始化 2 A" s- V" A" R" |
　　如前所述，消息映射数组的元素是消息映射条目，条目的格式符合结构AFX_MESSAGE_ENTRY的描述。所以，要初始化消息映射数组，就必须使用符合该格式的数据来填充：如果指定当前类处理某个消息，则把和该消息有关的信息（四个）和消息处理函数的地址及原型组合成为一个消息映射条目，加入到消息映射数组中。
　　显然，这是一个繁琐的工作。为了简化操作，MFC根据消息的不同和消息处理方式的不同，把消息映射划分成若干类别，每一类的消息映射至少有一个共性：消息处理函数的原型相同。对每一类消息映射，MFC定义了一个宏来简化初始化消息数组的工作。例如，前文提到的ON_COMMAND宏用来映射命令消息，只要指定命令ID和消息处理函数即可，因为对这类命令消息映射条目，其他四个属性都是固定的。ON_COMMAND宏的初始化内容如下：- t# e, B# n9 k2 y$ M7 M
　　{WM_COMMAND,4 K. d4 `# A. X6 r
　　CN_COMMAND,
　　(WORD)ID_APP_ABOUT,% b$ J8 h# Y7 S5 m; H+ ^: \
　　(WORD)ID_APP_ABOUT,' Z) v, G; P; o; F
　　AfxSig_vv,
　　(AFX_PMSG)OnAppAbout
　　}
　　这个消息映射条目的含义是：消息ID是ID_APP_ABOUT，OnAppAbout被转换成AFX_PMSG指针类型，AfxSig_vv是MFC预定义的枚举变量，用来标识OnAppAbout的函数类型为参数空(Void)、返回空(Void)。
　　在消息映射数组的最后，是宏END_MESSAGE_MAP的内容，它标识消息处理类的消息映射条目的终止。
$ O' p; Z0 ?- H' E% k
　　对messageMap的初始化
　　如前所述，messageMap的类型是AFX_MESSMAP。
　　经过初始化，域lpEntries保存了消息映射数组_messageEntries的地址；如果动态链接到MFC DLL，则pfnGetBaseMap保存了_GetBaseMessageMap成员函数的地址；否则pBaseMap保存了基类的消息映射数组的地址。
7 @$ B8 X9 ]- y  J. J2 }0 d
　　对函数的实现 3 \0 l  ]: V) v
　　_GetBaseMessageMap()
　　它返回基类的成员变量messagMap（当使用MFC DLL时），使用该函数得到基类消息映射入口表。
　　GetMessageMap()：1 E7 F3 w1 @" \+ e0 U" @1 q5 C
　　它返回成员变量messageMap，使用该函数得到自身消息映射入口表。- l3 E! W. W  m
　　顺便说一下，消息映射类的基类CCmdTarget也实现了上述和消息映射相关的函数，不过，它的消息映射数组是空的。
　　既然消息映射宏方便了消息映射的实现，那么有必要详细的讨论消息映射宏。下一节，介绍消息映射宏的分类、用法和用途。
　　消息映射宏的种类
　　为了简化程序员的工作，MFC定义了一系列的消息映射宏和像AfxSig_vv这样的枚举变量，以及标准消息处理函数，并且具体地实现这些函数。这里主要讨论消息映射宏，常用的分为以下几类。
　　用于Windows消息的宏，前缀为“ON_WM_”。 8 j+ j4 P- L& H" ~
　　这样的宏不带参数，因为它对应的消息和消息处理函数的函数名称、函数原型是确定的。MFC提供了这类消息处理函数的定义和缺省实现。每个这样的宏处理不同的Windows消息。3 R* X  }7 s( u9 Q% ]  O" n! o, R7 ^
　　例如：宏ON_WM_CREATE()把消息WM_CREATE映射到OnCreate函数，消息映射条目的第一个成员nMessage指定为要处理的Windows消息的ID，第二个成员nCode指定为0。$ G8 H7 z" y1 u9 r8 u5 x, t! T4 y
5 _; g; E. ]7 H
　　用于命令消息的宏ON_COMMAND + O6 d% k; t$ V! L, t
　　这类宏带有参数，需要通过参数指定命令ID和消息处理函数。这些消息都映射到WM_COMMAND上，也就是将消息映射条目的第一个成员 nMessage指定为WM_COMMAND，第二个成员nCode指定为CN_COMMAND(即0)。消息处理函数的原型是void (void)，不带参数，不返回值。
　　除了单条命令消息的映射，还有把一定范围的命令消息映射到一个消息处理函数的映射宏ON_COMMAND_RANGE。这类宏带有参数，需要指定命令ID的范围和消息处理函数。这些消息都映射到WM_COMMAND上，也就是将消息映射条目的第一个成员nMessage指定为WM_COMMAND，第二个成员nCode指定为CN_COMMAND(即0)，第三个成员nID和第四个成员nLastID指定了映射消息的起止范围。消息处理函数的原型是void (UINT)，有一个UINT类型的参数，表示要处理的命令消息ID，不返回值。
　　（3）用于控制通知消息的宏( G' e2 |9 o* r
　　这类宏可能带有三个参数，如ON_CONTROL，就需要指定控制窗口ID，通知码和消息处理函数；也可能带有两个参数，如具体处理特定通知消息的宏 ON_BN_CLICKED、ON_LBN_DBLCLK、ON_CBN_EDITCHANGE等，需要指定控制窗口ID和消息处理函数。5 Z5 }# \* D0 P3 F, J9 E$ j! }
　　控制通知消息也被映射到WM_COMMAND上，也就是将消息映射条目的第一个成员的nMessage指定为WM_COMMAND，但是第二个成员 nCode是特定的通知码，第三个成员nID是控制子窗口的ID，第四个成员nLastID等于第三个成员的值。消息处理函数的原型是void (void)，没有参数，不返回值。
　　还有一类宏处理通知消息 ON_NOTIFY，它类似于ON_CONTROL，但是控制通知消息被映射到WM_NOTIFY。消息映射条目的第一个成员的nMessage被指定为 WM_NOTIFY，第二个成员nCode是特定的通知码，第三个成员nID是控制子窗口的ID，第四个成员nLastID等于第三个成员的值。消息处理函数的原型是void (NMHDR*, LRESULT*)，参数1是NMHDR指针，参数2是LRESULT指针，用于返回结果，但函数不返回值。9 Q* q  q7 d8 D* K7 ~( B
　　对应地，还有把一定范围的控制子窗口的某个通知消息映射到一个消息处理函数的映射宏，这类宏包括ON__CONTROL_RANGE和ON_NOTIFY_RANGE。这类宏带有参数，需要指定控制子窗口ID的范围和通知消息，以及消息处理函数。
　　对于 ON__CONTROL_RANGE，是将消息映射条目的第一个成员的nMessage指定为WM_COMMAND，但是第二个成员nCode是特定的通知码，第三个成员nID和第四个成员nLastID等于指定了控制窗口ID的范围。消息处理函数的原型是void (UINT)，参数表示要处理的通知消息是哪个ID的控制子窗口发送的，函数不返回值。" L9 z* ]7 N$ ]2 M8 W1 Z4 E
　　对于ON__NOTIFY_RANGE，消息映射条目的第一个成员的nMessage被指定为WM_NOTIFY，第二个成员nCode是特定的通知码，第三个成员nID和第四个成员nLastID指定了控制窗口ID的范围。消息处理函数的原型是void (UINT, NMHDR*, LRESULT*)，参数1表示要处理的通知消息是哪个ID的控制子窗口发送的，参数2是NMHDR指针，参数3是LRESULT指针，用于返回结果，但函数不返回值。
　　（4）用于用户界面接口状态更新的ON_UPDATE_COMMAND_UI宏
　　这类宏被映射到消息 WM_COMMND上，带有两个参数，需要指定用户接口对象ID和消息处理函数。消息映射条目的第一个成员nMessage被指定为 WM_COMMAND，第二个成员nCode被指定为-1，第三个成员nID和第四个成员nLastID都指定为用户接口对象ID。消息处理函数的原型是 void (CCmdUI*)，参数指向一个CCmdUI对象，不返回值。; K8 t5 n8 d5 j7 i9 Y. }5 c
　　对应地，有更新一定ID范围的用户接口对象的宏ON_UPDATE_COMMAND_UI_RANGE，此宏带有三个参数，用于指定用户接口对象ID 的范围和消息处理函数。消息映射条目的第一个成员nMessage被指定为WM_COMMAND，第二个成员nCode被指定为-1，第三个成员nID和第四个成员nLastID用于指定用户接口对象ID的范围。消息处理函数的原型是 void (CCmdUI*)，参数指向一个CCmdUI对象，函数不返回值。之所以不用当前用户接口对象ID作为参数，是因为CCmdUI对象包含了有关信息。
　　（5）用于其他消息的宏$ k, O! A: [/ i# v/ E3 G- P
　　例如用于用户定义消息的ON_MESSAGE。这类宏带有参数，需要指定消息ID和消息处理函数。消息映射条目的第一个成员nMessage被指定为消息ID，第二个成员nCode被指定为0，第三个成员nID和第四个成员也是0。消息处理的原型是LRESULT (WPARAM, LPARAM)，参数1和参数2是消息参数wParam和lParam，返回LRESULT类型的值。
　　（6）扩展消息映射宏! j% w2 z0 g( Q- S! \# _6 ^; S0 [
　　很多普通消息映射宏都有对应的扩展消息映射宏，例如：ON_COMMAND对应的ON_COMMAND_EX，ON_ONTIFY对应的ON_ONTIFY_EX，等等。扩展宏除了具有普通宏的功能，还有特别的用途。关于扩展宏的具体讨论和分析，见4.4.3.2节。
　　作为一个总结，下表列出了这些常用的消息映射宏。
　　表4-1 常用的消息映射宏* h7 _% S! C) G+ v' P* ?5 h5 n
# P. F" l: N  D, s
　　消息映射宏 ) d8 j6 G% W; _& B; A

　　用途

　　ON_COMMAND
" u0 P5 M$ K$ A/ {/ s% [
　　把command message映射到相应的函数

　　ON_CONTROL

　　把control notification message映射到相应的函数。MFC根据不同的控制消息，在此基础上定义了更具体的宏，这样用户在使用时就不需要指定通知代码ID，如ON_BN_CLICKED。
1 R0 q0 A. {' ]) m
　　ON_MESSAGE

　　把user-defined message.映射到相应的函数 : @: Z) e. s+ Q% ^% w* [0 |- p3 u
! K; @- M$ X" z, G5 u
　　ON_REGISTERED_MESSAGE . `2 q) f' y, D! z1 ~  h. T8 {

　　把registered user-defined message映射到相应的函数，实际上nMessage等于0x0C000，nSig等于宏的消息参数。nSig的真实值为Afxsig_lwl。 + B+ x9 Q. u8 W
; l! z# Z% f) M
　　ON_UPDATE_COMMAND_UI 5 T  a" M+ j( |9 _

　　把user interface user update command message映射到相应的函数上。
; C6 \  z* ]0 D2 @% b. Q$ k
　　ON_COMMAND_RANGE 3 V$ p7 c; K  X8 _: D, T: e/ z

　　把一定范围内的command IDs 映射到相应的函数上
$ l6 Q  ~6 J6 v* l+ m' a1 t
　　ON_UPDATE_COMMAND_UI_RANGE
; a9 }1 _. u( n4 L
　　把一定范围内的user interface user update command message映射到相应的函数上

　　ON_CONTROL_RANGE
" G# X6 v0 L9 g
　　把一定范围内的control notification message映射到相应的函数上
　　在表4-1中，宏ON_REGISTERED_MESSAGE的定义如下：# D- X' u- E  ?0 E1 {0 N7 T
　　#define ON_REGISTERED_MESSAGE(nMessageVariable, memberFxn)
　　{ 0xC000, 0, 0, 0,
　　(UINT)(UINT*)(&nMessageVariable), 2 l* W  Y8 R( ]9 m# m6 t8 {
　　/*implied 'AfxSig_lwl'*/ . d" A% j4 e" c
　　(AFX_PMSG)(AFX_PMSGW)(LRESULT
　　(AFX_MSG_CALL CWnd::*)
　　(WPARAM, LPARAM))&memberFxn }
　　从上面的定义可以看出，实际上，该消息被映射到WM_COMMAND(0XC000)，指定的registered消息ID存放在nSig域内，nSig的值在这样的映射条目下隐含地定为AfxSig_lwl。由于ID和正常的nSig域存放的值范围不同，所以MFC可以判断出是否是registered消息映射条目。如果是，则使用AfxSig_lwl把消息处理函数转换成参数1为Word、参数2为long、返回值为long的类型。
　　在介绍完了消息映射的内幕之后，应该讨论消息处理过程了。由于CCmdTarge的特殊性和重要性，在4.3节先对其作一个大略的介绍。* N8 J; }* }8 w6 N- Y3 f5 |( A* P% V
　　CcmdTarget类
　　除了CObject类外，还有一个非常重要的类CCmdTarget。所有响应消息或事件的类都从它派生。例如，CWinapp，CWnd，CDocument，CView，CDocTemplate，CFrameWnd，等等。! l6 T7 Z( m/ f; `
　　CCmdTarget类是MFC处理命令消息的基础、核心。MFC为该类设计了许多成员函数和一些成员数据，基本上是为了解决消息映射问题的，而且，很大一部分是针对OLE设计的。在OLE应用中，CCmdTarget是MFC处理模块状态的重要环节，它起到了传递模块状态的作用：其构造函数获取当前模块状态，并保存在成员变量m_pModuleState里头。关于模块状态，在后面章节讲述。
　　CCmdTarget有两个与消息映射有密切关系的成员函数：DispatchCmdMsg和OnCmdMsg。
　　静态成员函数DispatchCmdMsg ! Q  v3 q* a7 s4 K& m
　　CCmdTarget的静态成员函数DispatchCmdMsg，用来分发Windows消息。此函数是MFC内部使用的，其原型如下：) q: Z7 m7 ?& P! p
　　static BOOL DispatchCmdMsg(5 @+ V  {5 B3 Q! T8 U
　　CCmdTarget* pTarget,
　　UINT nID,
　　int nCode,
　　AFX_PMSG pfn,
　　void* pExtra,$ x8 S0 u3 B+ s4 v
　　UINT nSig,
　　AFX_CMDHANDLERINFO* pHandlerInfo)
　　关于此函数将在4.4.3.2章节命令消息的处理中作更详细的描述。! z! X0 h2 N# J; _* O
4 y' X0 L" O, z) U3 i" g1 `! f
　　虚拟函数OnCmdMsg
　　CCmdTarget的虚拟函数OnCmdMsg，用来传递和发送消息、更新用户界面对象的状态，其原型如下：2 T5 M% \3 f: N! j4 m
　　OnCmdMsg(; r/ e8 R: J; K; [; c4 o
　　UINT nID,
　　int nCode,
　　void* pExtra,
　　AFX_CMDHANDLERINFO* pHandlerInfo)
　　框架的命令消息传递机制主要是通过该函数来实现的。其参数描述参见4.3.3.2章节DispacthCMdMessage的参数描述。
　　在本书中，命令目标指希望或者可能处理消息的对象；命令目标类指命令目标的类。
　　CCmdTarget对OnCmdMsg的默认实现：在当前命令目标(this所指)的类和基类的消息映射数组里搜索指定命令消息的消息处理函数（标准Windows消息不会送到这里处理）。2 K' H) t) l6 R9 _7 a
　　这里使用虚拟函数GetMessageMap得到命令目标类的消息映射入口数组_messageEntries，然后在数组里匹配指定的消息映射条目。匹配标准：命令消息ID相同，控制通知代码相同。因为GetMessageMap是虚拟函数，所以可以确认当前命令目标的确切类。
　　如果找到了一个匹配的消息映射条目，则使用DispachCmdMsg调用这个处理函数；; e( S9 G* y" {- L
　　如果没有找到，则使用_GetBaseMessageMap得到基类的消息映射数组，查找，直到找到或搜寻了所有的基类（到CCmdTarget）为止；
　　如果最后没有找到，则返回FASLE。
　　每个从 CCmdTarget派生的命令目标类都可以覆盖OnCmdMsg，利用它来确定是否可以处理某条命令，如果不能，就通过调用下一命令目标的 OnCmdMsg，把该命令送给下一个命令目标处理。通常，派生类覆盖OnCmdMsg时，要调用基类的被覆盖的OnCmdMsg。
　　在MFC框架中，一些MFC命令目标类覆盖了OnCmdMsg，如框架窗口类覆盖了该函数，实现了MFC的标准命令消息发送路径。具体实现见后续章节。1 ^8 o. ^; {8 o; l
　　必要的话，应用程序也可以覆盖OnCmdMsg，改变一个或多个类中的发送规定，实现与标准框架发送规定不同的发送路径。例如，在以下情况可以作这样的处理：在要打断发送顺序的类中把命令传给一个非MFC默认对象；在新的非默认对象中或在可能要传出命令的命令目标中。3 |' c; j9 |+ Y$ N' @+ `
　　本节对CCmdTarget的两个成员函数作一些讨论，是为了对MFC的消息处理有一个大致印象。后面4.4.3.2节和4.4.3.3节将作进一步的讨论。2 a" Y- l2 T$ W1 Z; O4 z
　　MFC窗口过程 $ M4 H$ q) Z! u; A2 h4 g& l
　　前文曾经提到，所有的消息都送给窗口过程处理，MFC的所有窗口都使用同一窗口过程，消息或者直接由窗口过程调用相应的消息处理函数处理，或者按MFC命令消息派发路径送给指定的命令目标处理。& w" _1 t2 ]5 [) X7 w6 X4 P; c
　　那么，MFC的窗口过程是什么？怎么处理标准Windows消息？怎么实现命令消息的派发？这些都将是下文要回答的问题。" ~' Z+ ~: X  V  ]& A
　　MFC窗口过程的指定
　　从前面的讨论可知，每一个“窗口类”都有自己的窗口过程。正常情况下使用该“窗口类”创建的窗口都使用它的窗口过程。
　　MFC的窗口对象在创建HWND窗口时，也使用了已经注册的“窗口类”，这些“窗口类”或者使用应用程序提供的窗口过程，或者使用Windows提供的窗口过程（例如 Windows控制窗口、对话框等）。那么，为什么说MFC创建的所有HWND窗口使用同一个窗口过程呢？
　　在MFC中，的确所有的窗口都使用同一个窗口过程：AfxWndProc或AfxWndProcBase（如果定义了_AFXDLL）。它们的原型如下：
　　LRESULT CALLBACK
　　AfxWndProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)6 J4 B6 e% f* _
　　LRESULT CALLBACK
　　AfxWndProcBase(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam). m. ?8 x* |* W9 V3 ^) y3 ?
　　这两个函数的原型都如4.1.1节描述的窗口过程一样。$ v7 c. [! a/ P( L5 z
　　如果动态链接到MFC DLL(定义了_AFXDLL)，则AfxWndProcBase被用作窗口过程，否则AfxWndProc被用作窗口过程。 AfxWndProcBase首先使用宏AFX_MANAGE_STATE设置正确的模块状态，然后调用AfxWndProc。$ {5 F: M- y4 Q
　　下面，假设不使用MFC DLL，讨论MFC如何使用AfxWndProc取代各个窗口的原窗口过程。
　　窗口过程的取代发生在窗口创建的过程时，使用了子类化(Subclass)的方法。所以，从窗口的创建过程来考察取代过程。从前面可以知道，窗口创建最终是通过调用CWnd::CreateEx函数完成的，分析该函数的流程，如图4-1所示。
　　* P$ {3 o$ u3 Z1 U* w2 J* q) s
　　图4-1中的CREATESTRUCT结构类型的变量cs包含了传递给窗口过程的初始化参数。CREATESTRUCT结构描述了创建窗口所需要的信息，定义如下：
　　typedef struct tagCREATESTRUCT {
　　LPVOID lpCreateParams; //用来创建窗口的数据
　　HANDLE hInstance; //创建窗口的实例; Q- E- W4 A! p2 n2 I: _- Y) ]
　　HMENU hMenu; //窗口菜单
　　HWND hwndParent; //父窗口
　　int cy; //高度; @7 T- n  d6 m8 f
　　int cx; //宽度
　　int y; //原点Y坐标
　　int x;//原点X坐标$ D7 n$ s7 b- q9 C! M8 d: h
　　LONG style; //窗口风格. b# V0 V& k5 I4 \/ q8 d
　　LPCSTR lpszName; //窗口名0 ?: F' q1 B5 _! B$ h, L, J
　　LPCSTR lpszClass; //窗口类& S, K: r  e' c; P, D2 \
　　DWORD dwExStyle; //窗口扩展风格/ e/ [  r( {0 t$ R6 k- ?
　　} CREATESTRUCT;
　　cs表示的创建参数可以在创建窗口之前被程序员修改，程序员可以覆盖当前窗口类的虚拟成员函数PreCreateWindow，通过该函数来修改cs的style域，改变窗口风格。这里 cs的主要作用是保存创建窗口的各种信息，::CreateWindowEx函数使用cs的各个域作为参数来创建窗口，关于该函数见2.2.2节。
　　在创建窗口之前，创建了一个WH_CBT类型的钩子（Hook）。这样，创建窗口时所有的消息都会被钩子过程函数_AfxCbtFilterHook截获。
　　 AfxCbtFilterHook函数首先检查是不是希望处理的Hook──HCBT_CREATEWND。如果是，则先把MFC窗口对象（该对象必须已经创建了）和刚刚创建的Windows窗口对象捆绑在一起，建立它们之间的映射（见后面模块-线程状态）；然后，调用::SetWindowLong设置窗口过程为AfxWndProc，并保存原窗口过程在窗口类成员变量m_pfnSuper中，这样形成一个窗口过程链。需要的时候，原窗口过程地址可以通过窗口类成员函数GetSuperWndProcAddr得到。, X- y% ]" u+ d) _
　　这样，AfxWndProc就成为CWnd或其派生类的窗口过程。不论队列消息，还是非队列消息，都送到AfxWndProc窗口过程来处理（如果使用MFC DLL，则AfxWndProcBase被调用，然后是AfxWndProc）。经过消息分发之后没有被处理的消息，将送给原窗口过程处理。; {' ]0 m( ~$ i- y) ^( e
　　最后，有一点可能需要解释：为什么不直接指定窗口过程为AfxWndProc，而要这么大费周折呢？这是因为原窗口过程（“窗口类”指定的窗口过程）常常是必要的，是不可缺少的。
　　接下来，讨论AfxWndProc窗口过程如何使用消息映射数据实现消息映射。Windows消息和命令消息的处理不一样，前者没有消息分发的过程。
1 M" A6 O9 N7 C# ~# b+ d* f
　　对Windows消息的接收和处理
　　Windows消息送给AfxWndProc窗口过程之后，AfxWndProc得到HWND窗口对应的MFC窗口对象，然后，搜索该MFC窗口对象和其基类的消息映射数组，判定它们是否处理当前消息，如果是则调用对应的消息处理函数，否则，进行缺省处理。5 p/ ~- d, \% h
　　下面，以一个应用程序的视窗口创建时，对WM_CREATE消息的处理为例，详细地讨论Windows消息的分发过程。
　　用第一章的例子，类CTview要处理WM_CREATE消息，使用ClassWizard加入消息处理函数CTview::OnCreate。下面，看这个函数怎么被调用：
　　视窗口最终调用::CreateEx函数来创建。由Windows系统发送WM_CREATE消息给视的窗口过程AfxWndProc，参数1是创建的视窗口的句柄，参数2是消息ID（WM_CREATE)，参数3、4是消息参数。图4-2描述了其余的处理过程。图中函数的类属限制并非源码中所具有的，而是根据处理过程得出的判断。例如，“CWnd::WindowProc”表示CWnd类的虚拟函数WindowProc被调用，并不一定当前对象是CWnd类的实例，事实上，它是CWnd派生类CTview类的实例；而“CTview::OnCreate”表示CTview的消息处理函数OnCreate被调用。下面描述每一步的详细处理。
　　/ m7 c7 l: x8 d$ l& x
　　从窗口过程到消息映射
/ r$ K% S% j8 o+ }
　　首先，分析AfxWndProc窗口过程函数。
　　AfxWndProc的原型如下： 0 s5 }$ V( ?( c8 U
　　LRESULT AfxWndProc(HWND hWnd, 8 `) i. y4 S! `
　　UINT nMsg, WPARAM wParam, LPARAM lParam)
　　如果收到的消息nMsg不是WM_QUERYAFXWNDPROC（该消息被MFC内部用来确认窗口过程是否使用AfxWndProc），则从hWnd得到对应的 MFC Windows对象（该对象必须已存在，是永久性对象）指针pWnd。pWnd所指的MFC窗口对象将负责完成消息的处理。这里，pWnd所指示的对象是 MFC视窗口对象，即CTview对象。
　　然后，把pWnd和AfxWndProc接受的四个参数传递给函数AfxCallWndProc执行。
　　AfxCallWndProc原型如下： * s4 O% d0 O- X6 l: f! F
　　LRESULT AFXAPI AfxCallWndProc(CWnd* pWnd, HWND hWnd,
　　UINT nMsg, WPARAM wParam = 0, LPARAM lParam = 0). A) n8 ^- G4 v/ M
　　MFC使用AfxCallWndProc函数把消息送给CWnd类或其派生类的对象。该函数主要是把消息和消息参数(nMsg、wParam、 lParam)传递给MFC窗口对象的成员函数WindowProc（pWnd->WindowProc）作进一步处理。如果是 WM_INITDIALOG消息，则在调用WindowProc前后要作一些处理。
　　WindowProc的函数原型如下：3 U+ u, z! d" R2 W5 Y# S
　　LRESULT CWnd::WindowProc(UINT message, " _9 I, j; y2 E2 }( X2 b* V& S
　　WPARAM wParam, LPARAM lParam)
　　这是一个虚拟函数，程序员可以在CWnd的派生类中覆盖它，改变MFC分发消息的方式。例如，MFC的CControlBar就覆盖了WindowProc，对某些消息作了自己的特别处理，其他消息处理由基类的WindowProc函数完成。% Y  U9 {* c2 G

阅读(271) | 评论(0) | 转发(0) |

上一篇：浅谈程序员的数学修养

下一篇：消息映射的实现（2）

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6