reactos/lib/atl/atlwin.h

   1 /*
   2  * ReactOS ATL
   3  *
   4  * Copyright 2009 Andrew Hill <ash77@reactos.org>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #ifndef _atlin_h
  22 #define _atlwin_h
  23
  24 #ifdef __GNUC__
  25 #define GCCU(x) x __attribute__((unused))
  26 #define Unused(x)
  27 #else
  28 #define GCCU(x)
  29 #define Unused(x)       (x);
  30 #endif // __GNUC__
  31
  32 #ifdef SetWindowLongPtr
  33 #undef SetWindowLongPtr
  34 inline LONG_PTR SetWindowLongPtr(HWND hWnd, int nIndex, LONG_PTR dwNewLong)
  35 {
  36         return SetWindowLong(hWnd, nIndex, (LONG)dwNewLong);
  37 }
  38 #endif
  39
  40 #ifdef GetWindowLongPtr
  41 #undef GetWindowLongPtr
  42 inline LONG_PTR GetWindowLongPtr(HWND hWnd, int nIndex)
  43 {
  44         return (LONG_PTR)GetWindowLong(hWnd, nIndex);
  45 }
  46 #endif
  47
  48 namespace ATL
  49 {
  50
  51 struct _ATL_WNDCLASSINFOW;
  52 typedef _ATL_WNDCLASSINFOW CWndClassInfo;
  53
  54 template <DWORD t_dwStyle = 0, DWORD t_dwExStyle = 0>
  55 class CWinTraits
  56 {
  57 public:
  58         static DWORD GetWndStyle(DWORD dwStyle)
  59         {
  60                 if (dwStyle == 0)
  61                         return t_dwStyle;
  62                 return dwStyle;
  63         }
  64
  65         static DWORD GetWndExStyle(DWORD dwExStyle)
  66         {
  67                 if (dwExStyle == 0)
  68                         return t_dwExStyle;
  69                 return dwExStyle;
  70         }
  71 };
  72
  73 typedef CWinTraits<WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, 0> CControlWinTraits;
  74 typedef CWinTraits<WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, WS_EX_APPWINDOW | WS_EX_WINDOWEDGE> CFrameWinTraits;
  75 typedef CWinTraits<WS_OVERLAPPEDWINDOW | WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, WS_EX_MDICHILD> CMDIChildWinTraits;
  76
  77 template <DWORD t_dwStyle = 0, DWORD t_dwExStyle = 0, class TWinTraits = CControlWinTraits>
  78 class CWinTraitsOR
  79 {
  80 public:
  81         static DWORD GetWndStyle(DWORD dwStyle)
  82         {
  83                 return dwStyle | t_dwStyle | TWinTraits::GetWndStyle(dwStyle);
  84         }
  85
  86         static DWORD GetWndExStyle(DWORD dwExStyle)
  87         {
  88                 return dwExStyle | t_dwExStyle | TWinTraits::GetWndExStyle(dwExStyle);
  89         }
  90 };
  91
  92 class _U_MENUorID
  93 {
  94 public:
  95         HMENU                                                                   m_hMenu;
  96 public:
  97         _U_MENUorID(HMENU hMenu)
  98         {
  99                 m_hMenu = hMenu;
 100         }
 101
 102         _U_MENUorID(UINT nID)
 103         {
 104                 m_hMenu = (HMENU)(UINT_PTR)nID;
 105         }
 106 };
 107
 108 class _U_RECT
 109 {
 110 public:
 111         LPRECT                                                                  m_lpRect;
 112 public:
 113         _U_RECT(LPRECT lpRect)
 114         {
 115                 m_lpRect = lpRect;
 116         }
 117
 118         _U_RECT(RECT &rc)
 119         {
 120                 m_lpRect = &rc;
 121         }
 122 };
 123
 124 struct _ATL_MSG : public MSG
 125 {
 126 public:
 127         BOOL                                                                    bHandled;
 128 public:
 129         _ATL_MSG(HWND hWnd, UINT uMsg, WPARAM wParamIn, LPARAM lParamIn, BOOL bHandledIn = TRUE)
 130         {
 131                 hwnd = hWnd;
 132                 message = uMsg;
 133                 wParam = wParamIn;
 134                 lParam = lParamIn;
 135                 time = 0;
 136                 pt.x = 0;
 137                 pt.y = 0;
 138                 bHandled = bHandledIn;
 139         }
 140 };
 141
 142 #if defined(_M_IX86)
 143
 144 #pragma pack(push,1)
 145 struct thunkCode
 146 {
 147         DWORD                                                                   m_mov;
 148         DWORD                                                                   m_this;
 149         BYTE                                                                    m_jmp;
 150         DWORD                                                                   m_relproc;
 151 };
 152 #pragma pack(pop)
 153
 154 class CWndProcThunk
 155 {
 156 public:
 157         thunkCode                                                               m_thunk;
 158         _AtlCreateWndData                                               cd;
 159 public:
 160         BOOL Init(WNDPROC proc, void *pThis)
 161         {
 162                 m_thunk.m_mov = 0x042444C7;
 163                 m_thunk.m_this = PtrToUlong(pThis);
 164                 m_thunk.m_jmp = 0xe9;
 165                 m_thunk.m_relproc = DWORD(reinterpret_cast<char *>(proc) - (reinterpret_cast<char *>(this) + sizeof(thunkCode)));
 166                 return TRUE;
 167         }
 168
 169         WNDPROC GetWNDPROC()
 170         {
 171                 return reinterpret_cast<WNDPROC>(&m_thunk);
 172         }
 173 };
 174
 175 #else
 176 #error Only X86 supported
 177 #endif
 178
 179 class CMessageMap
 180 {
 181 public:
 182         virtual BOOL ProcessWindowMessage(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT &lResult, DWORD dwMsgMapID) = 0;
 183 };
 184
 185 class CWindow
 186 {
 187 public:
 188         HWND                                                                    m_hWnd;
 189         static RECT                                                             rcDefault;
 190 public:
 191         CWindow(HWND hWnd = NULL)
 192         {
 193                 m_hWnd = hWnd;
 194         }
 195
 196         operator HWND() const
 197         {
 198                 return m_hWnd;
 199         }
 200
 201         static LPCTSTR GetWndClassName()
 202         {
 203                 return NULL;
 204         }
 205
 206         HDC BeginPaint(LPPAINTSTRUCT lpPaint)
 207         {
 208                 ATLASSERT(::IsWindow(m_hWnd));
 209                 return ::BeginPaint(m_hWnd, lpPaint);
 210         }
 211
 212         BOOL DestroyWindow()
 213         {
 214                 ATLASSERT(::IsWindow(m_hWnd));
 215
 216                 if (!::DestroyWindow(m_hWnd))
 217                         return FALSE;
 218
 219                 m_hWnd = NULL;
 220                 return TRUE;
 221         }
 222
 223         void EndPaint(LPPAINTSTRUCT lpPaint)
 224         {
 225                 ATLASSERT(::IsWindow(m_hWnd));
 226                 ::EndPaint(m_hWnd, lpPaint);
 227         }
 228
 229         BOOL GetClientRect(LPRECT lpRect) const
 230         {
 231                 ATLASSERT(::IsWindow(m_hWnd));
 232                 return ::GetClientRect(m_hWnd, lpRect);
 233         }
 234
 235         CWindow GetParent() const
 236         {
 237                 ATLASSERT(::IsWindow(m_hWnd));
 238                 return CWindow(::GetParent(m_hWnd));
 239         }
 240
 241         BOOL Invalidate(BOOL bErase = TRUE)
 242         {
 243                 ATLASSERT(::IsWindow(m_hWnd));
 244                 return ::InvalidateRect(m_hWnd, NULL, bErase);
 245         }
 246
 247         BOOL InvalidateRect(LPCRECT lpRect, BOOL bErase = TRUE)
 248         {
 249                 ATLASSERT(::IsWindow(m_hWnd));
 250                 return ::InvalidateRect(m_hWnd, lpRect, bErase);
 251         }
 252
 253         BOOL IsWindow() const
 254         {
 255                 return ::IsWindow(m_hWnd);
 256         }
 257
 258         BOOL KillTimer(UINT_PTR nIDEvent)
 259         {
 260                 ATLASSERT(::IsWindow(m_hWnd));
 261                 return ::KillTimer(m_hWnd, nIDEvent);
 262         }
 263
 264         BOOL LockWindowUpdate(BOOL bLock = TRUE)
 265         {
 266                 ATLASSERT(::IsWindow(m_hWnd));
 267                 if (bLock)
 268                         return ::LockWindowUpdate(m_hWnd);
 269                 return ::LockWindowUpdate(NULL);
 270         }
 271
 272         BOOL ScreenToClient(LPPOINT lpPoint) const
 273         {
 274                 ATLASSERT(::IsWindow(m_hWnd));
 275                 return ::ScreenToClient(m_hWnd, lpPoint);
 276         }
 277
 278         LRESULT SendMessage(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
 279         {
 280                 ATLASSERT(::IsWindow(m_hWnd));
 281                 return ::SendMessage(m_hWnd, message, wParam, lParam);
 282         }
 283
 284         static LRESULT SendMessage(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 285         {
 286                 ATLASSERT(::IsWindow(hWnd));
 287                 return ::SendMessage(hWnd, message, wParam, lParam);
 288         }
 289
 290         HWND SetCapture()
 291         {
 292                 ATLASSERT(::IsWindow(m_hWnd));
 293                 return ::SetCapture(m_hWnd);
 294         }
 295
 296         HWND SetFocus()
 297         {
 298                 ATLASSERT(::IsWindow(m_hWnd));
 299                 return ::SetFocus(m_hWnd);
 300         }
 301
 302         UINT_PTR SetTimer(UINT_PTR nIDEvent, UINT nElapse, void (CALLBACK *lpfnTimer)(HWND, UINT, UINT_PTR, DWORD) = NULL)
 303         {
 304                 ATLASSERT(::IsWindow(m_hWnd));
 305                 return ::SetTimer(m_hWnd, nIDEvent, nElapse, reinterpret_cast<TIMERPROC>(lpfnTimer));
 306         }
 307
 308         BOOL SetWindowPos(HWND hWndInsertAfter, int x, int y, int cx, int cy, UINT nFlags)
 309         {
 310                 ATLASSERT(::IsWindow(m_hWnd));
 311                 return ::SetWindowPos(m_hWnd, hWndInsertAfter, x, y, cx, cy, nFlags);
 312         }
 313
 314         BOOL SetWindowText(LPCTSTR lpszString)
 315         {
 316                 ATLASSERT(::IsWindow(m_hWnd));
 317                 return ::SetWindowText(m_hWnd, lpszString);
 318         }
 319
 320         BOOL ShowWindow(int nCmdShow)
 321         {
 322                 ATLASSERT(::IsWindow(m_hWnd));
 323                 return ::ShowWindow(m_hWnd, nCmdShow);
 324         }
 325
 326 };
 327
 328 _declspec(selectany) RECT CWindow::rcDefault = { CW_USEDEFAULT, CW_USEDEFAULT, 0, 0 };
 329
 330 template <class TBase = CWindow, class TWinTraits = CControlWinTraits>
 331 class CWindowImplBaseT : public TBase, public CMessageMap
 332 {
 333 public:
 334         enum { WINSTATE_DESTROYED = 0x00000001 };
 335         DWORD                                                                   m_dwState;
 336         const _ATL_MSG                                                  *m_pCurrentMsg;
 337         CWndProcThunk                                                   m_thunk;
 338         WNDPROC                                                                 m_pfnSuperWindowProc;
 339 public:
 340         CWindowImplBaseT()
 341         {
 342                 m_dwState = 0;
 343                 m_pCurrentMsg = NULL;
 344                 m_pfnSuperWindowProc = ::DefWindowProc;
 345         }
 346
 347         virtual void OnFinalMessage(HWND /* hWnd */)
 348         {
 349         }
 350
 351         BOOL SubclassWindow(HWND hWnd)
 352         {
 353                 CWindowImplBaseT<TBase, TWinTraits>     *pThis;
 354                 WNDPROC                                                         newWindowProc;
 355                 WNDPROC                                                         oldWindowProc;
 356                 BOOL                                                            result;
 357
 358                 ATLASSERT(m_hWnd == NULL);
 359                 ATLASSERT(::IsWindow(hWnd));
 360
 361                 pThis = reinterpret_cast<CWindowImplBaseT<TBase, TWinTraits>*>(this);
 362
 363                 result = m_thunk.Init(GetWindowProc(), this);
 364                 if (result == FALSE)
 365                         return FALSE;
 366                 newWindowProc = m_thunk.GetWNDPROC();
 367                 oldWindowProc = reinterpret_cast<WNDPROC>(::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(newWindowProc)));
 368                 if (oldWindowProc == NULL)
 369                         return FALSE;
 370                 m_pfnSuperWindowProc = oldWindowProc;
 371                 pThis->m_hWnd = hWnd;
 372                 return TRUE;
 373         }
 374
 375         virtual WNDPROC GetWindowProc()
 376         {
 377                 return WindowProc;
 378         }
 379
 380         static DWORD GetWndStyle(DWORD dwStyle)
 381         {
 382                 return TWinTraits::GetWndStyle(dwStyle);
 383         }
 384
 385         static DWORD GetWndExStyle(DWORD dwExStyle)
 386         {
 387                 return TWinTraits::GetWndExStyle(dwExStyle);
 388         }
 389
 390         LRESULT DefWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
 391         {
 392                 CWindowImplBaseT<TBase, TWinTraits>     *pThis;
 393
 394                 pThis = reinterpret_cast<CWindowImplBaseT<TBase, TWinTraits> *>(this);
 395                 return ::CallWindowProc(m_pfnSuperWindowProc, pThis->m_hWnd, uMsg, wParam, lParam);
 396         }
 397
 398         static LRESULT CALLBACK StartWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 399         {
 400                 CWindowImplBaseT<TBase, TWinTraits>     *pThis;
 401                 WNDPROC                                                         newWindowProc;
 402                 WNDPROC                                                         GCCU(pOldProc);
 403
 404                 pThis = reinterpret_cast<CWindowImplBaseT<TBase, TWinTraits> *>(_AtlWinModule.ExtractCreateWndData());
 405                 ATLASSERT(pThis != NULL);
 406                 if (pThis == NULL)
 407                         return 0;
 408                 pThis->m_thunk.Init(pThis->GetWindowProc(), pThis);
 409                 newWindowProc = pThis->m_thunk.GetWNDPROC();
 410                 pOldProc = reinterpret_cast<WNDPROC>(::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(newWindowProc)));
 411                 Unused(pOldProc); // TODO: should generate trace message if overwriting another subclass
 412                 pThis->m_hWnd = hWnd;
 413                 return newWindowProc(hWnd, uMsg, wParam, lParam);
 414         }
 415
 416         static LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 417         {
 418                 CWindowImplBaseT<TBase, TWinTraits>     *pThis = reinterpret_cast<CWindowImplBaseT< TBase, TWinTraits> *>(hWnd);
 419                 _ATL_MSG                                                        msg(pThis->m_hWnd, uMsg, wParam, lParam);
 420                 LRESULT                                                         lResult;
 421                 const _ATL_MSG                                          *previousMessage;
 422                 BOOL                                                            handled;
 423                 LONG_PTR                                                        saveWindowProc;
 424
 425                 ATLASSERT(pThis != NULL && (pThis->m_dwState & WINSTATE_DESTROYED) == 0 && pThis->m_hWnd != NULL);
 426                 if (pThis == NULL || (pThis->m_dwState & WINSTATE_DESTROYED) != 0 || pThis->m_hWnd == NULL)
 427                         return 0;
 428
 429                 hWnd = pThis->m_hWnd;
 430                 previousMessage = pThis->m_pCurrentMsg;
 431                 pThis->m_pCurrentMsg = &msg;
 432
 433                 handled = pThis->ProcessWindowMessage(hWnd, uMsg, wParam, lParam, lResult, 0);
 434                 ATLASSERT(pThis->m_pCurrentMsg == &msg);
 435
 436                 if (handled == FALSE)
 437                 {
 438                         if (uMsg == WM_NCDESTROY)
 439                         {
 440                                 saveWindowProc = ::GetWindowLongPtr(hWnd, GWLP_WNDPROC);
 441                                 lResult = pThis->DefWindowProc(uMsg, wParam, lParam);
 442                                 if (pThis->m_pfnSuperWindowProc != ::DefWindowProc && saveWindowProc == ::GetWindowLongPtr(hWnd, GWLP_WNDPROC))
 443                                         ::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(pThis->m_pfnSuperWindowProc));
 444                                 pThis->m_dwState |= WINSTATE_DESTROYED;
 445                         }
 446                         else
 447                                 lResult = pThis->DefWindowProc(uMsg, wParam, lParam);
 448                 }
 449                 ATLASSERT(pThis->m_pCurrentMsg == &msg);
 450                 pThis->m_pCurrentMsg = previousMessage;
 451                 if (previousMessage == NULL && (pThis->m_dwState & WINSTATE_DESTROYED) != 0)
 452                 {
 453                         pThis->m_dwState &= ~WINSTATE_DESTROYED;
 454                         pThis->m_hWnd = NULL;
 455                         pThis->OnFinalMessage(hWnd);
 456                 }
 457                 return lResult;
 458         }
 459
 460         HWND Create(HWND hWndParent, _U_RECT rect, LPCTSTR szWindowName, DWORD dwStyle, DWORD dwExStyle,
 461                                         _U_MENUorID MenuOrID, ATOM atom, LPVOID lpCreateParam)
 462         {
 463                 HWND                                                            hWnd;
 464
 465                 ATLASSERT(m_hWnd == NULL);
 466                 ATLASSERT(atom != 0);
 467                 if (atom == 0)
 468                         return NULL;
 469                 if (m_thunk.Init(NULL, NULL) == FALSE)
 470                 {
 471                         SetLastError(ERROR_OUTOFMEMORY);
 472                         return NULL;
 473                 }
 474
 475                 _AtlWinModule.AddCreateWndData(&m_thunk.cd, this);
 476                 if (MenuOrID.m_hMenu == NULL && (dwStyle & WS_CHILD) != 0)
 477                         MenuOrID.m_hMenu = (HMENU)(UINT_PTR)this;
 478                 if (rect.m_lpRect == NULL)
 479                         rect.m_lpRect = &TBase::rcDefault;
 480                 hWnd = ::CreateWindowEx(dwExStyle, reinterpret_cast<LPCWSTR>(MAKEINTATOM(atom)), szWindowName, dwStyle, rect.m_lpRect->left,
 481                                         rect.m_lpRect->top, rect.m_lpRect->right - rect.m_lpRect->left, rect.m_lpRect->bottom - rect.m_lpRect->top,
 482                                         hWndParent, MenuOrID.m_hMenu, _AtlBaseModule.GetModuleInstance(), lpCreateParam);
 483
 484                 ATLASSERT(m_hWnd == hWnd);
 485
 486                 return hWnd;
 487         }
 488 };
 489
 490 template <class T, class TBase = CWindow, class TWinTraits = CControlWinTraits>
 491 class CWindowImpl : public CWindowImplBaseT<TBase, TWinTraits>
 492 {
 493 public:
 494         static LPCTSTR GetWndCaption()
 495         {
 496                 return NULL;
 497         }
 498
 499         HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0,
 500                                         DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
 501         {
 502                 CWindowImplBaseT<TBase, TWinTraits>     *pThis;
 503                 ATOM                                                            atom;
 504
 505                 ATLASSERT(m_hWnd == NULL);
 506                 pThis = reinterpret_cast<CWindowImplBaseT<TBase, TWinTraits>*>(this);
 507
 508                 if (T::GetWndClassInfo().m_lpszOrigName == NULL)
 509                         T::GetWndClassInfo().m_lpszOrigName = pThis->GetWndClassName();
 510                 atom = T::GetWndClassInfo().Register(&pThis->m_pfnSuperWindowProc);
 511
 512                 if (szWindowName == NULL)
 513                         szWindowName = T::GetWndCaption();
 514                 dwStyle = T::GetWndStyle(dwStyle);
 515                 dwExStyle = T::GetWndExStyle(dwExStyle);
 516
 517                 return CWindowImplBaseT<TBase, TWinTraits>::Create(hWndParent, rect, szWindowName, dwStyle,
 518                                                 dwExStyle, MenuOrID, atom, lpCreateParam);
 519         }
 520 };
 521
 522 template <class TBase = CWindow, class TWinTraits = CControlWinTraits>
 523 class CContainedWindowT : public TBase
 524 {
 525 public:
 526         CWndProcThunk                                                   m_thunk;
 527         LPCTSTR                                                                 m_lpszClassName;
 528         WNDPROC                                                                 m_pfnSuperWindowProc;
 529         CMessageMap                                                             *m_pObject;
 530         DWORD                                                                   m_dwMsgMapID;
 531         const _ATL_MSG                                                  *m_pCurrentMsg;
 532 public:
 533         CContainedWindowT(CMessageMap *pObject, DWORD dwMsgMapID = 0)
 534         {
 535                 m_lpszClassName = TBase::GetWndClassName();
 536                 m_pfnSuperWindowProc = ::DefWindowProc;
 537                 m_pObject = pObject;
 538                 m_dwMsgMapID = dwMsgMapID;
 539                 m_pCurrentMsg = NULL;
 540         }
 541
 542         CContainedWindowT(LPTSTR lpszClassName, CMessageMap *pObject, DWORD dwMsgMapID = 0)
 543         {
 544                 m_lpszClassName = lpszClassName;
 545                 m_pfnSuperWindowProc = ::DefWindowProc;
 546                 m_pObject = pObject;
 547                 m_dwMsgMapID = dwMsgMapID;
 548                 m_pCurrentMsg = NULL;
 549         }
 550
 551         LRESULT DefWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
 552         {
 553                 CWindowImplBaseT<TBase, TWinTraits>     *pThis;
 554
 555                 pThis = reinterpret_cast<CWindowImplBaseT<TBase, TWinTraits> *>(this);
 556                 return ::CallWindowProc(m_pfnSuperWindowProc, pThis->m_hWnd, uMsg, wParam, lParam);
 557         }
 558
 559         BOOL SubclassWindow(HWND hWnd)
 560         {
 561                 CContainedWindowT<TBase>                        *pThis;
 562                 WNDPROC                                                         newWindowProc;
 563                 WNDPROC                                                         oldWindowProc;
 564                 BOOL                                                            result;
 565
 566                 ATLASSERT(m_hWnd == NULL);
 567                 ATLASSERT(::IsWindow(hWnd));
 568
 569                 pThis = reinterpret_cast<CContainedWindowT<TBase> *>(this);
 570
 571                 result = m_thunk.Init(WindowProc, pThis);
 572                 if (result == FALSE)
 573                         return FALSE;
 574                 newWindowProc = m_thunk.GetWNDPROC();
 575                 oldWindowProc = reinterpret_cast<WNDPROC>(::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(newWindowProc)));
 576                 if (oldWindowProc == NULL)
 577                         return FALSE;
 578                 m_pfnSuperWindowProc = oldWindowProc;
 579                 pThis->m_hWnd = hWnd;
 580                 return TRUE;
 581         }
 582
 583         static LRESULT CALLBACK StartWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 584         {
 585                 CContainedWindowT<TBase>                        *pThis;
 586                 WNDPROC                                                         newWindowProc;
 587                 WNDPROC                                                         GCCU(pOldProc);
 588
 589                 pThis = reinterpret_cast<CContainedWindowT<TBase> *>(_AtlWinModule.ExtractCreateWndData());
 590                 ATLASSERT(pThis != NULL);
 591                 if (pThis == NULL)
 592                         return 0;
 593                 pThis->m_thunk.Init(WindowProc, pThis);
 594                 newWindowProc = pThis->m_thunk.GetWNDPROC();
 595                 pOldProc = reinterpret_cast<WNDPROC>(::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(newWindowProc)));
 596                 Unused(pOldProc); // TODO: should generate trace message if overwriting another subclass
 597                 pThis->m_hWnd = hWnd;
 598                 return newWindowProc(hWnd, uMsg, wParam, lParam);
 599         }
 600
 601         static LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 602         {
 603                 CContainedWindowT<TBase>                        *pThis = reinterpret_cast<CContainedWindowT<TBase> *>(hWnd);
 604                 _ATL_MSG                                                        msg(pThis->m_hWnd, uMsg, wParam, lParam);
 605                 LRESULT                                                         lResult;
 606                 const _ATL_MSG                                          *previousMessage;
 607                 BOOL                                                            handled;
 608                 LONG_PTR                                                        saveWindowProc;
 609
 610                 ATLASSERT(pThis != NULL && pThis->m_hWnd != NULL && pThis->m_pObject != NULL);
 611                 if (pThis == NULL || pThis->m_hWnd == NULL || pThis->m_pObject == NULL)
 612                         return 0;
 613
 614                 hWnd = pThis->m_hWnd;
 615                 previousMessage = pThis->m_pCurrentMsg;
 616                 pThis->m_pCurrentMsg = &msg;
 617
 618                 handled = pThis->m_pObject->ProcessWindowMessage(hWnd, uMsg, wParam, lParam, lResult, pThis->m_dwMsgMapID);
 619                 ATLASSERT(pThis->m_pCurrentMsg == &msg);
 620
 621                 pThis->m_pCurrentMsg = previousMessage;
 622                 if (handled == FALSE)
 623                 {
 624                         if (uMsg == WM_NCDESTROY)
 625                         {
 626                                 saveWindowProc = ::GetWindowLongPtr(hWnd, GWLP_WNDPROC);
 627                                 lResult = pThis->DefWindowProc(uMsg, wParam, lParam);
 628                                 if (pThis->m_pfnSuperWindowProc != ::DefWindowProc && saveWindowProc == ::GetWindowLongPtr(hWnd, GWLP_WNDPROC))
 629                                         ::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(pThis->m_pfnSuperWindowProc));
 630                                 pThis->m_hWnd = NULL;
 631                         }
 632                         else
 633                                 lResult = pThis->DefWindowProc(uMsg, wParam, lParam);
 634                 }
 635                 return lResult;
 636         }
 637
 638 };
 639 typedef CContainedWindowT<CWindow>      CContainedWindow;
 640
 641 #define BEGIN_MSG_MAP(theClass)                                                                                                                                                                                         \
 642 public:                                                                                                                                                                                                                                         \
 643         BOOL ProcessWindowMessage(HWND GCCU(hWnd), UINT GCCU(uMsg), WPARAM GCCU(wParam), LPARAM GCCU(lParam), LRESULT &GCCU(lResult), DWORD dwMsgMapID = 0)     \
 644         {                                                                                                                                                                                                                                               \
 645                 BOOL GCCU(bHandled) = TRUE;                                                                                                                                                                                     \
 646                 Unused(hWnd);                                                                                                                                                                                                           \
 647                 Unused(uMsg);                                                                                                                                                                                                           \
 648                 Unused(wParam);                                                                                                                                                                                                         \
 649                 Unused(lParam);                                                                                                                                                                                                         \
 650                 Unused(lResult);                                                                                                                                                                                                        \
 651                 Unused(bHandled);                                                                                                                                                                                                       \
 652                 switch(dwMsgMapID)                                                                                                                                                                                                      \
 653                 {                                                                                                                                                                                                                                       \
 654                 case 0:
 655
 656 #define END_MSG_MAP()                                                                                                                                                   \
 657                         break;                                                                                                                                                          \
 658                 default:                                                                                                                                                                \
 659                         ATLASSERT(FALSE);                                                                                                                                       \
 660                         break;                                                                                                                                                          \
 661                 }                                                                                                                                                                               \
 662                 return FALSE;                                                                                                                                                   \
 663         }
 664
 665 #define MESSAGE_HANDLER(msg, func)                                                                                                                              \
 666         if (uMsg == msg)                                                                                                                                                        \
 667         {                                                                                                                                                                                       \
 668                 bHandled = TRUE;                                                                                                                                                \
 669                 lResult = func(uMsg, wParam, lParam, bHandled);                                                                                 \
 670                 if (bHandled)                                                                                                                                                   \
 671                         return TRUE;                                                                                                                                            \
 672         }
 673
 674 #define MESSAGE_RANGE_HANDLER(msgFirst, msgLast, func)                                                                                  \
 675         if (uMsg >= msgFirst && uMsg <= msgLast)                                                                                                        \
 676         {                                                                                                                                                                                       \
 677                 bHandled = TRUE;                                                                                                                                                \
 678                 lResult = func(uMsg, wParam, lParam, bHandled);                                                                                 \
 679                 if (bHandled)                                                                                                                                                   \
 680                         return TRUE;                                                                                                                                            \
 681         }
 682
 683 #define COMMAND_ID_HANDLER(id, func)                                                                                                                    \
 684         if (uMsg == WM_COMMAND && id == LOWORD(wParam))                                                                                         \
 685         {                                                                                                                                                                                       \
 686                 bHandled = TRUE;                                                                                                                                                \
 687                 lResult = func(HIWORD(wParam), LOWORD(wParam), (HWND)lParam, bHandled);                                 \
 688                 if (bHandled)                                                                                                                                                   \
 689                         return TRUE;                                                                                                                                            \
 690         }
 691
 692 #define COMMAND_RANGE_HANDLER(idFirst, idLast, func)                                                                                    \
 693         if (uMsg == WM_COMMAND && LOWORD(wParam) >= idFirst  && LOWORD(wParam) <= idLast)                       \
 694         {                                                                                                                                                                                       \
 695                 bHandled = TRUE;                                                                                                                                                \
 696                 lResult = func(HIWORD(wParam), LOWORD(wParam), (HWND)lParam, bHandled);                                 \
 697                 if (bHandled)                                                                                                                                                   \
 698                         return TRUE;                                                                                                                                            \
 699         }
 700
 701 #define NOTIFY_CODE_HANDLER(cd, func)                                                                                                                   \
 702         if(uMsg == WM_NOTIFY && cd == ((LPNMHDR)lParam)->code)                                                                          \
 703         {                                                                                                                                                                                       \
 704                 bHandled = TRUE;                                                                                                                                                \
 705                 lResult = func((int)wParam, (LPNMHDR)lParam, bHandled);                                                                 \
 706                 if (bHandled)                                                                                                                                                   \
 707                         return TRUE;                                                                                                                                            \
 708         }
 709
 710 #define NOTIFY_HANDLER(id, cd, func)                                                                                                                    \
 711         if(uMsg == WM_NOTIFY && id == ((LPNMHDR)lParam)->idFrom && cd == ((LPNMHDR)lParam)->code)       \
 712         {                                                                                                                                                                                       \
 713                 bHandled = TRUE;                                                                                                                                                \
 714                 lResult = func((int)wParam, (LPNMHDR)lParam, bHandled);                                                                 \
 715                 if (bHandled)                                                                                                                                                   \
 716                         return TRUE;                                                                                                                                            \
 717         }
 718
 719 #define DECLARE_WND_CLASS_EX(WndClassName, style, bkgnd)                                                                                \
 720 static ATL::CWndClassInfo& GetWndClassInfo()                                                                                                    \
 721 {                                                                                                                                                                                               \
 722         static ATL::CWndClassInfo wc =                                                                                                                          \
 723         {                                                                                                                                                                                       \
 724                 { sizeof(WNDCLASSEX), style, StartWindowProc,                                                                                   \
 725                   0, 0, NULL, NULL, NULL, (HBRUSH)(bkgnd + 1), NULL, WndClassName, NULL },                              \
 726                 NULL, NULL, IDC_ARROW, TRUE, 0, _T("")                                                                                                  \
 727         };                                                                                                                                                                                      \
 728         return wc;                                                                                                                                                                      \
 729 }
 730
 731 struct _ATL_WNDCLASSINFOW
 732 {
 733         WNDCLASSEXW                                                             m_wc;
 734         LPCWSTR                                                                 m_lpszOrigName;
 735         WNDPROC                                                                 pWndProc;
 736         LPCWSTR                                                                 m_lpszCursorID;
 737         BOOL                                                                    m_bSystemCursor;
 738         ATOM                                                                    m_atom;
 739         WCHAR                                                                   m_szAutoName[5 + sizeof(void *)];
 740
 741         ATOM Register(WNDPROC *p)
 742         {
 743                 if (m_atom == 0)
 744                         m_atom = RegisterClassEx(&m_wc);
 745                 return m_atom;
 746         }
 747 };
 748
 749 }; // namespace ATL
 750
 751 #endif // _atlwin_h