src/third_party/wtl/include/atlframe.h

   1 // Windows Template Library - WTL version 8.0
   2 // Copyright (C) Microsoft Corporation. All rights reserved.
   3 //
   4 // This file is a part of the Windows Template Library.
   5 // The use and distribution terms for this software are covered by the
   6 // Microsoft Permissive License (Ms-PL) which can be found in the file
   7 // Ms-PL.txt at the root of this distribution.
   8
   9 #ifndef __ATLFRAME_H__
  10 #define __ATLFRAME_H__
  11
  12 #pragma once
  13
  14 #ifndef __cplusplus
  15         #error ATL requires C++ compilation (use a .cpp suffix)
  16 #endif
  17
  18 #ifndef __ATLAPP_H__
  19         #error atlframe.h requires atlapp.h to be included first
  20 #endif
  21
  22 #ifndef __ATLWIN_H__
  23         #error atlframe.h requires atlwin.h to be included first
  24 #endif
  25
  26
  27 ///////////////////////////////////////////////////////////////////////////////
  28 // Classes in this file:
  29 //
  30 // CFrameWindowImpl<T, TBase, TWinTraits>
  31 // CMDIWindow
  32 // CMDIFrameWindowImpl<T, TBase, TWinTraits>
  33 // CMDIChildWindowImpl<T, TBase, TWinTraits>
  34 // COwnerDraw<T>
  35 // CUpdateUIBase
  36 // CUpdateUI<T>
  37 // CDynamicUpdateUI<T>
  38 // CDialogResize<T>
  39 // CDoubleBufferImpl<T>
  40 // CDoubleBufferWindowImpl<T, TBase, TWinTraits>
  41 //
  42 // Global functions:
  43 //   AtlCreateSimpleToolBar()
  44
  45
  46 namespace WTL
  47 {
  48
  49 ///////////////////////////////////////////////////////////////////////////////
  50 // CFrameWndClassInfo - Manages frame window Windows class information
  51
  52 class CFrameWndClassInfo
  53 {
  54 public:
  55 #ifndef _WIN32_WCE
  56         enum { cchAutoName = 5 + sizeof(void*) * 2 };   // sizeof(void*) * 2 is the number of digits %p outputs
  57         WNDCLASSEX m_wc;
  58 #else // CE specific
  59         enum { cchAutoName = MAX_PATH };   // MAX_PATH because this can be set in the wizard generated CMainFrame::ActivatePreviousInstance to a user defined string.
  60         WNDCLASS m_wc;
  61 #endif // !_WIN32_WCE
  62         LPCTSTR m_lpszOrigName;
  63         WNDPROC pWndProc;
  64         LPCTSTR m_lpszCursorID;
  65         BOOL m_bSystemCursor;
  66         ATOM m_atom;
  67         TCHAR m_szAutoName[cchAutoName];
  68         UINT m_uCommonResourceID;
  69
  70 #ifndef _WIN32_WCE
  71         ATOM Register(WNDPROC* pProc)
  72         {
  73                 if (m_atom == 0)
  74                 {
  75                         CWindowCreateCriticalSectionLock lock;
  76                         if(FAILED(lock.Lock()))
  77                         {
  78                                 ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CFrameWndClassInfo::Register.\n"));
  79                                 ATLASSERT(FALSE);
  80                                 return 0;
  81                         }
  82
  83                         if(m_atom == 0)
  84                         {
  85                                 HINSTANCE hInst = ModuleHelper::GetModuleInstance();
  86
  87                                 if (m_lpszOrigName != NULL)
  88                                 {
  89                                         ATLASSERT(pProc != NULL);
  90                                         LPCTSTR lpsz = m_wc.lpszClassName;
  91                                         WNDPROC proc = m_wc.lpfnWndProc;
  92
  93                                         WNDCLASSEX wc = { 0 };
  94                                         wc.cbSize = sizeof(WNDCLASSEX);
  95                                         // try process local class first
  96                                         if(!::GetClassInfoEx(ModuleHelper::GetModuleInstance(), m_lpszOrigName, &wc))
  97                                         {
  98                                                 // try global class
  99                                                 if(!::GetClassInfoEx(NULL, m_lpszOrigName, &wc))
 100                                                 {
 101                                                         lock.Unlock();
 102                                                         return 0;
 103                                                 }
 104                                         }
 105                                         m_wc = wc;
 106                                         pWndProc = m_wc.lpfnWndProc;
 107                                         m_wc.lpszClassName = lpsz;
 108                                         m_wc.lpfnWndProc = proc;
 109                                 }
 110                                 else
 111                                 {
 112                                         m_wc.hCursor = ::LoadCursor(m_bSystemCursor ? NULL : hInst, m_lpszCursorID);
 113                                 }
 114
 115                                 m_wc.hInstance = hInst;
 116                                 m_wc.style &= ~CS_GLOBALCLASS;   // we don't register global classes
 117                                 if (m_wc.lpszClassName == NULL)
 118                                 {
 119 #if (_WIN32_WINNT >= 0x0500) || defined(_WIN64)
 120                                         SecureHelper::wsprintf_x(m_szAutoName, cchAutoName, _T("ATL:%p"), &m_wc);
 121 #else // !((_WIN32_WINNT >= 0x0500) || defined(_WIN64))
 122                                         SecureHelper::wsprintf_x(m_szAutoName, cchAutoName, _T("ATL:%8.8X"), (DWORD_PTR)&m_wc);
 123 #endif // !((_WIN32_WINNT >= 0x0500) || defined(_WIN64))
 124                                         m_wc.lpszClassName = m_szAutoName;
 125                                 }
 126
 127                                 WNDCLASSEX wcTemp = m_wc;
 128                                 m_atom = (ATOM)::GetClassInfoEx(m_wc.hInstance, m_wc.lpszClassName, &wcTemp);
 129                                 if (m_atom == 0)
 130                                 {
 131                                         if(m_uCommonResourceID != 0)   // use it if not zero
 132                                         {
 133                                                 m_wc.hIcon = (HICON)::LoadImage(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(m_uCommonResourceID), IMAGE_ICON, 32, 32, LR_DEFAULTCOLOR);
 134                                                 m_wc.hIconSm = (HICON)::LoadImage(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(m_uCommonResourceID), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
 135                                         }
 136                                         m_atom = ::RegisterClassEx(&m_wc);
 137                                 }
 138                         }
 139
 140                         lock.Unlock();
 141                 }
 142
 143                 if (m_lpszOrigName != NULL)
 144                 {
 145                         ATLASSERT(pProc != NULL);
 146                         ATLASSERT(pWndProc != NULL);
 147                         *pProc = pWndProc;
 148                 }
 149
 150                 return m_atom;
 151         }
 152 #else // CE specific
 153         ATOM Register(WNDPROC* pProc)
 154         {
 155                 if (m_atom == 0)
 156                 {
 157                         CWindowCreateCriticalSectionLock lock;
 158                         if(FAILED(lock.Lock()))
 159                         {
 160                                 ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CFrameWndClassInfo::Register.\n"));
 161                                 ATLASSERT(FALSE);
 162                                 return 0;
 163                         }
 164
 165                         if(m_atom == 0)
 166                         {
 167                                 HINSTANCE hInst = ModuleHelper::GetModuleInstance();
 168
 169                                 if (m_lpszOrigName != NULL)
 170                                 {
 171                                         ATLASSERT(pProc != NULL);
 172                                         LPCTSTR lpsz = m_wc.lpszClassName;
 173                                         WNDPROC proc = m_wc.lpfnWndProc;
 174
 175                                         WNDCLASS wc = { 0 };
 176                                         // try process local class first
 177                                         if(!::GetClassInfo(ModuleHelper::GetModuleInstance(), m_lpszOrigName, &wc))
 178                                         {
 179                                                 // try global class
 180                                                 if(!::GetClassInfo(NULL, m_lpszOrigName, &wc))
 181                                                 {
 182                                                         lock.Unlock();
 183                                                         return 0;
 184                                                 }
 185                                         }
 186                                         m_wc = wc;
 187                                         pWndProc = m_wc.lpfnWndProc;
 188                                         m_wc.lpszClassName = lpsz;
 189                                         m_wc.lpfnWndProc = proc;
 190                                 }
 191                                 else
 192                                 {
 193 #if defined(GWES_CURSOR) || defined(GWES_MCURSOR)
 194                                         m_wc.hCursor = ::LoadCursor(m_bSystemCursor ? NULL : hInst, m_lpszCursorID);
 195 #else // !(defined(GWES_CURSOR) || defined(GWES_MCURSOR))
 196                                         m_wc.hCursor = NULL;
 197 #endif // !(defined(GWES_CURSOR) || defined(GWES_MCURSOR))
 198                                 }
 199
 200                                 m_wc.hInstance = hInst;
 201                                 m_wc.style &= ~CS_GLOBALCLASS;   // we don't register global classes
 202                                 if (m_wc.lpszClassName == NULL)
 203                                 {
 204                                         wsprintf(m_szAutoName, _T("ATL:%8.8X"), (DWORD_PTR)&m_wc);
 205                                         m_wc.lpszClassName = m_szAutoName;
 206                                 }
 207
 208                                 WNDCLASS wcTemp = m_wc;
 209                                 m_atom = (ATOM)::GetClassInfo(m_wc.hInstance, m_wc.lpszClassName, &wcTemp);
 210                                 if (m_atom == 0)
 211                                 {
 212                                         if(m_uCommonResourceID != 0)   // use it if not zero
 213                                                 m_wc.hIcon = (HICON)::LoadImage(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(m_uCommonResourceID), IMAGE_ICON, 32, 32, LR_DEFAULTCOLOR);
 214                                         m_atom = ::RegisterClass(&m_wc);
 215                                 }
 216                         }
 217
 218                         lock.Unlock();
 219                 }
 220
 221                 if (m_lpszOrigName != NULL)
 222                 {
 223                         ATLASSERT(pProc != NULL);
 224                         ATLASSERT(pWndProc != NULL);
 225                         *pProc = pWndProc;
 226                 }
 227
 228                 return m_atom;
 229         }
 230 #endif // _WIN32_WCE
 231 };
 232
 233
 234 ///////////////////////////////////////////////////////////////////////////////
 235 // Macros for declaring frame window WNDCLASS
 236
 237 #ifndef _WIN32_WCE
 238
 239 #define DECLARE_FRAME_WND_CLASS(WndClassName, uCommonResourceID) \
 240 static WTL::CFrameWndClassInfo& GetWndClassInfo() \
 241 { \
 242         static WTL::CFrameWndClassInfo wc = \
 243         { \
 244                 { sizeof(WNDCLASSEX), 0, StartWindowProc, \
 245                   0, 0, NULL, NULL, NULL, (HBRUSH)(COLOR_WINDOW + 1), NULL, WndClassName, NULL }, \
 246                 NULL, NULL, IDC_ARROW, TRUE, 0, _T(""), uCommonResourceID \
 247         }; \
 248         return wc; \
 249 }
 250
 251 #define DECLARE_FRAME_WND_CLASS_EX(WndClassName, uCommonResourceID, style, bkgnd) \
 252 static WTL::CFrameWndClassInfo& GetWndClassInfo() \
 253 { \
 254         static WTL::CFrameWndClassInfo wc = \
 255         { \
 256                 { sizeof(WNDCLASSEX), style, StartWindowProc, \
 257                   0, 0, NULL, NULL, NULL, (HBRUSH)(bkgnd + 1), NULL, WndClassName, NULL }, \
 258                 NULL, NULL, IDC_ARROW, TRUE, 0, _T(""), uCommonResourceID \
 259         }; \
 260         return wc; \
 261 }
 262
 263 #define DECLARE_FRAME_WND_SUPERCLASS(WndClassName, OrigWndClassName, uCommonResourceID) \
 264 static WTL::CFrameWndClassInfo& GetWndClassInfo() \
 265 { \
 266         static WTL::CFrameWndClassInfo wc = \
 267         { \
 268                 { sizeof(WNDCLASSEX), 0, StartWindowProc, \
 269                   0, 0, NULL, NULL, NULL, NULL, NULL, WndClassName, NULL }, \
 270                 OrigWndClassName, NULL, NULL, TRUE, 0, _T(""), uCommonResourceID \
 271         }; \
 272         return wc; \
 273 }
 274
 275 #else // CE specific
 276
 277 #define DECLARE_FRAME_WND_CLASS(WndClassName, uCommonResourceID) \
 278 static WTL::CFrameWndClassInfo& GetWndClassInfo() \
 279 { \
 280         static WTL::CFrameWndClassInfo wc = \
 281         { \
 282                 { 0, StartWindowProc, \
 283                   0, 0, NULL, NULL, NULL, (HBRUSH)(COLOR_WINDOW + 1), NULL, WndClassName }, \
 284                 NULL, NULL, IDC_ARROW, TRUE, 0, _T(""), uCommonResourceID \
 285         }; \
 286         return wc; \
 287 }
 288
 289 #define DECLARE_FRAME_WND_CLASS_EX(WndClassName, uCommonResourceID, style, bkgnd) \
 290 static WTL::CFrameWndClassInfo& GetWndClassInfo() \
 291 { \
 292         static WTL::CFrameWndClassInfo wc = \
 293         { \
 294                 { style, StartWindowProc, \
 295                   0, 0, NULL, NULL, NULL, (HBRUSH)(bkgnd + 1), NULL, WndClassName }, \
 296                 NULL, NULL, IDC_ARROW, TRUE, 0, _T(""), uCommonResourceID \
 297         }; \
 298         return wc; \
 299 }
 300
 301 #define DECLARE_FRAME_WND_SUPERCLASS(WndClassName, OrigWndClassName, uCommonResourceID) \
 302 static WTL::CFrameWndClassInfo& GetWndClassInfo() \
 303 { \
 304         static WTL::CFrameWndClassInfo wc = \
 305         { \
 306                 { NULL, StartWindowProc, \
 307                   0, 0, NULL, NULL, NULL, NULL, NULL, WndClassName }, \
 308                 OrigWndClassName, NULL, IDC_ARROW, TRUE, 0, _T(""), uCommonResourceID \
 309         }; \
 310         return wc; \
 311 }
 312
 313 #endif // !_WIN32_WCE
 314
 315
 316 ///////////////////////////////////////////////////////////////////////////////
 317 // CFrameWindowImpl
 318
 319 // Client window command chaining macro (only for frame windows)
 320 #define CHAIN_CLIENT_COMMANDS() \
 321         if(uMsg == WM_COMMAND && m_hWndClient != NULL) \
 322                 ::SendMessage(m_hWndClient, uMsg, wParam, lParam);
 323
 324 // standard toolbar styles
 325 #define ATL_SIMPLE_TOOLBAR_STYLE \
 326         (WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | TBSTYLE_TOOLTIPS)
 327 // toolbar in a rebar pane
 328 #define ATL_SIMPLE_TOOLBAR_PANE_STYLE \
 329         (WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | CCS_NODIVIDER | CCS_NORESIZE | CCS_NOPARENTALIGN | TBSTYLE_TOOLTIPS | TBSTYLE_FLAT)
 330 // standard rebar styles
 331 #if (_WIN32_IE >= 0x0400)
 332   #define ATL_SIMPLE_REBAR_STYLE \
 333         (WS_CHILD | WS_VISIBLE | WS_BORDER | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | RBS_VARHEIGHT | RBS_BANDBORDERS | RBS_AUTOSIZE)
 334 #else
 335   #define ATL_SIMPLE_REBAR_STYLE \
 336         (WS_CHILD | WS_VISIBLE | WS_BORDER | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | RBS_VARHEIGHT | RBS_BANDBORDERS)
 337 #endif // !(_WIN32_IE >= 0x0400)
 338 // rebar without borders
 339 #if (_WIN32_IE >= 0x0400)
 340   #define ATL_SIMPLE_REBAR_NOBORDER_STYLE \
 341         (WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | RBS_VARHEIGHT | RBS_BANDBORDERS | RBS_AUTOSIZE | CCS_NODIVIDER)
 342 #else
 343   #define ATL_SIMPLE_REBAR_NOBORDER_STYLE \
 344         (WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | RBS_VARHEIGHT | RBS_BANDBORDERS | CCS_NODIVIDER)
 345 #endif // !(_WIN32_IE >= 0x0400)
 346
 347 // command bar support
 348 #if !defined(__ATLCTRLW_H__) && !defined(_WIN32_WCE)
 349
 350 #define CBRM_GETCMDBAR                  (WM_USER + 301) // returns command bar HWND
 351 #define CBRM_GETMENU                    (WM_USER + 302) // returns loaded or attached menu
 352 #define CBRM_TRACKPOPUPMENU             (WM_USER + 303) // displays a popup menu
 353
 354 struct _AtlFrameWnd_CmdBarPopupMenu
 355 {
 356         int cbSize;
 357         HMENU hMenu;
 358         UINT uFlags;
 359         int x;
 360         int y;
 361         LPTPMPARAMS lptpm;
 362 };
 363
 364 #define CBRPOPUPMENU _AtlFrameWnd_CmdBarPopupMenu
 365
 366 #endif // !defined(__ATLCTRLW_H__) && !defined(_WIN32_WCE)
 367
 368
 369 template <class TBase = ATL::CWindow, class TWinTraits = ATL::CFrameWinTraits>
 370 class ATL_NO_VTABLE CFrameWindowImplBase : public ATL::CWindowImplBaseT< TBase, TWinTraits >
 371 {
 372 public:
 373         DECLARE_FRAME_WND_CLASS(NULL, 0)
 374
 375 // Data members
 376         HWND m_hWndToolBar;
 377         HWND m_hWndStatusBar;
 378         HWND m_hWndClient;
 379
 380         HACCEL m_hAccel;
 381
 382 #ifdef _WIN32_WCE
 383         HWND m_hWndCECommandBar;
 384 #endif // _WIN32_WCE
 385
 386         struct _AtlToolBarData
 387         {
 388                 WORD wVersion;
 389                 WORD wWidth;
 390                 WORD wHeight;
 391                 WORD wItemCount;
 392                 //WORD aItems[wItemCount]
 393
 394                 WORD* items()
 395                         { return (WORD*)(this+1); }
 396         };
 397
 398 #if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
 399         struct _ChevronMenuInfo
 400         {
 401                 HMENU hMenu;
 402                 LPNMREBARCHEVRON lpnm;
 403                 bool bCmdBar;
 404         };
 405 #endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
 406
 407 // Constructor
 408         CFrameWindowImplBase() :
 409 #ifdef _WIN32_WCE
 410                 m_hWndCECommandBar(NULL),
 411 #endif // _WIN32_WCE
 412                 m_hWndToolBar(NULL),
 413                 m_hWndStatusBar(NULL),
 414                 m_hWndClient(NULL),
 415                 m_hAccel(NULL)
 416         { }
 417
 418 // Methods
 419         HWND Create(HWND hWndParent, ATL::_U_RECT rect, LPCTSTR szWindowName, DWORD dwStyle, DWORD dwExStyle, ATL::_U_MENUorID MenuOrID, ATOM atom, LPVOID lpCreateParam)
 420         {
 421                 ATLASSERT(m_hWnd == NULL);
 422
 423                 if(atom == 0)
 424                         return NULL;
 425
 426                 ModuleHelper::AddCreateWndData(&m_thunk.cd, this);
 427
 428                 if(MenuOrID.m_hMenu == NULL && (dwStyle & WS_CHILD))
 429                         MenuOrID.m_hMenu = (HMENU)(UINT_PTR)this;
 430                 if(rect.m_lpRect == NULL)
 431                         rect.m_lpRect = &TBase::rcDefault;
 432
 433                 HWND hWnd = ::CreateWindowEx(dwExStyle, MAKEINTATOM(atom), szWindowName,
 434                         dwStyle, rect.m_lpRect->left, rect.m_lpRect->top, rect.m_lpRect->right - rect.m_lpRect->left,
 435                         rect.m_lpRect->bottom - rect.m_lpRect->top, hWndParent, MenuOrID.m_hMenu,
 436                         ModuleHelper::GetModuleInstance(), lpCreateParam);
 437
 438                 ATLASSERT(hWnd == NULL || m_hWnd == hWnd);
 439
 440                 return hWnd;
 441         }
 442
 443         static HWND CreateSimpleToolBarCtrl(HWND hWndParent, UINT nResourceID, BOOL bInitialSeparator = FALSE,
 444                         DWORD dwStyle = ATL_SIMPLE_TOOLBAR_STYLE, UINT nID = ATL_IDW_TOOLBAR)
 445         {
 446                 HINSTANCE hInst = ModuleHelper::GetResourceInstance();
 447                 HRSRC hRsrc = ::FindResource(hInst, MAKEINTRESOURCE(nResourceID), RT_TOOLBAR);
 448                 if (hRsrc == NULL)
 449                         return NULL;
 450
 451                 HGLOBAL hGlobal = ::LoadResource(hInst, hRsrc);
 452                 if (hGlobal == NULL)
 453                         return NULL;
 454
 455                 _AtlToolBarData* pData = (_AtlToolBarData*)::LockResource(hGlobal);
 456                 if (pData == NULL)
 457                         return NULL;
 458                 ATLASSERT(pData->wVersion == 1);
 459
 460                 WORD* pItems = pData->items();
 461                 int nItems = pData->wItemCount + (bInitialSeparator ? 1 : 0);
 462                 CTempBuffer<TBBUTTON, _WTL_STACK_ALLOC_THRESHOLD> buff;
 463                 TBBUTTON* pTBBtn = buff.Allocate(nItems);
 464                 ATLASSERT(pTBBtn != NULL);
 465                 if(pTBBtn == NULL)
 466                         return NULL;
 467
 468                 const int cxSeparator = 8;
 469
 470                 // set initial separator (half width)
 471                 if(bInitialSeparator)
 472                 {
 473                         pTBBtn[0].iBitmap = cxSeparator / 2;
 474                         pTBBtn[0].idCommand = 0;
 475                         pTBBtn[0].fsState = 0;
 476                         pTBBtn[0].fsStyle = TBSTYLE_SEP;
 477                         pTBBtn[0].dwData = 0;
 478                         pTBBtn[0].iString = 0;
 479                 }
 480
 481                 int nBmp = 0;
 482                 for(int i = 0, j = bInitialSeparator ? 1 : 0; i < pData->wItemCount; i++, j++)
 483                 {
 484                         if(pItems[i] != 0)
 485                         {
 486                                 pTBBtn[j].iBitmap = nBmp++;
 487                                 pTBBtn[j].idCommand = pItems[i];
 488                                 pTBBtn[j].fsState = TBSTATE_ENABLED;
 489                                 pTBBtn[j].fsStyle = TBSTYLE_BUTTON;
 490                                 pTBBtn[j].dwData = 0;
 491                                 pTBBtn[j].iString = 0;
 492                         }
 493                         else
 494                         {
 495                                 pTBBtn[j].iBitmap = cxSeparator;
 496                                 pTBBtn[j].idCommand = 0;
 497                                 pTBBtn[j].fsState = 0;
 498                                 pTBBtn[j].fsStyle = TBSTYLE_SEP;
 499                                 pTBBtn[j].dwData = 0;
 500                                 pTBBtn[j].iString = 0;
 501                         }
 502                 }
 503
 504 #ifndef _WIN32_WCE
 505                 HWND hWnd = ::CreateWindowEx(0, TOOLBARCLASSNAME, NULL, dwStyle, 0, 0, 100, 100, hWndParent, (HMENU)LongToHandle(nID), ModuleHelper::GetModuleInstance(), NULL);
 506                 if(hWnd == NULL)
 507                 {
 508                         ATLASSERT(FALSE);
 509                         return NULL;
 510                 }
 511 #else // CE specific
 512                 dwStyle;
 513                 nID;
 514                 // The toolbar must go onto the existing CommandBar or MenuBar
 515                 HWND hWnd = hWndParent;
 516 #endif // _WIN32_WCE
 517
 518                 ::SendMessage(hWnd, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0L);
 519
 520                 // check if font is taller than our bitmaps
 521                 CFontHandle font = (HFONT)::SendMessage(hWnd, WM_GETFONT, 0, 0L);
 522                 if(font.IsNull())
 523                         font = AtlGetDefaultGuiFont();
 524                 LOGFONT lf = { 0 };
 525                 font.GetLogFont(lf);
 526                 WORD cyFontHeight = (WORD)abs(lf.lfHeight);
 527
 528 #ifndef _WIN32_WCE
 529                 WORD bitsPerPixel = AtlGetBitmapResourceBitsPerPixel(nResourceID);
 530                 if(bitsPerPixel > 4)
 531                 {
 532                         COLORREF crMask = CLR_DEFAULT;
 533                         if(bitsPerPixel == 32)
 534                         {
 535                                 // 32-bit color bitmap with alpha channel (valid for Windows XP and later)
 536                                 crMask = CLR_NONE;
 537                         }
 538                         HIMAGELIST hImageList = ImageList_LoadImage(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(nResourceID), pData->wWidth, 1, crMask, IMAGE_BITMAP, LR_CREATEDIBSECTION | LR_DEFAULTSIZE);
 539                         ATLASSERT(hImageList != NULL);
 540                         ::SendMessage(hWnd, TB_SETIMAGELIST, 0, (LPARAM)hImageList);
 541                 }
 542                 else
 543 #endif // !_WIN32_WCE
 544                 {
 545                         TBADDBITMAP tbab = { 0 };
 546                         tbab.hInst = hInst;
 547                         tbab.nID = nResourceID;
 548                         ::SendMessage(hWnd, TB_ADDBITMAP, nBmp, (LPARAM)&tbab);
 549                 }
 550
 551                 ::SendMessage(hWnd, TB_ADDBUTTONS, nItems, (LPARAM)pTBBtn);
 552                 ::SendMessage(hWnd, TB_SETBITMAPSIZE, 0, MAKELONG(pData->wWidth, __max(pData->wHeight, cyFontHeight)));
 553                 const int cxyButtonMargin = 7;
 554                 ::SendMessage(hWnd, TB_SETBUTTONSIZE, 0, MAKELONG(pData->wWidth + cxyButtonMargin, __max(pData->wHeight, cyFontHeight) + cxyButtonMargin));
 555
 556                 return hWnd;
 557         }
 558
 559 #ifndef _WIN32_WCE
 560         static HWND CreateSimpleReBarCtrl(HWND hWndParent, DWORD dwStyle = ATL_SIMPLE_REBAR_STYLE, UINT nID = ATL_IDW_TOOLBAR)
 561         {
 562                 // Ensure style combinations for proper rebar painting
 563                 if(dwStyle & CCS_NODIVIDER && dwStyle & WS_BORDER)
 564                         dwStyle &= ~WS_BORDER;
 565                 else if(!(dwStyle & WS_BORDER) && !(dwStyle & CCS_NODIVIDER))
 566                         dwStyle |= CCS_NODIVIDER;
 567
 568                 // Create rebar window
 569                 HWND hWndReBar = ::CreateWindowEx(0, REBARCLASSNAME, NULL, dwStyle, 0, 0, 100, 100, hWndParent, (HMENU)LongToHandle(nID), ModuleHelper::GetModuleInstance(), NULL);
 570                 if(hWndReBar == NULL)
 571                 {
 572                         ATLTRACE2(atlTraceUI, 0, _T("Failed to create rebar.\n"));
 573                         return NULL;
 574                 }
 575
 576                 // Initialize and send the REBARINFO structure
 577                 REBARINFO rbi = { 0 };
 578                 rbi.cbSize = sizeof(REBARINFO);
 579                 rbi.fMask  = 0;
 580                 if(!::SendMessage(hWndReBar, RB_SETBARINFO, 0, (LPARAM)&rbi))
 581                 {
 582                         ATLTRACE2(atlTraceUI, 0, _T("Failed to initialize rebar.\n"));
 583                         ::DestroyWindow(hWndReBar);
 584                         return NULL;
 585                 }
 586
 587                 return hWndReBar;
 588         }
 589
 590         BOOL CreateSimpleReBar(DWORD dwStyle = ATL_SIMPLE_REBAR_STYLE, UINT nID = ATL_IDW_TOOLBAR)
 591         {
 592                 ATLASSERT(!::IsWindow(m_hWndToolBar));
 593                 m_hWndToolBar = CreateSimpleReBarCtrl(m_hWnd, dwStyle, nID);
 594                 return (m_hWndToolBar != NULL);
 595         }
 596
 597         static BOOL AddSimpleReBarBandCtrl(HWND hWndReBar, HWND hWndBand, int nID = 0, LPCTSTR lpstrTitle = NULL, BOOL bNewRow = FALSE, int cxWidth = 0, BOOL bFullWidthAlways = FALSE)
 598         {
 599                 ATLASSERT(::IsWindow(hWndReBar));   // must be already created
 600 #ifdef _DEBUG
 601                 // block - check if this is really a rebar
 602                 {
 603                         TCHAR lpszClassName[sizeof(REBARCLASSNAME)] = { 0 };
 604                         ::GetClassName(hWndReBar, lpszClassName, sizeof(REBARCLASSNAME));
 605                         ATLASSERT(lstrcmp(lpszClassName, REBARCLASSNAME) == 0);
 606                 }
 607 #endif // _DEBUG
 608                 ATLASSERT(::IsWindow(hWndBand));   // must be already created
 609
 610                 // Get number of buttons on the toolbar
 611                 int nBtnCount = (int)::SendMessage(hWndBand, TB_BUTTONCOUNT, 0, 0L);
 612
 613                 // Set band info structure
 614                 REBARBANDINFO rbBand = { RunTimeHelper::SizeOf_REBARBANDINFO() };
 615 #if (_WIN32_IE >= 0x0400)
 616                 rbBand.fMask = RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_STYLE | RBBIM_ID | RBBIM_SIZE | RBBIM_IDEALSIZE;
 617 #else
 618                 rbBand.fMask = RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_STYLE | RBBIM_ID | RBBIM_SIZE;
 619 #endif // !(_WIN32_IE >= 0x0400)
 620                 if(lpstrTitle != NULL)
 621                         rbBand.fMask |= RBBIM_TEXT;
 622                 rbBand.fStyle = RBBS_CHILDEDGE;
 623 #if (_WIN32_IE >= 0x0500)
 624                 if(nBtnCount > 0)   // add chevron style for toolbar with buttons
 625                         rbBand.fStyle |= RBBS_USECHEVRON;
 626 #endif // (_WIN32_IE >= 0x0500)
 627                 if(bNewRow)
 628                         rbBand.fStyle |= RBBS_BREAK;
 629
 630                 rbBand.lpText = (LPTSTR)lpstrTitle;
 631                 rbBand.hwndChild = hWndBand;
 632                 if(nID == 0)   // calc band ID
 633                         nID = ATL_IDW_BAND_FIRST + (int)::SendMessage(hWndReBar, RB_GETBANDCOUNT, 0, 0L);
 634                 rbBand.wID = nID;
 635
 636                 // Calculate the size of the band
 637                 BOOL bRet = FALSE;
 638                 RECT rcTmp = { 0 };
 639                 if(nBtnCount > 0)
 640                 {
 641                         bRet = (BOOL)::SendMessage(hWndBand, TB_GETITEMRECT, nBtnCount - 1, (LPARAM)&rcTmp);
 642                         ATLASSERT(bRet);
 643                         rbBand.cx = (cxWidth != 0) ? cxWidth : rcTmp.right;
 644                         rbBand.cyMinChild = rcTmp.bottom - rcTmp.top;
 645                         if(bFullWidthAlways)
 646                         {
 647                                 rbBand.cxMinChild = rbBand.cx;
 648                         }
 649                         else if(lpstrTitle == NULL)
 650                         {
 651                                 bRet = (BOOL)::SendMessage(hWndBand, TB_GETITEMRECT, 0, (LPARAM)&rcTmp);
 652                                 ATLASSERT(bRet);
 653                                 rbBand.cxMinChild = rcTmp.right;
 654                         }
 655                         else
 656                         {
 657                                 rbBand.cxMinChild = 0;
 658                         }
 659                 }
 660                 else    // no buttons, either not a toolbar or really has no buttons
 661                 {
 662                         bRet = ::GetWindowRect(hWndBand, &rcTmp);
 663                         ATLASSERT(bRet);
 664                         rbBand.cx = (cxWidth != 0) ? cxWidth : (rcTmp.right - rcTmp.left);
 665                         rbBand.cxMinChild = bFullWidthAlways ? rbBand.cx : 0;
 666                         rbBand.cyMinChild = rcTmp.bottom - rcTmp.top;
 667                 }
 668
 669 #if (_WIN32_IE >= 0x0400)
 670                 rbBand.cxIdeal = rbBand.cx;
 671 #endif // (_WIN32_IE >= 0x0400)
 672
 673                 // Add the band
 674                 LRESULT lRes = ::SendMessage(hWndReBar, RB_INSERTBAND, (WPARAM)-1, (LPARAM)&rbBand);
 675                 if(lRes == 0)
 676                 {
 677                         ATLTRACE2(atlTraceUI, 0, _T("Failed to add a band to the rebar.\n"));
 678                         return FALSE;
 679                 }
 680
 681 #if (_WIN32_IE >= 0x0501)
 682                 DWORD dwExStyle = (DWORD)::SendMessage(hWndBand, TB_GETEXTENDEDSTYLE, 0, 0L);
 683                 ::SendMessage(hWndBand, TB_SETEXTENDEDSTYLE, 0, dwExStyle | TBSTYLE_EX_HIDECLIPPEDBUTTONS);
 684 #endif // (_WIN32_IE >= 0x0501)
 685
 686                 return TRUE;
 687         }
 688
 689         BOOL AddSimpleReBarBand(HWND hWndBand, LPCTSTR lpstrTitle = NULL, BOOL bNewRow = FALSE, int cxWidth = 0, BOOL bFullWidthAlways = FALSE)
 690         {
 691                 ATLASSERT(::IsWindow(m_hWndToolBar));   // must be an existing rebar
 692                 ATLASSERT(::IsWindow(hWndBand));        // must be created
 693                 return AddSimpleReBarBandCtrl(m_hWndToolBar, hWndBand, 0, lpstrTitle, bNewRow, cxWidth, bFullWidthAlways);
 694         }
 695
 696 #if (_WIN32_IE >= 0x0400)
 697         void SizeSimpleReBarBands()
 698         {
 699                 ATLASSERT(::IsWindow(m_hWndToolBar));   // must be an existing rebar
 700
 701                 int nCount = (int)::SendMessage(m_hWndToolBar, RB_GETBANDCOUNT, 0, 0L);
 702
 703                 for(int i = 0; i < nCount; i++)
 704                 {
 705                         REBARBANDINFO rbBand = { RunTimeHelper::SizeOf_REBARBANDINFO() };
 706                         rbBand.fMask = RBBIM_SIZE;
 707                         BOOL bRet = (BOOL)::SendMessage(m_hWndToolBar, RB_GETBANDINFO, i, (LPARAM)&rbBand);
 708                         ATLASSERT(bRet);
 709                         RECT rect = { 0, 0, 0, 0 };
 710                         ::SendMessage(m_hWndToolBar, RB_GETBANDBORDERS, i, (LPARAM)&rect);
 711                         rbBand.cx += rect.left + rect.right;
 712                         bRet = (BOOL)::SendMessage(m_hWndToolBar, RB_SETBANDINFO, i, (LPARAM)&rbBand);
 713                         ATLASSERT(bRet);
 714                 }
 715         }
 716 #endif // (_WIN32_IE >= 0x0400)
 717 #endif // _WIN32_WCE
 718
 719 #ifndef _WIN32_WCE
 720         BOOL CreateSimpleStatusBar(LPCTSTR lpstrText, DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | SBARS_SIZEGRIP, UINT nID = ATL_IDW_STATUS_BAR)
 721 #else // CE specific
 722         BOOL CreateSimpleStatusBar(LPCTSTR lpstrText, DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, UINT nID = ATL_IDW_STATUS_BAR)
 723 #endif // _WIN32_WCE
 724         {
 725                 ATLASSERT(!::IsWindow(m_hWndStatusBar));
 726                 m_hWndStatusBar = ::CreateStatusWindow(dwStyle, lpstrText, m_hWnd, nID);
 727                 return (m_hWndStatusBar != NULL);
 728         }
 729
 730 #ifndef _WIN32_WCE
 731         BOOL CreateSimpleStatusBar(UINT nTextID = ATL_IDS_IDLEMESSAGE, DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | SBARS_SIZEGRIP, UINT nID = ATL_IDW_STATUS_BAR)
 732 #else // CE specific
 733         BOOL CreateSimpleStatusBar(UINT nTextID = ATL_IDS_IDLEMESSAGE, DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, UINT nID = ATL_IDW_STATUS_BAR)
 734 #endif // _WIN32_WCE
 735         {
 736                 const int cchMax = 128;   // max text length is 127 for status bars (+1 for null)
 737                 TCHAR szText[cchMax];
 738                 szText[0] = 0;
 739                 ::LoadString(ModuleHelper::GetResourceInstance(), nTextID, szText, cchMax);
 740                 return CreateSimpleStatusBar(szText, dwStyle, nID);
 741         }
 742
 743 #ifdef _WIN32_WCE
 744         BOOL CreateSimpleCECommandBar(LPTSTR pszMenu = NULL, WORD iButton = 0, DWORD dwFlags = 0, int nCmdBarID = 1)
 745         {
 746                 ATLASSERT(m_hWndCECommandBar == NULL);
 747                 ATLASSERT(m_hWndToolBar == NULL);
 748
 749                 m_hWndCECommandBar = ::CommandBar_Create(ModuleHelper::GetModuleInstance(), m_hWnd, nCmdBarID);
 750                 if(m_hWndCECommandBar == NULL)
 751                         return FALSE;
 752
 753                 m_hWndToolBar = m_hWndCECommandBar;
 754
 755                 BOOL bRet = TRUE;
 756
 757                 if(pszMenu != NULL)
 758                         bRet &= ::CommandBar_InsertMenubarEx(m_hWndCECommandBar, IS_INTRESOURCE(pszMenu) ? ModuleHelper::GetResourceInstance() : NULL, pszMenu, iButton);
 759
 760                 bRet &= ::CommandBar_AddAdornments(m_hWndCECommandBar, dwFlags, 0);
 761
 762                 return bRet;
 763         }
 764
 765 #if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__)
 766         BOOL CreateSimpleCEMenuBar(UINT nToolBarId = ATL_IDW_MENU_BAR, DWORD dwFlags = 0, int nBmpId = 0, int cBmpImages = 0)
 767         {
 768                 ATLASSERT(m_hWndCECommandBar == NULL);
 769
 770                 SHMENUBARINFO mbi = { 0 };
 771                 mbi.cbSize = sizeof(mbi);
 772                 mbi.hwndParent = m_hWnd;
 773                 mbi.dwFlags = dwFlags;
 774                 mbi.nToolBarId = nToolBarId;
 775                 mbi.hInstRes  = ModuleHelper::GetResourceInstance();
 776                 mbi.nBmpId = nBmpId;
 777                 mbi.cBmpImages = cBmpImages;
 778                 mbi.hwndMB = NULL;   // This gets set by SHCreateMenuBar
 779
 780                 BOOL bRet = ::SHCreateMenuBar(&mbi);
 781                 if(bRet != FALSE)
 782                 {
 783                         m_hWndCECommandBar = mbi.hwndMB;
 784                         SizeToMenuBar();
 785                 }
 786
 787                 return bRet;
 788         }
 789
 790         void SizeToMenuBar()   // for menu bar only
 791         {
 792                 ATLASSERT(::IsWindow(m_hWnd));
 793                 ATLASSERT(::IsWindow(m_hWndCECommandBar));
 794
 795                 RECT rect = { 0 };
 796                 GetWindowRect(&rect);
 797                 RECT rectMB = { 0 };
 798                 ::GetWindowRect(m_hWndCECommandBar, &rectMB);
 799                 int cy = ::IsWindowVisible(m_hWndCECommandBar) ? rectMB.top - rect.top : rectMB.bottom - rect.top;
 800                 SetWindowPos(NULL, 0, 0, rect.right - rect.left, cy, SWP_NOZORDER | SWP_NOMOVE);
 801         }
 802 #endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__)
 803 #endif // _WIN32_WCE
 804
 805         void UpdateLayout(BOOL bResizeBars = TRUE)
 806         {
 807                 RECT rect = { 0 };
 808                 GetClientRect(&rect);
 809
 810                 // position bars and offset their dimensions
 811                 UpdateBarsPosition(rect, bResizeBars);
 812
 813                 // resize client window
 814                 if(m_hWndClient != NULL)
 815                         ::SetWindowPos(m_hWndClient, NULL, rect.left, rect.top,
 816                                 rect.right - rect.left, rect.bottom - rect.top,
 817                                 SWP_NOZORDER | SWP_NOACTIVATE);
 818         }
 819
 820         void UpdateBarsPosition(RECT& rect, BOOL bResizeBars = TRUE)
 821         {
 822                 // resize toolbar
 823                 if(m_hWndToolBar != NULL && ((DWORD)::GetWindowLong(m_hWndToolBar, GWL_STYLE) & WS_VISIBLE))
 824                 {
 825                         if(bResizeBars)
 826                         {
 827                                 ::SendMessage(m_hWndToolBar, WM_SIZE, 0, 0);
 828                                 ::InvalidateRect(m_hWndToolBar, NULL, FALSE);
 829                         }
 830                         RECT rectTB = { 0 };
 831                         ::GetWindowRect(m_hWndToolBar, &rectTB);
 832                         rect.top += rectTB.bottom - rectTB.top;
 833                 }
 834
 835                 // resize status bar
 836                 if(m_hWndStatusBar != NULL && ((DWORD)::GetWindowLong(m_hWndStatusBar, GWL_STYLE) & WS_VISIBLE))
 837                 {
 838                         if(bResizeBars)
 839                                 ::SendMessage(m_hWndStatusBar, WM_SIZE, 0, 0);
 840                         RECT rectSB = { 0 };
 841                         ::GetWindowRect(m_hWndStatusBar, &rectSB);
 842                         rect.bottom -= rectSB.bottom - rectSB.top;
 843                 }
 844         }
 845
 846         BOOL PreTranslateMessage(MSG* pMsg)
 847         {
 848                 if(m_hAccel != NULL && ::TranslateAccelerator(m_hWnd, m_hAccel, pMsg))
 849                         return TRUE;
 850                 return FALSE;
 851         }
 852
 853         BEGIN_MSG_MAP(CFrameWindowImplBase)
 854                 MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)
 855 #ifndef _WIN32_WCE
 856                 MESSAGE_HANDLER(WM_MENUSELECT, OnMenuSelect)
 857 #endif // !_WIN32_WCE
 858                 MESSAGE_HANDLER(WM_SETFOCUS, OnSetFocus)
 859                 MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
 860 #ifndef _WIN32_WCE
 861                 NOTIFY_CODE_HANDLER(TTN_GETDISPINFOA, OnToolTipTextA)
 862                 NOTIFY_CODE_HANDLER(TTN_GETDISPINFOW, OnToolTipTextW)
 863 #endif // !_WIN32_WCE
 864         END_MSG_MAP()
 865
 866         LRESULT OnEraseBackground(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
 867         {
 868                 if(m_hWndClient != NULL)   // view will paint itself instead
 869                         return 1;
 870
 871                 bHandled = FALSE;
 872                 return 0;
 873         }
 874
 875 #ifndef _WIN32_WCE
 876         LRESULT OnMenuSelect(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
 877         {
 878                 bHandled = FALSE;
 879
 880                 if(m_hWndStatusBar == NULL)
 881                         return 1;
 882
 883                 WORD wFlags = HIWORD(wParam);
 884                 if(wFlags == 0xFFFF && lParam == NULL)   // menu closing
 885                 {
 886                         ::SendMessage(m_hWndStatusBar, SB_SIMPLE, FALSE, 0L);
 887                 }
 888                 else
 889                 {
 890                         const int cchBuff = 256;
 891                         TCHAR szBuff[cchBuff];
 892                         szBuff[0] = 0;
 893                         if(!(wFlags & MF_POPUP))
 894                         {
 895                                 WORD wID = LOWORD(wParam);
 896                                 // check for special cases
 897                                 if(wID >= 0xF000 && wID < 0xF1F0)   // system menu IDs
 898                                         wID = (WORD)(((wID - 0xF000) >> 4) + ATL_IDS_SCFIRST);
 899                                 else if(wID >= ID_FILE_MRU_FIRST && wID <= ID_FILE_MRU_LAST)   // MRU items
 900                                         wID = ATL_IDS_MRU_FILE;
 901                                 else if(wID >= ATL_IDM_FIRST_MDICHILD && wID <= ATL_IDM_LAST_MDICHILD)   // MDI child windows
 902                                         wID = ATL_IDS_MDICHILD;
 903
 904                                 int nRet = ::LoadString(ModuleHelper::GetResourceInstance(), wID, szBuff, cchBuff);
 905                                 for(int i = 0; i < nRet; i++)
 906                                 {
 907                                         if(szBuff[i] == _T('\n'))
 908                                         {
 909                                                 szBuff[i] = 0;
 910                                                 break;
 911                                         }
 912                                 }
 913                         }
 914                         ::SendMessage(m_hWndStatusBar, SB_SIMPLE, TRUE, 0L);
 915                         ::SendMessage(m_hWndStatusBar, SB_SETTEXT, (255 | SBT_NOBORDERS), (LPARAM)szBuff);
 916                 }
 917
 918                 return 1;
 919         }
 920 #endif // !_WIN32_WCE
 921
 922         LRESULT OnSetFocus(UINT, WPARAM, LPARAM, BOOL& bHandled)
 923         {
 924                 if(m_hWndClient != NULL)
 925                         ::SetFocus(m_hWndClient);
 926
 927                 bHandled = FALSE;
 928                 return 1;
 929         }
 930
 931         LRESULT OnDestroy(UINT, WPARAM, LPARAM, BOOL& bHandled)
 932         {
 933                 if((GetStyle() & (WS_CHILD | WS_POPUP)) == 0)
 934                         ::PostQuitMessage(1);
 935
 936                 bHandled = FALSE;
 937                 return 1;
 938         }
 939
 940 #ifndef _WIN32_WCE
 941         LRESULT OnToolTipTextA(int idCtrl, LPNMHDR pnmh, BOOL& /*bHandled*/)
 942         {
 943                 LPNMTTDISPINFOA pDispInfo = (LPNMTTDISPINFOA)pnmh;
 944                 pDispInfo->szText[0] = 0;
 945
 946                 if((idCtrl != 0) && !(pDispInfo->uFlags & TTF_IDISHWND))
 947                 {
 948                         const int cchBuff = 256;
 949                         char szBuff[cchBuff];
 950                         szBuff[0] = 0;
 951                         int nRet = ::LoadStringA(ModuleHelper::GetResourceInstance(), idCtrl, szBuff, cchBuff);
 952                         for(int i = 0; i < nRet; i++)
 953                         {
 954                                 if(szBuff[i] == '\n')
 955                                 {
 956                                         SecureHelper::strncpyA_x(pDispInfo->szText, _countof(pDispInfo->szText), &szBuff[i + 1], _TRUNCATE);
 957                                         break;
 958                                 }
 959                         }
 960 #if (_WIN32_IE >= 0x0300)
 961                         if(nRet > 0)   // string was loaded, save it
 962                                 pDispInfo->uFlags |= TTF_DI_SETITEM;
 963 #endif // (_WIN32_IE >= 0x0300)
 964                 }
 965
 966                 return 0;
 967         }
 968
 969         LRESULT OnToolTipTextW(int idCtrl, LPNMHDR pnmh, BOOL& /*bHandled*/)
 970         {
 971                 LPNMTTDISPINFOW pDispInfo = (LPNMTTDISPINFOW)pnmh;
 972                 pDispInfo->szText[0] = 0;
 973
 974                 if((idCtrl != 0) && !(pDispInfo->uFlags & TTF_IDISHWND))
 975                 {
 976                         const int cchBuff = 256;
 977                         wchar_t szBuff[cchBuff];
 978                         szBuff[0] = 0;
 979                         int nRet = ::LoadStringW(ModuleHelper::GetResourceInstance(), idCtrl, szBuff, cchBuff);
 980                         for(int i = 0; i < nRet; i++)
 981                         {
 982                                 if(szBuff[i] == L'\n')
 983                                 {
 984                                         SecureHelper::strncpyW_x(pDispInfo->szText, _countof(pDispInfo->szText), &szBuff[i + 1], _TRUNCATE);
 985                                         break;
 986                                 }
 987                         }
 988 #if (_WIN32_IE >= 0x0300)
 989                         if(nRet > 0)   // string was loaded, save it
 990                                 pDispInfo->uFlags |= TTF_DI_SETITEM;
 991 #endif // (_WIN32_IE >= 0x0300)
 992                 }
 993
 994                 return 0;
 995         }
 996 #endif // !_WIN32_WCE
 997
 998 // Implementation - chevron menu support
 999 #if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
1000         bool PrepareChevronMenu(_ChevronMenuInfo& cmi)
1001         {
1002                 // get rebar and toolbar
1003                 REBARBANDINFO rbbi = { RunTimeHelper::SizeOf_REBARBANDINFO() };
1004                 rbbi.fMask = RBBIM_CHILD;
1005                 BOOL bRet = (BOOL)::SendMessage(cmi.lpnm->hdr.hwndFrom, RB_GETBANDINFO, cmi.lpnm->uBand, (LPARAM)&rbbi);
1006                 ATLASSERT(bRet);
1007
1008                 // assume the band is a toolbar
1009                 ATL::CWindow wnd = rbbi.hwndChild;
1010                 int nCount = (int)wnd.SendMessage(TB_BUTTONCOUNT);
1011                 if(nCount <= 0)   // probably not a toolbar
1012                         return false;
1013
1014                 // check if it's a command bar
1015                 CMenuHandle menuCmdBar = (HMENU)wnd.SendMessage(CBRM_GETMENU);
1016                 cmi.bCmdBar = (menuCmdBar.m_hMenu != NULL);
1017
1018                 // build a menu from hidden items
1019                 CMenuHandle menu;
1020                 bRet = menu.CreatePopupMenu();
1021                 ATLASSERT(bRet);
1022                 RECT rcClient = { 0 };
1023                 bRet = wnd.GetClientRect(&rcClient);
1024                 ATLASSERT(bRet);
1025                 for(int i = 0; i < nCount; i++)
1026                 {
1027                         TBBUTTON tbb = { 0 };
1028                         bRet = (BOOL)wnd.SendMessage(TB_GETBUTTON, i, (LPARAM)&tbb);
1029                         ATLASSERT(bRet);
1030                         // skip hidden buttons
1031                         if((tbb.fsState & TBSTATE_HIDDEN) != 0)
1032                                 continue;
1033                         RECT rcButton = { 0 };
1034                         bRet = (BOOL)wnd.SendMessage(TB_GETITEMRECT, i, (LPARAM)&rcButton);
1035                         ATLASSERT(bRet);
1036                         bool bEnabled = ((tbb.fsState & TBSTATE_ENABLED) != 0);
1037                         if(rcButton.right > rcClient.right)
1038                         {
1039                                 if(tbb.fsStyle & BTNS_SEP)
1040                                 {
1041                                         if(menu.GetMenuItemCount() > 0)
1042                                                 menu.AppendMenu(MF_SEPARATOR);
1043                                 }
1044                                 else if(cmi.bCmdBar)
1045                                 {
1046                                         const int cchBuff = 200;
1047                                         TCHAR szBuff[cchBuff] = { 0 };
1048                                         CMenuItemInfo mii;
1049                                         mii.fMask = MIIM_TYPE | MIIM_SUBMENU;
1050                                         mii.dwTypeData = szBuff;
1051                                         mii.cch = cchBuff;
1052                                         bRet = menuCmdBar.GetMenuItemInfo(i, TRUE, &mii);
1053                                         ATLASSERT(bRet);
1054                                         // Note: CmdBar currently supports only drop-down items
1055                                         ATLASSERT(::IsMenu(mii.hSubMenu));
1056                                         bRet = menu.AppendMenu(MF_STRING | MF_POPUP | (bEnabled ? MF_ENABLED : MF_GRAYED), (UINT_PTR)mii.hSubMenu, mii.dwTypeData);
1057                                         ATLASSERT(bRet);
1058                                 }
1059                                 else
1060                                 {
1061                                         // get button's text
1062                                         const int cchBuff = 200;
1063                                         TCHAR szBuff[cchBuff] = { 0 };
1064                                         LPTSTR lpstrText = szBuff;
1065                                         TBBUTTONINFO tbbi = { 0 };
1066                                         tbbi.cbSize = sizeof(TBBUTTONINFO);
1067                                         tbbi.dwMask = TBIF_TEXT;
1068                                         tbbi.pszText = szBuff;
1069                                         tbbi.cchText = cchBuff;
1070                                         if(wnd.SendMessage(TB_GETBUTTONINFO, tbb.idCommand, (LPARAM)&tbbi) == -1 || lstrlen(szBuff) == 0)
1071                                         {
1072                                                 // no text for this button, try a resource string
1073                                                 lpstrText = _T("");
1074                                                 int nRet = ::LoadString(ModuleHelper::GetResourceInstance(), tbb.idCommand, szBuff, cchBuff);
1075                                                 for(int n = 0; n < nRet; n++)
1076                                                 {
1077                                                         if(szBuff[n] == _T('\n'))
1078                                                         {
1079                                                                 lpstrText = &szBuff[n + 1];
1080                                                                 break;
1081                                                         }
1082                                                 }
1083                                         }
1084                                         bRet = menu.AppendMenu(MF_STRING | (bEnabled ? MF_ENABLED : MF_GRAYED), tbb.idCommand, lpstrText);
1085                                         ATLASSERT(bRet);
1086                                 }
1087                         }
1088                 }
1089
1090                 if(menu.GetMenuItemCount() == 0)   // no hidden buttons after all
1091                 {
1092                         menu.DestroyMenu();
1093                         ::MessageBeep((UINT)-1);
1094                         return false;
1095                 }
1096
1097                 cmi.hMenu = menu;
1098                 return true;
1099         }
1100
1101         void DisplayChevronMenu(_ChevronMenuInfo& cmi)
1102         {
1103 #ifndef TPM_VERPOSANIMATION
1104                 const UINT TPM_VERPOSANIMATION = 0x1000L;   // Menu animation flag
1105 #endif
1106                 // convert chevron rect to screen coordinates
1107                 ATL::CWindow wndFrom = cmi.lpnm->hdr.hwndFrom;
1108                 POINT pt = { cmi.lpnm->rc.left, cmi.lpnm->rc.bottom };
1109                 wndFrom.MapWindowPoints(NULL, &pt, 1);
1110                 RECT rc = cmi.lpnm->rc;
1111                 wndFrom.MapWindowPoints(NULL, &rc);
1112                 // set up flags and rect
1113                 UINT uMenuFlags = TPM_LEFTBUTTON | TPM_VERTICAL | TPM_LEFTALIGN | TPM_TOPALIGN | (!AtlIsOldWindows() ? TPM_VERPOSANIMATION : 0);
1114                 TPMPARAMS TPMParams = { 0 };
1115                 TPMParams.cbSize = sizeof(TPMPARAMS);
1116                 TPMParams.rcExclude = rc;
1117                 // check if this window has a command bar
1118                 HWND hWndCmdBar = (HWND)::SendMessage(m_hWnd, CBRM_GETCMDBAR, 0, 0L);
1119                 if(::IsWindow(hWndCmdBar))
1120                 {
1121                         CBRPOPUPMENU CBRPopupMenu = { sizeof(CBRPOPUPMENU), cmi.hMenu, uMenuFlags, pt.x, pt.y, &TPMParams };
1122                         ::SendMessage(hWndCmdBar, CBRM_TRACKPOPUPMENU, 0, (LPARAM)&CBRPopupMenu);
1123                 }
1124                 else
1125                 {
1126                         CMenuHandle menu = cmi.hMenu;
1127                         menu.TrackPopupMenuEx(uMenuFlags, pt.x, pt.y, m_hWnd, &TPMParams);
1128                 }
1129         }
1130
1131         void CleanupChevronMenu(_ChevronMenuInfo& cmi)
1132         {
1133                 CMenuHandle menu = cmi.hMenu;
1134                 // if menu is from a command bar, detach submenus so they are not destroyed
1135                 if(cmi.bCmdBar)
1136                 {
1137                         for(int i = menu.GetMenuItemCount() - 1; i >=0; i--)
1138                                 menu.RemoveMenu(i, MF_BYPOSITION);
1139                 }
1140                 // destroy menu
1141                 menu.DestroyMenu();
1142                 // convert chevron rect to screen coordinates
1143                 ATL::CWindow wndFrom = cmi.lpnm->hdr.hwndFrom;
1144                 RECT rc = cmi.lpnm->rc;
1145                 wndFrom.MapWindowPoints(NULL, &rc);
1146                 // eat next message if click is on the same button
1147                 MSG msg = { 0 };
1148                 if(::PeekMessage(&msg, m_hWnd, WM_LBUTTONDOWN, WM_LBUTTONDOWN, PM_NOREMOVE) && ::PtInRect(&rc, msg.pt))
1149                         ::PeekMessage(&msg, m_hWnd, WM_LBUTTONDOWN, WM_LBUTTONDOWN, PM_REMOVE);
1150         }
1151 #endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
1152 };
1153
1154
1155 template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CFrameWinTraits>
1156 class ATL_NO_VTABLE CFrameWindowImpl : public CFrameWindowImplBase< TBase, TWinTraits >
1157 {
1158 public:
1159         HWND Create(HWND hWndParent = NULL, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
1160                         DWORD dwStyle = 0, DWORD dwExStyle = 0,
1161                         HMENU hMenu = NULL, LPVOID lpCreateParam = NULL)
1162         {
1163                 ATOM atom = T::GetWndClassInfo().Register(&m_pfnSuperWindowProc);
1164
1165                 dwStyle = T::GetWndStyle(dwStyle);
1166                 dwExStyle = T::GetWndExStyle(dwExStyle);
1167
1168                 if(rect.m_lpRect == NULL)
1169                         rect.m_lpRect = &TBase::rcDefault;
1170
1171                 return CFrameWindowImplBase< TBase, TWinTraits >::Create(hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, hMenu, atom, lpCreateParam);
1172         }
1173
1174         HWND CreateEx(HWND hWndParent = NULL, ATL::_U_RECT rect = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, LPVOID lpCreateParam = NULL)
1175         {
1176                 const int cchName = 256;
1177                 TCHAR szWindowName[cchName];
1178                 szWindowName[0] = 0;
1179 #ifndef _WIN32_WCE
1180                 ::LoadString(ModuleHelper::GetResourceInstance(), T::GetWndClassInfo().m_uCommonResourceID, szWindowName, cchName);
1181                 HMENU hMenu = ::LoadMenu(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(T::GetWndClassInfo().m_uCommonResourceID));
1182 #else // CE specific
1183                 ::LoadString(ModuleHelper::GetResourceInstance(), T::GetWndClassInfo().m_uCommonResourceID, szWindowName, cchName);
1184
1185                 // This always needs to be NULL for Windows CE.
1186                 // Frame Window menus have to go onto the CommandBar.
1187                 // Use CreateSimpleCECommandBar
1188                 HMENU hMenu = NULL;
1189 #endif // _WIN32_WCE
1190
1191                 T* pT = static_cast<T*>(this);
1192                 HWND hWnd = pT->Create(hWndParent, rect, szWindowName, dwStyle, dwExStyle, hMenu, lpCreateParam);
1193
1194                 if(hWnd != NULL)
1195                         m_hAccel = ::LoadAccelerators(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(T::GetWndClassInfo().m_uCommonResourceID));
1196
1197                 return hWnd;
1198         }
1199
1200         BOOL CreateSimpleToolBar(UINT nResourceID = 0, DWORD dwStyle = ATL_SIMPLE_TOOLBAR_STYLE, UINT nID = ATL_IDW_TOOLBAR)
1201         {
1202                 if(nResourceID == 0)
1203                         nResourceID = T::GetWndClassInfo().m_uCommonResourceID;
1204 #ifndef _WIN32_WCE
1205                 ATLASSERT(!::IsWindow(m_hWndToolBar));
1206                 m_hWndToolBar = T::CreateSimpleToolBarCtrl(m_hWnd, nResourceID, TRUE, dwStyle, nID);
1207                 return (m_hWndToolBar != NULL);
1208 #else // CE specific
1209                 HWND hWnd= T::CreateSimpleToolBarCtrl(m_hWndCECommandBar, nResourceID, TRUE, dwStyle, nID);
1210                 return (hWnd != NULL);
1211 #endif // _WIN32_WCE
1212         }
1213
1214 #ifdef _WIN32_WCE
1215         // CE specific variant that returns the handle of the toolbar
1216         HWND CreateSimpleCEToolBar(UINT nResourceID = 0, DWORD dwStyle = ATL_SIMPLE_TOOLBAR_STYLE, UINT nID = ATL_IDW_TOOLBAR)
1217         {
1218                 if(nResourceID == 0)
1219                         nResourceID = T::GetWndClassInfo().m_uCommonResourceID;
1220
1221                 return T::CreateSimpleToolBarCtrl(m_hWndCECommandBar, nResourceID, TRUE, dwStyle, nID);
1222         }
1223 #endif // _WIN32_WCE
1224
1225 // message map and handlers
1226         typedef CFrameWindowImplBase< TBase, TWinTraits >   _baseClass;
1227
1228         BEGIN_MSG_MAP(CFrameWindowImpl)
1229                 MESSAGE_HANDLER(WM_SIZE, OnSize)
1230 #ifndef _ATL_NO_REBAR_SUPPORT
1231 #if (_WIN32_IE >= 0x0400)
1232                 NOTIFY_CODE_HANDLER(RBN_AUTOSIZE, OnReBarAutoSize)
1233 #endif // (_WIN32_IE >= 0x0400)
1234 #if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
1235                 NOTIFY_CODE_HANDLER(RBN_CHEVRONPUSHED, OnChevronPushed)
1236 #endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
1237 #endif // !_ATL_NO_REBAR_SUPPORT
1238                 CHAIN_MSG_MAP(_baseClass)
1239         END_MSG_MAP()
1240
1241         LRESULT OnSize(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
1242         {
1243                 if(wParam != SIZE_MINIMIZED)
1244                 {
1245                         T* pT = static_cast<T*>(this);
1246                         pT->UpdateLayout();
1247                 }
1248                 bHandled = FALSE;
1249                 return 1;
1250         }
1251
1252 #ifndef _ATL_NO_REBAR_SUPPORT
1253 #if (_WIN32_IE >= 0x0400)
1254         LRESULT OnReBarAutoSize(int /*idCtrl*/, LPNMHDR /*pnmh*/, BOOL& /*bHandled*/)
1255         {
1256                 T* pT = static_cast<T*>(this);
1257                 pT->UpdateLayout(FALSE);
1258                 return 0;
1259         }
1260 #endif // (_WIN32_IE >= 0x0400)
1261
1262 #if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
1263         LRESULT OnChevronPushed(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled)
1264         {
1265                 T* pT = static_cast<T*>(this);
1266                 _ChevronMenuInfo cmi = { NULL, (LPNMREBARCHEVRON)pnmh, false };
1267                 if(!pT->PrepareChevronMenu(cmi))
1268                 {
1269                         bHandled = FALSE;
1270                         return 1;
1271                 }
1272                 // display a popup menu with hidden items
1273                 pT->DisplayChevronMenu(cmi);
1274                 // cleanup
1275                 pT->CleanupChevronMenu(cmi);
1276                 return 0;
1277         }
1278 #endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
1279 #endif // !_ATL_NO_REBAR_SUPPORT
1280 };
1281
1282
1283 ///////////////////////////////////////////////////////////////////////////////
1284 // AtlCreateSimpleToolBar - helper for creating simple toolbars
1285
1286 #ifndef _WIN32_WCE
1287
1288 inline HWND AtlCreateSimpleToolBar(HWND hWndParent, UINT nResourceID, BOOL bInitialSeparator = FALSE,
1289                 DWORD dwStyle = ATL_SIMPLE_TOOLBAR_STYLE, UINT nID = ATL_IDW_TOOLBAR)
1290 {
1291         return CFrameWindowImplBase<>::CreateSimpleToolBarCtrl(hWndParent, nResourceID, bInitialSeparator, dwStyle, nID);
1292 }
1293
1294 #endif // !_WIN32_WCE
1295
1296
1297 ///////////////////////////////////////////////////////////////////////////////
1298 // CMDIWindow
1299
1300 #ifndef _WIN32_WCE
1301
1302 #ifndef _WTL_MDIWINDOWMENU_TEXT
1303 #define _WTL_MDIWINDOWMENU_TEXT _T("&Window")
1304 #endif
1305
1306 class CMDIWindow : public ATL::CWindow
1307 {
1308 public:
1309 // Data members
1310         HWND m_hWndMDIClient;
1311         HMENU m_hMenu;
1312
1313 // Constructors
1314         CMDIWindow(HWND hWnd = NULL) : ATL::CWindow(hWnd), m_hWndMDIClient(NULL), m_hMenu(NULL)
1315         { }
1316
1317         CMDIWindow& operator =(HWND hWnd)
1318         {
1319                 m_hWnd = hWnd;
1320                 return *this;
1321         }
1322
1323 // Operations
1324         HWND MDIGetActive(BOOL* lpbMaximized = NULL)
1325         {
1326                 ATLASSERT(::IsWindow(m_hWndMDIClient));
1327                 return (HWND)::SendMessage(m_hWndMDIClient, WM_MDIGETACTIVE, 0, (LPARAM)lpbMaximized);
1328         }
1329
1330         void MDIActivate(HWND hWndChildToActivate)
1331         {
1332                 ATLASSERT(::IsWindow(m_hWndMDIClient));
1333                 ATLASSERT(::IsWindow(hWndChildToActivate));
1334                 ::SendMessage(m_hWndMDIClient, WM_MDIACTIVATE, (WPARAM)hWndChildToActivate, 0);
1335         }
1336
1337         void MDINext(HWND hWndChild, BOOL bPrevious = FALSE)
1338         {
1339                 ATLASSERT(::IsWindow(m_hWndMDIClient));
1340                 ATLASSERT(hWndChild == NULL || ::IsWindow(hWndChild));
1341                 ::SendMessage(m_hWndMDIClient, WM_MDINEXT, (WPARAM)hWndChild, (LPARAM)bPrevious);
1342         }
1343
1344         void MDIMaximize(HWND hWndChildToMaximize)
1345         {
1346                 ATLASSERT(::IsWindow(m_hWndMDIClient));
1347                 ATLASSERT(::IsWindow(hWndChildToMaximize));
1348                 ::SendMessage(m_hWndMDIClient, WM_MDIMAXIMIZE, (WPARAM)hWndChildToMaximize, 0);
1349         }
1350
1351         void MDIRestore(HWND hWndChildToRestore)
1352         {
1353                 ATLASSERT(::IsWindow(m_hWndMDIClient));
1354                 ATLASSERT(::IsWindow(hWndChildToRestore));
1355                 ::SendMessage(m_hWndMDIClient, WM_MDIRESTORE, (WPARAM)hWndChildToRestore, 0);
1356         }
1357
1358         void MDIDestroy(HWND hWndChildToDestroy)
1359         {
1360                 ATLASSERT(::IsWindow(m_hWndMDIClient));
1361                 ATLASSERT(::IsWindow(hWndChildToDestroy));
1362                 ::SendMessage(m_hWndMDIClient, WM_MDIDESTROY, (WPARAM)hWndChildToDestroy, 0);
1363         }
1364
1365         BOOL MDICascade(UINT uFlags = 0)
1366         {
1367                 ATLASSERT(::IsWindow(m_hWndMDIClient));
1368                 return (BOOL)::SendMessage(m_hWndMDIClient, WM_MDICASCADE, (WPARAM)uFlags, 0);
1369         }
1370
1371         BOOL MDITile(UINT uFlags = MDITILE_HORIZONTAL)
1372         {
1373                 ATLASSERT(::IsWindow(m_hWndMDIClient));
1374                 return (BOOL)::SendMessage(m_hWndMDIClient, WM_MDITILE, (WPARAM)uFlags, 0);
1375         }
1376
1377         void MDIIconArrange()
1378         {
1379                 ATLASSERT(::IsWindow(m_hWndMDIClient));
1380                 ::SendMessage(m_hWndMDIClient, WM_MDIICONARRANGE, 0, 0);
1381         }
1382
1383         HMENU MDISetMenu(HMENU hMenuFrame, HMENU hMenuWindow)
1384         {
1385                 ATLASSERT(::IsWindow(m_hWndMDIClient));
1386                 return (HMENU)::SendMessage(m_hWndMDIClient, WM_MDISETMENU, (WPARAM)hMenuFrame, (LPARAM)hMenuWindow);
1387         }
1388
1389         HMENU MDIRefreshMenu()
1390         {
1391                 ATLASSERT(::IsWindow(m_hWndMDIClient));
1392                 return (HMENU)::SendMessage(m_hWndMDIClient, WM_MDIREFRESHMENU, 0, 0);
1393         }
1394
1395 // Additional operations
1396         static HMENU GetStandardWindowMenu(HMENU hMenu)
1397         {
1398                 int nCount = ::GetMenuItemCount(hMenu);
1399                 if(nCount == -1)
1400                         return NULL;
1401                 int nLen = ::GetMenuString(hMenu, nCount - 2, NULL, 0, MF_BYPOSITION);
1402                 if(nLen == 0)
1403                         return NULL;
1404                 CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
1405                 LPTSTR lpszText = buff.Allocate(nLen + 1);
1406                 if(lpszText == NULL)
1407                         return NULL;
1408                 if(::GetMenuString(hMenu, nCount - 2, lpszText, nLen + 1, MF_BYPOSITION) != nLen)
1409                         return NULL;
1410                 if(lstrcmp(lpszText, _WTL_MDIWINDOWMENU_TEXT) != 0)
1411                         return NULL;
1412                 return ::GetSubMenu(hMenu, nCount - 2);
1413         }
1414
1415         void SetMDIFrameMenu()
1416         {
1417                 HMENU hWindowMenu = GetStandardWindowMenu(m_hMenu);
1418                 MDISetMenu(m_hMenu, hWindowMenu);
1419                 MDIRefreshMenu();
1420                 ::DrawMenuBar(GetMDIFrame());
1421         }
1422
1423         HWND GetMDIFrame() const
1424         {
1425                 return ::GetParent(m_hWndMDIClient);
1426         }
1427 };
1428
1429 #endif // !_WIN32_WCE
1430
1431
1432 ///////////////////////////////////////////////////////////////////////////////
1433 // CMDIFrameWindowImpl
1434
1435 #ifndef _WIN32_WCE
1436
1437 // MDI child command chaining macro (only for MDI frame windows)
1438 #define CHAIN_MDI_CHILD_COMMANDS() \
1439         if(uMsg == WM_COMMAND) \
1440         { \
1441                 HWND hWndChild = MDIGetActive(); \
1442                 if(hWndChild != NULL) \
1443                         ::SendMessage(hWndChild, uMsg, wParam, lParam); \
1444         }
1445
1446 template <class T, class TBase = CMDIWindow, class TWinTraits = ATL::CFrameWinTraits>
1447 class ATL_NO_VTABLE CMDIFrameWindowImpl : public CFrameWindowImplBase<TBase, TWinTraits >
1448 {
1449 public:
1450         HWND Create(HWND hWndParent = NULL, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
1451                         DWORD dwStyle = 0, DWORD dwExStyle = 0,
1452                         HMENU hMenu = NULL, LPVOID lpCreateParam = NULL)
1453         {
1454                 m_hMenu = hMenu;
1455                 ATOM atom = T::GetWndClassInfo().Register(&m_pfnSuperWindowProc);
1456
1457                 dwStyle = T::GetWndStyle(dwStyle);
1458                 dwExStyle = T::GetWndExStyle(dwExStyle);
1459
1460                 if(rect.m_lpRect == NULL)
1461                         rect.m_lpRect = &TBase::rcDefault;
1462
1463                 return CFrameWindowImplBase<TBase, TWinTraits >::Create(hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, hMenu, atom, lpCreateParam);
1464         }
1465
1466         HWND CreateEx(HWND hWndParent = NULL, ATL::_U_RECT rect = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, LPVOID lpCreateParam = NULL)
1467         {
1468                 const int cchName = 256;
1469                 TCHAR szWindowName[cchName];
1470                 szWindowName[0] = 0;
1471                 ::LoadString(ModuleHelper::GetResourceInstance(), T::GetWndClassInfo().m_uCommonResourceID, szWindowName, cchName);
1472                 HMENU hMenu = ::LoadMenu(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(T::GetWndClassInfo().m_uCommonResourceID));
1473
1474                 T* pT = static_cast<T*>(this);
1475                 HWND hWnd = pT->Create(hWndParent, rect, szWindowName, dwStyle, dwExStyle, hMenu, lpCreateParam);
1476
1477                 if(hWnd != NULL)
1478                         m_hAccel = ::LoadAccelerators(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(T::GetWndClassInfo().m_uCommonResourceID));
1479
1480                 return hWnd;
1481         }
1482
1483         BOOL CreateSimpleToolBar(UINT nResourceID = 0, DWORD dwStyle = ATL_SIMPLE_TOOLBAR_STYLE, UINT nID = ATL_IDW_TOOLBAR)
1484         {
1485                 ATLASSERT(!::IsWindow(m_hWndToolBar));
1486                 if(nResourceID == 0)
1487                         nResourceID = T::GetWndClassInfo().m_uCommonResourceID;
1488                 m_hWndToolBar = T::CreateSimpleToolBarCtrl(m_hWnd, nResourceID, TRUE, dwStyle, nID);
1489                 return (m_hWndToolBar != NULL);
1490         }
1491
1492         virtual WNDPROC GetWindowProc()
1493         {
1494                 return MDIFrameWindowProc;
1495         }
1496
1497         static LRESULT CALLBACK MDIFrameWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1498         {
1499                 CMDIFrameWindowImpl< T, TBase, TWinTraits >* pThis = (CMDIFrameWindowImpl< T, TBase, TWinTraits >*)hWnd;
1500                 // set a ptr to this message and save the old value
1501 #if (_ATL_VER >= 0x0700)
1502                 ATL::_ATL_MSG msg(pThis->m_hWnd, uMsg, wParam, lParam);
1503                 const ATL::_ATL_MSG* pOldMsg = pThis->m_pCurrentMsg;
1504 #else // !(_ATL_VER >= 0x0700)
1505                 MSG msg = { pThis->m_hWnd, uMsg, wParam, lParam, 0, { 0, 0 } };
1506                 const MSG* pOldMsg = pThis->m_pCurrentMsg;
1507 #endif // !(_ATL_VER >= 0x0700)
1508                 pThis->m_pCurrentMsg = &msg;
1509                 // pass to the message map to process
1510                 LRESULT lRes = 0;
1511                 BOOL bRet = pThis->ProcessWindowMessage(pThis->m_hWnd, uMsg, wParam, lParam, lRes, 0);
1512                 // restore saved value for the current message
1513                 ATLASSERT(pThis->m_pCurrentMsg == &msg);
1514                 pThis->m_pCurrentMsg = pOldMsg;
1515                 // do the default processing if message was not handled
1516                 if(!bRet)
1517                 {
1518                         if(uMsg != WM_NCDESTROY)
1519                                 lRes = pThis->DefWindowProc(uMsg, wParam, lParam);
1520                         else
1521                         {
1522                                 // unsubclass, if needed
1523                                 LONG_PTR pfnWndProc = ::GetWindowLongPtr(pThis->m_hWnd, GWLP_WNDPROC);
1524                                 lRes = pThis->DefWindowProc(uMsg, wParam, lParam);
1525                                 if(pThis->m_pfnSuperWindowProc != ::DefWindowProc && ::GetWindowLongPtr(pThis->m_hWnd, GWLP_WNDPROC) == pfnWndProc)
1526                                         ::SetWindowLongPtr(pThis->m_hWnd, GWLP_WNDPROC, (LONG_PTR)pThis->m_pfnSuperWindowProc);
1527 #if (_ATL_VER >= 0x0700)
1528                                 // mark window as destryed
1529                                 pThis->m_dwState |= WINSTATE_DESTROYED;
1530 #else // !(_ATL_VER >= 0x0700)
1531                                 // clear out window handle
1532                                 HWND hWnd = pThis->m_hWnd;
1533                                 pThis->m_hWnd = NULL;
1534                                 // clean up after window is destroyed
1535                                 pThis->OnFinalMessage(hWnd);
1536 #endif // !(_ATL_VER >= 0x0700)
1537                         }
1538                 }
1539 #if (_ATL_VER >= 0x0700)
1540                 if(pThis->m_dwState & WINSTATE_DESTROYED && pThis->m_pCurrentMsg == NULL)
1541                 {
1542                         // clear out window handle
1543                         HWND hWnd = pThis->m_hWnd;
1544                         pThis->m_hWnd = NULL;
1545                         pThis->m_dwState &= ~WINSTATE_DESTROYED;
1546                         // clean up after window is destroyed
1547                         pThis->OnFinalMessage(hWnd);
1548                 }
1549 #endif // (_ATL_VER >= 0x0700)
1550                 return lRes;
1551         }
1552
1553         // Overriden to call DefWindowProc which uses DefFrameProc
1554         LRESULT DefWindowProc()
1555         {
1556                 const MSG* pMsg = m_pCurrentMsg;
1557                 LRESULT lRes = 0;
1558                 if (pMsg != NULL)
1559                         lRes = DefWindowProc(pMsg->message, pMsg->wParam, pMsg->lParam);
1560                 return lRes;
1561         }
1562
1563         LRESULT DefWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
1564         {
1565                 return ::DefFrameProc(m_hWnd, m_hWndMDIClient, uMsg, wParam, lParam);
1566         }
1567
1568         BOOL PreTranslateMessage(MSG* pMsg)
1569         {
1570                 if(CFrameWindowImplBase<TBase, TWinTraits>::PreTranslateMessage(pMsg))
1571                         return TRUE;
1572                 return ::TranslateMDISysAccel(m_hWndMDIClient, pMsg);
1573         }
1574
1575         HWND CreateMDIClient(HMENU hWindowMenu = NULL, UINT nID = ATL_IDW_CLIENT, UINT nFirstChildID = ATL_IDM_FIRST_MDICHILD)
1576         {
1577                 DWORD dwStyle = WS_VISIBLE | WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | MDIS_ALLCHILDSTYLES;
1578                 DWORD dwExStyle = WS_EX_CLIENTEDGE;
1579
1580                 CLIENTCREATESTRUCT ccs = { 0 };
1581                 ccs.hWindowMenu = hWindowMenu;
1582                 ccs.idFirstChild = nFirstChildID;
1583
1584                 if((GetStyle() & (WS_HSCROLL | WS_VSCROLL)) != 0)
1585                 {
1586                         // parent MDI frame's scroll styles move to the MDICLIENT
1587                         dwStyle |= (GetStyle() & (WS_HSCROLL | WS_VSCROLL));
1588
1589                         // fast way to turn off the scrollbar bits (without a resize)
1590                         ModifyStyle(WS_HSCROLL | WS_VSCROLL, 0, SWP_NOREDRAW | SWP_FRAMECHANGED);
1591                 }
1592
1593                 // Create MDICLIENT window
1594                 m_hWndClient = ::CreateWindowEx(dwExStyle, _T("MDIClient"), NULL,
1595                         dwStyle, 0, 0, 1, 1, m_hWnd, (HMENU)LongToHandle(nID),
1596                         ModuleHelper::GetModuleInstance(), (LPVOID)&ccs);
1597                 if (m_hWndClient == NULL)
1598                 {
1599                         ATLTRACE2(atlTraceUI, 0, _T("MDI Frame failed to create MDICLIENT.\n"));
1600                         return NULL;
1601                 }
1602
1603                 // Move it to the top of z-order
1604                 ::BringWindowToTop(m_hWndClient);
1605
1606                 // set as MDI client window
1607                 m_hWndMDIClient = m_hWndClient;
1608
1609                 // update to proper size
1610                 T* pT = static_cast<T*>(this);
1611                 pT->UpdateLayout();
1612
1613                 return m_hWndClient;
1614         }
1615
1616         typedef CFrameWindowImplBase<TBase, TWinTraits >   _baseClass;
1617
1618         BEGIN_MSG_MAP(CMDIFrameWindowImpl)
1619                 MESSAGE_HANDLER(WM_SIZE, OnSize)
1620                 MESSAGE_HANDLER(WM_SETFOCUS, OnSetFocus)
1621                 MESSAGE_HANDLER(WM_MDISETMENU, OnMDISetMenu)
1622 #ifndef _ATL_NO_REBAR_SUPPORT
1623 #if (_WIN32_IE >= 0x0400)
1624                 NOTIFY_CODE_HANDLER(RBN_AUTOSIZE, OnReBarAutoSize)
1625 #endif // (_WIN32_IE >= 0x0400)
1626 #if (_WIN32_IE >= 0x0500)
1627                 NOTIFY_CODE_HANDLER(RBN_CHEVRONPUSHED, OnChevronPushed)
1628 #endif // (_WIN32_IE >= 0x0500)
1629 #endif // !_ATL_NO_REBAR_SUPPORT
1630                 CHAIN_MSG_MAP(_baseClass)
1631         END_MSG_MAP()
1632
1633         LRESULT OnSize(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
1634         {
1635                 if(wParam != SIZE_MINIMIZED)
1636                 {
1637                         T* pT = static_cast<T*>(this);
1638                         pT->UpdateLayout();
1639                 }
1640                 // message must be handled, otherwise DefFrameProc would resize the client again
1641                 return 0;
1642         }
1643
1644         LRESULT OnSetFocus(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
1645         {
1646                 // don't allow CFrameWindowImplBase to handle this one
1647                 return DefWindowProc(uMsg, wParam, lParam);
1648         }
1649
1650         LRESULT OnMDISetMenu(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
1651         {
1652                 SetMDIFrameMenu();
1653                 return 0;
1654         }
1655
1656 #ifndef _ATL_NO_REBAR_SUPPORT
1657 #if (_WIN32_IE >= 0x0400)
1658         LRESULT OnReBarAutoSize(int /*idCtrl*/, LPNMHDR /*pnmh*/, BOOL& /*bHandled*/)
1659         {
1660                 T* pT = static_cast<T*>(this);
1661                 pT->UpdateLayout(FALSE);
1662                 return 0;
1663         }
1664 #endif // (_WIN32_IE >= 0x0400)
1665
1666 #if (_WIN32_IE >= 0x0500)
1667         LRESULT OnChevronPushed(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled)
1668         {
1669                 T* pT = static_cast<T*>(this);
1670                 _ChevronMenuInfo cmi = { NULL, (LPNMREBARCHEVRON)pnmh, false };
1671                 if(!pT->PrepareChevronMenu(cmi))
1672                 {
1673                         bHandled = FALSE;
1674                         return 1;
1675                 }
1676                 // display a popup menu with hidden items
1677                 pT->DisplayChevronMenu(cmi);
1678                 // cleanup
1679                 pT->CleanupChevronMenu(cmi);
1680                 return 0;
1681         }
1682 #endif // (_WIN32_IE >= 0x0500)
1683 #endif // !_ATL_NO_REBAR_SUPPORT
1684 };
1685
1686 #endif // !_WIN32_WCE
1687
1688
1689 ///////////////////////////////////////////////////////////////////////////////
1690 // CMDIChildWindowImpl
1691
1692 #ifndef _WIN32_WCE
1693
1694 template <class T, class TBase = CMDIWindow, class TWinTraits = ATL::CMDIChildWinTraits>
1695 class ATL_NO_VTABLE CMDIChildWindowImpl : public CFrameWindowImplBase<TBase, TWinTraits >
1696 {
1697 public:
1698         HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
1699                         DWORD dwStyle = 0, DWORD dwExStyle = 0,
1700                         UINT nMenuID = 0, LPVOID lpCreateParam = NULL)
1701         {
1702                 ATOM atom = T::GetWndClassInfo().Register(&m_pfnSuperWindowProc);
1703
1704                 if(nMenuID != 0)
1705                         m_hMenu = ::LoadMenu(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(nMenuID));
1706
1707                 dwStyle = T::GetWndStyle(dwStyle);
1708                 dwExStyle = T::GetWndExStyle(dwExStyle);
1709
1710                 dwExStyle |= WS_EX_MDICHILD;   // force this one
1711                 m_pfnSuperWindowProc = ::DefMDIChildProc;
1712                 m_hWndMDIClient = hWndParent;
1713                 ATLASSERT(::IsWindow(m_hWndMDIClient));
1714
1715                 if(rect.m_lpRect == NULL)
1716                         rect.m_lpRect = &TBase::rcDefault;
1717
1718                 // If the currently active MDI child is maximized, we want to create this one maximized too
1719                 ATL::CWindow wndParent = hWndParent;
1720                 BOOL bMaximized = FALSE;
1721                 wndParent.SendMessage(WM_MDIGETACTIVE, 0, (LPARAM)&bMaximized);
1722                 if(bMaximized)
1723                         wndParent.SetRedraw(FALSE);
1724
1725                 HWND hWnd = CFrameWindowImplBase<TBase, TWinTraits >::Create(hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, (UINT)0U, atom, lpCreateParam);
1726
1727                 if(bMaximized)
1728                 {
1729                         // Maximize and redraw everything
1730                         if(hWnd != NULL)
1731                                 MDIMaximize(hWnd);
1732                         wndParent.SetRedraw(TRUE);
1733                         wndParent.RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN);
1734                         ::SetFocus(GetMDIFrame());   // focus will be set back to this window
1735                 }
1736                 else if(hWnd != NULL && ::IsWindowVisible(m_hWnd) && !::IsChild(hWnd, ::GetFocus()))
1737                 {
1738                         ::SetFocus(hWnd);
1739                 }
1740
1741                 return hWnd;
1742         }
1743
1744         HWND CreateEx(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR lpcstrWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, LPVOID lpCreateParam = NULL)
1745         {
1746                 const int cchName = 256;
1747                 TCHAR szWindowName[cchName];
1748                 szWindowName[0] = 0;
1749                 if(lpcstrWindowName == NULL)
1750                 {
1751                         ::LoadString(ModuleHelper::GetResourceInstance(), T::GetWndClassInfo().m_uCommonResourceID, szWindowName, cchName);
1752                         lpcstrWindowName = szWindowName;
1753                 }
1754
1755                 T* pT = static_cast<T*>(this);
1756                 HWND hWnd = pT->Create(hWndParent, rect, lpcstrWindowName, dwStyle, dwExStyle, T::GetWndClassInfo().m_uCommonResourceID, lpCreateParam);
1757
1758                 if(hWnd != NULL)
1759                         m_hAccel = ::LoadAccelerators(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(T::GetWndClassInfo().m_uCommonResourceID));
1760
1761                 return hWnd;
1762         }
1763
1764         BOOL CreateSimpleToolBar(UINT nResourceID = 0, DWORD dwStyle = ATL_SIMPLE_TOOLBAR_STYLE, UINT nID = ATL_IDW_TOOLBAR)
1765         {
1766                 ATLASSERT(!::IsWindow(m_hWndToolBar));
1767                 if(nResourceID == 0)
1768                         nResourceID = T::GetWndClassInfo().m_uCommonResourceID;
1769                 m_hWndToolBar = T::CreateSimpleToolBarCtrl(m_hWnd, nResourceID, TRUE, dwStyle, nID);
1770                 return (m_hWndToolBar != NULL);
1771         }
1772
1773         BOOL UpdateClientEdge(LPRECT lpRect = NULL)
1774         {
1775                 // only adjust for active MDI child window
1776                 HWND hWndChild = MDIGetActive();
1777                 if(hWndChild != NULL && hWndChild != m_hWnd)
1778                         return FALSE;
1779
1780                 // need to adjust the client edge style as max/restore happens
1781                 DWORD dwStyle = ::GetWindowLong(m_hWndMDIClient, GWL_EXSTYLE);
1782                 DWORD dwNewStyle = dwStyle;
1783                 if(hWndChild != NULL && ((GetExStyle() & WS_EX_CLIENTEDGE) == 0) && ((GetStyle() & WS_MAXIMIZE) != 0))
1784                         dwNewStyle &= ~(WS_EX_CLIENTEDGE);
1785                 else
1786                         dwNewStyle |= WS_EX_CLIENTEDGE;
1787
1788                 if(dwStyle != dwNewStyle)
1789                 {
1790                         // SetWindowPos will not move invalid bits
1791                         ::RedrawWindow(m_hWndMDIClient, NULL, NULL,
1792                                 RDW_INVALIDATE | RDW_ALLCHILDREN);
1793                         // remove/add WS_EX_CLIENTEDGE to MDI client area
1794                         ::SetWindowLong(m_hWndMDIClient, GWL_EXSTYLE, dwNewStyle);
1795                         ::SetWindowPos(m_hWndMDIClient, NULL, 0, 0, 0, 0,
1796                                 SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE |
1797                                 SWP_NOZORDER | SWP_NOCOPYBITS);
1798
1799                         // return new client area
1800                         if (lpRect != NULL)
1801                                 ::GetClientRect(m_hWndMDIClient, lpRect);
1802
1803                         return TRUE;
1804                 }
1805
1806                 return FALSE;
1807         }
1808
1809         typedef CFrameWindowImplBase<TBase, TWinTraits >   _baseClass;
1810         BEGIN_MSG_MAP(CMDIChildWindowImpl)
1811                 MESSAGE_HANDLER(WM_SIZE, OnSize)
1812                 MESSAGE_HANDLER(WM_WINDOWPOSCHANGED, OnWindowPosChanged)
1813                 MESSAGE_HANDLER(WM_MOUSEACTIVATE, OnMouseActivate)
1814                 MESSAGE_HANDLER(WM_MENUSELECT, OnMenuSelect)
1815                 MESSAGE_HANDLER(WM_MDIACTIVATE, OnMDIActivate)
1816                 MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
1817 #ifndef _ATL_NO_REBAR_SUPPORT
1818 #if (_WIN32_IE >= 0x0400)
1819                 NOTIFY_CODE_HANDLER(RBN_AUTOSIZE, OnReBarAutoSize)
1820 #endif // (_WIN32_IE >= 0x0400)
1821 #if (_WIN32_IE >= 0x0500)
1822                 NOTIFY_CODE_HANDLER(RBN_CHEVRONPUSHED, OnChevronPushed)
1823 #endif // (_WIN32_IE >= 0x0500)
1824 #endif // !_ATL_NO_REBAR_SUPPORT
1825                 CHAIN_MSG_MAP(_baseClass)
1826         END_MSG_MAP()
1827
1828         LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
1829         {
1830                 DefWindowProc(uMsg, wParam, lParam);   // needed for MDI children
1831                 if(wParam != SIZE_MINIMIZED)
1832                 {
1833                         T* pT = static_cast<T*>(this);
1834                         pT->UpdateLayout();
1835                 }
1836                 return 0;
1837         }
1838
1839         LRESULT OnWindowPosChanged(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
1840         {
1841                 // update MDI client edge and adjust MDI child rect
1842                 LPWINDOWPOS lpWndPos = (LPWINDOWPOS)lParam;
1843
1844                 if(!(lpWndPos->flags & SWP_NOSIZE))
1845                 {
1846                         RECT rectClient;
1847                         if(UpdateClientEdge(&rectClient) && ((GetStyle() & WS_MAXIMIZE) != 0))
1848                         {
1849                                 ::AdjustWindowRectEx(&rectClient, GetStyle(), FALSE, GetExStyle());
1850                                 lpWndPos->x = rectClient.left;
1851                                 lpWndPos->y = rectClient.top;
1852                                 lpWndPos->cx = rectClient.right - rectClient.left;
1853                                 lpWndPos->cy = rectClient.bottom - rectClient.top;
1854                         }
1855                 }
1856
1857                 bHandled = FALSE;
1858                 return 1;
1859         }
1860
1861         LRESULT OnMouseActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
1862         {
1863                 LRESULT lRes = DefWindowProc(uMsg, wParam, lParam);
1864
1865                 // Activate this MDI window if needed
1866                 if(lRes == MA_ACTIVATE || lRes == MA_ACTIVATEANDEAT)
1867                 {
1868                         if(MDIGetActive() != m_hWnd)
1869                                 MDIActivate(m_hWnd);
1870                 }
1871
1872                 return lRes;
1873         }
1874
1875         LRESULT OnMenuSelect(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
1876         {
1877                 return ::SendMessage(GetMDIFrame(), uMsg, wParam, lParam);
1878         }
1879
1880         LRESULT OnMDIActivate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
1881         {
1882                 if((HWND)lParam == m_hWnd && m_hMenu != NULL)
1883                         SetMDIFrameMenu();
1884                 else if((HWND)lParam == NULL)
1885                         ::SendMessage(GetMDIFrame(), WM_MDISETMENU, 0, 0);
1886
1887                 bHandled = FALSE;
1888                 return 1;
1889         }
1890
1891         LRESULT OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
1892         {
1893                 if(m_hMenu != NULL)
1894                 {
1895                         ::DestroyMenu(m_hMenu);
1896                         m_hMenu = NULL;
1897                 }
1898                 UpdateClientEdge();
1899                 bHandled = FALSE;
1900                 return 1;
1901         }
1902
1903 #ifndef _ATL_NO_REBAR_SUPPORT
1904 #if (_WIN32_IE >= 0x0400)
1905         LRESULT OnReBarAutoSize(int /*idCtrl*/, LPNMHDR /*pnmh*/, BOOL& /*bHandled*/)
1906         {
1907                 T* pT = static_cast<T*>(this);
1908                 pT->UpdateLayout(FALSE);
1909                 return 0;
1910         }
1911 #endif // (_WIN32_IE >= 0x0400)
1912
1913 #if (_WIN32_IE >= 0x0500)
1914         LRESULT OnChevronPushed(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled)
1915         {
1916                 T* pT = static_cast<T*>(this);
1917                 _ChevronMenuInfo cmi = { NULL, (LPNMREBARCHEVRON)pnmh, false };
1918                 if(!pT->PrepareChevronMenu(cmi))
1919                 {
1920                         bHandled = FALSE;
1921                         return 1;
1922                 }
1923                 // display a popup menu with hidden items
1924                 pT->DisplayChevronMenu(cmi);
1925                 // cleanup
1926                 pT->CleanupChevronMenu(cmi);
1927                 return 0;
1928         }
1929 #endif // (_WIN32_IE >= 0x0500)
1930 #endif // !_ATL_NO_REBAR_SUPPORT
1931 };
1932
1933 #endif // !_WIN32_WCE
1934
1935
1936 ///////////////////////////////////////////////////////////////////////////////
1937 // COwnerDraw - MI class for owner-draw support
1938
1939 template <class T>
1940 class COwnerDraw
1941 {
1942 public:
1943 #if (_ATL_VER < 0x0700)
1944         BOOL m_bHandledOD;
1945
1946         BOOL IsMsgHandled() const
1947         {
1948                 return m_bHandledOD;
1949         }
1950         void SetMsgHandled(BOOL bHandled)
1951         {
1952                 m_bHandledOD = bHandled;
1953         }
1954 #endif // (_ATL_VER < 0x0700)
1955
1956 // Message map and handlers
1957         BEGIN_MSG_MAP(COwnerDraw< T >)
1958                 MESSAGE_HANDLER(WM_DRAWITEM, OnDrawItem)
1959                 MESSAGE_HANDLER(WM_MEASUREITEM, OnMeasureItem)
1960                 MESSAGE_HANDLER(WM_COMPAREITEM, OnCompareItem)
1961                 MESSAGE_HANDLER(WM_DELETEITEM, OnDeleteItem)
1962         ALT_MSG_MAP(1)
1963                 MESSAGE_HANDLER(OCM_DRAWITEM, OnDrawItem)
1964                 MESSAGE_HANDLER(OCM_MEASUREITEM, OnMeasureItem)
1965                 MESSAGE_HANDLER(OCM_COMPAREITEM, OnCompareItem)
1966                 MESSAGE_HANDLER(OCM_DELETEITEM, OnDeleteItem)
1967         END_MSG_MAP()
1968
1969         LRESULT OnDrawItem(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
1970         {
1971                 T* pT = static_cast<T*>(this);
1972                 pT->SetMsgHandled(TRUE);
1973                 pT->DrawItem((LPDRAWITEMSTRUCT)lParam);
1974                 bHandled = pT->IsMsgHandled();
1975                 return (LRESULT)TRUE;
1976         }
1977
1978         LRESULT OnMeasureItem(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
1979         {
1980                 T* pT = static_cast<T*>(this);
1981                 pT->SetMsgHandled(TRUE);
1982                 pT->MeasureItem((LPMEASUREITEMSTRUCT)lParam);
1983                 bHandled = pT->IsMsgHandled();
1984                 return (LRESULT)TRUE;
1985         }
1986
1987         LRESULT OnCompareItem(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
1988         {
1989                 T* pT = static_cast<T*>(this);
1990                 pT->SetMsgHandled(TRUE);
1991                 bHandled = pT->IsMsgHandled();
1992                 return (LRESULT)pT->CompareItem((LPCOMPAREITEMSTRUCT)lParam);
1993         }
1994
1995         LRESULT OnDeleteItem(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
1996         {
1997                 T* pT = static_cast<T*>(this);
1998                 pT->SetMsgHandled(TRUE);
1999                 pT->DeleteItem((LPDELETEITEMSTRUCT)lParam);
2000                 bHandled = pT->IsMsgHandled();
2001                 return (LRESULT)TRUE;
2002         }
2003
2004 // Overrideables
2005         void DrawItem(LPDRAWITEMSTRUCT /*lpDrawItemStruct*/)
2006         {
2007                 // must be implemented
2008                 ATLASSERT(FALSE);
2009         }
2010
2011         void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct)
2012         {
2013                 if(lpMeasureItemStruct->CtlType != ODT_MENU)
2014                 {
2015                         // return default height for a system font
2016                         T* pT = static_cast<T*>(this);
2017                         HWND hWnd = pT->GetDlgItem(lpMeasureItemStruct->CtlID);
2018                         CClientDC dc(hWnd);
2019                         TEXTMETRIC tm = { 0 };
2020                         dc.GetTextMetrics(&tm);
2021
2022                         lpMeasureItemStruct->itemHeight = tm.tmHeight;
2023                 }
2024                 else
2025                         lpMeasureItemStruct->itemHeight = ::GetSystemMetrics(SM_CYMENU);
2026         }
2027
2028         int CompareItem(LPCOMPAREITEMSTRUCT /*lpCompareItemStruct*/)
2029         {
2030                 // all items are equal
2031                 return 0;
2032         }
2033
2034         void DeleteItem(LPDELETEITEMSTRUCT /*lpDeleteItemStruct*/)
2035         {
2036                 // default - nothing
2037         }
2038 };
2039
2040
2041 ///////////////////////////////////////////////////////////////////////////////
2042 // Update UI macros
2043
2044 // these build the Update UI map inside a class definition
2045 #define BEGIN_UPDATE_UI_MAP(thisClass) \
2046         static const CUpdateUIBase::_AtlUpdateUIMap* GetUpdateUIMap() \
2047         { \
2048                 static const _AtlUpdateUIMap theMap[] = \
2049                 {
2050
2051 #define UPDATE_ELEMENT(nID, wType) \
2052                         { nID,  wType },
2053
2054 #define END_UPDATE_UI_MAP() \
2055                         { (WORD)-1, 0 } \
2056                 }; \
2057                 return theMap; \
2058         }
2059
2060 ///////////////////////////////////////////////////////////////////////////////
2061 // CUpdateUI - manages UI elements updating
2062
2063 class CUpdateUIBase
2064 {
2065 public:
2066         // constants
2067         enum
2068         {
2069                 // UI element type
2070                 UPDUI_MENUPOPUP         = 0x0001,
2071                 UPDUI_MENUBAR           = 0x0002,
2072                 UPDUI_CHILDWINDOW       = 0x0004,
2073                 UPDUI_TOOLBAR           = 0x0008,
2074                 UPDUI_STATUSBAR         = 0x0010,
2075                 // state
2076                 UPDUI_ENABLED           = 0x0000,
2077                 UPDUI_DISABLED          = 0x0100,
2078                 UPDUI_CHECKED           = 0x0200,
2079                 UPDUI_CHECKED2          = 0x0400,
2080                 UPDUI_RADIO             = 0x0800,
2081                 UPDUI_DEFAULT           = 0x1000,
2082                 UPDUI_TEXT              = 0x2000,
2083                 // internal state
2084                 UPDUI_CLEARDEFAULT      = 0x4000,
2085         };
2086
2087         // element data
2088         struct _AtlUpdateUIElement
2089         {
2090                 HWND m_hWnd;
2091                 WORD m_wType;
2092
2093                 bool operator ==(const _AtlUpdateUIElement& e) const
2094                 { return (m_hWnd == e.m_hWnd && m_wType == e.m_wType); }
2095         };
2096
2097         // map data
2098         struct _AtlUpdateUIMap
2099         {
2100                 WORD m_nID;
2101                 WORD m_wType;
2102
2103                 bool operator ==(const _AtlUpdateUIMap& e) const
2104                 { return (m_nID == e.m_nID && m_wType == e.m_wType); }
2105         };
2106
2107         // instance data
2108         struct _AtlUpdateUIData
2109         {
2110                 WORD m_wState;
2111                 union
2112                 {
2113                         void* m_lpData;
2114                         LPTSTR m_lpstrText;
2115                 };
2116
2117                 bool operator ==(const _AtlUpdateUIData& e) const
2118                 { return (m_wState == e.m_wState && m_lpData == e.m_lpData); }
2119         };
2120
2121         ATL::CSimpleArray<_AtlUpdateUIElement> m_UIElements;   // elements data
2122         const _AtlUpdateUIMap* m_pUIMap;                       // static UI data
2123         _AtlUpdateUIData* m_pUIData;                           // instance UI data
2124         WORD m_wDirtyType;                                     // global dirty flag
2125
2126         bool m_bBlockAccelerators;
2127
2128
2129 // Constructor, destructor
2130         CUpdateUIBase() : m_pUIMap(NULL), m_pUIData(NULL), m_wDirtyType(0), m_bBlockAccelerators(false)
2131         { }
2132
2133         ~CUpdateUIBase()
2134         {
2135                 if(m_pUIMap != NULL && m_pUIData != NULL)
2136                 {
2137                         const _AtlUpdateUIMap* pUIMap = m_pUIMap;
2138                         _AtlUpdateUIData* pUIData = m_pUIData;
2139                         while(pUIMap->m_nID != (WORD)-1)
2140                         {
2141                                 if(pUIData->m_wState & UPDUI_TEXT)
2142                                         delete [] pUIData->m_lpstrText;
2143                                 pUIMap++;
2144                                 pUIData++;
2145                         }
2146                         delete [] m_pUIData;
2147                 }
2148         }
2149
2150 // Check for disabled commands
2151         bool UIGetBlockAccelerators() const
2152         {
2153                 return m_bBlockAccelerators;
2154         }
2155
2156         bool UISetBlockAccelerators(bool bBlock)
2157         {
2158                 bool bOld = m_bBlockAccelerators;
2159                 m_bBlockAccelerators = bBlock;
2160                 return bOld;
2161         }
2162
2163 // Add elements
2164         BOOL UIAddMenuBar(HWND hWnd)                // menu bar (main menu)
2165         {
2166                 if(hWnd == NULL)
2167                         return FALSE;
2168                 _AtlUpdateUIElement e;
2169                 e.m_hWnd = hWnd;
2170                 e.m_wType = UPDUI_MENUBAR;
2171                 return m_UIElements.Add(e);
2172         }
2173
2174         BOOL UIAddToolBar(HWND hWnd)                // toolbar
2175         {
2176                 if(hWnd == NULL)
2177                         return FALSE;
2178                 _AtlUpdateUIElement e;
2179                 e.m_hWnd = hWnd;
2180                 e.m_wType = UPDUI_TOOLBAR;
2181                 return m_UIElements.Add(e);
2182         }
2183
2184         BOOL UIAddStatusBar(HWND hWnd)              // status bar
2185         {
2186                 if(hWnd == NULL)
2187                         return FALSE;
2188                 _AtlUpdateUIElement e;
2189                 e.m_hWnd = hWnd;
2190                 e.m_wType = UPDUI_STATUSBAR;
2191                 return m_UIElements.Add(e);
2192         }
2193
2194         BOOL UIAddChildWindowContainer(HWND hWnd)   // child window
2195         {
2196                 if(hWnd == NULL)
2197                         return FALSE;
2198                 _AtlUpdateUIElement e;
2199                 e.m_hWnd = hWnd;
2200                 e.m_wType = UPDUI_CHILDWINDOW;
2201                 return m_UIElements.Add(e);
2202         }
2203
2204 // Message map for popup menu updates and accelerator blocking
2205         BEGIN_MSG_MAP(CUpdateUIBase)
2206                 MESSAGE_HANDLER(WM_INITMENUPOPUP, OnInitMenuPopup)
2207                 MESSAGE_HANDLER(WM_COMMAND, OnCommand)
2208         END_MSG_MAP()
2209
2210         LRESULT OnInitMenuPopup(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
2211         {
2212                 bHandled = FALSE;
2213                 HMENU hMenu = (HMENU)wParam;
2214                 if(hMenu == NULL)
2215                         return 1;
2216                 _AtlUpdateUIData* pUIData = m_pUIData;
2217                 if(pUIData == NULL)
2218                         return 1;
2219                 const _AtlUpdateUIMap* pMap = m_pUIMap;
2220                 while(pMap->m_nID != (WORD)-1)
2221                 {
2222                         if(pMap->m_wType & UPDUI_MENUPOPUP)
2223                                 UIUpdateMenuBarElement(pMap->m_nID, pUIData, hMenu);
2224                         pMap++;
2225                         pUIData++;
2226                 }
2227                 return 0;
2228         }
2229
2230         LRESULT OnCommand(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
2231         {
2232                 bHandled = FALSE;
2233                 if(m_bBlockAccelerators && HIWORD(wParam) == 1)   // accelerators only
2234                 {
2235                         int nID = LOWORD(wParam);
2236                         if((UIGetState(nID) & UPDUI_DISABLED) == UPDUI_DISABLED)
2237                         {
2238                                 ATLTRACE2(atlTraceUI, 0, _T("CUpdateUIBase::OnCommand - blocked disabled command 0x%4.4X\n"), nID);
2239                                 bHandled = TRUE;   // eat the command, UI item is disabled
2240                         }
2241                 }
2242                 return 0;
2243         }
2244
2245 // methods for setting UI element state
2246         BOOL UIEnable(int nID, BOOL bEnable, BOOL bForceUpdate = FALSE)
2247         {
2248                 const _AtlUpdateUIMap* pMap = m_pUIMap;
2249                 _AtlUpdateUIData* pUIData = m_pUIData;
2250                 if(pUIData == NULL)
2251                         return FALSE;
2252
2253                 for( ; pMap->m_nID != (WORD)-1; pMap++, pUIData++)
2254                 {
2255                         if(nID == (int)pMap->m_nID)
2256                         {
2257                                 if(bEnable)
2258                                 {
2259                                         if(pUIData->m_wState & UPDUI_DISABLED)
2260                                         {
2261                                                 pUIData->m_wState |= pMap->m_wType;
2262                                                 pUIData->m_wState &= ~UPDUI_DISABLED;
2263                                         }
2264                                 }
2265                                 else
2266                                 {
2267                                         if(!(pUIData->m_wState & UPDUI_DISABLED))
2268                                         {
2269                                                 pUIData->m_wState |= pMap->m_wType;
2270                                                 pUIData->m_wState |= UPDUI_DISABLED;
2271                                         }
2272                                 }
2273
2274                                 if(bForceUpdate)
2275                                         pUIData->m_wState |= pMap->m_wType;
2276                                 if(pUIData->m_wState & pMap->m_wType)
2277                                         m_wDirtyType |= pMap->m_wType;
2278
2279                                 break;   // found
2280                         }
2281                 }
2282
2283                 return TRUE;
2284         }
2285
2286         BOOL UISetCheck(int nID, int nCheck, BOOL bForceUpdate = FALSE)
2287         {
2288                 const _AtlUpdateUIMap* pMap = m_pUIMap;
2289                 _AtlUpdateUIData* pUIData = m_pUIData;
2290                 if(pUIData == NULL)
2291                         return FALSE;
2292
2293                 for( ; pMap->m_nID != (WORD)-1; pMap++, pUIData++)
2294                 {
2295                         if(nID == (int)pMap->m_nID)
2296                         {
2297                                 switch(nCheck)
2298                                 {
2299                                 case 0:
2300                                         if((pUIData->m_wState & UPDUI_CHECKED) || (pUIData->m_wState & UPDUI_CHECKED2))
2301                                         {
2302                                                 pUIData->m_wState |= pMap->m_wType;
2303                                                 pUIData->m_wState &= ~(UPDUI_CHECKED | UPDUI_CHECKED2);
2304                                         }
2305                                         break;
2306                                 case 1:
2307                                         if(!(pUIData->m_wState & UPDUI_CHECKED))
2308                                         {
2309                                                 pUIData->m_wState |= pMap->m_wType;
2310                                                 pUIData->m_wState &= ~UPDUI_CHECKED2;
2311                                                 pUIData->m_wState |= UPDUI_CHECKED;
2312                                         }
2313                                         break;
2314                                 case 2:
2315                                         if(!(pUIData->m_wState & UPDUI_CHECKED2))
2316                                         {
2317                                                 pUIData->m_wState |= pMap->m_wType;
2318                                                 pUIData->m_wState &= ~UPDUI_CHECKED;
2319                                                 pUIData->m_wState |= UPDUI_CHECKED2;
2320                                         }
2321                                         break;
2322                                 }
2323
2324                                 if(bForceUpdate)
2325                                         pUIData->m_wState |= pMap->m_wType;
2326                                 if(pUIData->m_wState & pMap->m_wType)
2327                                         m_wDirtyType |= pMap->m_wType;
2328
2329                                 break;   // found
2330                         }
2331                 }
2332
2333                 return TRUE;
2334         }
2335
2336         // variant that supports bool (checked/not-checked, no intermediate state)
2337         BOOL UISetCheck(int nID, bool bCheck, BOOL bForceUpdate = FALSE)
2338         {
2339                 return UISetCheck(nID, bCheck ? 1 : 0, bForceUpdate);
2340         }
2341
2342         BOOL UISetRadio(int nID, BOOL bRadio, BOOL bForceUpdate = FALSE)
2343         {
2344                 const _AtlUpdateUIMap* pMap = m_pUIMap;
2345                 _AtlUpdateUIData* pUIData = m_pUIData;
2346                 if(pUIData == NULL)
2347                         return FALSE;
2348
2349                 for( ; pMap->m_nID != (WORD)-1; pMap++, pUIData++)
2350                 {
2351                         if(nID == (int)pMap->m_nID)
2352                         {
2353                                 if(bRadio)
2354                                 {
2355                                         if(!(pUIData->m_wState & UPDUI_RADIO))
2356                                         {
2357                                                 pUIData->m_wState |= pMap->m_wType;
2358                                                 pUIData->m_wState |= UPDUI_RADIO;
2359                                         }
2360                                 }
2361                                 else
2362                                 {
2363                                         if(pUIData->m_wState & UPDUI_RADIO)
2364                                         {
2365                                                 pUIData->m_wState |= pMap->m_wType;
2366                                                 pUIData->m_wState &= ~UPDUI_RADIO;
2367                                         }
2368                                 }
2369
2370                                 if(bForceUpdate)
2371                                         pUIData->m_wState |= pMap->m_wType;
2372                                 if(pUIData->m_wState & pMap->m_wType)
2373                                         m_wDirtyType |= pMap->m_wType;
2374
2375                                 break;   // found
2376                         }
2377                 }
2378
2379                 return TRUE;
2380         }
2381
2382         BOOL UISetText(int nID, LPCTSTR lpstrText, BOOL bForceUpdate = FALSE)
2383         {
2384                 const _AtlUpdateUIMap* pMap = m_pUIMap;
2385                 _AtlUpdateUIData* pUIData = m_pUIData;
2386                 if(pUIData == NULL)
2387                         return FALSE;
2388                 if(lpstrText == NULL)
2389                         lpstrText = _T("");
2390
2391                 for( ; pMap->m_nID != (WORD)-1; pMap++, pUIData++)
2392                 {
2393                         if(nID == (int)pMap->m_nID)
2394                         {
2395                                 if(pUIData->m_lpstrText == NULL || lstrcmp(pUIData->m_lpstrText, lpstrText))
2396                                 {
2397                                         delete [] pUIData->m_lpstrText;
2398                                         pUIData->m_lpstrText = NULL;
2399                                         int nStrLen = lstrlen(lpstrText);
2400                                         ATLTRY(pUIData->m_lpstrText = new TCHAR[nStrLen + 1]);
2401                                         if(pUIData->m_lpstrText == NULL)
2402                                         {
2403                                                 ATLTRACE2(atlTraceUI, 0, _T("UISetText - memory allocation failed\n"));
2404                                                 break;
2405                                         }
2406                                         SecureHelper::strcpy_x(pUIData->m_lpstrText, nStrLen + 1, lpstrText);
2407                                         pUIData->m_wState |= (UPDUI_TEXT | pMap->m_wType);
2408                                 }
2409
2410                                 if(bForceUpdate)
2411                                         pUIData->m_wState |= (UPDUI_TEXT | pMap->m_wType);
2412                                 if(pUIData->m_wState & pMap->m_wType)
2413                                         m_wDirtyType |= pMap->m_wType;
2414
2415                                 break;   // found
2416                         }
2417                 }
2418
2419                 return TRUE;
2420         }
2421
2422         BOOL UISetDefault(int nID, BOOL bDefault, BOOL bForceUpdate = FALSE)
2423         {
2424                 const _AtlUpdateUIMap* pMap = m_pUIMap;
2425                 _AtlUpdateUIData* pUIData = m_pUIData;
2426                 if(pUIData == NULL)
2427                         return FALSE;
2428
2429                 for( ; pMap->m_nID != (WORD)-1; pMap++, pUIData++)
2430                 {
2431                         if(nID == (int)pMap->m_nID)
2432                         {
2433                                 if(bDefault)
2434                                 {
2435                                         if((pUIData->m_wState & UPDUI_DEFAULT) == 0)
2436                                         {
2437                                                 pUIData->m_wState |= pMap->m_wType;
2438                                                 pUIData->m_wState |= UPDUI_DEFAULT;
2439                                         }
2440                                 }
2441                                 else
2442                                 {
2443                                         if((pUIData->m_wState & UPDUI_DEFAULT) != 0)
2444                                         {
2445                                                 pUIData->m_wState |= pMap->m_wType;
2446                                                 pUIData->m_wState &= ~UPDUI_DEFAULT;
2447                                                 pUIData->m_wState |= UPDUI_CLEARDEFAULT;
2448                                         }
2449                                 }
2450
2451                                 if(bForceUpdate)
2452                                         pUIData->m_wState |= pMap->m_wType;
2453                                 if(pUIData->m_wState & pMap->m_wType)
2454                                         m_wDirtyType |= pMap->m_wType;
2455
2456                                 break;   // found
2457                         }
2458                 }
2459
2460                 return TRUE;
2461         }
2462
2463 // methods for complete state set/get
2464         BOOL UISetState(int nID, DWORD dwState)
2465         {
2466                 const _AtlUpdateUIMap* pMap = m_pUIMap;
2467                 _AtlUpdateUIData* pUIData = m_pUIData;
2468                 if(pUIData == NULL)
2469                         return FALSE;
2470                 for( ; pMap->m_nID != (WORD)-1; pMap++, pUIData++)
2471                 {
2472                         if(nID == (int)pMap->m_nID)
2473                         {
2474                                 pUIData->m_wState = (WORD)(dwState | pMap->m_wType);
2475                                 m_wDirtyType |= pMap->m_wType;
2476                                 break;   // found
2477                         }
2478                 }
2479                 return TRUE;
2480         }
2481
2482         DWORD UIGetState(int nID)
2483         {
2484                 const _AtlUpdateUIMap* pMap = m_pUIMap;
2485                 _AtlUpdateUIData* pUIData = m_pUIData;
2486                 if(pUIData == NULL)
2487                         return 0;
2488                 for( ; pMap->m_nID != (WORD)-1; pMap++, pUIData++)
2489                 {
2490                         if(nID == (int)pMap->m_nID)
2491                                 return pUIData->m_wState;
2492                 }
2493                 return 0;
2494         }
2495
2496 // methods for updating UI
2497 #ifndef _WIN32_WCE
2498         BOOL UIUpdateMenuBar(BOOL bForceUpdate = FALSE, BOOL bMainMenu = FALSE)
2499         {
2500                 if(!(m_wDirtyType & UPDUI_MENUBAR) && !bForceUpdate)
2501                         return TRUE;
2502
2503                 const _AtlUpdateUIMap* pMap = m_pUIMap;
2504                 _AtlUpdateUIData* pUIData = m_pUIData;
2505                 if(pUIData == NULL)
2506                         return FALSE;
2507
2508                 while(pMap->m_nID != (WORD)-1)
2509                 {
2510                         for(int i = 0; i < m_UIElements.GetSize(); i++)
2511                         {
2512                                 if(m_UIElements[i].m_wType == UPDUI_MENUBAR)
2513                                 {
2514                                         HMENU hMenu = ::GetMenu(m_UIElements[i].m_hWnd);
2515                                         if(hMenu != NULL && (pUIData->m_wState & UPDUI_MENUBAR) && (pMap->m_wType & UPDUI_MENUBAR))
2516                                                 UIUpdateMenuBarElement(pMap->m_nID, pUIData, hMenu);
2517                                 }
2518                                 if(bMainMenu)
2519                                         ::DrawMenuBar(m_UIElements[i].m_hWnd);
2520                         }
2521                         pMap++;
2522                         pUIData->m_wState &= ~UPDUI_MENUBAR;
2523                         if(pUIData->m_wState & UPDUI_TEXT)
2524                         {
2525                                 delete [] pUIData->m_lpstrText;
2526                                 pUIData->m_lpstrText = NULL;
2527                                 pUIData->m_wState &= ~UPDUI_TEXT;
2528                         }
2529                         pUIData++;
2530                 }
2531
2532                 m_wDirtyType &= ~UPDUI_MENUBAR;
2533                 return TRUE;
2534         }
2535 #endif // !_WIN32_WCE
2536
2537         BOOL UIUpdateToolBar(BOOL bForceUpdate = FALSE)
2538         {
2539                 if(!(m_wDirtyType & UPDUI_TOOLBAR) && !bForceUpdate)
2540                         return TRUE;
2541
2542                 const _AtlUpdateUIMap* pMap = m_pUIMap;
2543                 _AtlUpdateUIData* pUIData = m_pUIData;
2544                 if(pUIData == NULL)
2545                         return FALSE;
2546
2547                 while(pMap->m_nID != (WORD)-1)
2548                 {
2549                         for(int i = 0; i < m_UIElements.GetSize(); i++)
2550                         {
2551                                 if(m_UIElements[i].m_wType == UPDUI_TOOLBAR)
2552                                 {
2553                                         if((pUIData->m_wState & UPDUI_TOOLBAR) && (pMap->m_wType & UPDUI_TOOLBAR))
2554                                                 UIUpdateToolBarElement(pMap->m_nID, pUIData, m_UIElements[i].m_hWnd);
2555                                 }
2556                         }
2557                         pMap++;
2558                         pUIData->m_wState &= ~UPDUI_TOOLBAR;
2559                         pUIData++;
2560                 }
2561
2562                 m_wDirtyType &= ~UPDUI_TOOLBAR;
2563                 return TRUE;
2564         }
2565
2566         BOOL UIUpdateStatusBar(BOOL bForceUpdate = FALSE)
2567         {
2568                 if(!(m_wDirtyType & UPDUI_STATUSBAR) && !bForceUpdate)
2569                         return TRUE;
2570
2571                 const _AtlUpdateUIMap* pMap = m_pUIMap;
2572                 _AtlUpdateUIData* pUIData = m_pUIData;
2573                 if(pUIData == NULL)
2574                         return FALSE;
2575
2576                 while(pMap->m_nID != (WORD)-1)
2577                 {
2578                         for(int i = 0; i < m_UIElements.GetSize(); i++)
2579                         {
2580                                 if(m_UIElements[i].m_wType == UPDUI_STATUSBAR)
2581                                 {
2582                                         if((pUIData->m_wState & UPDUI_STATUSBAR) && (pMap->m_wType & UPDUI_STATUSBAR))
2583                                                 UIUpdateStatusBarElement(pMap->m_nID, pUIData, m_UIElements[i].m_hWnd);
2584                                 }
2585                         }
2586                         pMap++;
2587                         pUIData->m_wState &= ~UPDUI_STATUSBAR;
2588                         if(pUIData->m_wState & UPDUI_TEXT)
2589                         {
2590                                 delete [] pUIData->m_lpstrText;
2591                                 pUIData->m_lpstrText = NULL;
2592                                 pUIData->m_wState &= ~UPDUI_TEXT;
2593                         }
2594                         pUIData++;
2595                 }
2596
2597                 m_wDirtyType &= ~UPDUI_STATUSBAR;
2598                 return TRUE;
2599         }
2600
2601         BOOL UIUpdateChildWindows(BOOL bForceUpdate = FALSE)
2602         {
2603                 if(!(m_wDirtyType & UPDUI_CHILDWINDOW) && !bForceUpdate)
2604                         return TRUE;
2605
2606                 const _AtlUpdateUIMap* pMap = m_pUIMap;
2607                 _AtlUpdateUIData* pUIData = m_pUIData;
2608                 if(pUIData == NULL)
2609                         return FALSE;
2610
2611                 while(pMap->m_nID != (WORD)-1)
2612                 {
2613                         for(int i = 0; i < m_UIElements.GetSize(); i++)
2614                         {
2615                                 if(m_UIElements[i].m_wType == UPDUI_CHILDWINDOW)
2616                                 {
2617                                         if((pUIData->m_wState & UPDUI_CHILDWINDOW) && (pMap->m_wType & UPDUI_CHILDWINDOW))
2618                                                 UIUpdateChildWindow(pMap->m_nID, pUIData, m_UIElements[i].m_hWnd);
2619                                 }
2620                         }
2621                         pMap++;
2622                         pUIData->m_wState &= ~UPDUI_CHILDWINDOW;
2623                         if(pUIData->m_wState & UPDUI_TEXT)
2624                         {
2625                                 delete [] pUIData->m_lpstrText;
2626                                 pUIData->m_lpstrText = NULL;
2627                                 pUIData->m_wState &= ~UPDUI_TEXT;
2628                         }
2629                         pUIData++;
2630                 }
2631
2632                 m_wDirtyType &= ~UPDUI_CHILDWINDOW;
2633                 return TRUE;
2634         }
2635
2636 // internal element specific methods
2637         static void UIUpdateMenuBarElement(int nID, _AtlUpdateUIData* pUIData, HMENU hMenu)
2638         {
2639 #ifndef _WIN32_WCE
2640                 if((pUIData->m_wState & UPDUI_CLEARDEFAULT) != 0)
2641                 {
2642                         ::SetMenuDefaultItem(hMenu, (UINT)-1, 0);
2643                         pUIData->m_wState &= ~UPDUI_CLEARDEFAULT;
2644                 }
2645 #endif // !_WIN32_WCE
2646
2647                 CMenuItemInfo mii;
2648                 mii.fMask = MIIM_STATE;
2649                 mii.wID = nID;
2650
2651 #ifndef _WIN32_WCE
2652                 if((pUIData->m_wState & UPDUI_DISABLED) != 0)
2653                         mii.fState |= MFS_DISABLED | MFS_GRAYED;
2654                 else
2655                         mii.fState |= MFS_ENABLED;
2656
2657                 if((pUIData->m_wState & UPDUI_CHECKED) != 0)
2658                         mii.fState |= MFS_CHECKED;
2659                 else
2660                         mii.fState |= MFS_UNCHECKED;
2661
2662                 if((pUIData->m_wState & UPDUI_DEFAULT) != 0)
2663                         mii.fState |= MFS_DEFAULT;
2664 #else // CE specific
2665                 // ::SetMenuItemInfo() can't disable or check menu items
2666                 // on Windows CE, so we have to do that directly
2667                 UINT uEnable = MF_BYCOMMAND;
2668                 if((pUIData->m_wState & UPDUI_DISABLED) != 0)
2669                         uEnable |= MF_GRAYED;
2670                 else
2671                         uEnable |= MF_ENABLED;
2672                 ::EnableMenuItem(hMenu, nID, uEnable);
2673
2674                 UINT uCheck = MF_BYCOMMAND;
2675                 if((pUIData->m_wState & UPDUI_CHECKED) != 0)
2676                         uCheck |= MF_CHECKED;
2677                 else
2678                         uCheck |= MF_UNCHECKED;
2679                 ::CheckMenuItem(hMenu, nID, uCheck);
2680 #endif // _WIN32_WCE
2681
2682                 if((pUIData->m_wState & UPDUI_TEXT) != 0)
2683                 {
2684                         CMenuItemInfo miiNow;
2685                         miiNow.fMask = MIIM_TYPE;
2686                         miiNow.wID = nID;
2687                         if(::GetMenuItemInfo(hMenu, nID, FALSE, &miiNow))
2688                         {
2689                                 mii.fMask |= MIIM_TYPE;
2690                                 // MFT_BITMAP and MFT_SEPARATOR don't go together with MFT_STRING
2691 #ifndef _WIN32_WCE
2692                                 mii.fType |= (miiNow.fType & ~(MFT_BITMAP | MFT_SEPARATOR)) | MFT_STRING;
2693 #else // CE specific
2694                                 mii.fType |= (miiNow.fType & ~(MFT_SEPARATOR)) | MFT_STRING;
2695 #endif // _WIN32_WCE
2696                                 mii.dwTypeData = pUIData->m_lpstrText;
2697                         }
2698                 }
2699
2700                 ::SetMenuItemInfo(hMenu, nID, FALSE, &mii);
2701         }
2702
2703         static void UIUpdateToolBarElement(int nID, _AtlUpdateUIData* pUIData, HWND hWndToolBar)
2704         {
2705                 // Note: only handles enabled/disabled, checked state, and radio (press)
2706                 ::SendMessage(hWndToolBar, TB_ENABLEBUTTON, nID, (LPARAM)(pUIData->m_wState & UPDUI_DISABLED) ? FALSE : TRUE);
2707                 ::SendMessage(hWndToolBar, TB_CHECKBUTTON, nID, (LPARAM)(pUIData->m_wState & UPDUI_CHECKED) ? TRUE : FALSE);
2708                 ::SendMessage(hWndToolBar, TB_INDETERMINATE, nID, (LPARAM)(pUIData->m_wState & UPDUI_CHECKED2) ? TRUE : FALSE);
2709                 ::SendMessage(hWndToolBar, TB_PRESSBUTTON, nID, (LPARAM)(pUIData->m_wState & UPDUI_RADIO) ? TRUE : FALSE);
2710         }
2711
2712         static void UIUpdateStatusBarElement(int nID, _AtlUpdateUIData* pUIData, HWND hWndStatusBar)
2713         {
2714                 // Note: only handles text
2715                 if(pUIData->m_wState & UPDUI_TEXT)
2716                         ::SendMessage(hWndStatusBar, SB_SETTEXT, nID, (LPARAM)pUIData->m_lpstrText);
2717         }
2718
2719         static void UIUpdateChildWindow(int nID, _AtlUpdateUIData* pUIData, HWND hWnd)
2720         {
2721                 HWND hChild = ::GetDlgItem(hWnd, nID);
2722
2723                 ::EnableWindow(hChild, (pUIData->m_wState & UPDUI_DISABLED) ? FALSE : TRUE);
2724                 // for check and radio, assume that window is a button
2725                 int nCheck = BST_UNCHECKED;
2726                 if(pUIData->m_wState & UPDUI_CHECKED || pUIData->m_wState & UPDUI_RADIO)
2727                         nCheck = BST_CHECKED;
2728                 else if(pUIData->m_wState & UPDUI_CHECKED2)
2729                         nCheck = BST_INDETERMINATE;
2730                 ::SendMessage(hChild, BM_SETCHECK, nCheck, 0L);
2731                 if(pUIData->m_wState & UPDUI_DEFAULT)
2732                 {
2733                         DWORD dwRet = (DWORD)::SendMessage(hWnd, DM_GETDEFID, 0, 0L);
2734                         if(HIWORD(dwRet) == DC_HASDEFID)
2735                         {
2736                                 HWND hOldDef = ::GetDlgItem(hWnd, (int)(short)LOWORD(dwRet));
2737                                 // remove BS_DEFPUSHBUTTON
2738                                 ::SendMessage(hOldDef, BM_SETSTYLE, BS_PUSHBUTTON, MAKELPARAM(TRUE, 0));
2739                         }
2740                         ::SendMessage(hWnd, DM_SETDEFID, nID, 0L);
2741                 }
2742                 if(pUIData->m_wState & UPDUI_TEXT)
2743                         ::SetWindowText(hChild, pUIData->m_lpstrText);
2744         }
2745 };
2746
2747 template <class T>
2748 class CUpdateUI : public CUpdateUIBase
2749 {
2750 public:
2751         CUpdateUI()
2752         {
2753                 T* pT = static_cast<T*>(this);
2754                 pT;
2755                 const _AtlUpdateUIMap* pMap = pT->GetUpdateUIMap();
2756                 m_pUIMap = pMap;
2757                 ATLASSERT(m_pUIMap != NULL);
2758                 int nCount;
2759                 for(nCount = 1; pMap->m_nID != (WORD)-1; nCount++)
2760                         pMap++;
2761
2762                 // check for duplicates (debug only)
2763 #ifdef _DEBUG
2764                 for(int i = 0; i < nCount; i++)
2765                 {
2766                         for(int j = 0; j < nCount; j++)
2767                         {
2768                                 // shouldn't have duplicates in the update UI map
2769                                 if(i != j)
2770                                         ATLASSERT(m_pUIMap[j].m_nID != m_pUIMap[i].m_nID);
2771                         }
2772                 }
2773 #endif // _DEBUG
2774
2775                 ATLTRY(m_pUIData = new _AtlUpdateUIData[nCount]);
2776                 ATLASSERT(m_pUIData != NULL);
2777
2778                 if(m_pUIData != NULL)
2779                         memset(m_pUIData, 0, sizeof(_AtlUpdateUIData) * nCount);
2780         }
2781 };
2782
2783
2784 ///////////////////////////////////////////////////////////////////////////////
2785 // CDynamicUpdateUI - allows update elements to dynamically added and removed
2786 //                    in addition to a static update UI map
2787
2788 template <class T>
2789 class CDynamicUpdateUI : public CUpdateUIBase
2790 {
2791 public:
2792 // Data members
2793         ATL::CSimpleArray<_AtlUpdateUIMap> m_arrUIMap;     // copy of the static UI data
2794         ATL::CSimpleArray<_AtlUpdateUIData> m_arrUIData;   // instance UI data
2795
2796 // Constructor/destructor
2797         CDynamicUpdateUI()
2798         {
2799                 T* pT = static_cast<T*>(this);
2800                 pT;
2801                 const _AtlUpdateUIMap* pMap = pT->GetUpdateUIMap();
2802                 ATLASSERT(pMap != NULL);
2803
2804                 for(;;)
2805                 {
2806                         BOOL bRet = m_arrUIMap.Add(*(_AtlUpdateUIMap*)pMap);
2807                         ATLASSERT(bRet);
2808
2809                         if(bRet != FALSE)
2810                         {
2811                                 _AtlUpdateUIData data = { 0, NULL };
2812                                 bRet = m_arrUIData.Add(data);
2813                                 ATLASSERT(bRet);
2814                         }
2815
2816                         if(pMap->m_nID == (WORD)-1)
2817                                 break;
2818
2819                         pMap++;
2820                 }
2821
2822                 ATLASSERT(m_arrUIMap.GetSize() == m_arrUIData.GetSize());
2823
2824 #ifdef _DEBUG
2825                 // check for duplicates (debug only)
2826                 for(int i = 0; i < m_arrUIMap.GetSize(); i++)
2827                 {
2828                         for(int j = 0; j < m_arrUIMap.GetSize(); j++)
2829                         {
2830                                 // shouldn't have duplicates in the update UI map
2831                                 if(i != j)
2832                                         ATLASSERT(m_arrUIMap[j].m_nID != m_arrUIMap[i].m_nID);
2833                         }
2834                 }
2835 #endif // _DEBUG
2836
2837                 // Set internal data pointers to point to the new data arrays
2838                 m_pUIMap = m_arrUIMap.m_aT;
2839                 m_pUIData = m_arrUIData.m_aT;
2840         }
2841
2842         ~CDynamicUpdateUI()
2843         {
2844                 for(int i = 0; i < m_arrUIData.GetSize(); i++)
2845                 {
2846                         if((m_arrUIData[i].m_wState & UPDUI_TEXT) != 0)
2847                                 delete [] m_arrUIData[i].m_lpstrText;
2848                 }
2849
2850                 // Reset internal data pointers (memory will be released by CSimpleArray d-tor)
2851                 m_pUIMap = NULL;
2852                 m_pUIData = NULL;
2853         }
2854
2855 // Methods for dynamically adding and removing update elements
2856         bool UIAddUpdateElement(WORD nID, WORD wType)
2857         {
2858                 // check for duplicates
2859                 for(int i = 0; i < m_arrUIMap.GetSize(); i++)
2860                 {
2861                         // shouldn't have duplicates in the update UI map
2862                         ATLASSERT(m_arrUIMap[i].m_nID != nID);
2863                         if(m_arrUIMap[i].m_nID == nID)
2864                                 return false;
2865                 }
2866
2867                 bool bRetVal = false;
2868
2869                 // Add new end element
2870                 _AtlUpdateUIMap uumEnd = { (WORD)-1, 0 };
2871                 BOOL bRet = m_arrUIMap.Add(uumEnd);
2872                 ATLASSERT(bRet);
2873
2874                 if(bRet != FALSE)
2875                 {
2876                         _AtlUpdateUIData uud = { 0, NULL };
2877                         bRet = m_arrUIData.Add(uud);
2878                         ATLASSERT(bRet);
2879
2880                         // Set new data to the previous end element
2881                         if(bRet != FALSE)
2882                         {
2883                                 int nSize = m_arrUIMap.GetSize();
2884                                 _AtlUpdateUIMap uum = { nID, wType };
2885                                 m_arrUIMap.SetAtIndex(nSize - 2, uum);
2886                                 m_arrUIData.SetAtIndex(nSize - 2, uud);
2887
2888                                 // Set internal data pointers again, just in case that memory moved
2889                                 m_pUIMap = m_arrUIMap.m_aT;
2890                                 m_pUIData = m_arrUIData.m_aT;
2891
2892                                 bRetVal = true;
2893                         }
2894                 }
2895
2896                 return bRetVal;
2897         }
2898
2899         bool UIRemoveUpdateElement(WORD nID)
2900         {
2901                 bool bRetVal = false;
2902
2903                 for(int i = 0; i < m_arrUIMap.GetSize(); i++)
2904                 {
2905                         if(m_arrUIMap[i].m_nID == nID)
2906                         {
2907                                 BOOL bRet = m_arrUIMap.RemoveAt(i);
2908                                 ATLASSERT(bRet);
2909                                 bRet = m_arrUIData.RemoveAt(i);
2910                                 ATLASSERT(bRet);
2911
2912                                 bRetVal = true;
2913                                 break;
2914                         }
2915                 }
2916
2917                 return bRetVal;
2918         }
2919 };
2920
2921
2922 ///////////////////////////////////////////////////////////////////////////////
2923 // CDialogResize - provides support for resizing dialog controls
2924 //                 (works for any window that has child controls)
2925
2926 // Put CDialogResize in the list of base classes for a dialog (or even plain window),
2927 // then implement DLGRESIZE map by specifying controls and groups of control
2928 // and using DLSZ_* values to specify how are they supposed to be resized.
2929 //
2930 // Notes:
2931 // - Resizeable border (WS_THICKFRAME style) should be set in the dialog template
2932 //   for top level dialogs (popup or overlapped), so that users can resize the dialog.
2933 // - Some flags cannot be combined; for instance DLSZ_CENTER_X overrides DLSZ_SIZE_X,
2934 //   DLSZ_SIZE_X overrides DLSZ_MOVE_X. X and Y flags can be combined.
2935 // - Order of controls is important - group controls are resized and moved based
2936 //   on the position of the previous control in a group.
2937
2938 // dialog resize map macros
2939 #define BEGIN_DLGRESIZE_MAP(thisClass) \
2940         static const _AtlDlgResizeMap* GetDlgResizeMap() \
2941         { \
2942                 static const _AtlDlgResizeMap theMap[] = \
2943                 {
2944
2945 #define END_DLGRESIZE_MAP() \
2946                         { -1, 0 }, \
2947                 }; \
2948                 return theMap; \
2949         }
2950
2951 #define DLGRESIZE_CONTROL(id, flags) \
2952                 { id, flags },
2953
2954 #define BEGIN_DLGRESIZE_GROUP() \
2955                 { -1, _DLSZ_BEGIN_GROUP },
2956
2957 #define END_DLGRESIZE_GROUP() \
2958                 { -1, _DLSZ_END_GROUP },
2959
2960
2961 template <class T>
2962 class CDialogResize
2963 {
2964 public:
2965 // Data declarations and members
2966         enum
2967         {
2968                 DLSZ_SIZE_X             = 0x00000001,
2969                 DLSZ_SIZE_Y             = 0x00000002,
2970                 DLSZ_MOVE_X             = 0x00000004,
2971                 DLSZ_MOVE_Y             = 0x00000008,
2972                 DLSZ_REPAINT            = 0x00000010,
2973                 DLSZ_CENTER_X           = 0x00000020,
2974                 DLSZ_CENTER_Y           = 0x00000040,
2975
2976                 // internal use only
2977                 _DLSZ_BEGIN_GROUP       = 0x00001000,
2978                 _DLSZ_END_GROUP         = 0x00002000,
2979                 _DLSZ_GRIPPER           = 0x00004000
2980         };
2981
2982         struct _AtlDlgResizeMap
2983         {
2984                 int m_nCtlID;
2985                 DWORD m_dwResizeFlags;
2986         };
2987
2988         struct _AtlDlgResizeData
2989         {
2990                 int m_nCtlID;
2991                 DWORD m_dwResizeFlags;
2992                 RECT m_rect;
2993
2994                 int GetGroupCount() const
2995                 {
2996                         return (int)LOBYTE(HIWORD(m_dwResizeFlags));
2997                 }
2998
2999                 void SetGroupCount(int nCount)
3000                 {
3001                         ATLASSERT(nCount > 0 && nCount < 256);
3002                         DWORD dwCount = (DWORD)MAKELONG(0, MAKEWORD(nCount, 0));
3003                         m_dwResizeFlags &= 0xFF00FFFF;
3004                         m_dwResizeFlags |= dwCount;
3005                 }
3006
3007                 bool operator ==(const _AtlDlgResizeData& r) const
3008                 { return (m_nCtlID == r.m_nCtlID && m_dwResizeFlags == r.m_dwResizeFlags); }
3009         };
3010
3011         ATL::CSimpleArray<_AtlDlgResizeData> m_arrData;
3012         SIZE m_sizeDialog;
3013         POINT m_ptMinTrackSize;
3014         bool m_bGripper;
3015
3016
3017 // Constructor
3018         CDialogResize() : m_bGripper(false)
3019         {
3020                 m_sizeDialog.cx = 0;
3021                 m_sizeDialog.cy = 0;
3022                 m_ptMinTrackSize.x = -1;
3023                 m_ptMinTrackSize.y = -1;
3024         }
3025
3026 // Operations
3027         void DlgResize_Init(bool bAddGripper = true, bool bUseMinTrackSize = true, DWORD dwForceStyle = WS_CLIPCHILDREN)
3028         {
3029                 T* pT = static_cast<T*>(this);
3030                 ATLASSERT(::IsWindow(pT->m_hWnd));
3031
3032                 DWORD dwStyle = pT->GetStyle();
3033
3034 #ifdef _DEBUG
3035                 // Debug only: Check if top level dialogs have a resizeable border.
3036                 if(((dwStyle & WS_CHILD) == 0) && ((dwStyle & WS_THICKFRAME) == 0))
3037                         ATLTRACE2(atlTraceUI, 0, _T("DlgResize_Init - warning: top level dialog without the WS_THICKFRAME style - user cannot resize it\n"));
3038 #endif // _DEBUG
3039
3040                 // Force specified styles (default WS_CLIPCHILDREN reduces flicker)
3041                 if((dwStyle & dwForceStyle) != dwForceStyle)
3042                         pT->ModifyStyle(0, dwForceStyle);
3043
3044                 // Adding this style removes an empty icon that dialogs with WS_THICKFRAME have.
3045                 // Setting icon to NULL is required when XP themes are active.
3046                 // Note: This will not prevent adding an icon for the dialog using SetIcon()
3047                 if((dwStyle & WS_CHILD) == 0)
3048                 {
3049                         pT->ModifyStyleEx(0, WS_EX_DLGMODALFRAME);
3050                         if(pT->GetIcon(FALSE) == NULL)
3051                                 pT->SetIcon(NULL, FALSE);
3052                 }
3053
3054                 // Cleanup in case of multiple initialization
3055                 // block: first check for the gripper control, destroy it if needed
3056                 {
3057                         ATL::CWindow wndGripper = pT->GetDlgItem(ATL_IDW_STATUS_BAR);
3058                         if(wndGripper.IsWindow() && m_arrData.GetSize() > 0 && (m_arrData[0].m_dwResizeFlags & _DLSZ_GRIPPER) != 0)
3059                                 wndGripper.DestroyWindow();
3060                 }
3061                 // clear out everything else
3062                 m_arrData.RemoveAll();
3063                 m_sizeDialog.cx = 0;
3064                 m_sizeDialog.cy = 0;
3065                 m_ptMinTrackSize.x = -1;
3066                 m_ptMinTrackSize.y = -1;
3067
3068                 // Get initial dialog client size
3069                 RECT rectDlg = { 0 };
3070                 pT->GetClientRect(&rectDlg);
3071                 m_sizeDialog.cx = rectDlg.right;
3072                 m_sizeDialog.cy = rectDlg.bottom;
3073
3074 #ifndef _WIN32_WCE
3075                 // Create gripper if requested
3076                 m_bGripper = false;
3077                 if(bAddGripper)
3078                 {
3079                         // shouldn't exist already
3080                         ATLASSERT(!::IsWindow(pT->GetDlgItem(ATL_IDW_STATUS_BAR)));
3081                         if(!::IsWindow(pT->GetDlgItem(ATL_IDW_STATUS_BAR)))
3082                         {
3083                                 ATL::CWindow wndGripper;
3084                                 wndGripper.Create(_T("SCROLLBAR"), pT->m_hWnd, rectDlg, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | SBS_SIZEBOX | SBS_SIZEGRIP | SBS_SIZEBOXBOTTOMRIGHTALIGN, 0, ATL_IDW_STATUS_BAR);
3085                                 ATLASSERT(wndGripper.IsWindow());
3086                                 if(wndGripper.IsWindow())
3087                                 {
3088                                         m_bGripper = true;
3089                                         RECT rectCtl = { 0 };
3090                                         wndGripper.GetWindowRect(&rectCtl);
3091                                         ::MapWindowPoints(NULL, pT->m_hWnd, (LPPOINT)&rectCtl, 2);
3092                                         _AtlDlgResizeData data = { ATL_IDW_STATUS_BAR, DLSZ_MOVE_X | DLSZ_MOVE_Y | DLSZ_REPAINT | _DLSZ_GRIPPER, { rectCtl.left, rectCtl.top, rectCtl.right, rectCtl.bottom } };
3093                                         m_arrData.Add(data);
3094                                 }
3095                         }
3096                 }
3097 #else // CE specific
3098                 bAddGripper;   // avoid level 4 warning
3099 #endif // _WIN32_WCE
3100
3101                 // Get min track position if requested
3102                 if(bUseMinTrackSize)
3103                 {
3104                         if((dwStyle & WS_CHILD) != 0)
3105                         {
3106                                 RECT rect = { 0 };
3107                                 pT->GetClientRect(&rect);
3108                                 m_ptMinTrackSize.x = rect.right - rect.left;
3109                                 m_ptMinTrackSize.y = rect.bottom - rect.top;
3110                         }
3111                         else
3112                         {
3113                                 RECT rect = { 0 };
3114                                 pT->GetWindowRect(&rect);
3115                                 m_ptMinTrackSize.x = rect.right - rect.left;
3116                                 m_ptMinTrackSize.y = rect.bottom - rect.top;
3117                         }
3118                 }
3119
3120                 // Walk the map and initialize data
3121                 const _AtlDlgResizeMap* pMap = pT->GetDlgResizeMap();
3122                 ATLASSERT(pMap != NULL);
3123                 int nGroupStart = -1;
3124                 for(int nCount = 1; !(pMap->m_nCtlID == -1 && pMap->m_dwResizeFlags == 0); nCount++, pMap++)
3125                 {
3126                         if(pMap->m_nCtlID == -1)
3127                         {
3128                                 switch(pMap->m_dwResizeFlags)
3129                                 {
3130                                 case _DLSZ_BEGIN_GROUP:
3131                                         ATLASSERT(nGroupStart == -1);
3132                                         nGroupStart = m_arrData.GetSize();
3133                                         break;
3134                                 case _DLSZ_END_GROUP:
3135                                         {
3136                                                 ATLASSERT(nGroupStart != -1);
3137                                                 int nGroupCount = m_arrData.GetSize() - nGroupStart;
3138                                                 m_arrData[nGroupStart].SetGroupCount(nGroupCount);
3139                                                 nGroupStart = -1;
3140                                         }
3141                                         break;
3142                                 default:
3143                                         ATLASSERT(FALSE && _T("Invalid DLGRESIZE Map Entry"));
3144                                         break;
3145                                 }
3146                         }
3147                         else
3148                         {
3149                                 // this ID conflicts with the default gripper one
3150                                 ATLASSERT(m_bGripper ? (pMap->m_nCtlID != ATL_IDW_STATUS_BAR) : TRUE);
3151
3152                                 ATL::CWindow ctl = pT->GetDlgItem(pMap->m_nCtlID);
3153                                 ATLASSERT(ctl.IsWindow());
3154                                 RECT rectCtl = { 0 };
3155                                 ctl.GetWindowRect(&rectCtl);
3156                                 ::MapWindowPoints(NULL, pT->m_hWnd, (LPPOINT)&rectCtl, 2);
3157
3158                                 DWORD dwGroupFlag = (nGroupStart != -1 && m_arrData.GetSize() == nGroupStart) ? _DLSZ_BEGIN_GROUP : 0;
3159                                 _AtlDlgResizeData data = { pMap->m_nCtlID, pMap->m_dwResizeFlags | dwGroupFlag, { rectCtl.left, rectCtl.top, rectCtl.right, rectCtl.bottom } };
3160                                 m_arrData.Add(data);
3161                         }
3162                 }
3163                 ATLASSERT((nGroupStart == -1) && _T("No End Group Entry in the DLGRESIZE Map"));
3164         }
3165
3166         void DlgResize_UpdateLayout(int cxWidth, int cyHeight)
3167         {
3168                 T* pT = static_cast<T*>(this);
3169                 ATLASSERT(::IsWindow(pT->m_hWnd));
3170
3171                 // Restrict minimum size if requested
3172                 if(((pT->GetStyle() & WS_CHILD) != 0) && m_ptMinTrackSize.x != -1 && m_ptMinTrackSize.y != -1)
3173                 {
3174                         if(cxWidth < m_ptMinTrackSize.x)
3175                                 cxWidth = m_ptMinTrackSize.x;
3176                         if(cyHeight < m_ptMinTrackSize.y)
3177                                 cyHeight = m_ptMinTrackSize.y;
3178                 }
3179
3180                 BOOL bVisible = pT->IsWindowVisible();
3181                 if(bVisible)
3182                         pT->SetRedraw(FALSE);
3183
3184                 for(int i = 0; i < m_arrData.GetSize(); i++)
3185                 {
3186                         if((m_arrData[i].m_dwResizeFlags & _DLSZ_BEGIN_GROUP) != 0)   // start of a group
3187                         {
3188                                 int nGroupCount = m_arrData[i].GetGroupCount();
3189                                 ATLASSERT(nGroupCount > 0 && i + nGroupCount - 1 < m_arrData.GetSize());
3190                                 RECT rectGroup = m_arrData[i].m_rect;
3191
3192                                 int j = 1;
3193                                 for(j = 1; j < nGroupCount; j++)
3194                                 {
3195                                         rectGroup.left = __min(rectGroup.left, m_arrData[i + j].m_rect.left);
3196                                         rectGroup.top = __min(rectGroup.top, m_arrData[i + j].m_rect.top);
3197                                         rectGroup.right = __max(rectGroup.right, m_arrData[i + j].m_rect.right);
3198                                         rectGroup.bottom = __max(rectGroup.bottom, m_arrData[i + j].m_rect.bottom);
3199                                 }
3200
3201                                 for(j = 0; j < nGroupCount; j++)
3202                                 {
3203                                         _AtlDlgResizeData* pDataPrev = NULL;
3204                                         if(j > 0)
3205                                                 pDataPrev = &(m_arrData[i + j - 1]);
3206                                         pT->DlgResize_PositionControl(cxWidth, cyHeight, rectGroup, m_arrData[i + j], true, pDataPrev);
3207                                 }
3208
3209                                 i += nGroupCount - 1;   // increment to skip all group controls
3210                         }
3211                         else // one control entry
3212                         {
3213                                 RECT rectGroup = { 0, 0, 0, 0 };
3214                                 pT->DlgResize_PositionControl(cxWidth, cyHeight, rectGroup, m_arrData[i], false);
3215                         }
3216                 }
3217
3218                 if(bVisible)
3219                         pT->SetRedraw(TRUE);
3220
3221                 pT->RedrawWindow(NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_UPDATENOW | RDW_ALLCHILDREN);
3222         }
3223
3224 // Message map and handlers
3225         BEGIN_MSG_MAP(CDialogResize)
3226                 MESSAGE_HANDLER(WM_SIZE, OnSize)
3227 #ifndef _WIN32_WCE
3228                 MESSAGE_HANDLER(WM_GETMINMAXINFO, OnGetMinMaxInfo)
3229 #endif // _WIN32_WCE
3230         END_MSG_MAP()
3231
3232         LRESULT OnSize(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
3233         {
3234                 T* pT = static_cast<T*>(this);
3235 #ifndef _WIN32_WCE
3236                 if(m_bGripper)
3237                 {
3238                         ATL::CWindow wndGripper = pT->GetDlgItem(ATL_IDW_STATUS_BAR);
3239                         if(wParam == SIZE_MAXIMIZED)
3240                                 wndGripper.ShowWindow(SW_HIDE);
3241                         else if(wParam == SIZE_RESTORED)
3242                                 wndGripper.ShowWindow(SW_SHOW);
3243                 }
3244 #endif // _WIN32_WCE
3245                 if(wParam != SIZE_MINIMIZED)
3246                 {
3247                         ATLASSERT(::IsWindow(pT->m_hWnd));
3248                         pT->DlgResize_UpdateLayout(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
3249                 }
3250                 return 0;
3251         }
3252
3253 #ifndef _WIN32_WCE
3254         LRESULT OnGetMinMaxInfo(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/)
3255         {
3256                 if(m_ptMinTrackSize.x != -1 && m_ptMinTrackSize.y != -1)
3257                 {
3258                         LPMINMAXINFO lpMMI = (LPMINMAXINFO)lParam;
3259                         lpMMI->ptMinTrackSize =  m_ptMinTrackSize;
3260                 }
3261                 return 0;
3262         }
3263 #endif // _WIN32_WCE
3264
3265 // Implementation
3266         bool DlgResize_PositionControl(int cxWidth, int cyHeight, RECT& rectGroup, _AtlDlgResizeData& data, bool bGroup,
3267                                        _AtlDlgResizeData* pDataPrev = NULL)
3268         {
3269                 T* pT = static_cast<T*>(this);
3270                 ATLASSERT(::IsWindow(pT->m_hWnd));
3271                 ATL::CWindow ctl;
3272                 RECT rectCtl = { 0 };
3273
3274                 ctl = pT->GetDlgItem(data.m_nCtlID);
3275                 if(!ctl.GetWindowRect(&rectCtl))
3276                         return false;
3277                 ::MapWindowPoints(NULL, pT->m_hWnd, (LPPOINT)&rectCtl, 2);
3278
3279                 if(bGroup)
3280                 {
3281                         if((data.m_dwResizeFlags & DLSZ_CENTER_X) != 0)
3282                         {
3283                                 int cxRight = rectGroup.right + cxWidth - m_sizeDialog.cx;
3284                                 int cxCtl = data.m_rect.right - data.m_rect.left;
3285                                 rectCtl.left = rectGroup.left + (cxRight - rectGroup.left - cxCtl) / 2;
3286                                 rectCtl.right = rectCtl.left + cxCtl;
3287                         }
3288                         else if((data.m_dwResizeFlags & (DLSZ_SIZE_X | DLSZ_MOVE_X)) != 0)
3289                         {
3290                                 rectCtl.left = rectGroup.left + ::MulDiv(data.m_rect.left - rectGroup.left, rectGroup.right - rectGroup.left + (cxWidth - m_sizeDialog.cx), rectGroup.right - rectGroup.left);
3291
3292                                 if((data.m_dwResizeFlags & DLSZ_SIZE_X) != 0)
3293                                 {
3294                                         rectCtl.right = rectGroup.left + ::MulDiv(data.m_rect.right - rectGroup.left, rectGroup.right - rectGroup.left + (cxWidth - m_sizeDialog.cx), rectGroup.right - rectGroup.left);
3295
3296                                         if(pDataPrev != NULL)
3297                                         {
3298                                                 ATL::CWindow ctlPrev = pT->GetDlgItem(pDataPrev->m_nCtlID);
3299                                                 RECT rcPrev = { 0 };
3300                                                 ctlPrev.GetWindowRect(&rcPrev);
3301                                                 ::MapWindowPoints(NULL, pT->m_hWnd, (LPPOINT)&rcPrev, 2);
3302                                                 int dxAdjust = (rectCtl.left - rcPrev.right) - (data.m_rect.left - pDataPrev->m_rect.right);
3303                                                 rcPrev.right += dxAdjust;
3304                                                 ctlPrev.SetWindowPos(NULL, &rcPrev, SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE);
3305                                         }
3306                                 }
3307                                 else
3308                                 {
3309                                         rectCtl.right = rectCtl.left + (data.m_rect.right - data.m_rect.left);
3310                                 }
3311                         }
3312
3313                         if((data.m_dwResizeFlags & DLSZ_CENTER_Y) != 0)
3314                         {
3315                                 int cyBottom = rectGroup.bottom + cyHeight - m_sizeDialog.cy;
3316                                 int cyCtl = data.m_rect.bottom - data.m_rect.top;
3317                                 rectCtl.top = rectGroup.top + (cyBottom - rectGroup.top - cyCtl) / 2;
3318                                 rectCtl.bottom = rectCtl.top + cyCtl;
3319                         }
3320                         else if((data.m_dwResizeFlags & (DLSZ_SIZE_Y | DLSZ_MOVE_Y)) != 0)
3321                         {
3322                                 rectCtl.top = rectGroup.top + ::MulDiv(data.m_rect.top - rectGroup.top, rectGroup.bottom - rectGroup.top + (cyHeight - m_sizeDialog.cy), rectGroup.bottom - rectGroup.top);
3323
3324                                 if((data.m_dwResizeFlags & DLSZ_SIZE_Y) != 0)
3325                                 {
3326                                         rectCtl.bottom = rectGroup.top + ::MulDiv(data.m_rect.bottom - rectGroup.top, rectGroup.bottom - rectGroup.top + (cyHeight - m_sizeDialog.cy), rectGroup.bottom - rectGroup.top);
3327
3328                                         if(pDataPrev != NULL)
3329                                         {
3330                                                 ATL::CWindow ctlPrev = pT->GetDlgItem(pDataPrev->m_nCtlID);
3331                                                 RECT rcPrev = { 0 };
3332                                                 ctlPrev.GetWindowRect(&rcPrev);
3333                                                 ::MapWindowPoints(NULL, pT->m_hWnd, (LPPOINT)&rcPrev, 2);
3334                                                 int dxAdjust = (rectCtl.top - rcPrev.bottom) - (data.m_rect.top - pDataPrev->m_rect.bottom);
3335                                                 rcPrev.bottom += dxAdjust;
3336                                                 ctlPrev.SetWindowPos(NULL, &rcPrev, SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE);
3337                                         }
3338                                 }
3339                                 else
3340                                 {
3341                                         rectCtl.bottom = rectCtl.top + (data.m_rect.bottom - data.m_rect.top);
3342                                 }
3343                         }
3344                 }
3345                 else // no group
3346                 {
3347                         if((data.m_dwResizeFlags & DLSZ_CENTER_X) != 0)
3348                         {
3349                                 int cxCtl = data.m_rect.right - data.m_rect.left;
3350                                 rectCtl.left = (cxWidth - cxCtl) / 2;
3351                                 rectCtl.right = rectCtl.left + cxCtl;
3352                         }
3353                         else if((data.m_dwResizeFlags & (DLSZ_SIZE_X | DLSZ_MOVE_X)) != 0)
3354                         {
3355                                 rectCtl.right = data.m_rect.right + (cxWidth - m_sizeDialog.cx);
3356
3357                                 if((data.m_dwResizeFlags & DLSZ_MOVE_X) != 0)
3358                                         rectCtl.left = rectCtl.right - (data.m_rect.right - data.m_rect.left);
3359                         }
3360
3361                         if((data.m_dwResizeFlags & DLSZ_CENTER_Y) != 0)
3362                         {
3363                                 int cyCtl = data.m_rect.bottom - data.m_rect.top;
3364                                 rectCtl.top = (cyHeight - cyCtl) / 2;
3365                                 rectCtl.bottom = rectCtl.top + cyCtl;
3366                         }
3367                         else if((data.m_dwResizeFlags & (DLSZ_SIZE_Y | DLSZ_MOVE_Y)) != 0)
3368                         {
3369                                 rectCtl.bottom = data.m_rect.bottom + (cyHeight - m_sizeDialog.cy);
3370
3371                                 if((data.m_dwResizeFlags & DLSZ_MOVE_Y) != 0)
3372                                         rectCtl.top = rectCtl.bottom - (data.m_rect.bottom - data.m_rect.top);
3373                         }
3374                 }
3375
3376                 if((data.m_dwResizeFlags & DLSZ_REPAINT) != 0)
3377                         ctl.Invalidate();
3378
3379                 if((data.m_dwResizeFlags & (DLSZ_SIZE_X | DLSZ_SIZE_Y | DLSZ_MOVE_X | DLSZ_MOVE_Y | DLSZ_REPAINT | DLSZ_CENTER_X | DLSZ_CENTER_Y)) != 0)
3380                         ctl.SetWindowPos(NULL, &rectCtl, SWP_NOZORDER | SWP_NOACTIVATE);
3381
3382                 return true;
3383         }
3384 };
3385
3386
3387 ///////////////////////////////////////////////////////////////////////////////
3388 // CDoubleBufferImpl - Provides double-buffer painting support to any window
3389
3390 template <class T>
3391 class CDoubleBufferImpl
3392 {
3393 public:
3394 // Overrideables
3395         void DoPaint(CDCHandle /*dc*/)
3396         {
3397                 // must be implemented in a derived class
3398                 ATLASSERT(FALSE);
3399         }
3400
3401 // Message map and handlers
3402         BEGIN_MSG_MAP(CDoubleBufferImpl)
3403                 MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)
3404                 MESSAGE_HANDLER(WM_PAINT, OnPaint)
3405 #ifndef _WIN32_WCE
3406                 MESSAGE_HANDLER(WM_PRINTCLIENT, OnPaint)
3407 #endif // !_WIN32_WCE
3408         END_MSG_MAP()
3409
3410         LRESULT OnEraseBackground(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
3411         {
3412                 return 1;   // no background painting needed
3413         }
3414
3415         LRESULT OnPaint(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
3416         {
3417                 T* pT = static_cast<T*>(this);
3418                 ATLASSERT(::IsWindow(pT->m_hWnd));
3419
3420                 if(wParam != NULL)
3421                 {
3422                         RECT rect = { 0 };
3423                         pT->GetClientRect(&rect);
3424                         CMemoryDC dcMem((HDC)wParam, rect);
3425                         pT->DoPaint(dcMem.m_hDC);
3426                 }
3427                 else
3428                 {
3429                         CPaintDC dc(pT->m_hWnd);
3430                         CMemoryDC dcMem(dc.m_hDC, dc.m_ps.rcPaint);
3431                         pT->DoPaint(dcMem.m_hDC);
3432                 }
3433
3434                 return 0;
3435         }
3436 };
3437
3438
3439 ///////////////////////////////////////////////////////////////////////////////
3440 // CDoubleBufferWindowImpl - Implements a double-buffer painting window
3441
3442 template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits>
3443 class ATL_NO_VTABLE CDoubleBufferWindowImpl : public ATL::CWindowImpl< T, TBase, TWinTraits >, public CDoubleBufferImpl< T >
3444 {
3445 public:
3446         BEGIN_MSG_MAP(CDoubleBufferWindowImpl)
3447                 CHAIN_MSG_MAP(CDoubleBufferImpl< T >)
3448         END_MSG_MAP()
3449 };
3450
3451
3452 // command bar support
3453 #if !defined(__ATLCTRLW_H__) && !defined(_WIN32_WCE)
3454   #undef CBRM_GETMENU
3455   #undef CBRM_TRACKPOPUPMENU
3456   #undef CBRM_GETCMDBAR
3457   #undef CBRPOPUPMENU
3458 #endif // !defined(__ATLCTRLW_H__) && !defined(_WIN32_WCE)
3459
3460 }; // namespace WTL
3461
3462 #endif // __ATLFRAME_H__