自定义消息获取消息

1. 自定义消息, U; D- D, Q7 q* j( i) j
(1) 手工定义消息，可以这么写 #define WM_MY_MESSAGE(WM_USER+100), MS 推荐的至, Y0 L/ Q. q: `! o
少是 WM_USER+100;
6 |6 r+ w( T- x8 E. ?0 {/ H(2)写消息处理函数,用 WPARAM,LPARAM返回LRESULT.  J; s5 T6 k1 M+ U# \, T
LRESULT CMainFrame::OnMyMessage(WPARAM wparam,LPARAM lParam)1 s  d& M# _8 U2 N
{" W! y: V7 O7 z5 {6 e  O
//加入你的处理函数
  h! a7 @. B: C' r/ w}
7 D& N. [" g; s8 x(3) 在类的 AFX_MSG处进行声明，也就是常说的"宏映射"' W( _  d3 P$ y  h- j2 d
//-----------------------------------------------------------------------
$ }* D* |; v! H8 W6 |2. 获取有关窗口正在处理的当前消息的信息
0 S+ s, t2 q4 F, U调用CWnd: : GetCurrentMessage 可以获取一个MSG指针。例如，可以使用ClassWizard3 m6 C% {1 ?, @) i$ [# ]* q
将几个菜单项处理程序映射到一个函数中，然后调用GetCurrentMessage 来确定所选中0 Z" ?1 H$ ^+ n9 H: _+ r
的菜单项。
3 O/ S3 |5 h6 \" C3 r: eviod CMainFrame : : OnCommmonMenuHandler ( )
2 t! O5 ?: J8 @! G+ F. Q{& L) N8 S3 a4 S$ U( a/ D' P
//Display selected menu item in debug window .
" W4 m5 _6 ^. u: dTRACE ("Menu item %u was selected . \n" ,% [  f0 Q% a( Y; x5 z
GetCruuentMessage ( ) ―> wParam );: M5 i9 R, ?8 @  V
}; c& p! ^& m. G: J* O% d" [( L: [' T
//-----------------------------------------------------------------------* Y& ~: I5 K0 n* ^. N" F
3.窗口最大化、最小化及关闭的消息是什么
  t+ B2 ]2 N& P6 Z, A9 [9 T最大化、最小化将发送WM_SYSCOMMAND消息。要处理该消息，可以这么做： 3 \* o* b( e& Z3 `# V6 V, z$ z2 t# f
(1)、在Form的头文件中添加： 3 w8 i3 z9 S; k' j. Z
void __fastcall RestrictMinimizeMaximize(TMessage &Msg); ' Y  H, P! |& x* Z4 p; b* G, ]
BEGIN_MESSAGE_MAP 6 t! A2 a' [) x5 N5 y2 F
MESSAGE_HANDLER(WM_SYSCOMMAND, TMessage, RestrictMinimizeMaximize) 8 F, N/ e* I/ R+ J5 K' j  |' B: Z
END_MESSAGE_MAP(TForm) / S# C7 g! ?, e, g$ t+ y$ L
(2)、在Form的单元文件中添加： 7 b& K% u. O5 q! D" F& e5 x
void __fastcall TForm1::RestrictMinimizeMaximize(TMessage& Msg) * T( |% D  v7 q" @
{ $ Y( s4 ~, }- w
if (Msg.WParam == SC_MINIMIZE) # P3 e9 j/ f4 i/ w3 [7 O2 R
{ - j% U. s! R5 d) _5 u. H+ z
//catches minimize...
! g- z# a5 R* ]! b  v7 s}
4 L. y$ g2 S7 b/ m/ s4 }, uelse if (Msg.WParam == SC_MAXIMIZE)
; x& @3 {. x: T2 B3 t{ / T# T7 c' x3 Q4 U' v9 f& q# T
//catches maximize... 3 h: n" l; }* ^5 |% K
} 1 `3 Q- R9 Q; l) L4 ^% @9 A) g
TForm:ispatch(&Msg);
5 {4 Z1 U6 o, g// or "else TForm:ispatch(&Msg)" to trap
* l: I2 ]! m: u! R& J+ X}
# y1 u" q2 _; v7 `/ d( {5 C关闭窗口的消息为WM_CLOSE，C++Builder提供了OnClose事件  S' ]+ u' C% U3 }+ E7 F
//-----------------------------------------------------------------------; T+ I3 b: q. m# O* L8 K% ]
消息映射的定义和实现 6 P0 n; e4 p& R  E7 X
MFC处理的三类消息
) D: |/ s, w! \2 _$ B6 Q' ^根据处理函数和处理过程的不同， MFC主要处理三类消息： & }5 x/ z- _. j& R! U
Windows 消息，前缀以“WM_”打头，WM_COMMAND例外。Windows消息直接送给MFC窗口过程处理，窗口过程调用对应的消息处理函数。一般，由窗口对象来处理这类消息，也就是说，这类消息处理函数一般是MFC窗口类的成员函数。
% [4 N$ n* \7 o1 h1 {6 f4 q  L! B控制通知消息，是控制子窗口送给父窗口的 WM_COMMAND通知消息。窗口过程调用对应的消息处理函数。一般，由窗口对象来处理这类消息，也就是说，这类消息处理函数一般是MFC窗口类的成员函数。 3 I! d3 M* E+ S8 `* c
需要指出的是，Win32使用新的WM_NOFITY来处理复杂的通知消息。WM_COMMAND类型的通知消息仅仅能传递一个控制窗口句柄(lparam)、控制窗ID和通知代码(wparam)。WM_NOTIFY能传递任意复杂的信息。
+ x( ~/ {" w: k6 d: A; r# ^, Z命 令消息，这是来自菜单、工具条按钮、加速键等用户接口对象的WM_COMMAND通知消息，属于应用程序自己定义的消息。通过消息映射机制，MFC框架把 命令按一定的路径分发给多种类型的对象（具备消息处理能力）处理，如文档、窗口、应用程序、文档模板等对象。能处理消息映射的类必须从 CCmdTarget类派生。 4 T5 u: U$ M; J' A: O, ^
在讨论了消息的分类之后，应该是讨论各类消息如何处理的时候了。但是，要知道怎么处理消息，首先要知道如何映射消息。% ^& l8 t# f1 e3 T- T+ W' k, y
MFC消息映射的实现方法
) ]4 b) R  L7 @* I) \2 ~: HMFC 使用ClassWizard帮助实现消息映射，它在源码中添加一些消息映射的内容，并声明和实现消息处理函数。现在来分析这些被添加的内容。 % M* Y3 X/ k, L) j( `+ o
在类的定义（头文件）里，它增加了消息处理函数声明，并添加一行声明消息映射的宏 DECLARE_MESSAGE_MAP。
7 L$ d8 |1 y( w4 G* J9 S4 p2 N在类的实现（实现文件）里，实现消息处理函数，并使用 IMPLEMENT_MESSAGE_MAP宏实现消息映射。一般情况下，这些声明和实现是由MFC的ClassWizard自动来维护的。看一个例子：
! X; i" m- n0 f! U  ^4 O在 AppWizard产生的应用程序类的源码中，应用程序类的定义（头文件）包含了类似如下的代码： ! R- N5 u$ q0 [; x4 w
//{{AFX_MSG(CTttApp)
  }0 n9 C: V9 x0 `. C0 Iafx_msg void OnAppAbout();9 F9 p! q1 W9 o+ K/ Y5 c
//}}AFX_MSG
2 Y9 Y$ W) E7 \  cDECLARE_MESSAGE_MAP()7 Z0 I2 Y+ f* K' N4 u2 b' z( Z3 y. g
应用程序类的实现文件中包含了类似如下的代码：
" O6 T; r1 [6 e1 ^% P, [BEGIN_MESSAGE_MAP(CTApp, CWinApp)8 W4 O: z3 K( j" E- v  ^
//{{AFX_MSG_MAP(CTttApp)
8 G7 D2 K1 P9 w9 X, P( L( T& FON_COMMAND(ID_APP_ABOUT, OnAppAbout)  w* r6 ]' N& o3 z2 H! g5 T
//}}AFX_MSG_MAP
1 X/ T* h: y0 U( TEND_MESSAGE_MAP(): U$ v7 p& D- z
头文件里是消息映射和消息处理函数的声明，实现文件里是消息映射的实现和消息处理函数的现。它表示让应用程序对象处理命令消息 ID_APP_ABOUT，消息处理函数是OnAppAbout。 . R/ z  S# Y' K6 H  ?
为什么这样做之后就完成了一个消息映射？这些声明和实现到底作了些什么呢？接着，将讨论这些问题。
! [; S7 E! N; X$ a  B在声明与实现的内部
; l6 X) _  U& ^9 RDECLARE_MESSAGE_MAP宏： + R) U3 o3 {- \# K+ q
首先，看DECLARE_MESSAGE_MAP宏的内容：
! i9 f) y6 k1 d2 F( @#ifdef _AFXDLL: \) o- \  b/ y2 K
#define DECLARE_MESSAGE_MAP() \
" k/ m( g* [% @. X0 B2 X% Uprivate: \
& t0 i) {. u/ T8 X( y; pstatic const AFX_MSGMAP_ENTRY _messageEntries[]; \
4 G5 n- A' u  w- c8 uprotected: \
4 |" C; @4 A1 gstatic AFX_DATA const AFX_MSGMAP messageMap; \
) T3 x& X2 p2 o& f" X7 Dstatic const AFX_MSGMAP* PASCAL _GetBaseMessageMap(); \
! r, C  c5 A1 F2 K1 g. `$ mvirtual const AFX_MSGMAP* GetMessageMap() const; \
. M) f( W  v1 X) |( \' M#else* y, x  K7 ]4 @5 J6 m# T
#define DECLARE_MESSAGE_MAP() \
  y" s$ I6 L2 y8 Y4 ?private: \$ ~+ C4 y8 N$ N/ ]- ?& q) m4 @, @4 {
static const AFX_MSGMAP_ENTRY _messageEntries[]; \- o8 q9 I6 [: g
protected: \( ~( m5 Z% r3 V& j; @" }) p
static AFX_DATA const AFX_MSGMAP messageMap; \
( i" ]0 q) [2 R+ Zvirtual const AFX_MSGMAP* GetMessageMap() const; \- H+ r) i5 M; R4 z5 [4 b: @: x. ?9 u
#endif, J4 k* `* J! r5 U" i) W: ~, y  a
DECLARE_MESSAGE_MAP 定义了两个版本，分别用于静态或者动态链接到MFC DLL的情形。 % j) E0 j1 s6 L+ l/ c
BEGIN_MESSAE_MAP宏
' o- F2 O1 y. Z! L然后，看BEGIN_MESSAE_MAP宏的内容：
( d" _) g  X, t& Q8 o#ifdef _AFXDLL* f) K. S% c9 ]- W9 u4 e8 B
#define BEGIN_MESSAGE_MAP(theClass, baseClass) \& h4 \, p. ~6 P
const AFX_MSGMAP* PASCAL theClass::_GetBaseMessageMap() \0 Y' h2 z& V5 o/ Y) s  p
{ return &baseClass::messageMap; } \, {5 h% J& a- D! F
const AFX_MSGMAP* theClass::GetMessageMap() const \8 P/ ?: ~9 K% e) x4 ~; X1 u' {
{ return &theClass::messageMap; } \
# A* f' g0 S# F% C+ jAFX_DATADEF const AFX_MSGMAP theClass::messageMap = \. r7 O8 L% q3 Z: H
{ &theClass::_GetBaseMessageMap, &theClass::_messageEntries[0] }; \
1 ^9 g# I0 V) Oconst AFX_MSGMAP_ENTRY theClass::_messageEntries[] = \# v* F* |; d- C- E9 N
{ \
& [! l, d! A1 \#else
+ }. G% `  w8 C#define BEGIN_MESSAGE_MAP(theClass, baseClass) \
3 I0 \; c- J; [% Fconst AFX_MSGMAP* theClass::GetMessageMap() const \
( ]/ b: \: X( O% N{ return &theClass::messageMap; } \6 O( h  j* U+ d3 i
AFX_DATADEF const AFX_MSGMAP theClass::messageMap = \
# f4 c% |# `+ \. L, e/ S- _& t{ &baseClass::messageMap, &theClass::_messageEntries[0] }; \0 P/ v- u' z2 q& Y: n
const AFX_MSGMAP_ENTRY theClass::_messageEntries[] = \# B8 h7 a: _) w. p$ T% o5 G6 R
{ \; Y# f$ _( c" H* S" L( K# Z
#endif  o: f6 U" _/ v% P
#define END_MESSAGE_MAP() \
. M4 G8 T5 c2 y+ w! X) q9 Q% N{0, 0, 0, 0, AfxSig_end, (AFX_PMSG)0 } \' g% f5 U2 Z& M/ L; n, ~/ j, y
}; \
/ Q# ^4 c4 D4 e$ {- d对应地， BEGIN_MESSAGE_MAP定义了两个版本，分别用于静态或者动态链接到MFC DLL的情形。END_MESSAGE_MAP相对简单，就只有一种定义。 0 D+ G* [: h, O( F- F
ON_COMMAND宏
) H. G2 t8 ]4 c. O7 [. E最后，看ON_COMMAND宏的内容：4 l8 _. p8 f4 e5 e( b* w5 |, a
#define ON_COMMAND(id, memberFxn) \( A  r* T6 E2 V* |, j
{\8 J+ O9 Z0 p& Y: x
WM_COMMAND,\3 c% z4 m# t+ ^1 {( H
CN_COMMAND,\
/ p( J. O; x; K2 `) @. j; q, I/ u2 w(WORD)id,\1 f- X' D" n% T3 J, A. h1 _4 I9 q4 Z
(WORD)id,\: Q$ ?# A. W3 H& C! H
AfxSig_vv,\
4 J) h& f- q5 `! a, n( ~' E(AFX_PMSG)memberFxn\
$ `; E, R# {% R* C- U}；
- }, _% G0 ]) K* W0 `1 d# Z消息映射声明的解释
) u! C0 ~$ {8 G5 ?4 o在清楚了有关宏的定义之后，现在来分析它们的作用和功能。6 t  i/ \- e4 r7 c4 u- J5 D% a
消息映射声明的实质是给所在类添加几个静态成员变量和静态或虚拟函数，当然它们是与消息映射相关的变量和函数。