src/ui/gfx/win/msg_util.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef UI_GFX_WIN_MSG_UTIL_H_
   6 #define UI_GFX_WIN_MSG_UTIL_H_
   7
   8 #include "base/logging.h"
   9 #include "ui/gfx/geometry/point.h"
  10 #include "ui/gfx/geometry/size.h"
  11
  12 // Based on WTL version 8.0 atlcrack.h
  13
  14 // This differs from the original atlcrack.h by removing usage of CPoint,
  15 // CSize, etc.
  16
  17 ///////////////////////////////////////////////////////////////////////////////
  18 // Message map macro for cracked handlers
  19
  20 // Note about message maps with cracked handlers:
  21 // For ATL 3.0, a message map using cracked handlers MUST use BEGIN_MSG_MAP_EX.
  22 // For ATL 7.0 or higher, you can use BEGIN_MSG_MAP for CWindowImpl/CDialogImpl
  23 // derived classes,
  24 // but must use BEGIN_MSG_MAP_EX for classes that don't derive from
  25 // CWindowImpl/CDialogImpl.
  26
  27 #define CR_BEGIN_MSG_MAP_EX(theClass)                             \
  28  public:                                                          \
  29   BOOL m_bMsgHandled;                                             \
  30   /* "handled" management for cracked handlers */                 \
  31   BOOL IsMsgHandled() const { return m_bMsgHandled; }             \
  32   void SetMsgHandled(BOOL bHandled) { m_bMsgHandled = bHandled; } \
  33   BOOL ProcessWindowMessage(HWND hWnd,                            \
  34                             UINT uMsg,                            \
  35                             WPARAM wParam,                        \
  36                             LPARAM lParam,                        \
  37                             LRESULT& lResult,                     \
  38                             DWORD dwMsgMapID = 0) {               \
  39     BOOL bOldMsgHandled = m_bMsgHandled;                          \
  40     BOOL bRet = _ProcessWindowMessage(                            \
  41         hWnd, uMsg, wParam, lParam, lResult, dwMsgMapID);         \
  42     m_bMsgHandled = bOldMsgHandled;                               \
  43     return bRet;                                                  \
  44   }                                                               \
  45   BOOL _ProcessWindowMessage(HWND hWnd,                           \
  46                              UINT uMsg,                           \
  47                              WPARAM wParam,                       \
  48                              LPARAM lParam,                       \
  49                              LRESULT& lResult,                    \
  50                              DWORD dwMsgMapID) {                  \
  51     BOOL bHandled = TRUE;                                         \
  52     hWnd;                                                         \
  53     uMsg;                                                         \
  54     wParam;                                                       \
  55     lParam;                                                       \
  56     lResult;                                                      \
  57     bHandled;                                                     \
  58     switch (dwMsgMapID) {                                         \
  59       case 0:
  60
  61 // Replacement for atlwin.h's END_MSG_MAP for removing ATL usage.
  62 #define CR_END_MSG_MAP()                                      \
  63   break;                                                      \
  64   default:                                                    \
  65     NOTREACHED() << "Invalid message map ID: " << dwMsgMapID; \
  66     break;                                                    \
  67     }                                                         \
  68     return FALSE;                                             \
  69     }
  70
  71 #define CR_GET_X_LPARAM(lParam) ((int)(short)LOWORD(lParam))
  72 #define CR_GET_Y_LPARAM(lParam) ((int)(short)HIWORD(lParam))
  73
  74 ///////////////////////////////////////////////////////////////////////////////
  75 // Standard Windows message macros
  76
  77 // int OnCreate(LPCREATESTRUCT lpCreateStruct)
  78 #define CR_MSG_WM_CREATE(func)                       \
  79   if (uMsg == WM_CREATE) {                           \
  80     SetMsgHandled(TRUE);                             \
  81     lResult = (LRESULT)func((LPCREATESTRUCT)lParam); \
  82     if (IsMsgHandled())                              \
  83       return TRUE;                                   \
  84   }
  85
  86 // BOOL OnInitDialog(CWindow wndFocus, LPARAM lInitParam)
  87 #define CR_MSG_WM_INITDIALOG(func)                 \
  88   if (uMsg == WM_INITDIALOG) {                     \
  89     SetMsgHandled(TRUE);                           \
  90     lResult = (LRESULT)func((HWND)wParam, lParam); \
  91     if (IsMsgHandled())                            \
  92       return TRUE;                                 \
  93   }
  94
  95 // BOOL OnCopyData(CWindow wnd, PCOPYDATASTRUCT pCopyDataStruct)
  96 #define CR_MSG_WM_COPYDATA(func)                                    \
  97   if (uMsg == WM_COPYDATA) {                                        \
  98     SetMsgHandled(TRUE);                                            \
  99     lResult = (LRESULT)func((HWND)wParam, (PCOPYDATASTRUCT)lParam); \
 100     if (IsMsgHandled())                                             \
 101       return TRUE;                                                  \
 102   }
 103
 104 // void OnDestroy()
 105 #define CR_MSG_WM_DESTROY(func) \
 106   if (uMsg == WM_DESTROY) {     \
 107     SetMsgHandled(TRUE);        \
 108     func();                     \
 109     lResult = 0;                \
 110     if (IsMsgHandled())         \
 111       return TRUE;              \
 112   }
 113
 114 // void OnMove(CPoint ptPos)
 115 #define CR_MSG_WM_MOVE(func)                                            \
 116   if (uMsg == WM_MOVE) {                                                \
 117     SetMsgHandled(TRUE);                                                \
 118     func(gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 119     lResult = 0;                                                        \
 120     if (IsMsgHandled())                                                 \
 121       return TRUE;                                                      \
 122   }
 123
 124 // void OnSize(UINT nType, gfx::Size size)
 125 #define CR_MSG_WM_SIZE(func)                                           \
 126   if (uMsg == WM_SIZE) {                                               \
 127     SetMsgHandled(TRUE);                                               \
 128     func((UINT)wParam,                                                 \
 129          gfx::Size(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 130     lResult = 0;                                                       \
 131     if (IsMsgHandled())                                                \
 132       return TRUE;                                                     \
 133   }
 134
 135 // void OnActivate(UINT nState, BOOL bMinimized, CWindow wndOther)
 136 #define CR_MSG_WM_ACTIVATE(func)                                    \
 137   if (uMsg == WM_ACTIVATE) {                                        \
 138     SetMsgHandled(TRUE);                                            \
 139     func((UINT)LOWORD(wParam), (BOOL)HIWORD(wParam), (HWND)lParam); \
 140     lResult = 0;                                                    \
 141     if (IsMsgHandled())                                             \
 142       return TRUE;                                                  \
 143   }
 144
 145 // void OnSetFocus(CWindow wndOld)
 146 #define CR_MSG_WM_SETFOCUS(func) \
 147   if (uMsg == WM_SETFOCUS) {     \
 148     SetMsgHandled(TRUE);         \
 149     func((HWND)wParam);          \
 150     lResult = 0;                 \
 151     if (IsMsgHandled())          \
 152       return TRUE;               \
 153   }
 154
 155 // void OnKillFocus(CWindow wndFocus)
 156 #define CR_MSG_WM_KILLFOCUS(func) \
 157   if (uMsg == WM_KILLFOCUS) {     \
 158     SetMsgHandled(TRUE);          \
 159     func((HWND)wParam);           \
 160     lResult = 0;                  \
 161     if (IsMsgHandled())           \
 162       return TRUE;                \
 163   }
 164
 165 // void OnEnable(BOOL bEnable)
 166 #define CR_MSG_WM_ENABLE(func) \
 167   if (uMsg == WM_ENABLE) {     \
 168     SetMsgHandled(TRUE);       \
 169     func((BOOL)wParam);        \
 170     lResult = 0;               \
 171     if (IsMsgHandled())        \
 172       return TRUE;             \
 173   }
 174
 175 // void OnPaint(CDCHandle dc)
 176 #define CR_MSG_WM_PAINT(func) \
 177   if (uMsg == WM_PAINT) {     \
 178     SetMsgHandled(TRUE);      \
 179     func((HDC)wParam);        \
 180     lResult = 0;              \
 181     if (IsMsgHandled())       \
 182       return TRUE;            \
 183   }
 184
 185 // void OnClose()
 186 #define CR_MSG_WM_CLOSE(func) \
 187   if (uMsg == WM_CLOSE) {     \
 188     SetMsgHandled(TRUE);      \
 189     func();                   \
 190     lResult = 0;              \
 191     if (IsMsgHandled())       \
 192       return TRUE;            \
 193   }
 194
 195 // BOOL OnQueryEndSession(UINT nSource, UINT uLogOff)
 196 #define CR_MSG_WM_QUERYENDSESSION(func)                  \
 197   if (uMsg == WM_QUERYENDSESSION) {                      \
 198     SetMsgHandled(TRUE);                                 \
 199     lResult = (LRESULT)func((UINT)wParam, (UINT)lParam); \
 200     if (IsMsgHandled())                                  \
 201       return TRUE;                                       \
 202   }
 203
 204 // BOOL OnQueryOpen()
 205 #define CR_MSG_WM_QUERYOPEN(func) \
 206   if (uMsg == WM_QUERYOPEN) {     \
 207     SetMsgHandled(TRUE);          \
 208     lResult = (LRESULT)func();    \
 209     if (IsMsgHandled())           \
 210       return TRUE;                \
 211   }
 212
 213 // BOOL OnEraseBkgnd(CDCHandle dc)
 214 #define CR_MSG_WM_ERASEBKGND(func)        \
 215   if (uMsg == WM_ERASEBKGND) {            \
 216     SetMsgHandled(TRUE);                  \
 217     lResult = (LRESULT)func((HDC)wParam); \
 218     if (IsMsgHandled())                   \
 219       return TRUE;                        \
 220   }
 221
 222 // void OnSysColorChange()
 223 #define CR_MSG_WM_SYSCOLORCHANGE(func) \
 224   if (uMsg == WM_SYSCOLORCHANGE) {     \
 225     SetMsgHandled(TRUE);               \
 226     func();                            \
 227     lResult = 0;                       \
 228     if (IsMsgHandled())                \
 229       return TRUE;                     \
 230   }
 231
 232 // void OnEndSession(BOOL bEnding, UINT uLogOff)
 233 #define CR_MSG_WM_ENDSESSION(func)    \
 234   if (uMsg == WM_ENDSESSION) {        \
 235     SetMsgHandled(TRUE);              \
 236     func((BOOL)wParam, (UINT)lParam); \
 237     lResult = 0;                      \
 238     if (IsMsgHandled())               \
 239       return TRUE;                    \
 240   }
 241
 242 // void OnShowWindow(BOOL bShow, UINT nStatus)
 243 #define CR_MSG_WM_SHOWWINDOW(func)   \
 244   if (uMsg == WM_SHOWWINDOW) {       \
 245     SetMsgHandled(TRUE);             \
 246     func((BOOL)wParam, (int)lParam); \
 247     lResult = 0;                     \
 248     if (IsMsgHandled())              \
 249       return TRUE;                   \
 250   }
 251
 252 // HBRUSH OnCtlColorEdit(CDCHandle dc, CEdit edit)
 253 #define CR_MSG_WM_CTLCOLOREDIT(func)                    \
 254   if (uMsg == WM_CTLCOLOREDIT) {                        \
 255     SetMsgHandled(TRUE);                                \
 256     lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
 257     if (IsMsgHandled())                                 \
 258       return TRUE;                                      \
 259   }
 260
 261 // HBRUSH OnCtlColorListBox(CDCHandle dc, CListBox listBox)
 262 #define CR_MSG_WM_CTLCOLORLISTBOX(func)                 \
 263   if (uMsg == WM_CTLCOLORLISTBOX) {                     \
 264     SetMsgHandled(TRUE);                                \
 265     lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
 266     if (IsMsgHandled())                                 \
 267       return TRUE;                                      \
 268   }
 269
 270 // HBRUSH OnCtlColorBtn(CDCHandle dc, CButton button)
 271 #define CR_MSG_WM_CTLCOLORBTN(func)                     \
 272   if (uMsg == WM_CTLCOLORBTN) {                         \
 273     SetMsgHandled(TRUE);                                \
 274     lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
 275     if (IsMsgHandled())                                 \
 276       return TRUE;                                      \
 277   }
 278
 279 // HBRUSH OnCtlColorDlg(CDCHandle dc, CWindow wnd)
 280 #define CR_MSG_WM_CTLCOLORDLG(func)                     \
 281   if (uMsg == WM_CTLCOLORDLG) {                         \
 282     SetMsgHandled(TRUE);                                \
 283     lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
 284     if (IsMsgHandled())                                 \
 285       return TRUE;                                      \
 286   }
 287
 288 // HBRUSH OnCtlColorScrollBar(CDCHandle dc, CScrollBar scrollBar)
 289 #define CR_MSG_WM_CTLCOLORSCROLLBAR(func)               \
 290   if (uMsg == WM_CTLCOLORSCROLLBAR) {                   \
 291     SetMsgHandled(TRUE);                                \
 292     lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
 293     if (IsMsgHandled())                                 \
 294       return TRUE;                                      \
 295   }
 296
 297 // HBRUSH OnCtlColorStatic(CDCHandle dc, CStatic wndStatic)
 298 #define CR_MSG_WM_CTLCOLORSTATIC(func)                  \
 299   if (uMsg == WM_CTLCOLORSTATIC) {                      \
 300     SetMsgHandled(TRUE);                                \
 301     lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
 302     if (IsMsgHandled())                                 \
 303       return TRUE;                                      \
 304   }
 305
 306 // void OnSettingChange(UINT uFlags, LPCTSTR lpszSection)
 307 #define CR_MSG_WM_SETTINGCHANGE(func)    \
 308   if (uMsg == WM_SETTINGCHANGE) {        \
 309     SetMsgHandled(TRUE);                 \
 310     func((UINT)wParam, (LPCTSTR)lParam); \
 311     lResult = 0;                         \
 312     if (IsMsgHandled())                  \
 313       return TRUE;                       \
 314   }
 315
 316 // void OnDevModeChange(LPCTSTR lpDeviceName)
 317 #define CR_MSG_WM_DEVMODECHANGE(func) \
 318   if (uMsg == WM_DEVMODECHANGE) {     \
 319     SetMsgHandled(TRUE);              \
 320     func((LPCTSTR)lParam);            \
 321     lResult = 0;                      \
 322     if (IsMsgHandled())               \
 323       return TRUE;                    \
 324   }
 325
 326 // void OnActivateApp(BOOL bActive, DWORD dwThreadID)
 327 #define CR_MSG_WM_ACTIVATEAPP(func)    \
 328   if (uMsg == WM_ACTIVATEAPP) {        \
 329     SetMsgHandled(TRUE);               \
 330     func((BOOL)wParam, (DWORD)lParam); \
 331     lResult = 0;                       \
 332     if (IsMsgHandled())                \
 333       return TRUE;                     \
 334   }
 335
 336 // void OnFontChange()
 337 #define CR_MSG_WM_FONTCHANGE(func) \
 338   if (uMsg == WM_FONTCHANGE) {     \
 339     SetMsgHandled(TRUE);           \
 340     func();                        \
 341     lResult = 0;                   \
 342     if (IsMsgHandled())            \
 343       return TRUE;                 \
 344   }
 345
 346 // void OnTimeChange()
 347 #define CR_MSG_WM_TIMECHANGE(func) \
 348   if (uMsg == WM_TIMECHANGE) {     \
 349     SetMsgHandled(TRUE);           \
 350     func();                        \
 351     lResult = 0;                   \
 352     if (IsMsgHandled())            \
 353       return TRUE;                 \
 354   }
 355
 356 // void OnCancelMode()
 357 #define CR_MSG_WM_CANCELMODE(func) \
 358   if (uMsg == WM_CANCELMODE) {     \
 359     SetMsgHandled(TRUE);           \
 360     func();                        \
 361     lResult = 0;                   \
 362     if (IsMsgHandled())            \
 363       return TRUE;                 \
 364   }
 365
 366 // BOOL OnSetCursor(CWindow wnd, UINT nHitTest, UINT message)
 367 #define CR_MSG_WM_SETCURSOR(func)                                  \
 368   if (uMsg == WM_SETCURSOR) {                                      \
 369     SetMsgHandled(TRUE);                                           \
 370     lResult = (LRESULT)func(                                       \
 371         (HWND)wParam, (UINT)LOWORD(lParam), (UINT)HIWORD(lParam)); \
 372     if (IsMsgHandled())                                            \
 373       return TRUE;                                                 \
 374   }
 375
 376 // int OnMouseActivate(CWindow wndTopLevel, UINT nHitTest, UINT message)
 377 #define CR_MSG_WM_MOUSEACTIVATE(func)                              \
 378   if (uMsg == WM_MOUSEACTIVATE) {                                  \
 379     SetMsgHandled(TRUE);                                           \
 380     lResult = (LRESULT)func(                                       \
 381         (HWND)wParam, (UINT)LOWORD(lParam), (UINT)HIWORD(lParam)); \
 382     if (IsMsgHandled())                                            \
 383       return TRUE;                                                 \
 384   }
 385
 386 // void OnChildActivate()
 387 #define CR_MSG_WM_CHILDACTIVATE(func) \
 388   if (uMsg == WM_CHILDACTIVATE) {     \
 389     SetMsgHandled(TRUE);              \
 390     func();                           \
 391     lResult = 0;                      \
 392     if (IsMsgHandled())               \
 393       return TRUE;                    \
 394   }
 395
 396 // void OnGetMinMaxInfo(LPMINMAXINFO lpMMI)
 397 #define CR_MSG_WM_GETMINMAXINFO(func) \
 398   if (uMsg == WM_GETMINMAXINFO) {     \
 399     SetMsgHandled(TRUE);              \
 400     func((LPMINMAXINFO)lParam);       \
 401     lResult = 0;                      \
 402     if (IsMsgHandled())               \
 403       return TRUE;                    \
 404   }
 405
 406 // void OnIconEraseBkgnd(CDCHandle dc)
 407 #define CR_MSG_WM_ICONERASEBKGND(func) \
 408   if (uMsg == WM_ICONERASEBKGND) {     \
 409     SetMsgHandled(TRUE);               \
 410     func((HDC)wParam);                 \
 411     lResult = 0;                       \
 412     if (IsMsgHandled())                \
 413       return TRUE;                     \
 414   }
 415
 416 // void OnSpoolerStatus(UINT nStatus, UINT nJobs)
 417 #define CR_MSG_WM_SPOOLERSTATUS(func)         \
 418   if (uMsg == WM_SPOOLERSTATUS) {             \
 419     SetMsgHandled(TRUE);                      \
 420     func((UINT)wParam, (UINT)LOWORD(lParam)); \
 421     lResult = 0;                              \
 422     if (IsMsgHandled())                       \
 423       return TRUE;                            \
 424   }
 425
 426 // void OnDrawItem(int nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct)
 427 #define CR_MSG_WM_DRAWITEM(func)                  \
 428   if (uMsg == WM_DRAWITEM) {                      \
 429     SetMsgHandled(TRUE);                          \
 430     func((UINT)wParam, (LPDRAWITEMSTRUCT)lParam); \
 431     lResult = TRUE;                               \
 432     if (IsMsgHandled())                           \
 433       return TRUE;                                \
 434   }
 435
 436 // void OnMeasureItem(int nIDCtl, LPMEASUREITEMSTRUCT lpMeasureItemStruct)
 437 #define CR_MSG_WM_MEASUREITEM(func)                  \
 438   if (uMsg == WM_MEASUREITEM) {                      \
 439     SetMsgHandled(TRUE);                             \
 440     func((UINT)wParam, (LPMEASUREITEMSTRUCT)lParam); \
 441     lResult = TRUE;                                  \
 442     if (IsMsgHandled())                              \
 443       return TRUE;                                   \
 444   }
 445
 446 // void OnDeleteItem(int nIDCtl, LPDELETEITEMSTRUCT lpDeleteItemStruct)
 447 #define CR_MSG_WM_DELETEITEM(func)                  \
 448   if (uMsg == WM_DELETEITEM) {                      \
 449     SetMsgHandled(TRUE);                            \
 450     func((UINT)wParam, (LPDELETEITEMSTRUCT)lParam); \
 451     lResult = TRUE;                                 \
 452     if (IsMsgHandled())                             \
 453       return TRUE;                                  \
 454   }
 455
 456 // int OnCharToItem(UINT nChar, UINT nIndex, CListBox listBox)
 457 #define CR_MSG_WM_CHARTOITEM(func)                                 \
 458   if (uMsg == WM_CHARTOITEM) {                                     \
 459     SetMsgHandled(TRUE);                                           \
 460     lResult = (LRESULT)func(                                       \
 461         (UINT)LOWORD(wParam), (UINT)HIWORD(wParam), (HWND)lParam); \
 462     if (IsMsgHandled())                                            \
 463       return TRUE;                                                 \
 464   }
 465
 466 // int OnVKeyToItem(UINT nKey, UINT nIndex, CListBox listBox)
 467 #define CR_MSG_WM_VKEYTOITEM(func)                                 \
 468   if (uMsg == WM_VKEYTOITEM) {                                     \
 469     SetMsgHandled(TRUE);                                           \
 470     lResult = (LRESULT)func(                                       \
 471         (UINT)LOWORD(wParam), (UINT)HIWORD(wParam), (HWND)lParam); \
 472     if (IsMsgHandled())                                            \
 473       return TRUE;                                                 \
 474   }
 475
 476 // HCURSOR OnQueryDragIcon()
 477 #define CR_MSG_WM_QUERYDRAGICON(func) \
 478   if (uMsg == WM_QUERYDRAGICON) {     \
 479     SetMsgHandled(TRUE);              \
 480     lResult = (LRESULT)func();        \
 481     if (IsMsgHandled())               \
 482       return TRUE;                    \
 483   }
 484
 485 // int OnCompareItem(int nIDCtl, LPCOMPAREITEMSTRUCT lpCompareItemStruct)
 486 #define CR_MSG_WM_COMPAREITEM(func)                                     \
 487   if (uMsg == WM_COMPAREITEM) {                                         \
 488     SetMsgHandled(TRUE);                                                \
 489     lResult = (LRESULT)func((UINT)wParam, (LPCOMPAREITEMSTRUCT)lParam); \
 490     if (IsMsgHandled())                                                 \
 491       return TRUE;                                                      \
 492   }
 493
 494 // void OnCompacting(UINT nCpuTime)
 495 #define CR_MSG_WM_COMPACTING(func) \
 496   if (uMsg == WM_COMPACTING) {     \
 497     SetMsgHandled(TRUE);           \
 498     func((UINT)wParam);            \
 499     lResult = 0;                   \
 500     if (IsMsgHandled())            \
 501       return TRUE;                 \
 502   }
 503
 504 // BOOL OnNcCreate(LPCREATESTRUCT lpCreateStruct)
 505 #define CR_MSG_WM_NCCREATE(func)                     \
 506   if (uMsg == WM_NCCREATE) {                         \
 507     SetMsgHandled(TRUE);                             \
 508     lResult = (LRESULT)func((LPCREATESTRUCT)lParam); \
 509     if (IsMsgHandled())                              \
 510       return TRUE;                                   \
 511   }
 512
 513 // void OnNcDestroy()
 514 #define CR_MSG_WM_NCDESTROY(func) \
 515   if (uMsg == WM_NCDESTROY) {     \
 516     SetMsgHandled(TRUE);          \
 517     func();                       \
 518     lResult = 0;                  \
 519     if (IsMsgHandled())           \
 520       return TRUE;                \
 521   }
 522
 523 // LRESULT OnNcCalcSize(BOOL bCalcValidRects, LPARAM lParam)
 524 #define CR_MSG_WM_NCCALCSIZE(func)        \
 525   if (uMsg == WM_NCCALCSIZE) {            \
 526     SetMsgHandled(TRUE);                  \
 527     lResult = func((BOOL)wParam, lParam); \
 528     if (IsMsgHandled())                   \
 529       return TRUE;                        \
 530   }
 531
 532 // UINT OnNcHitTest(gfx::Point point)
 533 #define CR_MSG_WM_NCHITTEST(func)                                      \
 534   if (uMsg == WM_NCHITTEST) {                                          \
 535     SetMsgHandled(TRUE);                                               \
 536     lResult = (LRESULT)func(                                           \
 537         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 538     if (IsMsgHandled())                                                \
 539       return TRUE;                                                     \
 540   }
 541
 542 // void OnNcPaint(CRgn rgn)
 543 #define CR_MSG_WM_NCPAINT(func) \
 544   if (uMsg == WM_NCPAINT) {     \
 545     SetMsgHandled(TRUE);        \
 546     func((HRGN)wParam);         \
 547     lResult = 0;                \
 548     if (IsMsgHandled())         \
 549       return TRUE;              \
 550   }
 551
 552 // BOOL OnNcActivate(BOOL bActive)
 553 #define CR_MSG_WM_NCACTIVATE(func)         \
 554   if (uMsg == WM_NCACTIVATE) {             \
 555     SetMsgHandled(TRUE);                   \
 556     lResult = (LRESULT)func((BOOL)wParam); \
 557     if (IsMsgHandled())                    \
 558       return TRUE;                         \
 559   }
 560
 561 // UINT OnGetDlgCode(LPMSG lpMsg)
 562 #define CR_MSG_WM_GETDLGCODE(func)          \
 563   if (uMsg == WM_GETDLGCODE) {              \
 564     SetMsgHandled(TRUE);                    \
 565     lResult = (LRESULT)func((LPMSG)lParam); \
 566     if (IsMsgHandled())                     \
 567       return TRUE;                          \
 568   }
 569
 570 // void OnNcMouseMove(UINT nHitTest, gfx::Point point)
 571 #define CR_MSG_WM_NCMOUSEMOVE(func)                                     \
 572   if (uMsg == WM_NCMOUSEMOVE) {                                         \
 573     SetMsgHandled(TRUE);                                                \
 574     func((UINT)wParam,                                                  \
 575          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 576     lResult = 0;                                                        \
 577     if (IsMsgHandled())                                                 \
 578       return TRUE;                                                      \
 579   }
 580
 581 // void OnNcLButtonDown(UINT nHitTest, gfx::Point point)
 582 #define CR_MSG_WM_NCLBUTTONDOWN(func)                                   \
 583   if (uMsg == WM_NCLBUTTONDOWN) {                                       \
 584     SetMsgHandled(TRUE);                                                \
 585     func((UINT)wParam,                                                  \
 586          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 587     lResult = 0;                                                        \
 588     if (IsMsgHandled())                                                 \
 589       return TRUE;                                                      \
 590   }
 591
 592 // void OnNcLButtonUp(UINT nHitTest, gfx::Point point)
 593 #define CR_MSG_WM_NCLBUTTONUP(func)                                     \
 594   if (uMsg == WM_NCLBUTTONUP) {                                         \
 595     SetMsgHandled(TRUE);                                                \
 596     func((UINT)wParam,                                                  \
 597          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 598     lResult = 0;                                                        \
 599     if (IsMsgHandled())                                                 \
 600       return TRUE;                                                      \
 601   }
 602
 603 // void OnNcLButtonDblClk(UINT nHitTest, gfx::Point point)
 604 #define CR_MSG_WM_NCLBUTTONDBLCLK(func)                                 \
 605   if (uMsg == WM_NCLBUTTONDBLCLK) {                                     \
 606     SetMsgHandled(TRUE);                                                \
 607     func((UINT)wParam,                                                  \
 608          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 609     lResult = 0;                                                        \
 610     if (IsMsgHandled())                                                 \
 611       return TRUE;                                                      \
 612   }
 613
 614 // void OnNcRButtonDown(UINT nHitTest, gfx::Point point)
 615 #define CR_MSG_WM_NCRBUTTONDOWN(func)                                   \
 616   if (uMsg == WM_NCRBUTTONDOWN) {                                       \
 617     SetMsgHandled(TRUE);                                                \
 618     func((UINT)wParam,                                                  \
 619          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 620     lResult = 0;                                                        \
 621     if (IsMsgHandled())                                                 \
 622       return TRUE;                                                      \
 623   }
 624
 625 // void OnNcRButtonUp(UINT nHitTest, gfx::Point point)
 626 #define CR_MSG_WM_NCRBUTTONUP(func)                                     \
 627   if (uMsg == WM_NCRBUTTONUP) {                                         \
 628     SetMsgHandled(TRUE);                                                \
 629     func((UINT)wParam,                                                  \
 630          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 631     lResult = 0;                                                        \
 632     if (IsMsgHandled())                                                 \
 633       return TRUE;                                                      \
 634   }
 635
 636 // void OnNcRButtonDblClk(UINT nHitTest, CPoint point)
 637 #define CR_MSG_WM_NCRBUTTONDBLCLK(func)                                 \
 638   if (uMsg == WM_NCRBUTTONDBLCLK) {                                     \
 639     SetMsgHandled(TRUE);                                                \
 640     func((UINT)wParam,                                                  \
 641          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 642     lResult = 0;                                                        \
 643     if (IsMsgHandled())                                                 \
 644       return TRUE;                                                      \
 645   }
 646
 647 // void OnNcMButtonDown(UINT nHitTest, CPoint point)
 648 #define CR_MSG_WM_NCMBUTTONDOWN(func)                                   \
 649   if (uMsg == WM_NCMBUTTONDOWN) {                                       \
 650     SetMsgHandled(TRUE);                                                \
 651     func((UINT)wParam,                                                  \
 652          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 653     lResult = 0;                                                        \
 654     if (IsMsgHandled())                                                 \
 655       return TRUE;                                                      \
 656   }
 657
 658 // void OnNcMButtonUp(UINT nHitTest, CPoint point)
 659 #define CR_MSG_WM_NCMBUTTONUP(func)                                     \
 660   if (uMsg == WM_NCMBUTTONUP) {                                         \
 661     SetMsgHandled(TRUE);                                                \
 662     func((UINT)wParam,                                                  \
 663          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 664     lResult = 0;                                                        \
 665     if (IsMsgHandled())                                                 \
 666       return TRUE;                                                      \
 667   }
 668
 669 // void OnNcMButtonDblClk(UINT nHitTest, CPoint point)
 670 #define CR_MSG_WM_NCMBUTTONDBLCLK(func)                                 \
 671   if (uMsg == WM_NCMBUTTONDBLCLK) {                                     \
 672     SetMsgHandled(TRUE);                                                \
 673     func((UINT)wParam,                                                  \
 674          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 675     lResult = 0;                                                        \
 676     if (IsMsgHandled())                                                 \
 677       return TRUE;                                                      \
 678   }
 679
 680 // void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
 681 #define CR_MSG_WM_KEYDOWN(func)                \
 682   if (uMsg == WM_KEYDOWN) {                    \
 683     SetMsgHandled(TRUE);                       \
 684     func((TCHAR)wParam,                        \
 685          (UINT)lParam & 0xFFFF,                \
 686          (UINT)((lParam & 0xFFFF0000) >> 16)); \
 687     lResult = 0;                               \
 688     if (IsMsgHandled())                        \
 689       return TRUE;                             \
 690   }
 691
 692 // void OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags)
 693 #define CR_MSG_WM_KEYUP(func)                  \
 694   if (uMsg == WM_KEYUP) {                      \
 695     SetMsgHandled(TRUE);                       \
 696     func((TCHAR)wParam,                        \
 697          (UINT)lParam & 0xFFFF,                \
 698          (UINT)((lParam & 0xFFFF0000) >> 16)); \
 699     lResult = 0;                               \
 700     if (IsMsgHandled())                        \
 701       return TRUE;                             \
 702   }
 703
 704 // void OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
 705 #define CR_MSG_WM_CHAR(func)                   \
 706   if (uMsg == WM_CHAR) {                       \
 707     SetMsgHandled(TRUE);                       \
 708     func((TCHAR)wParam,                        \
 709          (UINT)lParam & 0xFFFF,                \
 710          (UINT)((lParam & 0xFFFF0000) >> 16)); \
 711     lResult = 0;                               \
 712     if (IsMsgHandled())                        \
 713       return TRUE;                             \
 714   }
 715
 716 // void OnDeadChar(UINT nChar, UINT nRepCnt, UINT nFlags)
 717 #define CR_MSG_WM_DEADCHAR(func)               \
 718   if (uMsg == WM_DEADCHAR) {                   \
 719     SetMsgHandled(TRUE);                       \
 720     func((TCHAR)wParam,                        \
 721          (UINT)lParam & 0xFFFF,                \
 722          (UINT)((lParam & 0xFFFF0000) >> 16)); \
 723     lResult = 0;                               \
 724     if (IsMsgHandled())                        \
 725       return TRUE;                             \
 726   }
 727
 728 // void OnSysKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
 729 #define CR_MSG_WM_SYSKEYDOWN(func)             \
 730   if (uMsg == WM_SYSKEYDOWN) {                 \
 731     SetMsgHandled(TRUE);                       \
 732     func((TCHAR)wParam,                        \
 733          (UINT)lParam & 0xFFFF,                \
 734          (UINT)((lParam & 0xFFFF0000) >> 16)); \
 735     lResult = 0;                               \
 736     if (IsMsgHandled())                        \
 737       return TRUE;                             \
 738   }
 739
 740 // void OnSysKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags)
 741 #define CR_MSG_WM_SYSKEYUP(func)               \
 742   if (uMsg == WM_SYSKEYUP) {                   \
 743     SetMsgHandled(TRUE);                       \
 744     func((TCHAR)wParam,                        \
 745          (UINT)lParam & 0xFFFF,                \
 746          (UINT)((lParam & 0xFFFF0000) >> 16)); \
 747     lResult = 0;                               \
 748     if (IsMsgHandled())                        \
 749       return TRUE;                             \
 750   }
 751
 752 // void OnSysChar(UINT nChar, UINT nRepCnt, UINT nFlags)
 753 #define CR_MSG_WM_SYSCHAR(func)                \
 754   if (uMsg == WM_SYSCHAR) {                    \
 755     SetMsgHandled(TRUE);                       \
 756     func((TCHAR)wParam,                        \
 757          (UINT)lParam & 0xFFFF,                \
 758          (UINT)((lParam & 0xFFFF0000) >> 16)); \
 759     lResult = 0;                               \
 760     if (IsMsgHandled())                        \
 761       return TRUE;                             \
 762   }
 763
 764 // void OnSysDeadChar(UINT nChar, UINT nRepCnt, UINT nFlags)
 765 #define CR_MSG_WM_SYSDEADCHAR(func)            \
 766   if (uMsg == WM_SYSDEADCHAR) {                \
 767     SetMsgHandled(TRUE);                       \
 768     func((TCHAR)wParam,                        \
 769          (UINT)lParam & 0xFFFF,                \
 770          (UINT)((lParam & 0xFFFF0000) >> 16)); \
 771     lResult = 0;                               \
 772     if (IsMsgHandled())                        \
 773       return TRUE;                             \
 774   }
 775
 776 // void OnSysCommand(UINT nID, LPARAM lParam)
 777 #define CR_MSG_WM_SYSCOMMAND(func)                                      \
 778   if (uMsg == WM_SYSCOMMAND) {                                          \
 779     SetMsgHandled(TRUE);                                                \
 780     func((UINT)wParam,                                                  \
 781          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 782     lResult = 0;                                                        \
 783     if (IsMsgHandled())                                                 \
 784       return TRUE;                                                      \
 785   }
 786
 787 // void OnTCard(UINT idAction, DWORD dwActionData)
 788 #define CR_MSG_WM_TCARD(func)          \
 789   if (uMsg == WM_TCARD) {              \
 790     SetMsgHandled(TRUE);               \
 791     func((UINT)wParam, (DWORD)lParam); \
 792     lResult = 0;                       \
 793     if (IsMsgHandled())                \
 794       return TRUE;                     \
 795   }
 796
 797 // void OnTimer(UINT_PTR nIDEvent)
 798 #define CR_MSG_WM_TIMER(func) \
 799   if (uMsg == WM_TIMER) {     \
 800     SetMsgHandled(TRUE);      \
 801     func((UINT_PTR)wParam);   \
 802     lResult = 0;              \
 803     if (IsMsgHandled())       \
 804       return TRUE;            \
 805   }
 806
 807 // void OnHScroll(UINT nSBCode, UINT nPos, CScrollBar pScrollBar)
 808 #define CR_MSG_WM_HSCROLL(func)                                     \
 809   if (uMsg == WM_HSCROLL) {                                         \
 810     SetMsgHandled(TRUE);                                            \
 811     func((int)LOWORD(wParam), (short)HIWORD(wParam), (HWND)lParam); \
 812     lResult = 0;                                                    \
 813     if (IsMsgHandled())                                             \
 814       return TRUE;                                                  \
 815   }
 816
 817 // void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar pScrollBar)
 818 #define CR_MSG_WM_VSCROLL(func)                                     \
 819   if (uMsg == WM_VSCROLL) {                                         \
 820     SetMsgHandled(TRUE);                                            \
 821     func((int)LOWORD(wParam), (short)HIWORD(wParam), (HWND)lParam); \
 822     lResult = 0;                                                    \
 823     if (IsMsgHandled())                                             \
 824       return TRUE;                                                  \
 825   }
 826
 827 // void OnInitMenu(CMenu menu)
 828 #define CR_MSG_WM_INITMENU(func) \
 829   if (uMsg == WM_INITMENU) {     \
 830     SetMsgHandled(TRUE);         \
 831     func((HMENU)wParam);         \
 832     lResult = 0;                 \
 833     if (IsMsgHandled())          \
 834       return TRUE;               \
 835   }
 836
 837 // void OnInitMenuPopup(CMenu menuPopup, UINT nIndex, BOOL bSysMenu)
 838 #define CR_MSG_WM_INITMENUPOPUP(func)                                \
 839   if (uMsg == WM_INITMENUPOPUP) {                                    \
 840     SetMsgHandled(TRUE);                                             \
 841     func((HMENU)wParam, (UINT)LOWORD(lParam), (BOOL)HIWORD(lParam)); \
 842     lResult = 0;                                                     \
 843     if (IsMsgHandled())                                              \
 844       return TRUE;                                                   \
 845   }
 846
 847 // void OnMenuSelect(UINT nItemID, UINT nFlags, CMenu menu)
 848 #define CR_MSG_WM_MENUSELECT(func)                                   \
 849   if (uMsg == WM_MENUSELECT) {                                       \
 850     SetMsgHandled(TRUE);                                             \
 851     func((UINT)LOWORD(wParam), (UINT)HIWORD(wParam), (HMENU)lParam); \
 852     lResult = 0;                                                     \
 853     if (IsMsgHandled())                                              \
 854       return TRUE;                                                   \
 855   }
 856
 857 // LRESULT OnMenuChar(UINT nChar, UINT nFlags, CMenu menu)
 858 #define CR_MSG_WM_MENUCHAR(func)                                          \
 859   if (uMsg == WM_MENUCHAR) {                                              \
 860     SetMsgHandled(TRUE);                                                  \
 861     lResult =                                                             \
 862         func((TCHAR)LOWORD(wParam), (UINT)HIWORD(wParam), (HMENU)lParam); \
 863     if (IsMsgHandled())                                                   \
 864       return TRUE;                                                        \
 865   }
 866
 867 // LRESULT OnNotify(int idCtrl, LPNMHDR pnmh)
 868 #define CR_MSG_WM_NOTIFY(func)                    \
 869   if (uMsg == WM_NOTIFY) {                        \
 870     SetMsgHandled(TRUE);                          \
 871     lResult = func((int)wParam, (LPNMHDR)lParam); \
 872     if (IsMsgHandled())                           \
 873       return TRUE;                                \
 874   }
 875
 876 // void OnEnterIdle(UINT nWhy, CWindow wndWho)
 877 #define CR_MSG_WM_ENTERIDLE(func)     \
 878   if (uMsg == WM_ENTERIDLE) {         \
 879     SetMsgHandled(TRUE);              \
 880     func((UINT)wParam, (HWND)lParam); \
 881     lResult = 0;                      \
 882     if (IsMsgHandled())               \
 883       return TRUE;                    \
 884   }
 885
 886 // void OnMouseMove(UINT nFlags, CPoint point)
 887 #define CR_MSG_WM_MOUSEMOVE(func)                                       \
 888   if (uMsg == WM_MOUSEMOVE) {                                           \
 889     SetMsgHandled(TRUE);                                                \
 890     func((UINT)wParam,                                                  \
 891          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 892     lResult = 0;                                                        \
 893     if (IsMsgHandled())                                                 \
 894       return TRUE;                                                      \
 895   }
 896
 897 // BOOL OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
 898 #define CR_MSG_WM_MOUSEWHEEL(func)                                     \
 899   if (uMsg == WM_MOUSEWHEEL) {                                         \
 900     SetMsgHandled(TRUE);                                               \
 901     lResult = (LRESULT)func(                                           \
 902         (UINT)LOWORD(wParam),                                          \
 903         (short)HIWORD(wParam),                                         \
 904         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 905     if (IsMsgHandled())                                                \
 906       return TRUE;                                                     \
 907   }
 908
 909 // void OnLButtonDown(UINT nFlags, CPoint point)
 910 #define CR_MSG_WM_LBUTTONDOWN(func)                                     \
 911   if (uMsg == WM_LBUTTONDOWN) {                                         \
 912     SetMsgHandled(TRUE);                                                \
 913     func((UINT)wParam,                                                  \
 914          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 915     lResult = 0;                                                        \
 916     if (IsMsgHandled())                                                 \
 917       return TRUE;                                                      \
 918   }
 919
 920 // void OnLButtonUp(UINT nFlags, CPoint point)
 921 #define CR_MSG_WM_LBUTTONUP(func)                                       \
 922   if (uMsg == WM_LBUTTONUP) {                                           \
 923     SetMsgHandled(TRUE);                                                \
 924     func((UINT)wParam,                                                  \
 925          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 926     lResult = 0;                                                        \
 927     if (IsMsgHandled())                                                 \
 928       return TRUE;                                                      \
 929   }
 930
 931 // void OnLButtonDblClk(UINT nFlags, CPoint point)
 932 #define CR_MSG_WM_LBUTTONDBLCLK(func)                                   \
 933   if (uMsg == WM_LBUTTONDBLCLK) {                                       \
 934     SetMsgHandled(TRUE);                                                \
 935     func((UINT)wParam,                                                  \
 936          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 937     lResult = 0;                                                        \
 938     if (IsMsgHandled())                                                 \
 939       return TRUE;                                                      \
 940   }
 941
 942 // void OnRButtonDown(UINT nFlags, CPoint point)
 943 #define CR_MSG_WM_RBUTTONDOWN(func)                                     \
 944   if (uMsg == WM_RBUTTONDOWN) {                                         \
 945     SetMsgHandled(TRUE);                                                \
 946     func((UINT)wParam,                                                  \
 947          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 948     lResult = 0;                                                        \
 949     if (IsMsgHandled())                                                 \
 950       return TRUE;                                                      \
 951   }
 952
 953 // void OnRButtonUp(UINT nFlags, CPoint point)
 954 #define CR_MSG_WM_RBUTTONUP(func)                                       \
 955   if (uMsg == WM_RBUTTONUP) {                                           \
 956     SetMsgHandled(TRUE);                                                \
 957     func((UINT)wParam,                                                  \
 958          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 959     lResult = 0;                                                        \
 960     if (IsMsgHandled())                                                 \
 961       return TRUE;                                                      \
 962   }
 963
 964 // void OnRButtonDblClk(UINT nFlags, CPoint point)
 965 #define CR_MSG_WM_RBUTTONDBLCLK(func)                                   \
 966   if (uMsg == WM_RBUTTONDBLCLK) {                                       \
 967     SetMsgHandled(TRUE);                                                \
 968     func((UINT)wParam,                                                  \
 969          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 970     lResult = 0;                                                        \
 971     if (IsMsgHandled())                                                 \
 972       return TRUE;                                                      \
 973   }
 974
 975 // void OnMButtonDown(UINT nFlags, CPoint point)
 976 #define CR_MSG_WM_MBUTTONDOWN(func)                                     \
 977   if (uMsg == WM_MBUTTONDOWN) {                                         \
 978     SetMsgHandled(TRUE);                                                \
 979     func((UINT)wParam,                                                  \
 980          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 981     lResult = 0;                                                        \
 982     if (IsMsgHandled())                                                 \
 983       return TRUE;                                                      \
 984   }
 985
 986 // void OnMButtonUp(UINT nFlags, CPoint point)
 987 #define CR_MSG_WM_MBUTTONUP(func)                                       \
 988   if (uMsg == WM_MBUTTONUP) {                                           \
 989     SetMsgHandled(TRUE);                                                \
 990     func((UINT)wParam,                                                  \
 991          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
 992     lResult = 0;                                                        \
 993     if (IsMsgHandled())                                                 \
 994       return TRUE;                                                      \
 995   }
 996
 997 // void OnMButtonDblClk(UINT nFlags, CPoint point)
 998 #define CR_MSG_WM_MBUTTONDBLCLK(func)                                   \
 999   if (uMsg == WM_MBUTTONDBLCLK) {                                       \
1000     SetMsgHandled(TRUE);                                                \
1001     func((UINT)wParam,                                                  \
1002          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
1003     lResult = 0;                                                        \
1004     if (IsMsgHandled())                                                 \
1005       return TRUE;                                                      \
1006   }
1007
1008 // void OnParentNotify(UINT message, UINT nChildID, LPARAM lParam)
1009 #define CR_MSG_WM_PARENTNOTIFY(func)                          \
1010   if (uMsg == WM_PARENTNOTIFY) {                              \
1011     SetMsgHandled(TRUE);                                      \
1012     func((UINT)LOWORD(wParam), (UINT)HIWORD(wParam), lParam); \
1013     lResult = 0;                                              \
1014     if (IsMsgHandled())                                       \
1015       return TRUE;                                            \
1016   }
1017
1018 // void OnMDIActivate(CWindow wndActivate, CWindow wndDeactivate)
1019 #define CR_MSG_WM_MDIACTIVATE(func)   \
1020   if (uMsg == WM_MDIACTIVATE) {       \
1021     SetMsgHandled(TRUE);              \
1022     func((HWND)wParam, (HWND)lParam); \
1023     lResult = 0;                      \
1024     if (IsMsgHandled())               \
1025       return TRUE;                    \
1026   }
1027
1028 // void OnRenderFormat(UINT nFormat)
1029 #define CR_MSG_WM_RENDERFORMAT(func) \
1030   if (uMsg == WM_RENDERFORMAT) {     \
1031     SetMsgHandled(TRUE);             \
1032     func((UINT)wParam);              \
1033     lResult = 0;                     \
1034     if (IsMsgHandled())              \
1035       return TRUE;                   \
1036   }
1037
1038 // void OnRenderAllFormats()
1039 #define CR_MSG_WM_RENDERALLFORMATS(func) \
1040   if (uMsg == WM_RENDERALLFORMATS) {     \
1041     SetMsgHandled(TRUE);                 \
1042     func();                              \
1043     lResult = 0;                         \
1044     if (IsMsgHandled())                  \
1045       return TRUE;                       \
1046   }
1047
1048 // void OnDestroyClipboard()
1049 #define CR_MSG_WM_DESTROYCLIPBOARD(func) \
1050   if (uMsg == WM_DESTROYCLIPBOARD) {     \
1051     SetMsgHandled(TRUE);                 \
1052     func();                              \
1053     lResult = 0;                         \
1054     if (IsMsgHandled())                  \
1055       return TRUE;                       \
1056   }
1057
1058 // void OnDrawClipboard()
1059 #define CR_MSG_WM_DRAWCLIPBOARD(func) \
1060   if (uMsg == WM_DRAWCLIPBOARD) {     \
1061     SetMsgHandled(TRUE);              \
1062     func();                           \
1063     lResult = 0;                      \
1064     if (IsMsgHandled())               \
1065       return TRUE;                    \
1066   }
1067
1068 // void OnPaintClipboard(CWindow wndViewer, const LPPAINTSTRUCT lpPaintStruct)
1069 #define CR_MSG_WM_PAINTCLIPBOARD(func)                                      \
1070   if (uMsg == WM_PAINTCLIPBOARD) {                                          \
1071     SetMsgHandled(TRUE);                                                    \
1072     func((HWND)wParam, (const LPPAINTSTRUCT)::GlobalLock((HGLOBAL)lParam)); \
1073     ::GlobalUnlock((HGLOBAL)lParam);                                        \
1074     lResult = 0;                                                            \
1075     if (IsMsgHandled())                                                     \
1076       return TRUE;                                                          \
1077   }
1078
1079 // void OnVScrollClipboard(CWindow wndViewer, UINT nSBCode, UINT nPos)
1080 #define CR_MSG_WM_VSCROLLCLIPBOARD(func)                            \
1081   if (uMsg == WM_VSCROLLCLIPBOARD) {                                \
1082     SetMsgHandled(TRUE);                                            \
1083     func((HWND)wParam, (UINT)LOWORD(lParam), (UINT)HIWORD(lParam)); \
1084     lResult = 0;                                                    \
1085     if (IsMsgHandled())                                             \
1086       return TRUE;                                                  \
1087   }
1088
1089 // void OnContextMenu(CWindow wnd, CPoint point)
1090 #define CR_MSG_WM_CONTEXTMENU(func)                                     \
1091   if (uMsg == WM_CONTEXTMENU) {                                         \
1092     SetMsgHandled(TRUE);                                                \
1093     func((HWND)wParam,                                                  \
1094          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
1095     lResult = 0;                                                        \
1096     if (IsMsgHandled())                                                 \
1097       return TRUE;                                                      \
1098   }
1099
1100 // void OnSizeClipboard(CWindow wndViewer, const LPRECT lpRect)
1101 #define CR_MSG_WM_SIZECLIPBOARD(func)                                \
1102   if (uMsg == WM_SIZECLIPBOARD) {                                    \
1103     SetMsgHandled(TRUE);                                             \
1104     func((HWND)wParam, (const LPRECT)::GlobalLock((HGLOBAL)lParam)); \
1105     ::GlobalUnlock((HGLOBAL)lParam);                                 \
1106     lResult = 0;                                                     \
1107     if (IsMsgHandled())                                              \
1108       return TRUE;                                                   \
1109   }
1110
1111 // void OnAskCbFormatName(UINT nMaxCount, LPTSTR lpszString)
1112 #define CR_MSG_WM_ASKCBFORMATNAME(func)  \
1113   if (uMsg == WM_ASKCBFORMATNAME) {      \
1114     SetMsgHandled(TRUE);                 \
1115     func((DWORD)wParam, (LPTSTR)lParam); \
1116     lResult = 0;                         \
1117     if (IsMsgHandled())                  \
1118       return TRUE;                       \
1119   }
1120
1121 // void OnChangeCbChain(CWindow wndRemove, CWindow wndAfter)
1122 #define CR_MSG_WM_CHANGECBCHAIN(func) \
1123   if (uMsg == WM_CHANGECBCHAIN) {     \
1124     SetMsgHandled(TRUE);              \
1125     func((HWND)wParam, (HWND)lParam); \
1126     lResult = 0;                      \
1127     if (IsMsgHandled())               \
1128       return TRUE;                    \
1129   }
1130
1131 // void OnHScrollClipboard(CWindow wndViewer, UINT nSBCode, UINT nPos)
1132 #define CR_MSG_WM_HSCROLLCLIPBOARD(func)                            \
1133   if (uMsg == WM_HSCROLLCLIPBOARD) {                                \
1134     SetMsgHandled(TRUE);                                            \
1135     func((HWND)wParam, (UINT)LOWORD(lParam), (UINT)HIWORD(lParam)); \
1136     lResult = 0;                                                    \
1137     if (IsMsgHandled())                                             \
1138       return TRUE;                                                  \
1139   }
1140
1141 // BOOL OnQueryNewPalette()
1142 #define CR_MSG_WM_QUERYNEWPALETTE(func) \
1143   if (uMsg == WM_QUERYNEWPALETTE) {     \
1144     SetMsgHandled(TRUE);                \
1145     lResult = (LRESULT)func();          \
1146     if (IsMsgHandled())                 \
1147       return TRUE;                      \
1148   }
1149
1150 // void OnPaletteChanged(CWindow wndFocus)
1151 #define CR_MSG_WM_PALETTECHANGED(func) \
1152   if (uMsg == WM_PALETTECHANGED) {     \
1153     SetMsgHandled(TRUE);               \
1154     func((HWND)wParam);                \
1155     lResult = 0;                       \
1156     if (IsMsgHandled())                \
1157       return TRUE;                     \
1158   }
1159
1160 // void OnPaletteIsChanging(CWindow wndPalChg)
1161 #define CR_MSG_WM_PALETTEISCHANGING(func) \
1162   if (uMsg == WM_PALETTEISCHANGING) {     \
1163     SetMsgHandled(TRUE);                  \
1164     func((HWND)wParam);                   \
1165     lResult = 0;                          \
1166     if (IsMsgHandled())                   \
1167       return TRUE;                        \
1168   }
1169
1170 // void OnDropFiles(HDROP hDropInfo)
1171 #define CR_MSG_WM_DROPFILES(func) \
1172   if (uMsg == WM_DROPFILES) {     \
1173     SetMsgHandled(TRUE);          \
1174     func((HDROP)wParam);          \
1175     lResult = 0;                  \
1176     if (IsMsgHandled())           \
1177       return TRUE;                \
1178   }
1179
1180 // void OnWindowPosChanging(LPWINDOWPOS lpWndPos)
1181 #define CR_MSG_WM_WINDOWPOSCHANGING(func) \
1182   if (uMsg == WM_WINDOWPOSCHANGING) {     \
1183     SetMsgHandled(TRUE);                  \
1184     func((LPWINDOWPOS)lParam);            \
1185     lResult = 0;                          \
1186     if (IsMsgHandled())                   \
1187       return TRUE;                        \
1188   }
1189
1190 // void OnWindowPosChanged(LPWINDOWPOS lpWndPos)
1191 #define CR_MSG_WM_WINDOWPOSCHANGED(func) \
1192   if (uMsg == WM_WINDOWPOSCHANGED) {     \
1193     SetMsgHandled(TRUE);                 \
1194     func((LPWINDOWPOS)lParam);           \
1195     lResult = 0;                         \
1196     if (IsMsgHandled())                  \
1197       return TRUE;                       \
1198   }
1199
1200 // void OnExitMenuLoop(BOOL fIsTrackPopupMenu)
1201 #define CR_MSG_WM_EXITMENULOOP(func) \
1202   if (uMsg == WM_EXITMENULOOP) {     \
1203     SetMsgHandled(TRUE);             \
1204     func((BOOL)wParam);              \
1205     lResult = 0;                     \
1206     if (IsMsgHandled())              \
1207       return TRUE;                   \
1208   }
1209
1210 // void OnEnterMenuLoop(BOOL fIsTrackPopupMenu)
1211 #define CR_MSG_WM_ENTERMENULOOP(func) \
1212   if (uMsg == WM_ENTERMENULOOP) {     \
1213     SetMsgHandled(TRUE);              \
1214     func((BOOL)wParam);               \
1215     lResult = 0;                      \
1216     if (IsMsgHandled())               \
1217       return TRUE;                    \
1218   }
1219
1220 // void OnStyleChanged(int nStyleType, LPSTYLESTRUCT lpStyleStruct)
1221 #define CR_MSG_WM_STYLECHANGED(func)           \
1222   if (uMsg == WM_STYLECHANGED) {               \
1223     SetMsgHandled(TRUE);                       \
1224     func((UINT)wParam, (LPSTYLESTRUCT)lParam); \
1225     lResult = 0;                               \
1226     if (IsMsgHandled())                        \
1227       return TRUE;                             \
1228   }
1229
1230 // void OnStyleChanging(int nStyleType, LPSTYLESTRUCT lpStyleStruct)
1231 #define CR_MSG_WM_STYLECHANGING(func)          \
1232   if (uMsg == WM_STYLECHANGING) {              \
1233     SetMsgHandled(TRUE);                       \
1234     func((UINT)wParam, (LPSTYLESTRUCT)lParam); \
1235     lResult = 0;                               \
1236     if (IsMsgHandled())                        \
1237       return TRUE;                             \
1238   }
1239
1240 // void OnSizing(UINT fwSide, LPRECT pRect)
1241 #define CR_MSG_WM_SIZING(func)          \
1242   if (uMsg == WM_SIZING) {              \
1243     SetMsgHandled(TRUE);                \
1244     func((UINT)wParam, (LPRECT)lParam); \
1245     lResult = TRUE;                     \
1246     if (IsMsgHandled())                 \
1247       return TRUE;                      \
1248   }
1249
1250 // void OnMoving(UINT fwSide, LPRECT pRect)
1251 #define CR_MSG_WM_MOVING(func)          \
1252   if (uMsg == WM_MOVING) {              \
1253     SetMsgHandled(TRUE);                \
1254     func((UINT)wParam, (LPRECT)lParam); \
1255     lResult = TRUE;                     \
1256     if (IsMsgHandled())                 \
1257       return TRUE;                      \
1258   }
1259
1260 // void OnCaptureChanged(CWindow wnd)
1261 #define CR_MSG_WM_CAPTURECHANGED(func) \
1262   if (uMsg == WM_CAPTURECHANGED) {     \
1263     SetMsgHandled(TRUE);               \
1264     func((HWND)lParam);                \
1265     lResult = 0;                       \
1266     if (IsMsgHandled())                \
1267       return TRUE;                     \
1268   }
1269
1270 // BOOL OnDeviceChange(UINT nEventType, DWORD dwData)
1271 #define CR_MSG_WM_DEVICECHANGE(func)                      \
1272   if (uMsg == WM_DEVICECHANGE) {                          \
1273     SetMsgHandled(TRUE);                                  \
1274     lResult = (LRESULT)func((UINT)wParam, (DWORD)lParam); \
1275     if (IsMsgHandled())                                   \
1276       return TRUE;                                        \
1277   }
1278
1279 // void OnCommand(UINT uNotifyCode, int nID, CWindow wndCtl)
1280 #define CR_MSG_WM_COMMAND(func)                                    \
1281   if (uMsg == WM_COMMAND) {                                        \
1282     SetMsgHandled(TRUE);                                           \
1283     func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam); \
1284     lResult = 0;                                                   \
1285     if (IsMsgHandled())                                            \
1286       return TRUE;                                                 \
1287   }
1288
1289 // void OnDisplayChange(UINT uBitsPerPixel, gfx::Size sizeScreen)
1290 #define CR_MSG_WM_DISPLAYCHANGE(func)                                  \
1291   if (uMsg == WM_DISPLAYCHANGE) {                                      \
1292     SetMsgHandled(TRUE);                                               \
1293     func((UINT)wParam,                                                 \
1294          gfx::Size(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
1295     lResult = 0;                                                       \
1296     if (IsMsgHandled())                                                \
1297       return TRUE;                                                     \
1298   }
1299
1300 // void OnEnterSizeMove()
1301 #define CR_MSG_WM_ENTERSIZEMOVE(func) \
1302   if (uMsg == WM_ENTERSIZEMOVE) {     \
1303     SetMsgHandled(TRUE);              \
1304     func();                           \
1305     lResult = 0;                      \
1306     if (IsMsgHandled())               \
1307       return TRUE;                    \
1308   }
1309
1310 // void OnExitSizeMove()
1311 #define CR_MSG_WM_EXITSIZEMOVE(func) \
1312   if (uMsg == WM_EXITSIZEMOVE) {     \
1313     SetMsgHandled(TRUE);             \
1314     func();                          \
1315     lResult = 0;                     \
1316     if (IsMsgHandled())              \
1317       return TRUE;                   \
1318   }
1319
1320 // HFONT OnGetFont()
1321 #define CR_MSG_WM_GETFONT(func) \
1322   if (uMsg == WM_GETFONT) {     \
1323     SetMsgHandled(TRUE);        \
1324     lResult = (LRESULT)func();  \
1325     if (IsMsgHandled())         \
1326       return TRUE;              \
1327   }
1328
1329 // LRESULT OnGetHotKey()
1330 #define CR_MSG_WM_GETHOTKEY(func) \
1331   if (uMsg == WM_GETHOTKEY) {     \
1332     SetMsgHandled(TRUE);          \
1333     lResult = func();             \
1334     if (IsMsgHandled())           \
1335       return TRUE;                \
1336   }
1337
1338 // HICON OnGetIcon()
1339 #define CR_MSG_WM_GETICON(func)            \
1340   if (uMsg == WM_GETICON) {                \
1341     SetMsgHandled(TRUE);                   \
1342     lResult = (LRESULT)func((UINT)wParam); \
1343     if (IsMsgHandled())                    \
1344       return TRUE;                         \
1345   }
1346
1347 // int OnGetText(int cchTextMax, LPTSTR lpszText)
1348 #define CR_MSG_WM_GETTEXT(func)                           \
1349   if (uMsg == WM_GETTEXT) {                               \
1350     SetMsgHandled(TRUE);                                  \
1351     lResult = (LRESULT)func((int)wParam, (LPTSTR)lParam); \
1352     if (IsMsgHandled())                                   \
1353       return TRUE;                                        \
1354   }
1355
1356 // int OnGetTextLength()
1357 #define CR_MSG_WM_GETTEXTLENGTH(func) \
1358   if (uMsg == WM_GETTEXTLENGTH) {     \
1359     SetMsgHandled(TRUE);              \
1360     lResult = (LRESULT)func();        \
1361     if (IsMsgHandled())               \
1362       return TRUE;                    \
1363   }
1364
1365 // void OnHelp(LPHELPINFO lpHelpInfo)
1366 #define CR_MSG_WM_HELP(func)  \
1367   if (uMsg == WM_HELP) {      \
1368     SetMsgHandled(TRUE);      \
1369     func((LPHELPINFO)lParam); \
1370     lResult = TRUE;           \
1371     if (IsMsgHandled())       \
1372       return TRUE;            \
1373   }
1374
1375 // void OnHotKey(int nHotKeyID, UINT uModifiers, UINT uVirtKey)
1376 #define CR_MSG_WM_HOTKEY(func)                                     \
1377   if (uMsg == WM_HOTKEY) {                                         \
1378     SetMsgHandled(TRUE);                                           \
1379     func((int)wParam, (UINT)LOWORD(lParam), (UINT)HIWORD(lParam)); \
1380     lResult = 0;                                                   \
1381     if (IsMsgHandled())                                            \
1382       return TRUE;                                                 \
1383   }
1384
1385 // void OnInputLangChange(DWORD dwCharSet, HKL hKbdLayout)
1386 #define CR_MSG_WM_INPUTLANGCHANGE(func) \
1387   if (uMsg == WM_INPUTLANGCHANGE) {     \
1388     SetMsgHandled(TRUE);                \
1389     func((DWORD)wParam, (HKL)lParam);   \
1390     lResult = TRUE;                     \
1391     if (IsMsgHandled())                 \
1392       return TRUE;                      \
1393   }
1394
1395 // void OnInputLangChangeRequest(BOOL bSysCharSet, HKL hKbdLayout)
1396 #define CR_MSG_WM_INPUTLANGCHANGEREQUEST(func) \
1397   if (uMsg == WM_INPUTLANGCHANGEREQUEST) {     \
1398     SetMsgHandled(TRUE);                       \
1399     func((BOOL)wParam, (HKL)lParam);           \
1400     lResult = 0;                               \
1401     if (IsMsgHandled())                        \
1402       return TRUE;                             \
1403   }
1404
1405 // void OnNextDlgCtl(BOOL bHandle, WPARAM wCtlFocus)
1406 #define CR_MSG_WM_NEXTDLGCTL(func)      \
1407   if (uMsg == WM_NEXTDLGCTL) {          \
1408     SetMsgHandled(TRUE);                \
1409     func((BOOL)LOWORD(lParam), wParam); \
1410     lResult = 0;                        \
1411     if (IsMsgHandled())                 \
1412       return TRUE;                      \
1413   }
1414
1415 // void OnNextMenu(int nVirtKey, LPMDINEXTMENU lpMdiNextMenu)
1416 #define CR_MSG_WM_NEXTMENU(func)              \
1417   if (uMsg == WM_NEXTMENU) {                  \
1418     SetMsgHandled(TRUE);                      \
1419     func((int)wParam, (LPMDINEXTMENU)lParam); \
1420     lResult = 0;                              \
1421     if (IsMsgHandled())                       \
1422       return TRUE;                            \
1423   }
1424
1425 // int OnNotifyFormat(CWindow wndFrom, int nCommand)
1426 #define CR_MSG_WM_NOTIFYFORMAT(func)                    \
1427   if (uMsg == WM_NOTIFYFORMAT) {                        \
1428     SetMsgHandled(TRUE);                                \
1429     lResult = (LRESULT)func((HWND)wParam, (int)lParam); \
1430     if (IsMsgHandled())                                 \
1431       return TRUE;                                      \
1432   }
1433
1434 // BOOL OnPowerBroadcast(DWORD dwPowerEvent, DWORD dwData)
1435 #define CR_MSG_WM_POWERBROADCAST(func)                     \
1436   if (uMsg == WM_POWERBROADCAST) {                         \
1437     SetMsgHandled(TRUE);                                   \
1438     lResult = (LRESULT)func((DWORD)wParam, (DWORD)lParam); \
1439     if (IsMsgHandled())                                    \
1440       return TRUE;                                         \
1441   }
1442
1443 // void OnPrint(CDCHandle dc, UINT uFlags)
1444 #define CR_MSG_WM_PRINT(func)        \
1445   if (uMsg == WM_PRINT) {            \
1446     SetMsgHandled(TRUE);             \
1447     func((HDC)wParam, (UINT)lParam); \
1448     lResult = 0;                     \
1449     if (IsMsgHandled())              \
1450       return TRUE;                   \
1451   }
1452
1453 // void OnPrintClient(CDCHandle dc, UINT uFlags)
1454 #define CR_MSG_WM_PRINTCLIENT(func)  \
1455   if (uMsg == WM_PRINTCLIENT) {      \
1456     SetMsgHandled(TRUE);             \
1457     func((HDC)wParam, (UINT)lParam); \
1458     lResult = 0;                     \
1459     if (IsMsgHandled())              \
1460       return TRUE;                   \
1461   }
1462
1463 // void OnRasDialEvent(RASCONNSTATE rasconnstate, DWORD dwError)
1464 #define CR_MSG_WM_RASDIALEVENT(func)           \
1465   if (uMsg == WM_RASDIALEVENT) {               \
1466     SetMsgHandled(TRUE);                       \
1467     func((RASCONNSTATE)wParam, (DWORD)lParam); \
1468     lResult = TRUE;                            \
1469     if (IsMsgHandled())                        \
1470       return TRUE;                             \
1471   }
1472
1473 // void OnSetFont(CFont font, BOOL bRedraw)
1474 #define CR_MSG_WM_SETFONT(func)                \
1475   if (uMsg == WM_SETFONT) {                    \
1476     SetMsgHandled(TRUE);                       \
1477     func((HFONT)wParam, (BOOL)LOWORD(lParam)); \
1478     lResult = 0;                               \
1479     if (IsMsgHandled())                        \
1480       return TRUE;                             \
1481   }
1482
1483 // int OnSetHotKey(int nVirtKey, UINT uFlags)
1484 #define CR_MSG_WM_SETHOTKEY(func)                          \
1485   if (uMsg == WM_SETHOTKEY) {                              \
1486     SetMsgHandled(TRUE);                                   \
1487     lResult = (LRESULT)func((int)LOBYTE(LOWORD(wParam)),   \
1488                             (UINT)HIBYTE(LOWORD(wParam))); \
1489     if (IsMsgHandled())                                    \
1490       return TRUE;                                         \
1491   }
1492
1493 // HICON OnSetIcon(UINT uType, HICON hIcon)
1494 #define CR_MSG_WM_SETICON(func)                           \
1495   if (uMsg == WM_SETICON) {                               \
1496     SetMsgHandled(TRUE);                                  \
1497     lResult = (LRESULT)func((UINT)wParam, (HICON)lParam); \
1498     if (IsMsgHandled())                                   \
1499       return TRUE;                                        \
1500   }
1501
1502 // void OnSetRedraw(BOOL bRedraw)
1503 #define CR_MSG_WM_SETREDRAW(func) \
1504   if (uMsg == WM_SETREDRAW) {     \
1505     SetMsgHandled(TRUE);          \
1506     func((BOOL)wParam);           \
1507     lResult = 0;                  \
1508     if (IsMsgHandled())           \
1509       return TRUE;                \
1510   }
1511
1512 // int OnSetText(LPCTSTR lpstrText)
1513 #define CR_MSG_WM_SETTEXT(func)               \
1514   if (uMsg == WM_SETTEXT) {                   \
1515     SetMsgHandled(TRUE);                      \
1516     lResult = (LRESULT)func((LPCTSTR)lParam); \
1517     if (IsMsgHandled())                       \
1518       return TRUE;                            \
1519   }
1520
1521 // void OnUserChanged()
1522 #define CR_MSG_WM_USERCHANGED(func) \
1523   if (uMsg == WM_USERCHANGED) {     \
1524     SetMsgHandled(TRUE);            \
1525     func();                         \
1526     lResult = 0;                    \
1527     if (IsMsgHandled())             \
1528       return TRUE;                  \
1529   }
1530
1531 ///////////////////////////////////////////////////////////////////////////////
1532 // New NT4 & NT5 messages
1533
1534 #if (_WIN32_WINNT >= 0x0400)
1535
1536 // void OnMouseHover(WPARAM wParam, CPoint ptPos)
1537 #define CR_MSG_WM_MOUSEHOVER(func)                                      \
1538   if (uMsg == WM_MOUSEHOVER) {                                          \
1539     SetMsgHandled(TRUE);                                                \
1540     func(wParam,                                                        \
1541          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
1542     lResult = 0;                                                        \
1543     if (IsMsgHandled())                                                 \
1544       return TRUE;                                                      \
1545   }
1546
1547 // void OnMouseLeave()
1548 #define CR_MSG_WM_MOUSELEAVE(func) \
1549   if (uMsg == WM_MOUSELEAVE) {     \
1550     SetMsgHandled(TRUE);           \
1551     func();                        \
1552     lResult = 0;                   \
1553     if (IsMsgHandled())            \
1554       return TRUE;                 \
1555   }
1556
1557 #endif /* _WIN32_WINNT >= 0x0400 */
1558
1559 #if (WINVER >= 0x0500)
1560
1561 // void OnMenuRButtonUp(WPARAM wParam, CMenu menu)
1562 #define CR_MSG_WM_MENURBUTTONUP(func) \
1563   if (uMsg == WM_MENURBUTTONUP) {     \
1564     SetMsgHandled(TRUE);              \
1565     func(wParam, (HMENU)lParam);      \
1566     lResult = 0;                      \
1567     if (IsMsgHandled())               \
1568       return TRUE;                    \
1569   }
1570
1571 // LRESULT OnMenuDrag(WPARAM wParam, CMenu menu)
1572 #define CR_MSG_WM_MENUDRAG(func)           \
1573   if (uMsg == WM_MENUDRAG) {               \
1574     SetMsgHandled(TRUE);                   \
1575     lResult = func(wParam, (HMENU)lParam); \
1576     if (IsMsgHandled())                    \
1577       return TRUE;                         \
1578   }
1579
1580 // LRESULT OnMenuGetObject(PMENUGETOBJECTINFO info)
1581 #define CR_MSG_WM_MENUGETOBJECT(func)           \
1582   if (uMsg == WM_MENUGETOBJECT) {               \
1583     SetMsgHandled(TRUE);                        \
1584     lResult = func((PMENUGETOBJECTINFO)lParam); \
1585     if (IsMsgHandled())                         \
1586       return TRUE;                              \
1587   }
1588
1589 // void OnUnInitMenuPopup(UINT nID, CMenu menu)
1590 #define CR_MSG_WM_UNINITMENUPOPUP(func)        \
1591   if (uMsg == WM_UNINITMENUPOPUP) {            \
1592     SetMsgHandled(TRUE);                       \
1593     func((UINT)HIWORD(lParam), (HMENU)wParam); \
1594     lResult = 0;                               \
1595     if (IsMsgHandled())                        \
1596       return TRUE;                             \
1597   }
1598
1599 // void OnMenuCommand(WPARAM nIndex, CMenu menu)
1600 #define CR_MSG_WM_MENUCOMMAND(func) \
1601   if (uMsg == WM_MENUCOMMAND) {     \
1602     SetMsgHandled(TRUE);            \
1603     func(wParam, (HMENU)lParam);    \
1604     lResult = 0;                    \
1605     if (IsMsgHandled())             \
1606       return TRUE;                  \
1607   }
1608
1609 #endif /* WINVER >= 0x0500 */
1610
1611 #if (_WIN32_WINNT >= 0x0500)
1612
1613 // BOOL OnAppCommand(CWindow wndFocus, short cmd, WORD uDevice, int dwKeys)
1614 #define CR_MSG_WM_APPCOMMAND(func)                         \
1615   if (uMsg == WM_APPCOMMAND) {                             \
1616     SetMsgHandled(TRUE);                                   \
1617     lResult = (LRESULT)func((HWND)wParam,                  \
1618                             GET_APPCOMMAND_LPARAM(lParam), \
1619                             GET_DEVICE_LPARAM(lParam),     \
1620                             GET_KEYSTATE_LPARAM(lParam));  \
1621     if (IsMsgHandled())                                    \
1622       return TRUE;                                         \
1623   }
1624
1625 // void OnNCXButtonDown(int fwButton, short nHittest, CPoint ptPos)
1626 #define CR_MSG_WM_NCXBUTTONDOWN(func)                                   \
1627   if (uMsg == WM_NCXBUTTONDOWN) {                                       \
1628     SetMsgHandled(TRUE);                                                \
1629     func(GET_XBUTTON_WPARAM(wParam),                                    \
1630          GET_NCHITTEST_WPARAM(wParam),                                  \
1631          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
1632     lResult = 0;                                                        \
1633     if (IsMsgHandled())                                                 \
1634       return TRUE;                                                      \
1635   }
1636
1637 // void OnNCXButtonUp(int fwButton, short nHittest, CPoint ptPos)
1638 #define CR_MSG_WM_NCXBUTTONUP(func)                                     \
1639   if (uMsg == WM_NCXBUTTONUP) {                                         \
1640     SetMsgHandled(TRUE);                                                \
1641     func(GET_XBUTTON_WPARAM(wParam),                                    \
1642          GET_NCHITTEST_WPARAM(wParam),                                  \
1643          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
1644     lResult = 0;                                                        \
1645     if (IsMsgHandled())                                                 \
1646       return TRUE;                                                      \
1647   }
1648
1649 // void OnNCXButtonDblClk(int fwButton, short nHittest, CPoint ptPos)
1650 #define CR_MSG_WM_NCXBUTTONDBLCLK(func)                                 \
1651   if (uMsg == WM_NCXBUTTONDBLCLK) {                                     \
1652     SetMsgHandled(TRUE);                                                \
1653     func(GET_XBUTTON_WPARAM(wParam),                                    \
1654          GET_NCHITTEST_WPARAM(wParam),                                  \
1655          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
1656     lResult = 0;                                                        \
1657     if (IsMsgHandled())                                                 \
1658       return TRUE;                                                      \
1659   }
1660
1661 // void OnXButtonDown(int fwButton, int dwKeys, CPoint ptPos)
1662 #define CR_MSG_WM_XBUTTONDOWN(func)                                     \
1663   if (uMsg == WM_XBUTTONDOWN) {                                         \
1664     SetMsgHandled(TRUE);                                                \
1665     func(GET_XBUTTON_WPARAM(wParam),                                    \
1666          GET_KEYSTATE_WPARAM(wParam),                                   \
1667          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
1668     lResult = 0;                                                        \
1669     if (IsMsgHandled())                                                 \
1670       return TRUE;                                                      \
1671   }
1672
1673 // void OnXButtonUp(int fwButton, int dwKeys, CPoint ptPos)
1674 #define CR_MSG_WM_XBUTTONUP(func)                                       \
1675   if (uMsg == WM_XBUTTONUP) {                                           \
1676     SetMsgHandled(TRUE);                                                \
1677     func(GET_XBUTTON_WPARAM(wParam),                                    \
1678          GET_KEYSTATE_WPARAM(wParam),                                   \
1679          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
1680     lResult = 0;                                                        \
1681     if (IsMsgHandled())                                                 \
1682       return TRUE;                                                      \
1683   }
1684
1685 // void OnXButtonDblClk(int fwButton, int dwKeys, CPoint ptPos)
1686 #define CR_MSG_WM_XBUTTONDBLCLK(func)                                   \
1687   if (uMsg == WM_XBUTTONDBLCLK) {                                       \
1688     SetMsgHandled(TRUE);                                                \
1689     func(GET_XBUTTON_WPARAM(wParam),                                    \
1690          GET_KEYSTATE_WPARAM(wParam),                                   \
1691          gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
1692     lResult = 0;                                                        \
1693     if (IsMsgHandled())                                                 \
1694       return TRUE;                                                      \
1695   }
1696
1697 // void OnChangeUIState(WORD nAction, WORD nState)
1698 #define CR_MSG_WM_CHANGEUISTATE(func)     \
1699   if (uMsg == WM_CHANGEUISTATE) {         \
1700     SetMsgHandled(TRUE);                  \
1701     func(LOWORD(wParam), HIWORD(wParam)); \
1702     lResult = 0;                          \
1703     if (IsMsgHandled())                   \
1704       return TRUE;                        \
1705   }
1706
1707 // void OnUpdateUIState(WORD nAction, WORD nState)
1708 #define CR_MSG_WM_UPDATEUISTATE(func)     \
1709   if (uMsg == WM_UPDATEUISTATE) {         \
1710     SetMsgHandled(TRUE);                  \
1711     func(LOWORD(wParam), HIWORD(wParam)); \
1712     lResult = 0;                          \
1713     if (IsMsgHandled())                   \
1714       return TRUE;                        \
1715   }
1716
1717 // LRESULT OnQueryUIState()
1718 #define CR_MSG_WM_QUERYUISTATE(func) \
1719   if (uMsg == WM_QUERYUISTATE) {     \
1720     SetMsgHandled(TRUE);             \
1721     lResult = func();                \
1722     if (IsMsgHandled())              \
1723       return TRUE;                   \
1724   }
1725
1726 #endif  // (_WIN32_WINNT >= 0x0500)
1727
1728 #if (_WIN32_WINNT >= 0x0501)
1729
1730 // void OnInput(WPARAM RawInputCode, HRAWINPUT hRawInput)
1731 #define CR_MSG_WM_INPUT(func)                                  \
1732   if (uMsg == WM_INPUT) {                                      \
1733     SetMsgHandled(TRUE);                                       \
1734     func(GET_RAWINPUT_CODE_WPARAM(wParam), (HRAWINPUT)lParam); \
1735     lResult = 0;                                               \
1736     if (IsMsgHandled())                                        \
1737       return TRUE;                                             \
1738   }
1739
1740 // void OnUniChar(TCHAR nChar, UINT nRepCnt, UINT nFlags)
1741 #define CR_MSG_WM_UNICHAR(func)                            \
1742   if (uMsg == WM_UNICHAR) {                                \
1743     SetMsgHandled(TRUE);                                   \
1744     func((TCHAR)wParam,                                    \
1745          (UINT)lParam & 0xFFFF,                            \
1746          (UINT)((lParam & 0xFFFF0000) >> 16));             \
1747     if (IsMsgHandled()) {                                  \
1748       lResult = (wParam == UNICODE_NOCHAR) ? TRUE : FALSE; \
1749       return TRUE;                                         \
1750     }                                                      \
1751   }
1752
1753 // void OnWTSSessionChange(WPARAM nStatusCode, PWTSSESSION_NOTIFICATION
1754 // nSessionID)
1755 #define CR_MSG_WM_WTSSESSION_CHANGE(func)           \
1756   if (uMsg == WM_WTSSESSION_CHANGE) {               \
1757     SetMsgHandled(TRUE);                            \
1758     func(wParam, (PWTSSESSION_NOTIFICATION)lParam); \
1759     lResult = 0;                                    \
1760     if (IsMsgHandled())                             \
1761       return TRUE;                                  \
1762   }
1763
1764 // OnThemeChanged()
1765 #define CR_MSG_WM_THEMECHANGED(func) \
1766   if (uMsg == WM_THEMECHANGED) {     \
1767     SetMsgHandled(TRUE);             \
1768     func();                          \
1769     lResult = 0;                     \
1770     if (IsMsgHandled())              \
1771       return TRUE;                   \
1772   }
1773
1774 #endif /* _WIN32_WINNT >= 0x0501 */
1775
1776 ///////////////////////////////////////////////////////////////////////////////
1777 // ATL defined messages
1778
1779 // BOOL OnForwardMsg(LPMSG Msg, DWORD nUserData)
1780 #define CR_MSG_WM_FORWARDMSG(func)                         \
1781   if (uMsg == WM_FORWARDMSG) {                             \
1782     SetMsgHandled(TRUE);                                   \
1783     lResult = (LRESULT)func((LPMSG)lParam, (DWORD)wParam); \
1784     if (IsMsgHandled())                                    \
1785       return TRUE;                                         \
1786   }
1787
1788 ///////////////////////////////////////////////////////////////////////////////
1789 // Dialog specific messages
1790
1791 // LRESULT OnDMGetDefID()
1792 #define MSG_DM_GETDEFID(func) \
1793   if (uMsg == DM_GETDEFID) {  \
1794     SetMsgHandled(TRUE);      \
1795     lResult = func();         \
1796     if (IsMsgHandled())       \
1797       return TRUE;            \
1798   }
1799
1800 // void OnDMSetDefID(UINT DefID)
1801 #define MSG_DM_SETDEFID(func) \
1802   if (uMsg == DM_SETDEFID) {  \
1803     SetMsgHandled(TRUE);      \
1804     func((UINT)wParam);       \
1805     lResult = TRUE;           \
1806     if (IsMsgHandled())       \
1807       return TRUE;            \
1808   }
1809
1810 // void OnDMReposition()
1811 #define MSG_DM_REPOSITION(func) \
1812   if (uMsg == DM_REPOSITION) {  \
1813     SetMsgHandled(TRUE);        \
1814     func();                     \
1815     lResult = 0;                \
1816     if (IsMsgHandled())         \
1817       return TRUE;              \
1818   }
1819
1820 ///////////////////////////////////////////////////////////////////////////////
1821 // Reflected messages
1822
1823 // void OnReflectedCommand(UINT uNotifyCode, int nID, CWindow wndCtl)
1824 #define MSG_OCM_COMMAND(func)                                      \
1825   if (uMsg == OCM_COMMAND) {                                       \
1826     SetMsgHandled(TRUE);                                           \
1827     func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam); \
1828     lResult = 0;                                                   \
1829     if (IsMsgHandled())                                            \
1830       return TRUE;                                                 \
1831   }
1832
1833 // LRESULT OnReflectedNotify(int idCtrl, LPNMHDR pnmh)
1834 #define MSG_OCM_NOTIFY(func)                      \
1835   if (uMsg == OCM_NOTIFY) {                       \
1836     SetMsgHandled(TRUE);                          \
1837     lResult = func((int)wParam, (LPNMHDR)lParam); \
1838     if (IsMsgHandled())                           \
1839       return TRUE;                                \
1840   }
1841
1842 // void OnReflectedParentNotify(UINT message, UINT nChildID, LPARAM lParam)
1843 #define MSG_OCM_PARENTNOTIFY(func)                            \
1844   if (uMsg == OCM_PARENTNOTIFY) {                             \
1845     SetMsgHandled(TRUE);                                      \
1846     func((UINT)LOWORD(wParam), (UINT)HIWORD(wParam), lParam); \
1847     lResult = 0;                                              \
1848     if (IsMsgHandled())                                       \
1849       return TRUE;                                            \
1850   }
1851
1852 // void OnReflectedDrawItem(int nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct)
1853 #define MSG_OCM_DRAWITEM(func)                    \
1854   if (uMsg == OCM_DRAWITEM) {                     \
1855     SetMsgHandled(TRUE);                          \
1856     func((UINT)wParam, (LPDRAWITEMSTRUCT)lParam); \
1857     lResult = TRUE;                               \
1858     if (IsMsgHandled())                           \
1859       return TRUE;                                \
1860   }
1861
1862 // void OnReflectedMeasureItem(int nIDCtl, LPMEASUREITEMSTRUCT
1863 // lpMeasureItemStruct)
1864 #define MSG_OCM_MEASUREITEM(func)                    \
1865   if (uMsg == OCM_MEASUREITEM) {                     \
1866     SetMsgHandled(TRUE);                             \
1867     func((UINT)wParam, (LPMEASUREITEMSTRUCT)lParam); \
1868     lResult = TRUE;                                  \
1869     if (IsMsgHandled())                              \
1870       return TRUE;                                   \
1871   }
1872
1873 // int OnReflectedCompareItem(int nIDCtl, LPCOMPAREITEMSTRUCT
1874 // lpCompareItemStruct)
1875 #define MSG_OCM_COMPAREITEM(func)                                       \
1876   if (uMsg == OCM_COMPAREITEM) {                                        \
1877     SetMsgHandled(TRUE);                                                \
1878     lResult = (LRESULT)func((UINT)wParam, (LPCOMPAREITEMSTRUCT)lParam); \
1879     if (IsMsgHandled())                                                 \
1880       return TRUE;                                                      \
1881   }
1882
1883 // void OnReflectedDeleteItem(int nIDCtl, LPDELETEITEMSTRUCT lpDeleteItemStruct)
1884 #define MSG_OCM_DELETEITEM(func)                    \
1885   if (uMsg == OCM_DELETEITEM) {                     \
1886     SetMsgHandled(TRUE);                            \
1887     func((UINT)wParam, (LPDELETEITEMSTRUCT)lParam); \
1888     lResult = TRUE;                                 \
1889     if (IsMsgHandled())                             \
1890       return TRUE;                                  \
1891   }
1892
1893 // int OnReflectedVKeyToItem(UINT nKey, UINT nIndex, CListBox listBox)
1894 #define MSG_OCM_VKEYTOITEM(func)                                   \
1895   if (uMsg == OCM_VKEYTOITEM) {                                    \
1896     SetMsgHandled(TRUE);                                           \
1897     lResult = (LRESULT)func(                                       \
1898         (UINT)LOWORD(wParam), (UINT)HIWORD(wParam), (HWND)lParam); \
1899     if (IsMsgHandled())                                            \
1900       return TRUE;                                                 \
1901   }
1902
1903 // int OnReflectedCharToItem(UINT nChar, UINT nIndex, CListBox listBox)
1904 #define MSG_OCM_CHARTOITEM(func)                                   \
1905   if (uMsg == OCM_CHARTOITEM) {                                    \
1906     SetMsgHandled(TRUE);                                           \
1907     lResult = (LRESULT)func(                                       \
1908         (UINT)LOWORD(wParam), (UINT)HIWORD(wParam), (HWND)lParam); \
1909     if (IsMsgHandled())                                            \
1910       return TRUE;                                                 \
1911   }
1912
1913 // void OnReflectedHScroll(UINT nSBCode, UINT nPos, CScrollBar pScrollBar)
1914 #define MSG_OCM_HSCROLL(func)                                       \
1915   if (uMsg == OCM_HSCROLL) {                                        \
1916     SetMsgHandled(TRUE);                                            \
1917     func((int)LOWORD(wParam), (short)HIWORD(wParam), (HWND)lParam); \
1918     lResult = 0;                                                    \
1919     if (IsMsgHandled())                                             \
1920       return TRUE;                                                  \
1921   }
1922
1923 // void OnReflectedVScroll(UINT nSBCode, UINT nPos, CScrollBar pScrollBar)
1924 #define MSG_OCM_VSCROLL(func)                                       \
1925   if (uMsg == OCM_VSCROLL) {                                        \
1926     SetMsgHandled(TRUE);                                            \
1927     func((int)LOWORD(wParam), (short)HIWORD(wParam), (HWND)lParam); \
1928     lResult = 0;                                                    \
1929     if (IsMsgHandled())                                             \
1930       return TRUE;                                                  \
1931   }
1932
1933 // HBRUSH OnReflectedCtlColorEdit(CDCHandle dc, CEdit edit)
1934 #define MSG_OCM_CTLCOLOREDIT(func)                      \
1935   if (uMsg == OCM_CTLCOLOREDIT) {                       \
1936     SetMsgHandled(TRUE);                                \
1937     lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
1938     if (IsMsgHandled())                                 \
1939       return TRUE;                                      \
1940   }
1941
1942 // HBRUSH OnReflectedCtlColorListBox(CDCHandle dc, CListBox listBox)
1943 #define MSG_OCM_CTLCOLORLISTBOX(func)                   \
1944   if (uMsg == OCM_CTLCOLORLISTBOX) {                    \
1945     SetMsgHandled(TRUE);                                \
1946     lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
1947     if (IsMsgHandled())                                 \
1948       return TRUE;                                      \
1949   }
1950
1951 // HBRUSH OnReflectedCtlColorBtn(CDCHandle dc, CButton button)
1952 #define MSG_OCM_CTLCOLORBTN(func)                       \
1953   if (uMsg == OCM_CTLCOLORBTN) {                        \
1954     SetMsgHandled(TRUE);                                \
1955     lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
1956     if (IsMsgHandled())                                 \
1957       return TRUE;                                      \
1958   }
1959
1960 // HBRUSH OnReflectedCtlColorDlg(CDCHandle dc, CWindow wnd)
1961 #define MSG_OCM_CTLCOLORDLG(func)                       \
1962   if (uMsg == OCM_CTLCOLORDLG) {                        \
1963     SetMsgHandled(TRUE);                                \
1964     lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
1965     if (IsMsgHandled())                                 \
1966       return TRUE;                                      \
1967   }
1968
1969 // HBRUSH OnReflectedCtlColorScrollBar(CDCHandle dc, CScrollBar scrollBar)
1970 #define MSG_OCM_CTLCOLORSCROLLBAR(func)                 \
1971   if (uMsg == OCM_CTLCOLORSCROLLBAR) {                  \
1972     SetMsgHandled(TRUE);                                \
1973     lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
1974     if (IsMsgHandled())                                 \
1975       return TRUE;                                      \
1976   }
1977
1978 // HBRUSH OnReflectedCtlColorStatic(CDCHandle dc, CStatic wndStatic)
1979 #define MSG_OCM_CTLCOLORSTATIC(func)                    \
1980   if (uMsg == OCM_CTLCOLORSTATIC) {                     \
1981     SetMsgHandled(TRUE);                                \
1982     lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
1983     if (IsMsgHandled())                                 \
1984       return TRUE;                                      \
1985   }
1986
1987 ///////////////////////////////////////////////////////////////////////////////
1988 // Edit specific messages
1989
1990 // void OnClear()
1991 #define CR_MSG_WM_CLEAR(func) \
1992   if (uMsg == WM_CLEAR) {     \
1993     SetMsgHandled(TRUE);      \
1994     func();                   \
1995     lResult = 0;              \
1996     if (IsMsgHandled())       \
1997       return TRUE;            \
1998   }
1999
2000 // void OnCopy()
2001 #define CR_MSG_WM_COPY(func) \
2002   if (uMsg == WM_COPY) {     \
2003     SetMsgHandled(TRUE);     \
2004     func();                  \
2005     lResult = 0;             \
2006     if (IsMsgHandled())      \
2007       return TRUE;           \
2008   }
2009
2010 // void OnCut()
2011 #define CR_MSG_WM_CUT(func) \
2012   if (uMsg == WM_CUT) {     \
2013     SetMsgHandled(TRUE);    \
2014     func();                 \
2015     lResult = 0;            \
2016     if (IsMsgHandled())     \
2017       return TRUE;          \
2018   }
2019
2020 // void OnPaste()
2021 #define CR_MSG_WM_PASTE(func) \
2022   if (uMsg == WM_PASTE) {     \
2023     SetMsgHandled(TRUE);      \
2024     func();                   \
2025     lResult = 0;              \
2026     if (IsMsgHandled())       \
2027       return TRUE;            \
2028   }
2029
2030 // void OnUndo()
2031 #define CR_MSG_WM_UNDO(func) \
2032   if (uMsg == WM_UNDO) {     \
2033     SetMsgHandled(TRUE);     \
2034     func();                  \
2035     lResult = 0;             \
2036     if (IsMsgHandled())      \
2037       return TRUE;           \
2038   }
2039
2040 ///////////////////////////////////////////////////////////////////////////////
2041 // Generic message handlers
2042
2043 // LRESULT OnMessageHandlerEX(UINT uMsg, WPARAM wParam, LPARAM lParam)
2044 #define CR_MESSAGE_HANDLER_EX(msg, func)  \
2045   if (uMsg == msg) {                      \
2046     SetMsgHandled(TRUE);                  \
2047     lResult = func(uMsg, wParam, lParam); \
2048     if (IsMsgHandled())                   \
2049       return TRUE;                        \
2050   }
2051
2052 // LRESULT OnMessageRangeHandlerEX(UINT uMsg, WPARAM wParam, LPARAM lParam)
2053 #define CR_MESSAGE_RANGE_HANDLER_EX(msgFirst, msgLast, func) \
2054   if (uMsg >= msgFirst && uMsg <= msgLast) {                 \
2055     SetMsgHandled(TRUE);                                     \
2056     lResult = func(uMsg, wParam, lParam);                    \
2057     if (IsMsgHandled())                                      \
2058       return TRUE;                                           \
2059   }
2060
2061 ///////////////////////////////////////////////////////////////////////////////
2062 // Commands and notifications
2063
2064 // void OnCommandHandlerEX(UINT uNotifyCode, int nID, CWindow wndCtl)
2065 #define CR_COMMAND_HANDLER_EX(id, code, func)                                 \
2066   if (uMsg == WM_COMMAND && code == HIWORD(wParam) && id == LOWORD(wParam)) { \
2067     SetMsgHandled(TRUE);                                                      \
2068     func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam);            \
2069     lResult = 0;                                                              \
2070     if (IsMsgHandled())                                                       \
2071       return TRUE;                                                            \
2072   }
2073
2074 // void OnCommandIDHandlerEX(UINT uNotifyCode, int nID, CWindow wndCtl)
2075 #define CR_COMMAND_ID_HANDLER_EX(id, func)                         \
2076   if (uMsg == WM_COMMAND && id == LOWORD(wParam)) {                \
2077     SetMsgHandled(TRUE);                                           \
2078     func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam); \
2079     lResult = 0;                                                   \
2080     if (IsMsgHandled())                                            \
2081       return TRUE;                                                 \
2082   }
2083
2084 // void OnCommandCodeHandlerEX(UINT uNotifyCode, int nID, CWindow wndCtl)
2085 #define CR_COMMAND_CODE_HANDLER_EX(code, func)                     \
2086   if (uMsg == WM_COMMAND && code == HIWORD(wParam)) {              \
2087     SetMsgHandled(TRUE);                                           \
2088     func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam); \
2089     lResult = 0;                                                   \
2090     if (IsMsgHandled())                                            \
2091       return TRUE;                                                 \
2092   }
2093
2094 // LRESULT OnNotifyHandlerEX(LPNMHDR pnmh)
2095 #define CR_NOTIFY_HANDLER_EX(id, cd, func)                  \
2096   if (uMsg == WM_NOTIFY && cd == ((LPNMHDR)lParam)->code && \
2097       id == ((LPNMHDR)lParam)->idFrom) {                    \
2098     SetMsgHandled(TRUE);                                    \
2099     lResult = func((LPNMHDR)lParam);                        \
2100     if (IsMsgHandled())                                     \
2101       return TRUE;                                          \
2102   }
2103
2104 // LRESULT OnNotifyIDHandlerEX(LPNMHDR pnmh)
2105 #define CR_NOTIFY_ID_HANDLER_EX(id, func)                     \
2106   if (uMsg == WM_NOTIFY && id == ((LPNMHDR)lParam)->idFrom) { \
2107     SetMsgHandled(TRUE);                                      \
2108     lResult = func((LPNMHDR)lParam);                          \
2109     if (IsMsgHandled())                                       \
2110       return TRUE;                                            \
2111   }
2112
2113 // LRESULT OnNotifyCodeHandlerEX(LPNMHDR pnmh)
2114 #define CR_NOTIFY_CODE_HANDLER_EX(cd, func)                 \
2115   if (uMsg == WM_NOTIFY && cd == ((LPNMHDR)lParam)->code) { \
2116     SetMsgHandled(TRUE);                                    \
2117     lResult = func((LPNMHDR)lParam);                        \
2118     if (IsMsgHandled())                                     \
2119       return TRUE;                                          \
2120   }
2121
2122 // void OnCommandRangeHandlerEX(UINT uNotifyCode, int nID, CWindow wndCtl)
2123 #define CR_COMMAND_RANGE_HANDLER_EX(idFirst, idLast, func)         \
2124   if (uMsg == WM_COMMAND && LOWORD(wParam) >= idFirst &&           \
2125       LOWORD(wParam) <= idLast) {                                  \
2126     SetMsgHandled(TRUE);                                           \
2127     func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam); \
2128     lResult = 0;                                                   \
2129     if (IsMsgHandled())                                            \
2130       return TRUE;                                                 \
2131   }
2132
2133 // void OnCommandRangeCodeHandlerEX(UINT uNotifyCode, int nID, CWindow wndCtl)
2134 #define CR_COMMAND_RANGE_CODE_HANDLER_EX(idFirst, idLast, code, func) \
2135   if (uMsg == WM_COMMAND && code == HIWORD(wParam) &&                 \
2136       LOWORD(wParam) >= idFirst && LOWORD(wParam) <= idLast) {        \
2137     SetMsgHandled(TRUE);                                              \
2138     func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam);    \
2139     lResult = 0;                                                      \
2140     if (IsMsgHandled())                                               \
2141       return TRUE;                                                    \
2142   }
2143
2144 // LRESULT OnNotifyRangeHandlerEX(LPNMHDR pnmh)
2145 #define CR_NOTIFY_RANGE_HANDLER_EX(idFirst, idLast, func)          \
2146   if (uMsg == WM_NOTIFY && ((LPNMHDR)lParam)->idFrom >= idFirst && \
2147       ((LPNMHDR)lParam)->idFrom <= idLast) {                       \
2148     SetMsgHandled(TRUE);                                           \
2149     lResult = func((LPNMHDR)lParam);                               \
2150     if (IsMsgHandled())                                            \
2151       return TRUE;                                                 \
2152   }
2153
2154 // LRESULT OnNotifyRangeCodeHandlerEX(LPNMHDR pnmh)
2155 #define CR_NOTIFY_RANGE_CODE_HANDLER_EX(idFirst, idLast, cd, func) \
2156   if (uMsg == WM_NOTIFY && cd == ((LPNMHDR)lParam)->code &&        \
2157       ((LPNMHDR)lParam)->idFrom >= idFirst &&                      \
2158       ((LPNMHDR)lParam)->idFrom <= idLast) {                       \
2159     SetMsgHandled(TRUE);                                           \
2160     lResult = func((LPNMHDR)lParam);                               \
2161     if (IsMsgHandled())                                            \
2162       return TRUE;                                                 \
2163   }
2164
2165 // LRESULT OnReflectedCommandHandlerEX(UINT uNotifyCode, int nID, CWindow
2166 // wndCtl)
2167 #define CR_REFLECTED_COMMAND_HANDLER_EX(id, code, func)                        \
2168   if (uMsg == OCM_COMMAND && code == HIWORD(wParam) && id == LOWORD(wParam)) { \
2169     SetMsgHandled(TRUE);                                                       \
2170     func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam);             \
2171     lResult = 0;                                                               \
2172     if (IsMsgHandled())                                                        \
2173       return TRUE;                                                             \
2174   }
2175
2176 // LRESULT OnReflectedCommandIDHandlerEX(UINT uNotifyCode, int nID, CWindow
2177 // wndCtl)
2178 #define CR_REFLECTED_COMMAND_ID_HANDLER_EX(id, func)               \
2179   if (uMsg == OCM_COMMAND && id == LOWORD(wParam)) {               \
2180     SetMsgHandled(TRUE);                                           \
2181     func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam); \
2182     lResult = 0;                                                   \
2183     if (IsMsgHandled())                                            \
2184       return TRUE;                                                 \
2185   }
2186
2187 // LRESULT OnReflectedCommandCodeHandlerEX(UINT uNotifyCode, int nID, CWindow
2188 // wndCtl)
2189 #define CR_REFLECTED_COMMAND_CODE_HANDLER_EX(code, func)           \
2190   if (uMsg == OCM_COMMAND && code == HIWORD(wParam)) {             \
2191     SetMsgHandled(TRUE);                                           \
2192     func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam); \
2193     lResult = 0;                                                   \
2194     if (IsMsgHandled())                                            \
2195       return TRUE;                                                 \
2196   }
2197
2198 // LRESULT OnReflectedNotifyHandlerEX(LPNMHDR pnmh)
2199 #define CR_REFLECTED_NOTIFY_HANDLER_EX(id, cd, func)         \
2200   if (uMsg == OCM_NOTIFY && cd == ((LPNMHDR)lParam)->code && \
2201       id == ((LPNMHDR)lParam)->idFrom) {                     \
2202     SetMsgHandled(TRUE);                                     \
2203     lResult = func((LPNMHDR)lParam);                         \
2204     if (IsMsgHandled())                                      \
2205       return TRUE;                                           \
2206   }
2207
2208 // LRESULT OnReflectedNotifyIDHandlerEX(LPNMHDR pnmh)
2209 #define CR_REFLECTED_NOTIFY_ID_HANDLER_EX(id, func)            \
2210   if (uMsg == OCM_NOTIFY && id == ((LPNMHDR)lParam)->idFrom) { \
2211     SetMsgHandled(TRUE);                                       \
2212     lResult = func((LPNMHDR)lParam);                           \
2213     if (IsMsgHandled())                                        \
2214       return TRUE;                                             \
2215   }
2216
2217 // LRESULT OnReflectedNotifyCodeHandlerEX(LPNMHDR pnmh)
2218 #define CR_REFLECTED_NOTIFY_CODE_HANDLER_EX(cd, func)        \
2219   if (uMsg == OCM_NOTIFY && cd == ((LPNMHDR)lParam)->code) { \
2220     SetMsgHandled(TRUE);                                     \
2221     lResult = func((LPNMHDR)lParam);                         \
2222     if (IsMsgHandled())                                      \
2223       return TRUE;                                           \
2224   }
2225
2226 // void OnReflectedCommandRangeHandlerEX(UINT uNotifyCode, int nID, CWindow
2227 // wndCtl)
2228 #define CR_REFLECTED_COMMAND_RANGE_HANDLER_EX(idFirst, idLast, func) \
2229   if (uMsg == OCM_COMMAND && LOWORD(wParam) >= idFirst &&            \
2230       LOWORD(wParam) <= idLast) {                                    \
2231     SetMsgHandled(TRUE);                                             \
2232     func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam);   \
2233     lResult = 0;                                                     \
2234     if (IsMsgHandled())                                              \
2235       return TRUE;                                                   \
2236   }
2237
2238 // void OnReflectedCommandRangeCodeHandlerEX(UINT uNotifyCode, int nID, CWindow
2239 // wndCtl)
2240 #define CR_REFLECTED_COMMAND_RANGE_CODE_HANDLER_EX(                \
2241     idFirst, idLast, code, func)                                   \
2242   if (uMsg == OCM_COMMAND && code == HIWORD(wParam) &&             \
2243       LOWORD(wParam) >= idFirst && LOWORD(wParam) <= idLast) {     \
2244     SetMsgHandled(TRUE);                                           \
2245     func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam); \
2246     lResult = 0;                                                   \
2247     if (IsMsgHandled())                                            \
2248       return TRUE;                                                 \
2249   }
2250
2251 // LRESULT OnReflectedNotifyRangeHandlerEX(LPNMHDR pnmh)
2252 #define CR_REFLECTED_NOTIFY_RANGE_HANDLER_EX(idFirst, idLast, func) \
2253   if (uMsg == OCM_NOTIFY && ((LPNMHDR)lParam)->idFrom >= idFirst && \
2254       ((LPNMHDR)lParam)->idFrom <= idLast) {                        \
2255     SetMsgHandled(TRUE);                                            \
2256     lResult = func((LPNMHDR)lParam);                                \
2257     if (IsMsgHandled())                                             \
2258       return TRUE;                                                  \
2259   }
2260
2261 // LRESULT OnReflectedNotifyRangeCodeHandlerEX(LPNMHDR pnmh)
2262 #define CR_REFLECTED_NOTIFY_RANGE_CODE_HANDLER_EX(idFirst, idLast, cd, func) \
2263   if (uMsg == OCM_NOTIFY && cd == ((LPNMHDR)lParam)->code &&                 \
2264       ((LPNMHDR)lParam)->idFrom >= idFirst &&                                \
2265       ((LPNMHDR)lParam)->idFrom <= idLast) {                                 \
2266     SetMsgHandled(TRUE);                                                     \
2267     lResult = func((LPNMHDR)lParam);                                         \
2268     if (IsMsgHandled())                                                      \
2269       return TRUE;                                                           \
2270   }
2271
2272 #define CR_DEFLATE_RECT(rect, by)   \
2273   {                                 \
2274     (rect)->left += (by)->left;     \
2275     (rect)->top += (by)->top;       \
2276     (rect)->right -= (by)->right;   \
2277     (rect)->bottom -= (by)->bottom; \
2278   }
2279
2280 #define CR_POINT_INITIALIZER_FROM_LPARAM(lparam) \
2281   { LOWORD(lparam), HIWORD(lparam) }
2282
2283 #endif  // UI_GFX_WIN_MSG_UTIL_H_