| OLD | NEW |
|---|
| (Empty) | |
| 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 __ATLCTRLW_H__ |
| 10 #define __ATLCTRLW_H__ |
| 11 |
| 12 #pragma once |
| 13 |
| 14 #ifndef __cplusplus |
| 15 #error ATL requires C++ compilation (use a .cpp suffix) |
| 16 #endif |
| 17 |
| 18 #ifdef _WIN32_WCE |
| 19 #error atlctrlw.h is not supported on Windows CE |
| 20 #endif |
| 21 |
| 22 #ifndef __ATLAPP_H__ |
| 23 #error atlctrlw.h requires atlapp.h to be included first |
| 24 #endif |
| 25 |
| 26 #ifndef __ATLCTRLS_H__ |
| 27 #error atlctrlw.h requires atlctrls.h to be included first |
| 28 #endif |
| 29 |
| 30 #if (_WIN32_IE < 0x0400) |
| 31 #error atlctrlw.h requires _WIN32_IE >= 0x0400 |
| 32 #endif |
| 33 |
| 34 // Define _WTL_CMDBAR_VISTA_MENUS as 0 to exclude Vista menus support |
| 35 #if !defined(_WTL_CMDBAR_VISTA_MENUS) && (WINVER >= 0x0500) && (_WIN32_WINNT >=
0x0501) && (_WIN32_IE >= 0x0501) |
| 36 #define _WTL_CMDBAR_VISTA_MENUS 1 |
| 37 #endif |
| 38 |
| 39 #if _WTL_CMDBAR_VISTA_MENUS |
| 40 #if !((_WIN32_WINNT >= 0x0501) && (_WIN32_IE >= 0x0501)) |
| 41 #error _WTL_CMDBAR_VISTA_MENUS requires (_WIN32_WINNT >= 0x0501) && (_WI
N32_IE >= 0x0501) |
| 42 #endif |
| 43 #endif |
| 44 |
| 45 |
| 46 /////////////////////////////////////////////////////////////////////////////// |
| 47 // Classes in this file: |
| 48 // |
| 49 // CCommandBarCtrlImpl<T, TBase, TWinTraits> |
| 50 // CCommandBarCtrl |
| 51 // CMDICommandBarCtrlImpl<T, TBase, TWinTraits> |
| 52 // CMDICommandBarCtrl |
| 53 |
| 54 |
| 55 namespace WTL |
| 56 { |
| 57 |
| 58 /////////////////////////////////////////////////////////////////////////////// |
| 59 // Command Bars |
| 60 |
| 61 // Window Styles: |
| 62 #define CBRWS_TOP CCS_TOP |
| 63 #define CBRWS_BOTTOM CCS_BOTTOM |
| 64 #define CBRWS_NORESIZE CCS_NORESIZE |
| 65 #define CBRWS_NOPARENTALIGN CCS_NOPARENTALIGN |
| 66 #define CBRWS_NODIVIDER CCS_NODIVIDER |
| 67 |
| 68 // Extended styles |
| 69 #define CBR_EX_TRANSPARENT 0x00000001L |
| 70 #define CBR_EX_SHAREMENU 0x00000002L |
| 71 #define CBR_EX_ALTFOCUSMODE 0x00000004L |
| 72 #define CBR_EX_TRACKALWAYS 0x00000008L |
| 73 #define CBR_EX_NOVISTAMENUS 0x00000010L |
| 74 |
| 75 // standard command bar styles |
| 76 #define ATL_SIMPLE_CMDBAR_PANE_STYLE \ |
| 77 (WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | CBRWS_NODIV
IDER | CBRWS_NORESIZE | CBRWS_NOPARENTALIGN) |
| 78 |
| 79 // Messages - support chevrons for frame windows |
| 80 #define CBRM_GETCMDBAR (WM_USER + 301) // returns command bar H
WND |
| 81 #define CBRM_GETMENU (WM_USER + 302) // returns loaded or att
ached menu |
| 82 #define CBRM_TRACKPOPUPMENU (WM_USER + 303) // displays a popup menu |
| 83 |
| 84 typedef struct tagCBRPOPUPMENU |
| 85 { |
| 86 int cbSize; |
| 87 HMENU hMenu; // popup menu do display |
| 88 UINT uFlags; // TPM_* flags for ::TrackPopupMenuEx |
| 89 int x; |
| 90 int y; |
| 91 LPTPMPARAMS lptpm; // ptr to TPMPARAMS for ::TrackPopupMenuEx |
| 92 } CBRPOPUPMENU, *LPCBRPOPUPMENU; |
| 93 |
| 94 // helper class |
| 95 template <class T> |
| 96 class CSimpleStack : public ATL::CSimpleArray< T > |
| 97 { |
| 98 public: |
| 99 BOOL Push(T t) |
| 100 { |
| 101 #ifdef _CMDBAR_EXTRA_TRACE |
| 102 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - STACK-PUSH (%8.8X) size =
%i\n"), t, GetSize()); |
| 103 #endif |
| 104 return Add(t); |
| 105 } |
| 106 |
| 107 T Pop() |
| 108 { |
| 109 int nLast = GetSize() - 1; |
| 110 if(nLast < 0) |
| 111 return NULL; // must be able to convert to NULL |
| 112 T t = m_aT[nLast]; |
| 113 #ifdef _CMDBAR_EXTRA_TRACE |
| 114 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - STACK-POP (%8.8X) size = %
i\n"), t, GetSize()); |
| 115 #endif |
| 116 if(!RemoveAt(nLast)) |
| 117 return NULL; |
| 118 return t; |
| 119 } |
| 120 |
| 121 T GetCurrent() |
| 122 { |
| 123 int nLast = GetSize() - 1; |
| 124 if(nLast < 0) |
| 125 return NULL; // must be able to convert to NULL |
| 126 return m_aT[nLast]; |
| 127 } |
| 128 }; |
| 129 |
| 130 |
| 131 /////////////////////////////////////////////////////////////////////////////// |
| 132 // CCommandBarCtrlBase - base class for the Command Bar implementation |
| 133 |
| 134 class CCommandBarCtrlBase : public CToolBarCtrl |
| 135 { |
| 136 public: |
| 137 struct _MsgHookData |
| 138 { |
| 139 HHOOK hMsgHook; |
| 140 DWORD dwUsage; |
| 141 |
| 142 _MsgHookData() : hMsgHook(NULL), dwUsage(0) |
| 143 { } |
| 144 }; |
| 145 |
| 146 typedef ATL::CSimpleMap<DWORD, _MsgHookData*> CMsgHookMap; |
| 147 static CMsgHookMap* s_pmapMsgHook; |
| 148 |
| 149 static HHOOK s_hCreateHook; |
| 150 static bool s_bW2K; // For animation flag |
| 151 static CCommandBarCtrlBase* s_pCurrentBar; |
| 152 static bool s_bStaticInit; |
| 153 |
| 154 CSimpleStack<HWND> m_stackMenuWnd; |
| 155 CSimpleStack<HMENU> m_stackMenuHandle; |
| 156 |
| 157 HWND m_hWndHook; |
| 158 DWORD m_dwMagic; |
| 159 |
| 160 |
| 161 CCommandBarCtrlBase() : m_hWndHook(NULL), m_dwMagic(1314) |
| 162 { |
| 163 // init static variables |
| 164 if(!s_bStaticInit) |
| 165 { |
| 166 CStaticDataInitCriticalSectionLock lock; |
| 167 if(FAILED(lock.Lock())) |
| 168 { |
| 169 ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to l
ock critical section in CCommandBarCtrlBase::CCommandBarCtrlBase.\n")); |
| 170 ATLASSERT(FALSE); |
| 171 return; |
| 172 } |
| 173 |
| 174 if(!s_bStaticInit) |
| 175 { |
| 176 // Just in case... |
| 177 AtlInitCommonControls(ICC_COOL_CLASSES | ICC_BAR
_CLASSES); |
| 178 // Animation on Win2000 only |
| 179 s_bW2K = !AtlIsOldWindows(); |
| 180 // done |
| 181 s_bStaticInit = true; |
| 182 } |
| 183 |
| 184 lock.Unlock(); |
| 185 } |
| 186 } |
| 187 |
| 188 bool IsCommandBarBase() const { return m_dwMagic == 1314; } |
| 189 }; |
| 190 |
| 191 __declspec(selectany) CCommandBarCtrlBase::CMsgHookMap* CCommandBarCtrlBase::s_p
mapMsgHook = NULL; |
| 192 __declspec(selectany) HHOOK CCommandBarCtrlBase::s_hCreateHook = NULL; |
| 193 __declspec(selectany) CCommandBarCtrlBase* CCommandBarCtrlBase::s_pCurrentBar =
NULL; |
| 194 __declspec(selectany) bool CCommandBarCtrlBase::s_bW2K = false; |
| 195 __declspec(selectany) bool CCommandBarCtrlBase::s_bStaticInit = false; |
| 196 |
| 197 |
| 198 /////////////////////////////////////////////////////////////////////////////// |
| 199 // CCommandBarCtrl - ATL implementation of Command Bars |
| 200 |
| 201 template <class T, class TBase = CCommandBarCtrlBase, class TWinTraits = ATL::CC
ontrolWinTraits> |
| 202 class ATL_NO_VTABLE CCommandBarCtrlImpl : public ATL::CWindowImpl< T, TBase, TWi
nTraits > |
| 203 { |
| 204 public: |
| 205 DECLARE_WND_SUPERCLASS(NULL, TBase::GetWndClassName()) |
| 206 |
| 207 // Declarations |
| 208 struct _MenuItemData // menu item data |
| 209 { |
| 210 DWORD dwMagic; |
| 211 LPTSTR lpstrText; |
| 212 UINT fType; |
| 213 UINT fState; |
| 214 int iButton; |
| 215 |
| 216 _MenuItemData() { dwMagic = 0x1313; } |
| 217 bool IsCmdBarMenuItem() { return (dwMagic == 0x1313); } |
| 218 }; |
| 219 |
| 220 struct _ToolBarData // toolbar resource data |
| 221 { |
| 222 WORD wVersion; |
| 223 WORD wWidth; |
| 224 WORD wHeight; |
| 225 WORD wItemCount; |
| 226 //WORD aItems[wItemCount] |
| 227 |
| 228 WORD* items() |
| 229 { return (WORD*)(this+1); } |
| 230 }; |
| 231 |
| 232 // Constants |
| 233 enum _CmdBarDrawConstants |
| 234 { |
| 235 s_kcxGap = 1, |
| 236 s_kcxTextMargin = 2, |
| 237 s_kcxButtonMargin = 3, |
| 238 s_kcyButtonMargin = 3 |
| 239 }; |
| 240 |
| 241 enum |
| 242 { |
| 243 _nMaxMenuItemTextLength = 100, |
| 244 _chChevronShortcut = _T('/') |
| 245 }; |
| 246 |
| 247 #ifndef DT_HIDEPREFIX |
| 248 enum { DT_HIDEPREFIX = 0x00100000 }; |
| 249 #endif // !DT_HIDEPREFIX |
| 250 |
| 251 // Data members |
| 252 HMENU m_hMenu; |
| 253 HIMAGELIST m_hImageList; |
| 254 ATL::CSimpleValArray<WORD> m_arrCommand; |
| 255 |
| 256 DWORD m_dwExtendedStyle; // Command Bar specific extended styles |
| 257 |
| 258 ATL::CContainedWindow m_wndParent; |
| 259 |
| 260 bool m_bMenuActive:1; |
| 261 bool m_bAttachedMenu:1; |
| 262 bool m_bImagesVisible:1; |
| 263 bool m_bPopupItem:1; |
| 264 bool m_bContextMenu:1; |
| 265 bool m_bEscapePressed:1; |
| 266 bool m_bSkipMsg:1; |
| 267 bool m_bParentActive:1; |
| 268 bool m_bFlatMenus:1; |
| 269 bool m_bUseKeyboardCues:1; |
| 270 bool m_bShowKeyboardCues:1; |
| 271 bool m_bAllowKeyboardCues:1; |
| 272 bool m_bKeyboardInput:1; |
| 273 bool m_bAlphaImages:1; |
| 274 bool m_bLayoutRTL:1; |
| 275 bool m_bSkipPostDown:1; |
| 276 bool m_bVistaMenus:1; |
| 277 |
| 278 int m_nPopBtn; |
| 279 int m_nNextPopBtn; |
| 280 |
| 281 SIZE m_szBitmap; |
| 282 SIZE m_szButton; |
| 283 |
| 284 COLORREF m_clrMask; |
| 285 CFont m_fontMenu; // used internally, only to measure text |
| 286 |
| 287 UINT m_uSysKey; |
| 288 |
| 289 HWND m_hWndFocus; // Alternate focus mode |
| 290 |
| 291 int m_cxExtraSpacing; |
| 292 |
| 293 #if _WTL_CMDBAR_VISTA_MENUS |
| 294 ATL::CSimpleValArray<HBITMAP> m_arrVistaBitmap; // Bitmaps for Vista m
enus |
| 295 #endif // _WTL_CMDBAR_VISTA_MENUS |
| 296 |
| 297 // Constructor/destructor |
| 298 CCommandBarCtrlImpl() : |
| 299 m_hMenu(NULL), |
| 300 m_hImageList(NULL), |
| 301 m_wndParent(this, 1), |
| 302 m_bMenuActive(false), |
| 303 m_bAttachedMenu(false), |
| 304 m_nPopBtn(-1), |
| 305 m_nNextPopBtn(-1), |
| 306 m_bPopupItem(false), |
| 307 m_bImagesVisible(true), |
| 308 m_bSkipMsg(false), |
| 309 m_uSysKey(0), |
| 310 m_hWndFocus(NULL), |
| 311 m_bContextMenu(false), |
| 312 m_bEscapePressed(false), |
| 313 m_clrMask(RGB(192, 192, 192)), |
| 314 m_dwExtendedStyle(CBR_EX_TRANSPARENT | CBR_EX_SHAREMENU
| CBR_EX_TRACKALWAYS), |
| 315 m_bParentActive(true), |
| 316 m_bFlatMenus(false), |
| 317 m_bUseKeyboardCues(false), |
| 318 m_bShowKeyboardCues(false), |
| 319 m_bAllowKeyboardCues(true), |
| 320 m_bKeyboardInput(false), |
| 321 m_cxExtraSpacing(0), |
| 322 m_bAlphaImages(false), |
| 323 m_bLayoutRTL(false), |
| 324 m_bSkipPostDown(false), |
| 325 m_bVistaMenus(false) |
| 326 { |
| 327 SetImageSize(16, 15); // default |
| 328 } |
| 329 |
| 330 ~CCommandBarCtrlImpl() |
| 331 { |
| 332 if(m_wndParent.IsWindow()) |
| 333 /*scary!*/ m_wndParent.UnsubclassWindow(); |
| 334 |
| 335 if(m_hMenu != NULL && (m_dwExtendedStyle & CBR_EX_SHAREMENU) ==
0) |
| 336 ::DestroyMenu(m_hMenu); |
| 337 |
| 338 if(m_hImageList != NULL) |
| 339 ::ImageList_Destroy(m_hImageList); |
| 340 } |
| 341 |
| 342 // Attributes |
| 343 DWORD GetCommandBarExtendedStyle() const |
| 344 { |
| 345 return m_dwExtendedStyle; |
| 346 } |
| 347 |
| 348 DWORD SetCommandBarExtendedStyle(DWORD dwExtendedStyle, DWORD dwMask = 0
) |
| 349 { |
| 350 DWORD dwPrevStyle = m_dwExtendedStyle; |
| 351 if(dwMask == 0) |
| 352 m_dwExtendedStyle = dwExtendedStyle; |
| 353 else |
| 354 m_dwExtendedStyle = (m_dwExtendedStyle & ~dwMask) | (dwE
xtendedStyle & dwMask); |
| 355 return dwPrevStyle; |
| 356 } |
| 357 |
| 358 CMenuHandle GetMenu() const |
| 359 { |
| 360 ATLASSERT(::IsWindow(m_hWnd)); |
| 361 return m_hMenu; |
| 362 } |
| 363 |
| 364 COLORREF GetImageMaskColor() const |
| 365 { |
| 366 return m_clrMask; |
| 367 } |
| 368 |
| 369 COLORREF SetImageMaskColor(COLORREF clrMask) |
| 370 { |
| 371 COLORREF clrOld = m_clrMask; |
| 372 m_clrMask = clrMask; |
| 373 return clrOld; |
| 374 } |
| 375 |
| 376 bool GetImagesVisible() const |
| 377 { |
| 378 return m_bImagesVisible; |
| 379 } |
| 380 |
| 381 bool SetImagesVisible(bool bVisible) |
| 382 { |
| 383 bool bOld = m_bImagesVisible; |
| 384 m_bImagesVisible = bVisible; |
| 385 return bOld; |
| 386 } |
| 387 |
| 388 void GetImageSize(SIZE& size) const |
| 389 { |
| 390 size = m_szBitmap; |
| 391 } |
| 392 |
| 393 bool SetImageSize(SIZE& size) |
| 394 { |
| 395 return SetImageSize(size.cx, size.cy); |
| 396 } |
| 397 |
| 398 bool SetImageSize(int cx, int cy) |
| 399 { |
| 400 if(m_hImageList != NULL) |
| 401 { |
| 402 if(::ImageList_GetImageCount(m_hImageList) == 0) // em
pty |
| 403 { |
| 404 ::ImageList_Destroy(m_hImageList); |
| 405 m_hImageList = NULL; |
| 406 } |
| 407 else |
| 408 { |
| 409 return false; // can't set, image list exists |
| 410 } |
| 411 } |
| 412 |
| 413 if(cx == 0 || cy == 0) |
| 414 return false; |
| 415 |
| 416 m_szBitmap.cx = cx; |
| 417 m_szBitmap.cy = cy; |
| 418 m_szButton.cx = m_szBitmap.cx + 2 * s_kcxButtonMargin; |
| 419 m_szButton.cy = m_szBitmap.cy + 2 * s_kcyButtonMargin; |
| 420 |
| 421 return true; |
| 422 } |
| 423 |
| 424 bool GetAlphaImages() const |
| 425 { |
| 426 return m_bAlphaImages; |
| 427 } |
| 428 |
| 429 bool SetAlphaImages(bool bAlphaImages) |
| 430 { |
| 431 if(m_hImageList != NULL) |
| 432 { |
| 433 if(::ImageList_GetImageCount(m_hImageList) == 0) // em
pty |
| 434 { |
| 435 ::ImageList_Destroy(m_hImageList); |
| 436 m_hImageList = NULL; |
| 437 } |
| 438 else |
| 439 { |
| 440 return false; // can't set, image list exists |
| 441 } |
| 442 } |
| 443 |
| 444 m_bAlphaImages = bAlphaImages; |
| 445 return true; |
| 446 } |
| 447 |
| 448 HWND GetCmdBar() const |
| 449 { |
| 450 ATLASSERT(::IsWindow(m_hWnd)); |
| 451 return (HWND)::SendMessage(m_hWnd, CBRM_GETCMDBAR, 0, 0L); |
| 452 } |
| 453 |
| 454 // Methods |
| 455 HWND Create(HWND hWndParent, RECT& rcPos, LPCTSTR szWindowName = NULL, |
| 456 DWORD dwStyle = 0, DWORD dwExStyle = 0, |
| 457 UINT nID = 0, LPVOID lpCreateParam = NULL) |
| 458 { |
| 459 // These styles are required for command bars |
| 460 dwStyle |= TBSTYLE_LIST | TBSTYLE_FLAT; |
| 461 #if (_MSC_VER >= 1300) |
| 462 return ATL::CWindowImpl< T, TBase, TWinTraits >::Create(hWndPare
nt, rcPos, szWindowName, dwStyle, dwExStyle, nID, lpCreateParam); |
| 463 #else // !(_MSC_VER >= 1300) |
| 464 typedef ATL::CWindowImpl< T, TBase, TWinTraits > _baseClass; |
| 465 return _baseClass::Create(hWndParent, rcPos, szWindowName, dwSty
le, dwExStyle, nID, lpCreateParam); |
| 466 #endif // !(_MSC_VER >= 1300) |
| 467 } |
| 468 |
| 469 BOOL AttachToWindow(HWND hWnd) |
| 470 { |
| 471 ATLASSERT(m_hWnd == NULL); |
| 472 ATLASSERT(::IsWindow(hWnd)); |
| 473 BOOL bRet = SubclassWindow(hWnd); |
| 474 if(bRet) |
| 475 { |
| 476 m_bAttachedMenu = true; |
| 477 T* pT = static_cast<T*>(this); |
| 478 pT->GetSystemSettings(); |
| 479 } |
| 480 return bRet; |
| 481 } |
| 482 |
| 483 BOOL LoadMenu(ATL::_U_STRINGorID menu) |
| 484 { |
| 485 ATLASSERT(::IsWindow(m_hWnd)); |
| 486 |
| 487 if(m_bAttachedMenu) // doesn't work in this mode |
| 488 return FALSE; |
| 489 if(menu.m_lpstr == NULL) |
| 490 return FALSE; |
| 491 |
| 492 HMENU hMenu = ::LoadMenu(ModuleHelper::GetResourceInstance(), me
nu.m_lpstr); |
| 493 if(hMenu == NULL) |
| 494 return FALSE; |
| 495 |
| 496 return AttachMenu(hMenu); |
| 497 } |
| 498 |
| 499 BOOL AttachMenu(HMENU hMenu) |
| 500 { |
| 501 ATLASSERT(::IsWindow(m_hWnd)); |
| 502 ATLASSERT(hMenu == NULL || ::IsMenu(hMenu)); |
| 503 if(hMenu != NULL && !::IsMenu(hMenu)) |
| 504 return FALSE; |
| 505 |
| 506 #if _WTL_CMDBAR_VISTA_MENUS |
| 507 // remove Vista bitmaps if used |
| 508 if(m_bVistaMenus && (m_hMenu != NULL)) |
| 509 { |
| 510 T* pT = static_cast<T*>(this); |
| 511 pT->_RemoveVistaBitmapsFromMenu(); |
| 512 } |
| 513 #endif // _WTL_CMDBAR_VISTA_MENUS |
| 514 |
| 515 // destroy old menu, if needed, and set new one |
| 516 if(m_hMenu != NULL && (m_dwExtendedStyle & CBR_EX_SHAREMENU) ==
0) |
| 517 ::DestroyMenu(m_hMenu); |
| 518 |
| 519 m_hMenu = hMenu; |
| 520 |
| 521 if(m_bAttachedMenu) // Nothing else in this mode |
| 522 return TRUE; |
| 523 |
| 524 // Build buttons according to menu |
| 525 SetRedraw(FALSE); |
| 526 |
| 527 // Clear all buttons |
| 528 int nCount = GetButtonCount(); |
| 529 for(int i = 0; i < nCount; i++) |
| 530 ATLVERIFY(DeleteButton(0) != FALSE); |
| 531 |
| 532 // Add buttons for each menu item |
| 533 if(m_hMenu != NULL) |
| 534 { |
| 535 int nItems = ::GetMenuItemCount(m_hMenu); |
| 536 |
| 537 T* pT = static_cast<T*>(this); |
| 538 pT; // avoid level 4 warning |
| 539 TCHAR szString[pT->_nMaxMenuItemTextLength]; |
| 540 for(int i = 0; i < nItems; i++) |
| 541 { |
| 542 CMenuItemInfo mii; |
| 543 mii.fMask = MIIM_TYPE | MIIM_STATE | MIIM_SUBMEN
U; |
| 544 mii.fType = MFT_STRING; |
| 545 mii.dwTypeData = szString; |
| 546 mii.cch = pT->_nMaxMenuItemTextLength; |
| 547 BOOL bRet = ::GetMenuItemInfo(m_hMenu, i, TRUE,
&mii); |
| 548 ATLASSERT(bRet); |
| 549 // If we have more than the buffer, we assume we
have bitmaps bits |
| 550 if(lstrlen(szString) > pT->_nMaxMenuItemTextLeng
th - 1) |
| 551 { |
| 552 mii.fType = MFT_BITMAP; |
| 553 ::SetMenuItemInfo(m_hMenu, i, TRUE, &mii
); |
| 554 szString[0] = 0; |
| 555 } |
| 556 |
| 557 // NOTE: Command Bar currently supports only dro
p-down menu items |
| 558 ATLASSERT(mii.hSubMenu != NULL); |
| 559 |
| 560 TBBUTTON btn = { 0 }; |
| 561 btn.iBitmap = 0; |
| 562 btn.idCommand = i; |
| 563 btn.fsState = (BYTE)(((mii.fState & MFS_DISABLED
) == 0) ? TBSTATE_ENABLED : 0); |
| 564 btn.fsStyle = TBSTYLE_BUTTON | TBSTYLE_AUTOSIZE
| TBSTYLE_DROPDOWN; |
| 565 btn.dwData = 0; |
| 566 btn.iString = 0; |
| 567 |
| 568 bRet = InsertButton(-1, &btn); |
| 569 ATLASSERT(bRet); |
| 570 |
| 571 TBBUTTONINFO bi = { 0 }; |
| 572 bi.cbSize = sizeof(TBBUTTONINFO); |
| 573 bi.dwMask = TBIF_TEXT; |
| 574 bi.pszText = szString; |
| 575 |
| 576 bRet = SetButtonInfo(i, &bi); |
| 577 ATLASSERT(bRet); |
| 578 } |
| 579 } |
| 580 |
| 581 SetRedraw(TRUE); |
| 582 Invalidate(); |
| 583 UpdateWindow(); |
| 584 |
| 585 return TRUE; |
| 586 } |
| 587 |
| 588 BOOL LoadImages(ATL::_U_STRINGorID image) |
| 589 { |
| 590 return _LoadImagesHelper(image, false); |
| 591 } |
| 592 |
| 593 BOOL LoadMappedImages(UINT nIDImage, UINT nFlags = 0, LPCOLORMAP lpColor
Map = NULL, int nMapSize = 0) |
| 594 { |
| 595 return _LoadImagesHelper(nIDImage, true, nFlags , lpColorMap, nM
apSize); |
| 596 } |
| 597 |
| 598 BOOL _LoadImagesHelper(ATL::_U_STRINGorID image, bool bMapped, UINT nFla
gs = 0, LPCOLORMAP lpColorMap = NULL, int nMapSize = 0) |
| 599 { |
| 600 ATLASSERT(::IsWindow(m_hWnd)); |
| 601 HINSTANCE hInstance = ModuleHelper::GetResourceInstance(); |
| 602 |
| 603 HRSRC hRsrc = ::FindResource(hInstance, image.m_lpstr, (LPTSTR)R
T_TOOLBAR); |
| 604 if(hRsrc == NULL) |
| 605 return FALSE; |
| 606 |
| 607 HGLOBAL hGlobal = ::LoadResource(hInstance, hRsrc); |
| 608 if(hGlobal == NULL) |
| 609 return FALSE; |
| 610 |
| 611 _ToolBarData* pData = (_ToolBarData*)::LockResource(hGlobal); |
| 612 if(pData == NULL) |
| 613 return FALSE; |
| 614 ATLASSERT(pData->wVersion == 1); |
| 615 |
| 616 WORD* pItems = pData->items(); |
| 617 int nItems = pData->wItemCount; |
| 618 |
| 619 // Set internal data |
| 620 SetImageSize(pData->wWidth, pData->wHeight); |
| 621 |
| 622 // Create image list if needed |
| 623 if(m_hImageList == NULL) |
| 624 { |
| 625 // Check if the bitmap is 32-bit (alpha channel) bitmap
(valid for Windows XP only) |
| 626 T* pT = static_cast<T*>(this); |
| 627 m_bAlphaImages = AtlIsAlphaBitmapResource(image); |
| 628 |
| 629 if(!pT->CreateInternalImageList(pData->wItemCount)) |
| 630 return FALSE; |
| 631 } |
| 632 |
| 633 #if _WTL_CMDBAR_VISTA_MENUS |
| 634 int nOldImageCount = ::ImageList_GetImageCount(m_hImageList); |
| 635 #endif // _WTL_CMDBAR_VISTA_MENUS |
| 636 |
| 637 // Add bitmap to our image list |
| 638 CBitmap bmp; |
| 639 if(bMapped) |
| 640 { |
| 641 ATLASSERT(HIWORD(PtrToUlong(image.m_lpstr)) == 0); //
if mapped, must be a numeric ID |
| 642 int nIDImage = (int)(short)LOWORD(PtrToUlong(image.m_lps
tr)); |
| 643 bmp.LoadMappedBitmap(nIDImage, (WORD)nFlags, lpColorMap,
nMapSize); |
| 644 } |
| 645 else |
| 646 { |
| 647 if(m_bAlphaImages) |
| 648 bmp = (HBITMAP)::LoadImage(ModuleHelper::GetReso
urceInstance(), image.m_lpstr, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION | LR_DEFA
ULTSIZE); |
| 649 else |
| 650 bmp.LoadBitmap(image.m_lpstr); |
| 651 } |
| 652 ATLASSERT(bmp.m_hBitmap != NULL); |
| 653 if(bmp.m_hBitmap == NULL) |
| 654 return FALSE; |
| 655 if(::ImageList_AddMasked(m_hImageList, bmp, m_clrMask) == -1) |
| 656 return FALSE; |
| 657 |
| 658 // Fill the array with command IDs |
| 659 for(int i = 0; i < nItems; i++) |
| 660 { |
| 661 if(pItems[i] != 0) |
| 662 m_arrCommand.Add(pItems[i]); |
| 663 } |
| 664 |
| 665 int nImageCount = ::ImageList_GetImageCount(m_hImageList); |
| 666 ATLASSERT(nImageCount == m_arrCommand.GetSize()); |
| 667 if(nImageCount != m_arrCommand.GetSize()) |
| 668 return FALSE; |
| 669 |
| 670 #if _WTL_CMDBAR_VISTA_MENUS |
| 671 if(RunTimeHelper::IsVista()) |
| 672 { |
| 673 T* pT = static_cast<T*>(this); |
| 674 pT->_AddVistaBitmapsFromImageList(nOldImageCount, nImage
Count - nOldImageCount); |
| 675 ATLASSERT(nImageCount == m_arrVistaBitmap.GetSize()); |
| 676 } |
| 677 #endif // _WTL_CMDBAR_VISTA_MENUS |
| 678 |
| 679 return TRUE; |
| 680 } |
| 681 |
| 682 BOOL AddBitmap(ATL::_U_STRINGorID bitmap, int nCommandID) |
| 683 { |
| 684 ATLASSERT(::IsWindow(m_hWnd)); |
| 685 CBitmap bmp; |
| 686 bmp.LoadBitmap(bitmap.m_lpstr); |
| 687 if(bmp.m_hBitmap == NULL) |
| 688 return FALSE; |
| 689 return AddBitmap(bmp, nCommandID); |
| 690 } |
| 691 |
| 692 BOOL AddBitmap(HBITMAP hBitmap, UINT nCommandID) |
| 693 { |
| 694 ATLASSERT(::IsWindow(m_hWnd)); |
| 695 T* pT = static_cast<T*>(this); |
| 696 // Create image list if it doesn't exist |
| 697 if(m_hImageList == NULL) |
| 698 { |
| 699 if(!pT->CreateInternalImageList(1)) |
| 700 return FALSE; |
| 701 } |
| 702 // check bitmap size |
| 703 CBitmapHandle bmp = hBitmap; |
| 704 SIZE size = { 0, 0 }; |
| 705 bmp.GetSize(size); |
| 706 if(size.cx != m_szBitmap.cx || size.cy != m_szBitmap.cy) |
| 707 { |
| 708 ATLASSERT(FALSE); // must match size! |
| 709 return FALSE; |
| 710 } |
| 711 // add bitmap |
| 712 int nRet = ::ImageList_AddMasked(m_hImageList, hBitmap, m_clrMas
k); |
| 713 if(nRet == -1) |
| 714 return FALSE; |
| 715 BOOL bRet = m_arrCommand.Add((WORD)nCommandID); |
| 716 ATLASSERT(::ImageList_GetImageCount(m_hImageList) == m_arrComman
d.GetSize()); |
| 717 #if _WTL_CMDBAR_VISTA_MENUS |
| 718 if(RunTimeHelper::IsVista()) |
| 719 { |
| 720 pT->_AddVistaBitmapFromImageList(m_arrCommand.GetSize()
- 1); |
| 721 ATLASSERT(m_arrVistaBitmap.GetSize() == m_arrCommand.Get
Size()); |
| 722 } |
| 723 #endif // _WTL_CMDBAR_VISTA_MENUS |
| 724 return bRet; |
| 725 } |
| 726 |
| 727 BOOL AddIcon(ATL::_U_STRINGorID icon, UINT nCommandID) |
| 728 { |
| 729 ATLASSERT(::IsWindow(m_hWnd)); |
| 730 HICON hIcon = ::LoadIcon(ModuleHelper::GetResourceInstance(), ic
on.m_lpstr); |
| 731 if(hIcon == NULL) |
| 732 return FALSE; |
| 733 return AddIcon(hIcon, nCommandID); |
| 734 } |
| 735 |
| 736 BOOL AddIcon(HICON hIcon, UINT nCommandID) |
| 737 { |
| 738 ATLASSERT(::IsWindow(m_hWnd)); |
| 739 T* pT = static_cast<T*>(this); |
| 740 // create image list if it doesn't exist |
| 741 if(m_hImageList == NULL) |
| 742 { |
| 743 if(!pT->CreateInternalImageList(1)) |
| 744 return FALSE; |
| 745 } |
| 746 |
| 747 int nRet = ::ImageList_AddIcon(m_hImageList, hIcon); |
| 748 if(nRet == -1) |
| 749 return FALSE; |
| 750 BOOL bRet = m_arrCommand.Add((WORD)nCommandID); |
| 751 ATLASSERT(::ImageList_GetImageCount(m_hImageList) == m_arrComman
d.GetSize()); |
| 752 #if _WTL_CMDBAR_VISTA_MENUS |
| 753 if(RunTimeHelper::IsVista()) |
| 754 { |
| 755 pT->_AddVistaBitmapFromImageList(m_arrCommand.GetSize()
- 1); |
| 756 ATLASSERT(m_arrVistaBitmap.GetSize() == m_arrCommand.Get
Size()); |
| 757 } |
| 758 #endif // _WTL_CMDBAR_VISTA_MENUS |
| 759 return bRet; |
| 760 } |
| 761 |
| 762 BOOL ReplaceBitmap(ATL::_U_STRINGorID bitmap, int nCommandID) |
| 763 { |
| 764 ATLASSERT(::IsWindow(m_hWnd)); |
| 765 CBitmap bmp; |
| 766 bmp.LoadBitmap(bitmap.m_lpstr); |
| 767 if(bmp.m_hBitmap == NULL) |
| 768 return FALSE; |
| 769 return ReplaceBitmap(bmp, nCommandID); |
| 770 } |
| 771 |
| 772 BOOL ReplaceBitmap(HBITMAP hBitmap, UINT nCommandID) |
| 773 { |
| 774 ATLASSERT(::IsWindow(m_hWnd)); |
| 775 BOOL bRet = FALSE; |
| 776 for(int i = 0; i < m_arrCommand.GetSize(); i++) |
| 777 { |
| 778 if(m_arrCommand[i] == nCommandID) |
| 779 { |
| 780 bRet = ::ImageList_Remove(m_hImageList, i); |
| 781 if(bRet) |
| 782 { |
| 783 m_arrCommand.RemoveAt(i); |
| 784 #if _WTL_CMDBAR_VISTA_MENUS |
| 785 if(RunTimeHelper::IsVista()) |
| 786 { |
| 787 if(m_arrVistaBitmap[i] != NULL) |
| 788 ::DeleteObject(m_arrVist
aBitmap[i]); |
| 789 m_arrVistaBitmap.RemoveAt(i); |
| 790 } |
| 791 #endif // _WTL_CMDBAR_VISTA_MENUS |
| 792 } |
| 793 break; |
| 794 } |
| 795 } |
| 796 if(bRet) |
| 797 bRet = AddBitmap(hBitmap, nCommandID); |
| 798 return bRet; |
| 799 } |
| 800 |
| 801 BOOL ReplaceIcon(ATL::_U_STRINGorID icon, UINT nCommandID) |
| 802 { |
| 803 ATLASSERT(::IsWindow(m_hWnd)); |
| 804 HICON hIcon = ::LoadIcon(ModuleHelper::GetResourceInstance(), ic
on.m_lpstr); |
| 805 if(hIcon == NULL) |
| 806 return FALSE; |
| 807 return ReplaceIcon(hIcon, nCommandID); |
| 808 } |
| 809 |
| 810 BOOL ReplaceIcon(HICON hIcon, UINT nCommandID) |
| 811 { |
| 812 ATLASSERT(::IsWindow(m_hWnd)); |
| 813 BOOL bRet = FALSE; |
| 814 for(int i = 0; i < m_arrCommand.GetSize(); i++) |
| 815 { |
| 816 if(m_arrCommand[i] == nCommandID) |
| 817 { |
| 818 bRet = (::ImageList_ReplaceIcon(m_hImageList, i,
hIcon) != -1); |
| 819 #if _WTL_CMDBAR_VISTA_MENUS |
| 820 if(RunTimeHelper::IsVista() && bRet != FALSE) |
| 821 { |
| 822 T* pT = static_cast<T*>(this); |
| 823 pT->_ReplaceVistaBitmapFromImageList(i); |
| 824 } |
| 825 #endif // _WTL_CMDBAR_VISTA_MENUS |
| 826 break; |
| 827 } |
| 828 } |
| 829 return bRet; |
| 830 } |
| 831 |
| 832 BOOL RemoveImage(int nCommandID) |
| 833 { |
| 834 ATLASSERT(::IsWindow(m_hWnd)); |
| 835 |
| 836 BOOL bRet = FALSE; |
| 837 for(int i = 0; i < m_arrCommand.GetSize(); i++) |
| 838 { |
| 839 if(m_arrCommand[i] == nCommandID) |
| 840 { |
| 841 bRet = ::ImageList_Remove(m_hImageList, i); |
| 842 if(bRet) |
| 843 { |
| 844 m_arrCommand.RemoveAt(i); |
| 845 #if _WTL_CMDBAR_VISTA_MENUS |
| 846 if(RunTimeHelper::IsVista()) |
| 847 { |
| 848 if(m_arrVistaBitmap[i] != NULL) |
| 849 ::DeleteObject(m_arrVist
aBitmap[i]); |
| 850 m_arrVistaBitmap.RemoveAt(i); |
| 851 } |
| 852 #endif // _WTL_CMDBAR_VISTA_MENUS |
| 853 } |
| 854 break; |
| 855 } |
| 856 } |
| 857 return bRet; |
| 858 } |
| 859 |
| 860 BOOL RemoveAllImages() |
| 861 { |
| 862 ATLASSERT(::IsWindow(m_hWnd)); |
| 863 |
| 864 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Removing all images\n")); |
| 865 BOOL bRet = ::ImageList_RemoveAll(m_hImageList); |
| 866 if(bRet) |
| 867 { |
| 868 m_arrCommand.RemoveAll(); |
| 869 #if _WTL_CMDBAR_VISTA_MENUS |
| 870 for(int i = 0; i < m_arrVistaBitmap.GetSize(); i++) |
| 871 { |
| 872 if(m_arrVistaBitmap[i] != NULL) |
| 873 ::DeleteObject(m_arrVistaBitmap[i]); |
| 874 } |
| 875 m_arrVistaBitmap.RemoveAll(); |
| 876 #endif // _WTL_CMDBAR_VISTA_MENUS |
| 877 } |
| 878 return bRet; |
| 879 } |
| 880 |
| 881 BOOL TrackPopupMenu(HMENU hMenu, UINT uFlags, int x, int y, LPTPMPARAMS
lpParams = NULL) |
| 882 { |
| 883 ATLASSERT(::IsWindow(m_hWnd)); |
| 884 ATLASSERT(::IsMenu(hMenu)); |
| 885 if(!::IsMenu(hMenu)) |
| 886 return FALSE; |
| 887 m_bContextMenu = true; |
| 888 if(m_bUseKeyboardCues) |
| 889 m_bShowKeyboardCues = m_bKeyboardInput; |
| 890 T* pT = static_cast<T*>(this); |
| 891 return pT->DoTrackPopupMenu(hMenu, uFlags, x, y, lpParams); |
| 892 } |
| 893 |
| 894 BOOL SetMDIClient(HWND /*hWndMDIClient*/) |
| 895 { |
| 896 // Use CMDICommandBarCtrl for MDI support |
| 897 ATLASSERT(FALSE); |
| 898 return FALSE; |
| 899 } |
| 900 |
| 901 // Message map and handlers |
| 902 BEGIN_MSG_MAP(CCommandBarCtrlImpl) |
| 903 MESSAGE_HANDLER(WM_CREATE, OnCreate) |
| 904 MESSAGE_HANDLER(WM_DESTROY, OnDestroy) |
| 905 MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground) |
| 906 MESSAGE_HANDLER(WM_INITMENU, OnInitMenu) |
| 907 MESSAGE_HANDLER(WM_INITMENUPOPUP, OnInitMenuPopup) |
| 908 MESSAGE_HANDLER(WM_MENUSELECT, OnMenuSelect) |
| 909 MESSAGE_HANDLER(GetAutoPopupMessage(), OnInternalAutoPopup) |
| 910 MESSAGE_HANDLER(GetGetBarMessage(), OnInternalGetBar) |
| 911 MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange) |
| 912 MESSAGE_HANDLER(WM_MENUCHAR, OnMenuChar) |
| 913 |
| 914 MESSAGE_HANDLER(WM_KEYDOWN, OnKeyDown) |
| 915 MESSAGE_HANDLER(WM_KEYUP, OnKeyUp) |
| 916 MESSAGE_HANDLER(WM_CHAR, OnChar) |
| 917 MESSAGE_HANDLER(WM_SYSKEYDOWN, OnSysKeyDown) |
| 918 MESSAGE_HANDLER(WM_SYSKEYUP, OnSysKeyUp) |
| 919 MESSAGE_HANDLER(WM_SYSCHAR, OnSysChar) |
| 920 // public API handlers - these stay to support chevrons in atlframe.h |
| 921 MESSAGE_HANDLER(CBRM_GETMENU, OnAPIGetMenu) |
| 922 MESSAGE_HANDLER(CBRM_TRACKPOPUPMENU, OnAPITrackPopupMenu) |
| 923 MESSAGE_HANDLER(CBRM_GETCMDBAR, OnAPIGetCmdBar) |
| 924 |
| 925 MESSAGE_HANDLER(WM_DRAWITEM, OnDrawItem) |
| 926 MESSAGE_HANDLER(WM_MEASUREITEM, OnMeasureItem) |
| 927 |
| 928 MESSAGE_HANDLER(WM_FORWARDMSG, OnForwardMsg) |
| 929 ALT_MSG_MAP(1) // Parent window messages |
| 930 NOTIFY_CODE_HANDLER(TBN_HOTITEMCHANGE, OnParentHotItemChange) |
| 931 NOTIFY_CODE_HANDLER(TBN_DROPDOWN, OnParentDropDown) |
| 932 MESSAGE_HANDLER(WM_INITMENUPOPUP, OnParentInitMenuPopup) |
| 933 MESSAGE_HANDLER(GetGetBarMessage(), OnParentInternalGetBar) |
| 934 MESSAGE_HANDLER(WM_SYSCOMMAND, OnParentSysCommand) |
| 935 MESSAGE_HANDLER(CBRM_GETMENU, OnParentAPIGetMenu) |
| 936 MESSAGE_HANDLER(WM_MENUCHAR, OnParentMenuChar) |
| 937 MESSAGE_HANDLER(CBRM_TRACKPOPUPMENU, OnParentAPITrackPopupMenu) |
| 938 MESSAGE_HANDLER(CBRM_GETCMDBAR, OnParentAPIGetCmdBar) |
| 939 MESSAGE_HANDLER(WM_SETTINGCHANGE, OnParentSettingChange) |
| 940 |
| 941 MESSAGE_HANDLER(WM_DRAWITEM, OnParentDrawItem) |
| 942 MESSAGE_HANDLER(WM_MEASUREITEM, OnParentMeasureItem) |
| 943 |
| 944 MESSAGE_HANDLER(WM_ACTIVATE, OnParentActivate) |
| 945 NOTIFY_CODE_HANDLER(NM_CUSTOMDRAW, OnParentCustomDraw) |
| 946 ALT_MSG_MAP(2) // MDI client window messages |
| 947 // Use CMDICommandBarCtrl for MDI support |
| 948 ALT_MSG_MAP(3) // Message hook messages |
| 949 MESSAGE_HANDLER(WM_MOUSEMOVE, OnHookMouseMove) |
| 950 MESSAGE_HANDLER(WM_SYSKEYDOWN, OnHookSysKeyDown) |
| 951 MESSAGE_HANDLER(WM_SYSKEYUP, OnHookSysKeyUp) |
| 952 MESSAGE_HANDLER(WM_SYSCHAR, OnHookSysChar) |
| 953 MESSAGE_HANDLER(WM_KEYDOWN, OnHookKeyDown) |
| 954 MESSAGE_HANDLER(WM_NEXTMENU, OnHookNextMenu) |
| 955 MESSAGE_HANDLER(WM_CHAR, OnHookChar) |
| 956 END_MSG_MAP() |
| 957 |
| 958 LRESULT OnForwardMsg(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BO
OL& /*bHandled*/) |
| 959 { |
| 960 LPMSG pMsg = (LPMSG)lParam; |
| 961 if(pMsg->message >= WM_MOUSEFIRST && pMsg->message <= WM_MOUSELA
ST) |
| 962 m_bKeyboardInput = false; |
| 963 else if(pMsg->message >= WM_KEYFIRST && pMsg->message <= WM_KEYL
AST) |
| 964 m_bKeyboardInput = true; |
| 965 LRESULT lRet = 0; |
| 966 ProcessWindowMessage(pMsg->hwnd, pMsg->message, pMsg->wParam, pM
sg->lParam, lRet, 3); |
| 967 return lRet; |
| 968 } |
| 969 |
| 970 LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandl
ed*/) |
| 971 { |
| 972 // Let the toolbar initialize itself |
| 973 LRESULT lRet = DefWindowProc(uMsg, wParam, lParam); |
| 974 // get and use system settings |
| 975 T* pT = static_cast<T*>(this); |
| 976 pT->GetSystemSettings(); |
| 977 // Parent init |
| 978 ATL::CWindow wndParent = GetParent(); |
| 979 ATL::CWindow wndTopLevelParent = wndParent.GetTopLevelParent(); |
| 980 m_wndParent.SubclassWindow(wndTopLevelParent); |
| 981 // Toolbar Init |
| 982 SetButtonStructSize(); |
| 983 SetImageList(NULL); |
| 984 |
| 985 // Create message hook if needed |
| 986 CWindowCreateCriticalSectionLock lock; |
| 987 if(FAILED(lock.Lock())) |
| 988 { |
| 989 ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock crit
ical section in CCommandBarCtrlImpl::OnCreate.\n")); |
| 990 ATLASSERT(FALSE); |
| 991 return -1; |
| 992 } |
| 993 |
| 994 if(s_pmapMsgHook == NULL) |
| 995 { |
| 996 ATLTRY(s_pmapMsgHook = new CMsgHookMap); |
| 997 ATLASSERT(s_pmapMsgHook != NULL); |
| 998 } |
| 999 |
| 1000 if(s_pmapMsgHook != NULL) |
| 1001 { |
| 1002 DWORD dwThreadID = ::GetCurrentThreadId(); |
| 1003 _MsgHookData* pData = s_pmapMsgHook->Lookup(dwThreadID); |
| 1004 if(pData == NULL) |
| 1005 { |
| 1006 ATLTRY(pData = new _MsgHookData); |
| 1007 ATLASSERT(pData != NULL); |
| 1008 HHOOK hMsgHook = ::SetWindowsHookEx(WH_GETMESSAG
E, MessageHookProc, ModuleHelper::GetModuleInstance(), dwThreadID); |
| 1009 ATLASSERT(hMsgHook != NULL); |
| 1010 if(pData != NULL && hMsgHook != NULL) |
| 1011 { |
| 1012 pData->hMsgHook = hMsgHook; |
| 1013 pData->dwUsage = 1; |
| 1014 BOOL bRet = s_pmapMsgHook->Add(dwThreadI
D, pData); |
| 1015 bRet; |
| 1016 ATLASSERT(bRet); |
| 1017 } |
| 1018 } |
| 1019 else |
| 1020 { |
| 1021 (pData->dwUsage)++; |
| 1022 } |
| 1023 } |
| 1024 lock.Unlock(); |
| 1025 |
| 1026 // Get layout |
| 1027 #if (WINVER >= 0x0500) |
| 1028 m_bLayoutRTL = ((GetExStyle() & WS_EX_LAYOUTRTL) != 0); |
| 1029 #endif // (WINVER >= 0x0500) |
| 1030 |
| 1031 return lRet; |
| 1032 } |
| 1033 |
| 1034 LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHand
led*/) |
| 1035 { |
| 1036 LRESULT lRet = DefWindowProc(uMsg, wParam, lParam); |
| 1037 |
| 1038 #if _WTL_CMDBAR_VISTA_MENUS |
| 1039 if(m_bVistaMenus && (m_hMenu != NULL)) |
| 1040 { |
| 1041 T* pT = static_cast<T*>(this); |
| 1042 pT->_RemoveVistaBitmapsFromMenu(); |
| 1043 } |
| 1044 |
| 1045 for(int i = 0; i < m_arrVistaBitmap.GetSize(); i++) |
| 1046 { |
| 1047 if(m_arrVistaBitmap[i] != NULL) |
| 1048 ::DeleteObject(m_arrVistaBitmap[i]); |
| 1049 } |
| 1050 #endif // _WTL_CMDBAR_VISTA_MENUS |
| 1051 |
| 1052 if(m_bAttachedMenu) // nothing to do in this mode |
| 1053 return lRet; |
| 1054 |
| 1055 CWindowCreateCriticalSectionLock lock; |
| 1056 if(FAILED(lock.Lock())) |
| 1057 { |
| 1058 ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock crit
ical section in CCommandBarCtrlImpl::OnDestroy.\n")); |
| 1059 ATLASSERT(FALSE); |
| 1060 return lRet; |
| 1061 } |
| 1062 |
| 1063 if(s_pmapMsgHook != NULL) |
| 1064 { |
| 1065 DWORD dwThreadID = ::GetCurrentThreadId(); |
| 1066 _MsgHookData* pData = s_pmapMsgHook->Lookup(dwThreadID); |
| 1067 if(pData != NULL) |
| 1068 { |
| 1069 (pData->dwUsage)--; |
| 1070 if(pData->dwUsage == 0) |
| 1071 { |
| 1072 BOOL bRet = ::UnhookWindowsHookEx(pData-
>hMsgHook); |
| 1073 ATLASSERT(bRet); |
| 1074 bRet = s_pmapMsgHook->Remove(dwThreadID)
; |
| 1075 ATLASSERT(bRet); |
| 1076 if(bRet) |
| 1077 delete pData; |
| 1078 } |
| 1079 |
| 1080 if(s_pmapMsgHook->GetSize() == 0) |
| 1081 { |
| 1082 delete s_pmapMsgHook; |
| 1083 s_pmapMsgHook = NULL; |
| 1084 } |
| 1085 } |
| 1086 } |
| 1087 |
| 1088 lock.Unlock(); |
| 1089 |
| 1090 return lRet; |
| 1091 } |
| 1092 |
| 1093 LRESULT OnKeyDown(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHa
ndled) |
| 1094 { |
| 1095 #ifdef _CMDBAR_EXTRA_TRACE |
| 1096 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnKeyDown\n")); |
| 1097 #endif |
| 1098 bHandled = FALSE; |
| 1099 // Simulate Alt+Space for the parent |
| 1100 if(wParam == VK_SPACE) |
| 1101 { |
| 1102 m_wndParent.PostMessage(WM_SYSKEYDOWN, wParam, lParam |
(1 << 29)); |
| 1103 bHandled = TRUE; |
| 1104 } |
| 1105 #if (_WIN32_IE >= 0x0500) |
| 1106 else if(wParam == VK_LEFT || wParam == VK_RIGHT) |
| 1107 { |
| 1108 WPARAM wpNext = m_bLayoutRTL ? VK_LEFT : VK_RIGHT; |
| 1109 |
| 1110 if(!m_bMenuActive) |
| 1111 { |
| 1112 T* pT = static_cast<T*>(this); |
| 1113 int nBtn = GetHotItem(); |
| 1114 int nNextBtn = (wParam == wpNext) ? pT->GetNextM
enuItem(nBtn) : pT->GetPreviousMenuItem(nBtn); |
| 1115 if(nNextBtn == -2) |
| 1116 { |
| 1117 SetHotItem(-1); |
| 1118 if(pT->DisplayChevronMenu()) |
| 1119 bHandled = TRUE; |
| 1120 } |
| 1121 } |
| 1122 } |
| 1123 #endif // (_WIN32_IE >= 0x0500) |
| 1124 return 0; |
| 1125 } |
| 1126 |
| 1127 LRESULT OnKeyUp(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& b
Handled) |
| 1128 { |
| 1129 #ifdef _CMDBAR_EXTRA_TRACE |
| 1130 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnKeyUp\n")); |
| 1131 #endif |
| 1132 if(wParam != VK_SPACE) |
| 1133 bHandled = FALSE; |
| 1134 return 0; |
| 1135 } |
| 1136 |
| 1137 LRESULT OnChar(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bH
andled) |
| 1138 { |
| 1139 #ifdef _CMDBAR_EXTRA_TRACE |
| 1140 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnChar\n")); |
| 1141 #endif |
| 1142 if(wParam != VK_SPACE) |
| 1143 bHandled = FALSE; |
| 1144 else |
| 1145 return 0; |
| 1146 // Security |
| 1147 if(!m_wndParent.IsWindowEnabled() || ::GetFocus() != m_hWnd) |
| 1148 return 0; |
| 1149 |
| 1150 // Handle mnemonic press when we have focus |
| 1151 int nBtn = 0; |
| 1152 if(wParam != VK_RETURN && !MapAccelerator((TCHAR)LOWORD(wParam),
nBtn)) |
| 1153 { |
| 1154 #if (_WIN32_IE >= 0x0500) |
| 1155 if((TCHAR)LOWORD(wParam) != _chChevronShortcut) |
| 1156 #endif // (_WIN32_IE >= 0x0500) |
| 1157 ::MessageBeep(0); |
| 1158 } |
| 1159 else |
| 1160 { |
| 1161 #if (_WIN32_IE >= 0x0500) |
| 1162 RECT rcClient = { 0 }; |
| 1163 GetClientRect(&rcClient); |
| 1164 RECT rcBtn = { 0 }; |
| 1165 GetItemRect(nBtn, &rcBtn); |
| 1166 TBBUTTON tbb = { 0 }; |
| 1167 GetButton(nBtn, &tbb); |
| 1168 if((tbb.fsState & TBSTATE_ENABLED) != 0 && (tbb.fsState
& TBSTATE_HIDDEN) == 0 && rcBtn.right <= rcClient.right) |
| 1169 { |
| 1170 #endif // (_WIN32_IE >= 0x0500) |
| 1171 PostMessage(WM_KEYDOWN, VK_DOWN, 0L); |
| 1172 if(wParam != VK_RETURN) |
| 1173 SetHotItem(nBtn); |
| 1174 #if (_WIN32_IE >= 0x0500) |
| 1175 } |
| 1176 else |
| 1177 { |
| 1178 ::MessageBeep(0); |
| 1179 bHandled = TRUE; |
| 1180 } |
| 1181 #endif // (_WIN32_IE >= 0x0500) |
| 1182 } |
| 1183 return 0; |
| 1184 } |
| 1185 |
| 1186 LRESULT OnSysKeyDown(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/
, BOOL& bHandled) |
| 1187 { |
| 1188 #ifdef _CMDBAR_EXTRA_TRACE |
| 1189 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnSysKeyDown\n")); |
| 1190 #endif |
| 1191 bHandled = FALSE; |
| 1192 return 0; |
| 1193 } |
| 1194 |
| 1195 LRESULT OnSysKeyUp(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/,
BOOL& bHandled) |
| 1196 { |
| 1197 #ifdef _CMDBAR_EXTRA_TRACE |
| 1198 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnSysKeyUp\n")); |
| 1199 #endif |
| 1200 bHandled = FALSE; |
| 1201 return 0; |
| 1202 } |
| 1203 |
| 1204 LRESULT OnSysChar(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, B
OOL& bHandled) |
| 1205 { |
| 1206 #ifdef _CMDBAR_EXTRA_TRACE |
| 1207 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnSysChar\n")); |
| 1208 #endif |
| 1209 bHandled = FALSE; |
| 1210 return 0; |
| 1211 } |
| 1212 |
| 1213 LRESULT OnEraseBackground(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*
/, BOOL& bHandled) |
| 1214 { |
| 1215 if(m_bAttachedMenu || (m_dwExtendedStyle & CBR_EX_TRANSPARENT)) |
| 1216 { |
| 1217 bHandled = FALSE; |
| 1218 return 0; |
| 1219 } |
| 1220 |
| 1221 CDCHandle dc = (HDC)wParam; |
| 1222 RECT rect = { 0 }; |
| 1223 GetClientRect(&rect); |
| 1224 dc.FillRect(&rect, COLOR_MENU); |
| 1225 |
| 1226 return 1; // don't do the default erase |
| 1227 } |
| 1228 |
| 1229 LRESULT OnInitMenu(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/,
BOOL& bHandled) |
| 1230 { |
| 1231 int nIndex = GetHotItem(); |
| 1232 SendMessage(WM_MENUSELECT, MAKEWPARAM(nIndex, MF_POPUP|MF_HILITE
), (LPARAM)m_hMenu); |
| 1233 bHandled = FALSE; |
| 1234 return 1; |
| 1235 } |
| 1236 |
| 1237 LRESULT OnInitMenuPopup(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& b
Handled) |
| 1238 { |
| 1239 if((BOOL)HIWORD(lParam)) // System menu, do nothing |
| 1240 { |
| 1241 bHandled = FALSE; |
| 1242 return 1; |
| 1243 } |
| 1244 |
| 1245 if(!(m_bAttachedMenu || m_bMenuActive)) // Not attached or our
s, do nothing |
| 1246 { |
| 1247 bHandled = FALSE; |
| 1248 return 1; |
| 1249 } |
| 1250 |
| 1251 #ifdef _CMDBAR_EXTRA_TRACE |
| 1252 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnInitMenuPopup\n")); |
| 1253 #endif |
| 1254 // forward to the parent or subclassed window, so it can handle
update UI |
| 1255 LRESULT lRet = 0; |
| 1256 if(m_bAttachedMenu) |
| 1257 lRet = DefWindowProc(uMsg, wParam, (lParam || m_bContext
Menu) ? lParam : GetHotItem()); |
| 1258 else |
| 1259 lRet = m_wndParent.DefWindowProc(uMsg, wParam, (lParam |
| m_bContextMenu) ? lParam : GetHotItem()); |
| 1260 |
| 1261 #if _WTL_CMDBAR_VISTA_MENUS |
| 1262 // If Vista menus are active, just set bitmaps and return |
| 1263 if(m_bVistaMenus) |
| 1264 { |
| 1265 CMenuHandle menu = (HMENU)wParam; |
| 1266 ATLASSERT(menu.m_hMenu != NULL); |
| 1267 |
| 1268 for(int i = 0; i < menu.GetMenuItemCount(); i++) |
| 1269 { |
| 1270 WORD nID = (WORD)menu.GetMenuItemID(i); |
| 1271 int nIndex = m_arrCommand.Find(nID); |
| 1272 |
| 1273 CMenuItemInfo mii; |
| 1274 mii.fMask = MIIM_BITMAP; |
| 1275 mii.hbmpItem = (m_bImagesVisible && (nIndex != -
1)) ? m_arrVistaBitmap[nIndex] : NULL; |
| 1276 menu.SetMenuItemInfo(i, TRUE, &mii); |
| 1277 } |
| 1278 |
| 1279 return lRet; |
| 1280 } |
| 1281 #endif // _WTL_CMDBAR_VISTA_MENUS |
| 1282 |
| 1283 // Convert menu items to ownerdraw, add our data |
| 1284 if(m_bImagesVisible) |
| 1285 { |
| 1286 CMenuHandle menuPopup = (HMENU)wParam; |
| 1287 ATLASSERT(menuPopup.m_hMenu != NULL); |
| 1288 |
| 1289 T* pT = static_cast<T*>(this); |
| 1290 pT; // avoid level 4 warning |
| 1291 TCHAR szString[pT->_nMaxMenuItemTextLength]; |
| 1292 BOOL bRet = FALSE; |
| 1293 for(int i = 0; i < menuPopup.GetMenuItemCount(); i++) |
| 1294 { |
| 1295 CMenuItemInfo mii; |
| 1296 mii.cch = pT->_nMaxMenuItemTextLength; |
| 1297 mii.fMask = MIIM_CHECKMARKS | MIIM_DATA | MIIM_I
D | MIIM_STATE | MIIM_SUBMENU | MIIM_TYPE; |
| 1298 mii.dwTypeData = szString; |
| 1299 bRet = menuPopup.GetMenuItemInfo(i, TRUE, &mii); |
| 1300 ATLASSERT(bRet); |
| 1301 |
| 1302 if(!(mii.fType & MFT_OWNERDRAW)) // Not alread
y an ownerdraw item |
| 1303 { |
| 1304 mii.fMask = MIIM_DATA | MIIM_TYPE | MIIM
_STATE; |
| 1305 _MenuItemData* pMI = NULL; |
| 1306 ATLTRY(pMI = new _MenuItemData); |
| 1307 ATLASSERT(pMI != NULL); |
| 1308 if(pMI != NULL) |
| 1309 { |
| 1310 pMI->fType = mii.fType; |
| 1311 pMI->fState = mii.fState; |
| 1312 mii.fType |= MFT_OWNERDRAW; |
| 1313 pMI->iButton = -1; |
| 1314 for(int j = 0; j < m_arrCommand.
GetSize(); j++) |
| 1315 { |
| 1316 if(m_arrCommand[j] == mi
i.wID) |
| 1317 { |
| 1318 pMI->iButton = j
; |
| 1319 break; |
| 1320 } |
| 1321 } |
| 1322 int cchLen = lstrlen(szString) +
1; |
| 1323 pMI->lpstrText = NULL; |
| 1324 ATLTRY(pMI->lpstrText = new TCHA
R[cchLen]); |
| 1325 ATLASSERT(pMI->lpstrText != NULL
); |
| 1326 if(pMI->lpstrText != NULL) |
| 1327 SecureHelper::strcpy_x(p
MI->lpstrText, cchLen, szString); |
| 1328 mii.dwItemData = (ULONG_PTR)pMI; |
| 1329 bRet = menuPopup.SetMenuItemInfo
(i, TRUE, &mii); |
| 1330 ATLASSERT(bRet); |
| 1331 } |
| 1332 } |
| 1333 } |
| 1334 |
| 1335 // Add it to the list |
| 1336 m_stackMenuHandle.Push(menuPopup.m_hMenu); |
| 1337 } |
| 1338 |
| 1339 return lRet; |
| 1340 } |
| 1341 |
| 1342 LRESULT OnMenuSelect(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHan
dled) |
| 1343 { |
| 1344 if(!m_bAttachedMenu) // Not attached, do nothing, forward to p
arent |
| 1345 { |
| 1346 m_bPopupItem = (lParam != NULL) && ((HMENU)lParam != m_h
Menu) && (HIWORD(wParam) & MF_POPUP); |
| 1347 if(m_wndParent.IsWindow()) |
| 1348 m_wndParent.SendMessage(uMsg, wParam, lParam); |
| 1349 bHandled = FALSE; |
| 1350 return 1; |
| 1351 } |
| 1352 |
| 1353 // Check if a menu is closing, do a cleanup |
| 1354 if(HIWORD(wParam) == 0xFFFF && lParam == NULL) // Menu closing |
| 1355 { |
| 1356 #ifdef _CMDBAR_EXTRA_TRACE |
| 1357 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnMenuSelect - CLO
SING!!!!\n")); |
| 1358 #endif |
| 1359 ATLASSERT(m_stackMenuWnd.GetSize() == 0); |
| 1360 // Restore the menu items to the previous state for all
menus that were converted |
| 1361 if(m_bImagesVisible) |
| 1362 { |
| 1363 HMENU hMenu = NULL; |
| 1364 while((hMenu = m_stackMenuHandle.Pop()) != NULL) |
| 1365 { |
| 1366 CMenuHandle menuPopup = hMenu; |
| 1367 ATLASSERT(menuPopup.m_hMenu != NULL); |
| 1368 // Restore state and delete menu item da
ta |
| 1369 BOOL bRet = FALSE; |
| 1370 for(int i = 0; i < menuPopup.GetMenuItem
Count(); i++) |
| 1371 { |
| 1372 CMenuItemInfo mii; |
| 1373 mii.fMask = MIIM_DATA | MIIM_TYP
E; |
| 1374 bRet = menuPopup.GetMenuItemInfo
(i, TRUE, &mii); |
| 1375 ATLASSERT(bRet); |
| 1376 |
| 1377 _MenuItemData* pMI = (_MenuItemD
ata*)mii.dwItemData; |
| 1378 if(pMI != NULL && pMI->IsCmdBarM
enuItem()) |
| 1379 { |
| 1380 mii.fMask = MIIM_DATA |
MIIM_TYPE | MIIM_STATE; |
| 1381 mii.fType = pMI->fType; |
| 1382 mii.dwTypeData = pMI->lp
strText; |
| 1383 mii.cch = lstrlen(pMI->l
pstrText); |
| 1384 mii.dwItemData = NULL; |
| 1385 |
| 1386 bRet = menuPopup.SetMenu
ItemInfo(i, TRUE, &mii); |
| 1387 ATLASSERT(bRet); |
| 1388 |
| 1389 delete [] pMI->lpstrText
; |
| 1390 pMI->dwMagic = 0x6666; |
| 1391 delete pMI; |
| 1392 } |
| 1393 } |
| 1394 } |
| 1395 } |
| 1396 } |
| 1397 |
| 1398 bHandled = FALSE; |
| 1399 return 1; |
| 1400 } |
| 1401 |
| 1402 LRESULT OnInternalAutoPopup(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lPara
m*/, BOOL& /*bHandled*/) |
| 1403 { |
| 1404 int nIndex = (int)wParam; |
| 1405 T* pT = static_cast<T*>(this); |
| 1406 pT->DoPopupMenu(nIndex, false); |
| 1407 return 0; |
| 1408 } |
| 1409 |
| 1410 LRESULT OnInternalGetBar(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/
, BOOL& /*bHandled*/) |
| 1411 { |
| 1412 // Let's make sure we're not embedded in another process |
| 1413 if((LPVOID)wParam != NULL) |
| 1414 *((DWORD*)wParam) = GetCurrentProcessId(); |
| 1415 if(IsWindowVisible()) |
| 1416 return (LRESULT)static_cast<CCommandBarCtrlBase*>(this); |
| 1417 else |
| 1418 return NULL; |
| 1419 } |
| 1420 |
| 1421 LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/,
BOOL& /*bHandled*/) |
| 1422 { |
| 1423 #ifndef SPI_GETKEYBOARDCUES |
| 1424 const UINT SPI_SETKEYBOARDCUES = 0x100B; |
| 1425 #endif // !SPI_GETKEYBOARDCUES |
| 1426 #ifndef SPI_GETFLATMENU |
| 1427 const UINT SPI_SETFLATMENU = 0x1023; |
| 1428 #endif // !SPI_GETFLATMENU |
| 1429 |
| 1430 if(wParam == SPI_SETNONCLIENTMETRICS || wParam == SPI_SETKEYBOAR
DCUES || wParam == SPI_SETFLATMENU) |
| 1431 { |
| 1432 T* pT = static_cast<T*>(this); |
| 1433 pT->GetSystemSettings(); |
| 1434 } |
| 1435 |
| 1436 return 0; |
| 1437 } |
| 1438 |
| 1439 LRESULT OnWindowPosChanging(UINT uMsg, WPARAM wParam, LPARAM lParam, BOO
L& /*bHandled*/) |
| 1440 { |
| 1441 LRESULT lRet = DefWindowProc(uMsg, wParam, lParam); |
| 1442 |
| 1443 LPWINDOWPOS lpWP = (LPWINDOWPOS)lParam; |
| 1444 int cyMin = ::GetSystemMetrics(SM_CYMENU); |
| 1445 if(lpWP->cy < cyMin) |
| 1446 lpWP->cy = cyMin; |
| 1447 |
| 1448 return lRet; |
| 1449 } |
| 1450 |
| 1451 LRESULT OnMenuChar(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bH
andled) |
| 1452 { |
| 1453 #ifdef _CMDBAR_EXTRA_TRACE |
| 1454 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnMenuChar\n")); |
| 1455 #endif |
| 1456 bHandled = TRUE; |
| 1457 T* pT = static_cast<T*>(this); |
| 1458 |
| 1459 LRESULT lRet; |
| 1460 if(m_bMenuActive && LOWORD(wParam) != 0x0D) |
| 1461 lRet = 0; |
| 1462 else |
| 1463 lRet = MAKELRESULT(1, 1); |
| 1464 |
| 1465 if(m_bMenuActive && HIWORD(wParam) == MF_POPUP) |
| 1466 { |
| 1467 // Convert character to lower/uppercase and possibly Uni
code, using current keyboard layout |
| 1468 TCHAR ch = (TCHAR)LOWORD(wParam); |
| 1469 CMenuHandle menu = (HMENU)lParam; |
| 1470 int nCount = ::GetMenuItemCount(menu); |
| 1471 int nRetCode = MNC_EXECUTE; |
| 1472 BOOL bRet = FALSE; |
| 1473 TCHAR szString[pT->_nMaxMenuItemTextLength]; |
| 1474 WORD wMnem = 0; |
| 1475 bool bFound = false; |
| 1476 for(int i = 0; i < nCount; i++) |
| 1477 { |
| 1478 CMenuItemInfo mii; |
| 1479 mii.cch = pT->_nMaxMenuItemTextLength; |
| 1480 mii.fMask = MIIM_CHECKMARKS | MIIM_DATA | MIIM_I
D | MIIM_STATE | MIIM_SUBMENU | MIIM_TYPE; |
| 1481 mii.dwTypeData = szString; |
| 1482 bRet = menu.GetMenuItemInfo(i, TRUE, &mii); |
| 1483 if(!bRet || (mii.fType & MFT_SEPARATOR)) |
| 1484 continue; |
| 1485 _MenuItemData* pmd = (_MenuItemData*)mii.dwItemD
ata; |
| 1486 if(pmd != NULL && pmd->IsCmdBarMenuItem()) |
| 1487 { |
| 1488 LPTSTR p = pmd->lpstrText; |
| 1489 |
| 1490 if(p != NULL) |
| 1491 { |
| 1492 while(*p && *p != _T('&')) |
| 1493 p = ::CharNext(p); |
| 1494 if(p != NULL && *p) |
| 1495 { |
| 1496 DWORD dwP = MAKELONG(*(+
+p), 0); |
| 1497 DWORD dwC = MAKELONG(ch,
0); |
| 1498 if(::CharLower((LPTSTR)U
LongToPtr(dwP)) == ::CharLower((LPTSTR)ULongToPtr(dwC))) |
| 1499 { |
| 1500 if(!bFound) |
| 1501 { |
| 1502 wMnem =
(WORD)i; |
| 1503 bFound =
true; |
| 1504 } |
| 1505 else |
| 1506 { |
| 1507 nRetCode
= MNC_SELECT; |
| 1508 break; |
| 1509 } |
| 1510 } |
| 1511 } |
| 1512 } |
| 1513 } |
| 1514 } |
| 1515 if(bFound) |
| 1516 { |
| 1517 if(nRetCode == MNC_EXECUTE) |
| 1518 { |
| 1519 PostMessage(TB_SETHOTITEM, (WPARAM)-1, 0
L); |
| 1520 pT->GiveFocusBack(); |
| 1521 } |
| 1522 bHandled = TRUE; |
| 1523 lRet = MAKELRESULT(wMnem, nRetCode); |
| 1524 } |
| 1525 } |
| 1526 else if(!m_bMenuActive) |
| 1527 { |
| 1528 int nBtn = 0; |
| 1529 if(!MapAccelerator((TCHAR)LOWORD(wParam), nBtn)) |
| 1530 { |
| 1531 bHandled = FALSE; |
| 1532 PostMessage(TB_SETHOTITEM, (WPARAM)-1, 0L); |
| 1533 pT->GiveFocusBack(); |
| 1534 |
| 1535 #if (_WIN32_IE >= 0x0500) |
| 1536 // check if we should display chevron menu |
| 1537 if((TCHAR)LOWORD(wParam) == pT->_chChevronShortc
ut) |
| 1538 { |
| 1539 if(pT->DisplayChevronMenu()) |
| 1540 bHandled = TRUE; |
| 1541 } |
| 1542 #endif // (_WIN32_IE >= 0x0500) |
| 1543 } |
| 1544 else if(m_wndParent.IsWindowEnabled()) |
| 1545 { |
| 1546 #if (_WIN32_IE >= 0x0500) |
| 1547 RECT rcClient = { 0 }; |
| 1548 GetClientRect(&rcClient); |
| 1549 RECT rcBtn = { 0 }; |
| 1550 GetItemRect(nBtn, &rcBtn); |
| 1551 TBBUTTON tbb = { 0 }; |
| 1552 GetButton(nBtn, &tbb); |
| 1553 if((tbb.fsState & TBSTATE_ENABLED) != 0 && (tbb.
fsState & TBSTATE_HIDDEN) == 0 && rcBtn.right <= rcClient.right) |
| 1554 { |
| 1555 #endif // (_WIN32_IE >= 0x0500) |
| 1556 if(m_bUseKeyboardCues && !m_bShowKeyboar
dCues) |
| 1557 { |
| 1558 m_bAllowKeyboardCues = true; |
| 1559 ShowKeyboardCues(true); |
| 1560 } |
| 1561 pT->TakeFocus(); |
| 1562 PostMessage(WM_KEYDOWN, VK_DOWN, 0L); |
| 1563 SetHotItem(nBtn); |
| 1564 #if (_WIN32_IE >= 0x0500) |
| 1565 } |
| 1566 else |
| 1567 { |
| 1568 ::MessageBeep(0); |
| 1569 } |
| 1570 #endif // (_WIN32_IE >= 0x0500) |
| 1571 } |
| 1572 } |
| 1573 |
| 1574 return lRet; |
| 1575 } |
| 1576 |
| 1577 LRESULT OnDrawItem(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL
& bHandled) |
| 1578 { |
| 1579 LPDRAWITEMSTRUCT lpDrawItemStruct = (LPDRAWITEMSTRUCT)lParam; |
| 1580 _MenuItemData* pmd = (_MenuItemData*)lpDrawItemStruct->itemData; |
| 1581 if(lpDrawItemStruct->CtlType == ODT_MENU && pmd != NULL && pmd->
IsCmdBarMenuItem()) |
| 1582 { |
| 1583 T* pT = static_cast<T*>(this); |
| 1584 pT->DrawItem(lpDrawItemStruct); |
| 1585 } |
| 1586 else |
| 1587 { |
| 1588 bHandled = FALSE; |
| 1589 } |
| 1590 return (LRESULT)TRUE; |
| 1591 } |
| 1592 |
| 1593 LRESULT OnMeasureItem(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, B
OOL& bHandled) |
| 1594 { |
| 1595 LPMEASUREITEMSTRUCT lpMeasureItemStruct = (LPMEASUREITEMSTRUCT)l
Param; |
| 1596 _MenuItemData* pmd = (_MenuItemData*)lpMeasureItemStruct->itemDa
ta; |
| 1597 if(lpMeasureItemStruct->CtlType == ODT_MENU && pmd != NULL && pm
d->IsCmdBarMenuItem()) |
| 1598 { |
| 1599 T* pT = static_cast<T*>(this); |
| 1600 pT->MeasureItem(lpMeasureItemStruct); |
| 1601 } |
| 1602 else |
| 1603 { |
| 1604 bHandled = FALSE; |
| 1605 } |
| 1606 return (LRESULT)TRUE; |
| 1607 } |
| 1608 |
| 1609 // API message handlers |
| 1610 LRESULT OnAPIGetMenu(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/
, BOOL& /*bHandled*/) |
| 1611 { |
| 1612 return (LRESULT)m_hMenu; |
| 1613 } |
| 1614 |
| 1615 LRESULT OnAPITrackPopupMenu(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lPa
ram, BOOL& /*bHandled*/) |
| 1616 { |
| 1617 if(lParam == NULL) |
| 1618 return FALSE; |
| 1619 LPCBRPOPUPMENU lpCBRPopupMenu = (LPCBRPOPUPMENU)lParam; |
| 1620 if(lpCBRPopupMenu->cbSize != sizeof(CBRPOPUPMENU)) |
| 1621 return FALSE; |
| 1622 |
| 1623 T* pT = static_cast<T*>(this); |
| 1624 return pT->TrackPopupMenu(lpCBRPopupMenu->hMenu, lpCBRPopupMenu-
>uFlags, lpCBRPopupMenu->x, lpCBRPopupMenu->y, lpCBRPopupMenu->lptpm); |
| 1625 } |
| 1626 |
| 1627 LRESULT OnAPIGetCmdBar(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam
*/, BOOL& /*bHandled*/) |
| 1628 { |
| 1629 return (LRESULT)m_hWnd; |
| 1630 } |
| 1631 |
| 1632 // Parent window message handlers |
| 1633 LRESULT OnParentHotItemChange(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandl
ed) |
| 1634 { |
| 1635 LPNMTBHOTITEM lpNMHT = (LPNMTBHOTITEM)pnmh; |
| 1636 |
| 1637 // Check if this comes from us |
| 1638 if(pnmh->hwndFrom != m_hWnd) |
| 1639 { |
| 1640 bHandled = FALSE; |
| 1641 return 0; |
| 1642 } |
| 1643 |
| 1644 bool bBlockTracking = false; |
| 1645 if((m_dwExtendedStyle & CBR_EX_TRACKALWAYS) == 0) |
| 1646 { |
| 1647 DWORD dwProcessID; |
| 1648 ::GetWindowThreadProcessId(::GetActiveWindow(), &dwProce
ssID); |
| 1649 bBlockTracking = (::GetCurrentProcessId() != dwProcessID
); |
| 1650 } |
| 1651 |
| 1652 if((!m_wndParent.IsWindowEnabled() || bBlockTracking) && (lpNMHT
->dwFlags & HICF_MOUSE)) |
| 1653 { |
| 1654 return 1; |
| 1655 } |
| 1656 else |
| 1657 { |
| 1658 #ifndef HICF_LMOUSE |
| 1659 const DWORD HICF_LMOUSE = 0x00000080; // left mouse bu
tton selected |
| 1660 #endif |
| 1661 bHandled = FALSE; |
| 1662 |
| 1663 // Send WM_MENUSELECT to the app if it needs to display
a status text |
| 1664 if(!(lpNMHT->dwFlags & HICF_MOUSE) |
| 1665 && !(lpNMHT->dwFlags & HICF_ACCELERATOR) |
| 1666 && !(lpNMHT->dwFlags & HICF_LMOUSE)) |
| 1667 { |
| 1668 if(lpNMHT->dwFlags & HICF_ENTERING) |
| 1669 m_wndParent.SendMessage(WM_MENUSELECT, 0
, (LPARAM)m_hMenu); |
| 1670 if(lpNMHT->dwFlags & HICF_LEAVING) |
| 1671 m_wndParent.SendMessage(WM_MENUSELECT, M
AKEWPARAM(0, 0xFFFF), NULL); |
| 1672 } |
| 1673 |
| 1674 return 0; |
| 1675 } |
| 1676 } |
| 1677 |
| 1678 LRESULT OnParentDropDown(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled) |
| 1679 { |
| 1680 // Check if this comes from us |
| 1681 if(pnmh->hwndFrom != m_hWnd) |
| 1682 { |
| 1683 bHandled = FALSE; |
| 1684 return 1; |
| 1685 } |
| 1686 |
| 1687 T* pT = static_cast<T*>(this); |
| 1688 if(::GetFocus() != m_hWnd) |
| 1689 pT->TakeFocus(); |
| 1690 LPNMTOOLBAR pNMToolBar = (LPNMTOOLBAR)pnmh; |
| 1691 int nIndex = CommandToIndex(pNMToolBar->iItem); |
| 1692 m_bContextMenu = false; |
| 1693 m_bEscapePressed = false; |
| 1694 pT->DoPopupMenu(nIndex, true); |
| 1695 |
| 1696 return TBDDRET_DEFAULT; |
| 1697 } |
| 1698 |
| 1699 LRESULT OnParentInitMenuPopup(UINT uMsg, WPARAM wParam, LPARAM lParam, B
OOL& bHandled) |
| 1700 { |
| 1701 return OnInitMenuPopup(uMsg, wParam, lParam, bHandled); |
| 1702 } |
| 1703 |
| 1704 LRESULT OnParentInternalGetBar(UINT uMsg, WPARAM wParam, LPARAM lParam,
BOOL& bHandled) |
| 1705 { |
| 1706 return OnInternalGetBar(uMsg, wParam, lParam, bHandled); |
| 1707 } |
| 1708 |
| 1709 LRESULT OnParentSysCommand(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam
*/, BOOL& bHandled) |
| 1710 { |
| 1711 bHandled = FALSE; |
| 1712 if((m_uSysKey == VK_MENU |
| 1713 || (m_uSysKey == VK_F10 && !(::GetKeyState(VK_SHIFT) & 0
x80)) |
| 1714 || m_uSysKey == VK_SPACE) |
| 1715 && wParam == SC_KEYMENU) |
| 1716 { |
| 1717 T* pT = static_cast<T*>(this); |
| 1718 if(::GetFocus() == m_hWnd) |
| 1719 { |
| 1720 pT->GiveFocusBack(); // exit menu "loop" |
| 1721 PostMessage(TB_SETHOTITEM, (WPARAM)-1, 0L); |
| 1722 } |
| 1723 else if(m_uSysKey != VK_SPACE && !m_bSkipMsg) |
| 1724 { |
| 1725 if(m_bUseKeyboardCues && !m_bShowKeyboardCues &&
m_bAllowKeyboardCues) |
| 1726 ShowKeyboardCues(true); |
| 1727 |
| 1728 pT->TakeFocus(); // enter menu "loop" |
| 1729 bHandled = TRUE; |
| 1730 } |
| 1731 else if(m_uSysKey != VK_SPACE) |
| 1732 { |
| 1733 bHandled = TRUE; |
| 1734 } |
| 1735 } |
| 1736 m_bSkipMsg = false; |
| 1737 return 0; |
| 1738 } |
| 1739 |
| 1740 LRESULT OnParentAPIGetMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL
& bHandled) |
| 1741 { |
| 1742 return OnAPIGetMenu(uMsg, wParam, lParam, bHandled); |
| 1743 } |
| 1744 |
| 1745 LRESULT OnParentMenuChar(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL&
bHandled) |
| 1746 { |
| 1747 return OnMenuChar(uMsg, wParam, lParam, bHandled); |
| 1748 } |
| 1749 |
| 1750 LRESULT OnParentAPITrackPopupMenu(UINT uMsg, WPARAM wParam, LPARAM lPara
m, BOOL& bHandled) |
| 1751 { |
| 1752 return OnAPITrackPopupMenu(uMsg, wParam, lParam, bHandled); |
| 1753 } |
| 1754 |
| 1755 LRESULT OnParentAPIGetCmdBar(UINT uMsg, WPARAM wParam, LPARAM lParam, BO
OL& bHandled) |
| 1756 { |
| 1757 return OnAPIGetCmdBar(uMsg, wParam, lParam, bHandled); |
| 1758 } |
| 1759 |
| 1760 LRESULT OnParentSettingChange(UINT uMsg, WPARAM wParam, LPARAM lParam, B
OOL& bHandled) |
| 1761 { |
| 1762 OnSettingChange(uMsg, wParam, lParam, bHandled); |
| 1763 bHandled = FALSE; |
| 1764 return 1; |
| 1765 } |
| 1766 |
| 1767 LRESULT OnParentDrawItem(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL&
bHandled) |
| 1768 { |
| 1769 return OnDrawItem(uMsg, wParam, lParam, bHandled); |
| 1770 } |
| 1771 |
| 1772 LRESULT OnParentMeasureItem(UINT uMsg, WPARAM wParam, LPARAM lParam, BOO
L& bHandled) |
| 1773 { |
| 1774 return OnMeasureItem(uMsg, wParam, lParam, bHandled); |
| 1775 } |
| 1776 |
| 1777 LRESULT OnParentActivate(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/
, BOOL& bHandled) |
| 1778 { |
| 1779 m_bParentActive = (LOWORD(wParam) != WA_INACTIVE); |
| 1780 if(!m_bParentActive && m_bUseKeyboardCues && m_bShowKeyboardCues
) |
| 1781 { |
| 1782 ShowKeyboardCues(false); // this will repaint our wind
ow |
| 1783 } |
| 1784 else |
| 1785 { |
| 1786 Invalidate(); |
| 1787 UpdateWindow(); |
| 1788 } |
| 1789 bHandled = FALSE; |
| 1790 return 1; |
| 1791 } |
| 1792 |
| 1793 LRESULT OnParentCustomDraw(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled) |
| 1794 { |
| 1795 LRESULT lRet = CDRF_DODEFAULT; |
| 1796 bHandled = FALSE; |
| 1797 if(pnmh->hwndFrom == m_hWnd) |
| 1798 { |
| 1799 LPNMTBCUSTOMDRAW lpTBCustomDraw = (LPNMTBCUSTOMDRAW)pnmh
; |
| 1800 if(lpTBCustomDraw->nmcd.dwDrawStage == CDDS_PREPAINT) |
| 1801 { |
| 1802 lRet = CDRF_NOTIFYITEMDRAW; |
| 1803 bHandled = TRUE; |
| 1804 } |
| 1805 else if(lpTBCustomDraw->nmcd.dwDrawStage == CDDS_ITEMPRE
PAINT) |
| 1806 { |
| 1807 if(m_bFlatMenus) |
| 1808 { |
| 1809 #ifndef COLOR_MENUHILIGHT |
| 1810 const int COLOR_MENUHILIGHT = 29; |
| 1811 #endif // !COLOR_MENUHILIGHT |
| 1812 bool bDisabled = ((lpTBCustomDraw->nmcd.
uItemState & CDIS_DISABLED) == CDIS_DISABLED); |
| 1813 if(!bDisabled && ((lpTBCustomDraw->nmcd.
uItemState & CDIS_HOT) == CDIS_HOT || |
| 1814 (lpTBCustomDraw->nmcd.uItemState
& CDIS_SELECTED) == CDIS_SELECTED)) |
| 1815 { |
| 1816 ::FillRect(lpTBCustomDraw->nmcd.
hdc, &lpTBCustomDraw->nmcd.rc, ::GetSysColorBrush(COLOR_MENUHILIGHT)); |
| 1817 ::FrameRect(lpTBCustomDraw->nmcd
.hdc, &lpTBCustomDraw->nmcd.rc, ::GetSysColorBrush(COLOR_HIGHLIGHT)); |
| 1818 lpTBCustomDraw->clrText = ::GetS
ysColor(m_bParentActive ? COLOR_HIGHLIGHTTEXT : COLOR_GRAYTEXT); |
| 1819 } |
| 1820 else if(bDisabled || !m_bParentActive) |
| 1821 { |
| 1822 lpTBCustomDraw->clrText = ::GetS
ysColor(COLOR_GRAYTEXT); |
| 1823 } |
| 1824 CDCHandle dc = lpTBCustomDraw->nmcd.hdc; |
| 1825 dc.SetTextColor(lpTBCustomDraw->clrText)
; |
| 1826 dc.SetBkMode(lpTBCustomDraw->nStringBkMo
de); |
| 1827 HFONT hFont = GetFont(); |
| 1828 HFONT hFontOld = NULL; |
| 1829 if(hFont != NULL) |
| 1830 hFontOld = dc.SelectFont(hFont); |
| 1831 const int cchText = 200; |
| 1832 TCHAR szText[cchText] = { 0 }; |
| 1833 TBBUTTONINFO tbbi = { 0 }; |
| 1834 tbbi.cbSize = sizeof(TBBUTTONINFO); |
| 1835 tbbi.dwMask = TBIF_TEXT; |
| 1836 tbbi.pszText = szText; |
| 1837 tbbi.cchText = cchText; |
| 1838 GetButtonInfo((int)lpTBCustomDraw->nmcd.
dwItemSpec, &tbbi); |
| 1839 dc.DrawText(szText, -1, &lpTBCustomDraw-
>nmcd.rc, DT_SINGLELINE | DT_CENTER | DT_VCENTER | (m_bShowKeyboardCues ? 0 : DT
_HIDEPREFIX)); |
| 1840 if(hFont != NULL) |
| 1841 dc.SelectFont(hFontOld); |
| 1842 lRet = CDRF_SKIPDEFAULT; |
| 1843 bHandled = TRUE; |
| 1844 } |
| 1845 else if(!m_bParentActive) |
| 1846 { |
| 1847 lpTBCustomDraw->clrText = ::GetSysColor(
COLOR_GRAYTEXT); |
| 1848 bHandled = TRUE; |
| 1849 } |
| 1850 } |
| 1851 } |
| 1852 return lRet; |
| 1853 } |
| 1854 |
| 1855 // Message hook handlers |
| 1856 LRESULT OnHookMouseMove(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lPara
m*/, BOOL& bHandled) |
| 1857 { |
| 1858 static POINT s_point = { -1, -1 }; |
| 1859 DWORD dwPoint = ::GetMessagePos(); |
| 1860 POINT point = { GET_X_LPARAM(dwPoint), GET_Y_LPARAM(dwPoint) }; |
| 1861 |
| 1862 bHandled = FALSE; |
| 1863 if(m_bMenuActive) |
| 1864 { |
| 1865 if(::WindowFromPoint(point) == m_hWnd) |
| 1866 { |
| 1867 ScreenToClient(&point); |
| 1868 int nHit = HitTest(&point); |
| 1869 |
| 1870 if((point.x != s_point.x || point.y != s_point.y
) && nHit >= 0 && nHit < ::GetMenuItemCount(m_hMenu) && nHit != m_nPopBtn && m_n
PopBtn != -1) |
| 1871 { |
| 1872 TBBUTTON tbb = { 0 }; |
| 1873 GetButton(nHit, &tbb); |
| 1874 if((tbb.fsState & TBSTATE_ENABLED) != 0) |
| 1875 { |
| 1876 m_nNextPopBtn = nHit | 0xFFFF000
0; |
| 1877 HWND hWndMenu = m_stackMenuWnd.G
etCurrent(); |
| 1878 ATLASSERT(hWndMenu != NULL); |
| 1879 |
| 1880 // this one is needed to close a
menu if mouse button was down |
| 1881 ::PostMessage(hWndMenu, WM_LBUTT
ONUP, 0, MAKELPARAM(point.x, point.y)); |
| 1882 // this one closes a popup menu |
| 1883 ::PostMessage(hWndMenu, WM_KEYDO
WN, VK_ESCAPE, 0L); |
| 1884 |
| 1885 bHandled = TRUE; |
| 1886 } |
| 1887 } |
| 1888 } |
| 1889 } |
| 1890 else |
| 1891 { |
| 1892 ScreenToClient(&point); |
| 1893 } |
| 1894 |
| 1895 s_point = point; |
| 1896 return 0; |
| 1897 } |
| 1898 |
| 1899 LRESULT OnHookSysKeyDown(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/
, BOOL& bHandled) |
| 1900 { |
| 1901 bHandled = FALSE; |
| 1902 #ifdef _CMDBAR_EXTRA_TRACE |
| 1903 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook WM_SYSKEYDOWN (0x%2.2
X)\n"), wParam); |
| 1904 #endif |
| 1905 |
| 1906 if(wParam == VK_MENU && m_bParentActive && m_bUseKeyboardCues &&
!m_bShowKeyboardCues && m_bAllowKeyboardCues) |
| 1907 ShowKeyboardCues(true); |
| 1908 |
| 1909 if(wParam != VK_SPACE && !m_bMenuActive && ::GetFocus() == m_hWn
d) |
| 1910 { |
| 1911 m_bAllowKeyboardCues = false; |
| 1912 PostMessage(TB_SETHOTITEM, (WPARAM)-1, 0L); |
| 1913 T* pT = static_cast<T*>(this); |
| 1914 pT->GiveFocusBack(); |
| 1915 m_bSkipMsg = true; |
| 1916 } |
| 1917 else |
| 1918 { |
| 1919 if(wParam == VK_SPACE && m_bUseKeyboardCues && m_bShowKe
yboardCues) |
| 1920 { |
| 1921 m_bAllowKeyboardCues = true; |
| 1922 ShowKeyboardCues(false); |
| 1923 } |
| 1924 m_uSysKey = (UINT)wParam; |
| 1925 } |
| 1926 return 0; |
| 1927 } |
| 1928 |
| 1929 LRESULT OnHookSysKeyUp(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/,
BOOL& bHandled) |
| 1930 { |
| 1931 if(!m_bAllowKeyboardCues) |
| 1932 m_bAllowKeyboardCues = true; |
| 1933 bHandled = FALSE; |
| 1934 wParam; |
| 1935 #ifdef _CMDBAR_EXTRA_TRACE |
| 1936 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook WM_SYSKEYUP (0x%2.2X)
\n"), wParam); |
| 1937 #endif |
| 1938 return 0; |
| 1939 } |
| 1940 |
| 1941 LRESULT OnHookSysChar(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, B
OOL& bHandled) |
| 1942 { |
| 1943 bHandled = FALSE; |
| 1944 #ifdef _CMDBAR_EXTRA_TRACE |
| 1945 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook WM_SYSCHAR (0x%2.2X)\
n"), wParam); |
| 1946 #endif |
| 1947 |
| 1948 if(!m_bMenuActive && m_hWndHook != m_hWnd && wParam != VK_SPACE) |
| 1949 bHandled = TRUE; |
| 1950 return 0; |
| 1951 } |
| 1952 |
| 1953 LRESULT OnHookKeyDown(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, B
OOL& bHandled) |
| 1954 { |
| 1955 #ifdef _CMDBAR_EXTRA_TRACE |
| 1956 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook WM_KEYDOWN (0x%2.2X)\
n"), wParam); |
| 1957 #endif |
| 1958 bHandled = FALSE; |
| 1959 T* pT = static_cast<T*>(this); |
| 1960 |
| 1961 if(wParam == VK_ESCAPE && m_stackMenuWnd.GetSize() <= 1) |
| 1962 { |
| 1963 if(m_bMenuActive && !m_bContextMenu) |
| 1964 { |
| 1965 int nHot = GetHotItem(); |
| 1966 if(nHot == -1) |
| 1967 nHot = m_nPopBtn; |
| 1968 if(nHot == -1) |
| 1969 nHot = 0; |
| 1970 SetHotItem(nHot); |
| 1971 bHandled = TRUE; |
| 1972 pT->TakeFocus(); |
| 1973 m_bEscapePressed = true; // To keep focus |
| 1974 m_bSkipPostDown = false; |
| 1975 } |
| 1976 else if(::GetFocus() == m_hWnd && m_wndParent.IsWindow()
) |
| 1977 { |
| 1978 SetHotItem(-1); |
| 1979 pT->GiveFocusBack(); |
| 1980 bHandled = TRUE; |
| 1981 } |
| 1982 } |
| 1983 else if(wParam == VK_RETURN || wParam == VK_UP || wParam == VK_D
OWN) |
| 1984 { |
| 1985 if(!m_bMenuActive && ::GetFocus() == m_hWnd && m_wndPare
nt.IsWindow()) |
| 1986 { |
| 1987 int nHot = GetHotItem(); |
| 1988 if(nHot != -1) |
| 1989 { |
| 1990 if(wParam != VK_RETURN) |
| 1991 { |
| 1992 if(!m_bSkipPostDown) |
| 1993 { |
| 1994 // IE4 only: WM_KEYDOWN doesn't generate TBN_DROPDOWN, we need to simulate a mou
se click |
| 1995 #if (_WIN32_IE < 0x0500) |
| 1996 DWORD dwMajor = 0, dwMin
or = 0; |
| 1997 ATL::AtlGetCommCtrlVersi
on(&dwMajor, &dwMinor); |
| 1998 if(dwMajor <= 4 || (dwMa
jor == 5 && dwMinor < 80)) |
| 1999 { |
| 2000 RECT rect; |
| 2001 GetItemRect(nHot
, &rect); |
| 2002 PostMessage(WM_L
BUTTONDOWN, MK_LBUTTON, MAKELPARAM(rect.left, rect.top)); |
| 2003 } |
| 2004 #endif // (_WIN32_IE < 0x0500) |
| 2005 PostMessage(WM_KEYDOWN,
VK_DOWN, 0L); |
| 2006 m_bSkipPostDown = true; |
| 2007 } |
| 2008 else |
| 2009 { |
| 2010 ATLTRACE2(atlTraceUI, 0,
_T("CmdBar - skipping posting another VK_DOWN\n")); |
| 2011 m_bSkipPostDown = false; |
| 2012 } |
| 2013 } |
| 2014 } |
| 2015 else |
| 2016 { |
| 2017 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Ca
n't find hot button\n")); |
| 2018 } |
| 2019 } |
| 2020 if(wParam == VK_RETURN && m_bMenuActive) |
| 2021 { |
| 2022 PostMessage(TB_SETHOTITEM, (WPARAM)-1, 0L); |
| 2023 m_nNextPopBtn = -1; |
| 2024 pT->GiveFocusBack(); |
| 2025 } |
| 2026 } |
| 2027 else if(wParam == VK_LEFT || wParam == VK_RIGHT) |
| 2028 { |
| 2029 WPARAM wpNext = m_bLayoutRTL ? VK_LEFT : VK_RIGHT; |
| 2030 WPARAM wpPrev = m_bLayoutRTL ? VK_RIGHT : VK_LEFT; |
| 2031 |
| 2032 if(m_bMenuActive && !m_bContextMenu && !(wParam == wpNex
t && m_bPopupItem)) |
| 2033 { |
| 2034 bool bAction = false; |
| 2035 if(wParam == wpPrev && s_pCurrentBar->m_stackMen
uWnd.GetSize() == 1) |
| 2036 { |
| 2037 m_nNextPopBtn = pT->GetPreviousMenuItem(
m_nPopBtn); |
| 2038 if(m_nNextPopBtn != -1) |
| 2039 bAction = true; |
| 2040 } |
| 2041 else if(wParam == wpNext) |
| 2042 { |
| 2043 m_nNextPopBtn = pT->GetNextMenuItem(m_nP
opBtn); |
| 2044 if(m_nNextPopBtn != -1) |
| 2045 bAction = true; |
| 2046 } |
| 2047 HWND hWndMenu = m_stackMenuWnd.GetCurrent(); |
| 2048 ATLASSERT(hWndMenu != NULL); |
| 2049 |
| 2050 // Close the popup menu |
| 2051 if(bAction) |
| 2052 { |
| 2053 ::PostMessage(hWndMenu, WM_KEYDOWN, VK_E
SCAPE, 0L); |
| 2054 if(wParam == wpNext) |
| 2055 { |
| 2056 int cItem = m_stackMenuWnd.GetSi
ze() - 1; |
| 2057 while(cItem >= 0) |
| 2058 { |
| 2059 hWndMenu = m_stackMenuWn
d[cItem]; |
| 2060 if(hWndMenu != NULL) |
| 2061 ::PostMessage(hW
ndMenu, WM_KEYDOWN, VK_ESCAPE, 0L); |
| 2062 cItem--; |
| 2063 } |
| 2064 } |
| 2065 #if (_WIN32_IE >= 0x0500) |
| 2066 if(m_nNextPopBtn == -2) |
| 2067 { |
| 2068 m_nNextPopBtn = -1; |
| 2069 pT->DisplayChevronMenu(); |
| 2070 } |
| 2071 #endif // (_WIN32_IE >= 0x0500) |
| 2072 bHandled = TRUE; |
| 2073 } |
| 2074 } |
| 2075 } |
| 2076 return 0; |
| 2077 } |
| 2078 |
| 2079 LRESULT OnHookNextMenu(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam
*/, BOOL& bHandled) |
| 2080 { |
| 2081 #ifdef _CMDBAR_EXTRA_TRACE |
| 2082 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook WM_NEXTMENU\n")); |
| 2083 #endif |
| 2084 bHandled = FALSE; |
| 2085 return 1; |
| 2086 } |
| 2087 |
| 2088 LRESULT OnHookChar(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL
& bHandled) |
| 2089 { |
| 2090 #ifdef _CMDBAR_EXTRA_TRACE |
| 2091 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook WM_CHAR (0x%2.2X)\n")
, wParam); |
| 2092 #endif |
| 2093 bHandled = (wParam == VK_ESCAPE); |
| 2094 return 0; |
| 2095 } |
| 2096 |
| 2097 // Implementation - ownerdraw overrideables and helpers |
| 2098 void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct) |
| 2099 { |
| 2100 T* pT = static_cast<T*>(this); |
| 2101 if(m_bFlatMenus) |
| 2102 pT->DrawItemFlat(lpDrawItemStruct); |
| 2103 else |
| 2104 pT->DrawItem3D(lpDrawItemStruct); |
| 2105 |
| 2106 } |
| 2107 |
| 2108 void DrawItem3D(LPDRAWITEMSTRUCT lpDrawItemStruct) |
| 2109 { |
| 2110 _MenuItemData* pmd = (_MenuItemData*)lpDrawItemStruct->itemData; |
| 2111 CDCHandle dc = lpDrawItemStruct->hDC; |
| 2112 const RECT& rcItem = lpDrawItemStruct->rcItem; |
| 2113 T* pT = static_cast<T*>(this); |
| 2114 |
| 2115 if(pmd->fType & MFT_SEPARATOR) |
| 2116 { |
| 2117 // draw separator |
| 2118 RECT rc = rcItem; |
| 2119 rc.top += (rc.bottom - rc.top) / 2; // vertical cen
ter |
| 2120 dc.DrawEdge(&rc, EDGE_ETCHED, BF_TOP); // draw separat
or line |
| 2121 } |
| 2122 else // not a separator |
| 2123 { |
| 2124 BOOL bDisabled = lpDrawItemStruct->itemState & ODS_GRAYE
D; |
| 2125 BOOL bSelected = lpDrawItemStruct->itemState & ODS_SELEC
TED; |
| 2126 BOOL bChecked = lpDrawItemStruct->itemState & ODS_CHECKE
D; |
| 2127 BOOL bHasImage = FALSE; |
| 2128 |
| 2129 if(LOWORD(lpDrawItemStruct->itemID) == (WORD)-1) |
| 2130 bSelected = FALSE; |
| 2131 RECT rcButn = { rcItem.left, rcItem.top, rcItem.left + m
_szButton.cx, rcItem.top + m_szButton.cy }; // button rect |
| 2132 ::OffsetRect(&rcButn, 0, ((rcItem.bottom - rcItem.top) -
(rcButn.bottom - rcButn.top)) / 2); // center vertically |
| 2133 |
| 2134 int iButton = pmd->iButton; |
| 2135 if(iButton >= 0) |
| 2136 { |
| 2137 bHasImage = TRUE; |
| 2138 |
| 2139 // calc drawing point |
| 2140 SIZE sz = { rcButn.right - rcButn.left - m_szBit
map.cx, rcButn.bottom - rcButn.top - m_szBitmap.cy }; |
| 2141 sz.cx /= 2; |
| 2142 sz.cy /= 2; |
| 2143 POINT point = { rcButn.left + sz.cx, rcButn.top
+ sz.cy }; |
| 2144 |
| 2145 // fill background depending on state |
| 2146 if(!bChecked || (bSelected && !bDisabled)) |
| 2147 { |
| 2148 if(!bDisabled) |
| 2149 dc.FillRect(&rcButn, (bChecked &
& !bSelected) ? COLOR_3DLIGHT : COLOR_MENU); |
| 2150 else |
| 2151 dc.FillRect(&rcButn, COLOR_MENU)
; |
| 2152 } |
| 2153 else |
| 2154 { |
| 2155 COLORREF crTxt = dc.SetTextColor(::GetSy
sColor(COLOR_BTNFACE)); |
| 2156 COLORREF crBk = dc.SetBkColor(::GetSysCo
lor(COLOR_BTNHILIGHT)); |
| 2157 CBrush hbr(CDCHandle::GetHalftoneBrush()
); |
| 2158 dc.SetBrushOrg(rcButn.left, rcButn.top); |
| 2159 dc.FillRect(&rcButn, hbr); |
| 2160 dc.SetTextColor(crTxt); |
| 2161 dc.SetBkColor(crBk); |
| 2162 } |
| 2163 |
| 2164 // draw disabled or normal |
| 2165 if(!bDisabled) |
| 2166 { |
| 2167 // draw pushed-in or popped-out edge |
| 2168 if(bSelected || bChecked) |
| 2169 { |
| 2170 RECT rc2 = rcButn; |
| 2171 dc.DrawEdge(&rc2, bChecked ? BDR
_SUNKENOUTER : BDR_RAISEDINNER, BF_RECT); |
| 2172 } |
| 2173 // draw the image |
| 2174 ::ImageList_Draw(m_hImageList, iButton,
dc, point.x, point.y, ILD_TRANSPARENT); |
| 2175 } |
| 2176 else |
| 2177 { |
| 2178 HBRUSH hBrushBackground = bChecked ? NUL
L : ::GetSysColorBrush(COLOR_MENU); |
| 2179 pT->DrawBitmapDisabled(dc, iButton, poin
t, hBrushBackground); |
| 2180 } |
| 2181 } |
| 2182 else |
| 2183 { |
| 2184 // no image - look for custom checked/unchecked
bitmaps |
| 2185 CMenuItemInfo info; |
| 2186 info.fMask = MIIM_CHECKMARKS | MIIM_TYPE; |
| 2187 ::GetMenuItemInfo((HMENU)lpDrawItemStruct->hwndI
tem, lpDrawItemStruct->itemID, MF_BYCOMMAND, &info); |
| 2188 if(bChecked || info.hbmpUnchecked != NULL) |
| 2189 { |
| 2190 BOOL bRadio = ((info.fType & MFT_RADIOCH
ECK) != 0); |
| 2191 bHasImage = pT->DrawCheckmark(dc, rcButn
, bSelected, bDisabled, bRadio, bChecked ? info.hbmpChecked : info.hbmpUnchecked
); |
| 2192 } |
| 2193 } |
| 2194 |
| 2195 // draw item text |
| 2196 int cxButn = m_szButton.cx; |
| 2197 COLORREF colorBG = ::GetSysColor(bSelected ? COLOR_HIGHL
IGHT : COLOR_MENU); |
| 2198 if(bSelected || lpDrawItemStruct->itemAction == ODA_SELE
CT) |
| 2199 { |
| 2200 RECT rcBG = rcItem; |
| 2201 if(bHasImage) |
| 2202 rcBG.left += cxButn + s_kcxGap; |
| 2203 dc.FillRect(&rcBG, bSelected ? COLOR_HIGHLIGHT :
COLOR_MENU); |
| 2204 } |
| 2205 |
| 2206 // calc text rectangle and colors |
| 2207 RECT rcText = rcItem; |
| 2208 rcText.left += cxButn + s_kcxGap + s_kcxTextMargin; |
| 2209 rcText.right -= cxButn; |
| 2210 dc.SetBkMode(TRANSPARENT); |
| 2211 COLORREF colorText = ::GetSysColor(bDisabled ? (bSelect
ed ? COLOR_GRAYTEXT : COLOR_3DSHADOW) : (bSelected ? COLOR_HIGHLIGHTTEXT : COLOR
_MENUTEXT)); |
| 2212 |
| 2213 // font already selected by Windows |
| 2214 if(bDisabled && (!bSelected || colorText == colorBG)) |
| 2215 { |
| 2216 // disabled - draw shadow text shifted down and
right 1 pixel (unles selected) |
| 2217 RECT rcDisabled = rcText; |
| 2218 ::OffsetRect(&rcDisabled, 1, 1); |
| 2219 pT->DrawMenuText(dc, rcDisabled, pmd->lpstrText,
::GetSysColor(COLOR_3DHILIGHT)); |
| 2220 } |
| 2221 pT->DrawMenuText(dc, rcText, pmd->lpstrText, colorText);
// finally! |
| 2222 } |
| 2223 } |
| 2224 |
| 2225 void DrawItemFlat(LPDRAWITEMSTRUCT lpDrawItemStruct) |
| 2226 { |
| 2227 _MenuItemData* pmd = (_MenuItemData*)lpDrawItemStruct->itemData; |
| 2228 CDCHandle dc = lpDrawItemStruct->hDC; |
| 2229 const RECT& rcItem = lpDrawItemStruct->rcItem; |
| 2230 T* pT = static_cast<T*>(this); |
| 2231 |
| 2232 #ifndef COLOR_MENUHILIGHT |
| 2233 const int COLOR_MENUHILIGHT = 29; |
| 2234 #endif // !COLOR_MENUHILIGHT |
| 2235 |
| 2236 BOOL bDisabled = lpDrawItemStruct->itemState & ODS_GRAYED; |
| 2237 BOOL bSelected = lpDrawItemStruct->itemState & ODS_SELECTED; |
| 2238 BOOL bChecked = lpDrawItemStruct->itemState & ODS_CHECKED; |
| 2239 |
| 2240 // paint background |
| 2241 if(bSelected || lpDrawItemStruct->itemAction == ODA_SELECT) |
| 2242 { |
| 2243 if(bSelected) |
| 2244 { |
| 2245 dc.FillRect(&rcItem, ::GetSysColorBrush(COLOR_ME
NUHILIGHT)); |
| 2246 dc.FrameRect(&rcItem, ::GetSysColorBrush(COLOR_H
IGHLIGHT)); |
| 2247 } |
| 2248 else |
| 2249 { |
| 2250 dc.FillRect(&rcItem, ::GetSysColorBrush(COLOR_ME
NU)); |
| 2251 } |
| 2252 } |
| 2253 |
| 2254 if(pmd->fType & MFT_SEPARATOR) |
| 2255 { |
| 2256 // draw separator |
| 2257 RECT rc = rcItem; |
| 2258 rc.top += (rc.bottom - rc.top) / 2; // vertical cen
ter |
| 2259 dc.DrawEdge(&rc, EDGE_ETCHED, BF_TOP); // draw separat
or line |
| 2260 } |
| 2261 else // not a separator |
| 2262 { |
| 2263 if(LOWORD(lpDrawItemStruct->itemID) == (WORD)-1) |
| 2264 bSelected = FALSE; |
| 2265 RECT rcButn = { rcItem.left, rcItem.top, rcItem.left + m
_szButton.cx, rcItem.top + m_szButton.cy }; // button rect |
| 2266 ::OffsetRect(&rcButn, 0, ((rcItem.bottom - rcItem.top) -
(rcButn.bottom - rcButn.top)) / 2); // center vertically |
| 2267 |
| 2268 // draw background and border for checked items |
| 2269 if(bChecked) |
| 2270 { |
| 2271 RECT rcCheck = rcButn; |
| 2272 ::InflateRect(&rcCheck, -1, -1); |
| 2273 if(bSelected) |
| 2274 dc.FillRect(&rcCheck, ::GetSysColorBrush
(COLOR_MENU)); |
| 2275 dc.FrameRect(&rcCheck, ::GetSysColorBrush(COLOR_
HIGHLIGHT)); |
| 2276 } |
| 2277 |
| 2278 int iButton = pmd->iButton; |
| 2279 if(iButton >= 0) |
| 2280 { |
| 2281 // calc drawing point |
| 2282 SIZE sz = { rcButn.right - rcButn.left - m_szBit
map.cx, rcButn.bottom - rcButn.top - m_szBitmap.cy }; |
| 2283 sz.cx /= 2; |
| 2284 sz.cy /= 2; |
| 2285 POINT point = { rcButn.left + sz.cx, rcButn.top
+ sz.cy }; |
| 2286 |
| 2287 // draw disabled or normal |
| 2288 if(!bDisabled) |
| 2289 { |
| 2290 ::ImageList_Draw(m_hImageList, iButton,
dc, point.x, point.y, ILD_TRANSPARENT); |
| 2291 } |
| 2292 else |
| 2293 { |
| 2294 HBRUSH hBrushBackground = ::GetSysColorB
rush((bSelected && !(bDisabled && bChecked)) ? COLOR_MENUHILIGHT : COLOR_MENU); |
| 2295 HBRUSH hBrushDisabledImage = ::GetSysCol
orBrush(COLOR_3DSHADOW); |
| 2296 pT->DrawBitmapDisabled(dc, iButton, poin
t, hBrushBackground, hBrushBackground, hBrushDisabledImage); |
| 2297 } |
| 2298 } |
| 2299 else |
| 2300 { |
| 2301 // no image - look for custom checked/unchecked
bitmaps |
| 2302 CMenuItemInfo info; |
| 2303 info.fMask = MIIM_CHECKMARKS | MIIM_TYPE; |
| 2304 ::GetMenuItemInfo((HMENU)lpDrawItemStruct->hwndI
tem, lpDrawItemStruct->itemID, MF_BYCOMMAND, &info); |
| 2305 if(bChecked || info.hbmpUnchecked != NULL) |
| 2306 { |
| 2307 BOOL bRadio = ((info.fType & MFT_RADIOCH
ECK) != 0); |
| 2308 pT->DrawCheckmark(dc, rcButn, bSelected,
bDisabled, bRadio, bChecked ? info.hbmpChecked : info.hbmpUnchecked); |
| 2309 } |
| 2310 } |
| 2311 |
| 2312 // draw item text |
| 2313 int cxButn = m_szButton.cx; |
| 2314 // calc text rectangle and colors |
| 2315 RECT rcText = rcItem; |
| 2316 rcText.left += cxButn + s_kcxGap + s_kcxTextMargin; |
| 2317 rcText.right -= cxButn; |
| 2318 dc.SetBkMode(TRANSPARENT); |
| 2319 COLORREF colorText = ::GetSysColor(bDisabled ? (bSelect
ed ? COLOR_GRAYTEXT : COLOR_3DSHADOW) : (bSelected ? COLOR_HIGHLIGHTTEXT : COLOR
_MENUTEXT)); |
| 2320 |
| 2321 pT->DrawMenuText(dc, rcText, pmd->lpstrText, colorText);
// finally! |
| 2322 } |
| 2323 } |
| 2324 |
| 2325 void DrawMenuText(CDCHandle& dc, RECT& rc, LPCTSTR lpstrText, COLORREF c
olor) |
| 2326 { |
| 2327 int nTab = -1; |
| 2328 for(int i = 0; i < lstrlen(lpstrText); i++) |
| 2329 { |
| 2330 if(lpstrText[i] == _T('\t')) |
| 2331 { |
| 2332 nTab = i; |
| 2333 break; |
| 2334 } |
| 2335 } |
| 2336 dc.SetTextColor(color); |
| 2337 dc.DrawText(lpstrText, nTab, &rc, DT_SINGLELINE | DT_LEFT | DT_V
CENTER | (m_bShowKeyboardCues ? 0 : DT_HIDEPREFIX)); |
| 2338 if(nTab != -1) |
| 2339 dc.DrawText(&lpstrText[nTab + 1], -1, &rc, DT_SINGLELINE
| DT_RIGHT | DT_VCENTER | (m_bShowKeyboardCues ? 0 : DT_HIDEPREFIX)); |
| 2340 } |
| 2341 |
| 2342 void DrawBitmapDisabled(CDCHandle& dc, int nImage, POINT point, |
| 2343 HBRUSH hBrushBackground = ::GetSysColorBrush(COLOR_3DFAC
E), |
| 2344 HBRUSH hBrush3DEffect = ::GetSysColorBrush(COLOR_3DHILIG
HT), |
| 2345 HBRUSH hBrushDisabledImage = ::GetSysColorBrush(COLOR_3D
SHADOW)) |
| 2346 { |
| 2347 #if (_WIN32_WINNT >= 0x0501) && (_WIN32_IE >= 0x0501) |
| 2348 if(m_bAlphaImages) |
| 2349 { |
| 2350 IMAGELISTDRAWPARAMS ildp = { 0 }; |
| 2351 ildp.cbSize = sizeof(IMAGELISTDRAWPARAMS); |
| 2352 ildp.himl = m_hImageList; |
| 2353 ildp.i = nImage; |
| 2354 ildp.hdcDst = dc; |
| 2355 ildp.x = point.x; |
| 2356 ildp.y = point.y; |
| 2357 ildp.cx = 0; |
| 2358 ildp.cy = 0; |
| 2359 ildp.xBitmap = 0; |
| 2360 ildp.yBitmap = 0; |
| 2361 ildp.fStyle = ILD_TRANSPARENT; |
| 2362 ildp.fState = ILS_SATURATE; |
| 2363 ildp.Frame = 0; |
| 2364 ::ImageList_DrawIndirect(&ildp); |
| 2365 } |
| 2366 else |
| 2367 #endif // (_WIN32_WINNT >= 0x0501) && (_WIN32_IE >= 0x0501) |
| 2368 { |
| 2369 // create memory DC |
| 2370 CDC dcMem; |
| 2371 dcMem.CreateCompatibleDC(dc); |
| 2372 // create mono or color bitmap |
| 2373 CBitmap bmp; |
| 2374 bmp.CreateCompatibleBitmap(dc, m_szBitmap.cx, m_szBitmap
.cy); |
| 2375 ATLASSERT(bmp.m_hBitmap != NULL); |
| 2376 // draw image into memory DC--fill BG white first |
| 2377 HBITMAP hBmpOld = dcMem.SelectBitmap(bmp); |
| 2378 dcMem.PatBlt(0, 0, m_szBitmap.cx, m_szBitmap.cy, WHITENE
SS); |
| 2379 // If white is the text color, we can't use the normal p
ainting since |
| 2380 // it would blend with the WHITENESS, but the mask is OK |
| 2381 UINT uDrawStyle = (::GetSysColor(COLOR_BTNTEXT) == RGB(2
55, 255, 255)) ? ILD_MASK : ILD_NORMAL; |
| 2382 ::ImageList_Draw(m_hImageList, nImage, dcMem, 0, 0, uDra
wStyle); |
| 2383 dc.DitherBlt(point.x, point.y, m_szBitmap.cx, m_szBitmap
.cy, dcMem, NULL, 0, 0, hBrushBackground, hBrush3DEffect, hBrushDisabledImage); |
| 2384 dcMem.SelectBitmap(hBmpOld); // restore |
| 2385 } |
| 2386 } |
| 2387 |
| 2388 // old name |
| 2389 BOOL Draw3DCheckmark(CDCHandle& dc, const RECT& rc, BOOL bSelected, BOOL
bDisabled, BOOL bRadio, HBITMAP hBmpCheck) |
| 2390 { |
| 2391 return DrawCheckmark(dc, rc, bSelected, bDisabled, bRadio, hBmpC
heck); |
| 2392 } |
| 2393 |
| 2394 BOOL DrawCheckmark(CDCHandle& dc, const RECT& rc, BOOL bSelected, BOOL b
Disabled, BOOL bRadio, HBITMAP hBmpCheck) |
| 2395 { |
| 2396 // get checkmark bitmap, if none, use Windows standard |
| 2397 SIZE size = { 0, 0 }; |
| 2398 CBitmapHandle bmp = hBmpCheck; |
| 2399 if(hBmpCheck != NULL) |
| 2400 { |
| 2401 bmp.GetSize(size); |
| 2402 } |
| 2403 else |
| 2404 { |
| 2405 size.cx = ::GetSystemMetrics(SM_CXMENUCHECK); |
| 2406 size.cy = ::GetSystemMetrics(SM_CYMENUCHECK); |
| 2407 bmp.CreateCompatibleBitmap(dc, size.cx, size.cy); |
| 2408 ATLASSERT(bmp.m_hBitmap != NULL); |
| 2409 } |
| 2410 // center bitmap in caller's rectangle |
| 2411 RECT rcDest = rc; |
| 2412 if((rc.right - rc.left) > size.cx) |
| 2413 { |
| 2414 rcDest.left = rc.left + (rc.right - rc.left - size.cx) /
2; |
| 2415 rcDest.right = rcDest.left + size.cx; |
| 2416 } |
| 2417 if((rc.bottom - rc.top) > size.cy) |
| 2418 { |
| 2419 rcDest.top = rc.top + (rc.bottom - rc.top - size.cy) / 2
; |
| 2420 rcDest.bottom = rcDest.top + size.cy; |
| 2421 } |
| 2422 // paint background |
| 2423 if(!m_bFlatMenus) |
| 2424 { |
| 2425 if(bSelected && !bDisabled) |
| 2426 { |
| 2427 dc.FillRect(&rcDest, COLOR_MENU); |
| 2428 } |
| 2429 else |
| 2430 { |
| 2431 COLORREF clrTextOld = dc.SetTextColor(::GetSysCo
lor(COLOR_BTNFACE)); |
| 2432 COLORREF clrBkOld = dc.SetBkColor(::GetSysColor(
COLOR_BTNHILIGHT)); |
| 2433 CBrush hbr(CDCHandle::GetHalftoneBrush()); |
| 2434 dc.SetBrushOrg(rcDest.left, rcDest.top); |
| 2435 dc.FillRect(&rcDest, hbr); |
| 2436 dc.SetTextColor(clrTextOld); |
| 2437 dc.SetBkColor(clrBkOld); |
| 2438 } |
| 2439 } |
| 2440 |
| 2441 // create source image |
| 2442 CDC dcSource; |
| 2443 dcSource.CreateCompatibleDC(dc); |
| 2444 HBITMAP hBmpOld = dcSource.SelectBitmap(bmp); |
| 2445 // set colors |
| 2446 const COLORREF clrBlack = RGB(0, 0, 0); |
| 2447 const COLORREF clrWhite = RGB(255, 255, 255); |
| 2448 COLORREF clrTextOld = dc.SetTextColor(clrBlack); |
| 2449 COLORREF clrBkOld = dc.SetBkColor(clrWhite); |
| 2450 // create mask |
| 2451 CDC dcMask; |
| 2452 dcMask.CreateCompatibleDC(dc); |
| 2453 CBitmap bmpMask; |
| 2454 bmpMask.CreateBitmap(size.cx, size.cy, 1, 1, NULL); |
| 2455 HBITMAP hBmpOld1 = dcMask.SelectBitmap(bmpMask); |
| 2456 |
| 2457 // draw the checkmark transparently |
| 2458 int cx = rcDest.right - rcDest.left; |
| 2459 int cy = rcDest.bottom - rcDest.top; |
| 2460 if(hBmpCheck != NULL) |
| 2461 { |
| 2462 // build mask based on transparent color |
| 2463 dcSource.SetBkColor(m_clrMask); |
| 2464 dcMask.SetBkColor(clrBlack); |
| 2465 dcMask.SetTextColor(clrWhite); |
| 2466 dcMask.BitBlt(0, 0, size.cx, size.cy, dcSource, 0, 0, SR
CCOPY); |
| 2467 // draw bitmap using the mask |
| 2468 dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcSource, 0,
0, SRCINVERT); |
| 2469 dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcMask, 0, 0,
SRCAND); |
| 2470 dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcSource, 0,
0, SRCINVERT); |
| 2471 } |
| 2472 else |
| 2473 { |
| 2474 const DWORD ROP_DSno = 0x00BB0226L; |
| 2475 const DWORD ROP_DSa = 0x008800C6L; |
| 2476 const DWORD ROP_DSo = 0x00EE0086L; |
| 2477 const DWORD ROP_DSna = 0x00220326L; |
| 2478 |
| 2479 // draw mask |
| 2480 RECT rcSource = { 0, 0, __min(size.cx, rc.right - rc.lef
t), __min(size.cy, rc.bottom - rc.top) }; |
| 2481 dcMask.DrawFrameControl(&rcSource, DFC_MENU, bRadio ? DF
CS_MENUBULLET : DFCS_MENUCHECK); |
| 2482 |
| 2483 // draw shadow if disabled |
| 2484 if(!m_bFlatMenus && bDisabled) |
| 2485 { |
| 2486 // offset by one pixel |
| 2487 int x = rcDest.left + 1; |
| 2488 int y = rcDest.top + 1; |
| 2489 // paint source bitmap |
| 2490 const int nColor = COLOR_3DHILIGHT; |
| 2491 dcSource.FillRect(&rcSource, nColor); |
| 2492 // draw checkmark - special case black and white
colors |
| 2493 COLORREF clrCheck = ::GetSysColor(nColor); |
| 2494 if(clrCheck == clrWhite) |
| 2495 { |
| 2496 dc.BitBlt(x, y, cx, cy, dcMask, 0, 0,
ROP_DSno); |
| 2497 dc.BitBlt(x, y, cx, cy, dcSource, 0, 0,
ROP_DSa); |
| 2498 } |
| 2499 else |
| 2500 { |
| 2501 if(clrCheck != clrBlack) |
| 2502 { |
| 2503 ATLASSERT(dcSource.GetTextColor(
) == clrBlack); |
| 2504 ATLASSERT(dcSource.GetBkColor()
== clrWhite); |
| 2505 dcSource.BitBlt(0, 0, size.cx, s
ize.cy, dcMask, 0, 0, ROP_DSna); |
| 2506 } |
| 2507 dc.BitBlt(x, y, cx, cy, dcMask, 0, 0,
ROP_DSa); |
| 2508 dc.BitBlt(x, y, cx, cy, dcSource, 0, 0,
ROP_DSo); |
| 2509 } |
| 2510 } |
| 2511 |
| 2512 // paint source bitmap |
| 2513 const int nColor = bDisabled ? COLOR_BTNSHADOW : COLOR_M
ENUTEXT; |
| 2514 dcSource.FillRect(&rcSource, nColor); |
| 2515 // draw checkmark - special case black and white colors |
| 2516 COLORREF clrCheck = ::GetSysColor(nColor); |
| 2517 if(clrCheck == clrWhite) |
| 2518 { |
| 2519 dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcMas
k, 0, 0, ROP_DSno); |
| 2520 dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcSou
rce, 0, 0, ROP_DSa); |
| 2521 } |
| 2522 else |
| 2523 { |
| 2524 if(clrCheck != clrBlack) |
| 2525 { |
| 2526 ATLASSERT(dcSource.GetTextColor() == clr
Black); |
| 2527 ATLASSERT(dcSource.GetBkColor() == clrWh
ite); |
| 2528 dcSource.BitBlt(0, 0, size.cx, size.cy,
dcMask, 0, 0, ROP_DSna); |
| 2529 } |
| 2530 dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcMas
k, 0, 0, ROP_DSa); |
| 2531 dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcSou
rce, 0, 0, ROP_DSo); |
| 2532 } |
| 2533 } |
| 2534 // restore all |
| 2535 dc.SetTextColor(clrTextOld); |
| 2536 dc.SetBkColor(clrBkOld); |
| 2537 dcSource.SelectBitmap(hBmpOld); |
| 2538 dcMask.SelectBitmap(hBmpOld1); |
| 2539 if(hBmpCheck == NULL) |
| 2540 bmp.DeleteObject(); |
| 2541 // draw pushed-in hilight |
| 2542 if(!m_bFlatMenus && !bDisabled) |
| 2543 { |
| 2544 if(rc.right - rc.left > size.cx) |
| 2545 ::InflateRect(&rcDest, 1,1); // inflate checkm
ark by one pixel all around |
| 2546 dc.DrawEdge(&rcDest, BDR_SUNKENOUTER, BF_RECT); |
| 2547 } |
| 2548 |
| 2549 return TRUE; |
| 2550 } |
| 2551 |
| 2552 void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct) |
| 2553 { |
| 2554 _MenuItemData* pmd = (_MenuItemData*)lpMeasureItemStruct->itemDa
ta; |
| 2555 |
| 2556 if(pmd->fType & MFT_SEPARATOR) // separator - use half system
height and zero width |
| 2557 { |
| 2558 lpMeasureItemStruct->itemHeight = ::GetSystemMetrics(SM_
CYMENU) / 2; |
| 2559 lpMeasureItemStruct->itemWidth = 0; |
| 2560 } |
| 2561 else |
| 2562 { |
| 2563 // compute size of text - use DrawText with DT_CALCRECT |
| 2564 CWindowDC dc(NULL); |
| 2565 CFont fontBold; |
| 2566 HFONT hOldFont = NULL; |
| 2567 if(pmd->fState & MFS_DEFAULT) |
| 2568 { |
| 2569 // need bold version of font |
| 2570 LOGFONT lf = { 0 }; |
| 2571 m_fontMenu.GetLogFont(lf); |
| 2572 lf.lfWeight += 200; |
| 2573 fontBold.CreateFontIndirect(&lf); |
| 2574 ATLASSERT(fontBold.m_hFont != NULL); |
| 2575 hOldFont = dc.SelectFont(fontBold); |
| 2576 } |
| 2577 else |
| 2578 { |
| 2579 hOldFont = dc.SelectFont(m_fontMenu); |
| 2580 } |
| 2581 |
| 2582 RECT rcText = { 0, 0, 0, 0 }; |
| 2583 dc.DrawText(pmd->lpstrText, -1, &rcText, DT_SINGLELINE |
DT_LEFT | DT_VCENTER | DT_CALCRECT); |
| 2584 int cx = rcText.right - rcText.left; |
| 2585 dc.SelectFont(hOldFont); |
| 2586 |
| 2587 LOGFONT lf = { 0 }; |
| 2588 m_fontMenu.GetLogFont(lf); |
| 2589 int cy = lf.lfHeight; |
| 2590 if(cy < 0) |
| 2591 cy = -cy; |
| 2592 const int cyMargin = 8; |
| 2593 cy += cyMargin; |
| 2594 |
| 2595 // height of item is the bigger of these two |
| 2596 lpMeasureItemStruct->itemHeight = __max(cy, (int)m_szBut
ton.cy); |
| 2597 |
| 2598 // width is width of text plus a bunch of stuff |
| 2599 cx += 2 * s_kcxTextMargin; // L/R margin for readabili
ty |
| 2600 cx += s_kcxGap; // space between button and
menu text |
| 2601 cx += 2 * m_szButton.cx; // button width (L=button;
R=empty margin) |
| 2602 cx += m_cxExtraSpacing; // extra between item text
and accelerator keys |
| 2603 |
| 2604 // Windows adds 1 to returned value |
| 2605 cx -= ::GetSystemMetrics(SM_CXMENUCHECK) - 1; |
| 2606 lpMeasureItemStruct->itemWidth = cx; // done deal |
| 2607 } |
| 2608 } |
| 2609 |
| 2610 // Implementation - Hook procs |
| 2611 static LRESULT CALLBACK CreateHookProc(int nCode, WPARAM wParam, LPARAM
lParam) |
| 2612 { |
| 2613 const int cchClassName = 7; |
| 2614 TCHAR szClassName[cchClassName] = { 0 }; |
| 2615 |
| 2616 if(nCode == HCBT_CREATEWND) |
| 2617 { |
| 2618 HWND hWndMenu = (HWND)wParam; |
| 2619 #ifdef _CMDBAR_EXTRA_TRACE |
| 2620 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - HCBT_CREATEWND (HW
ND = %8.8X)\n"), hWndMenu); |
| 2621 #endif |
| 2622 |
| 2623 ::GetClassName(hWndMenu, szClassName, cchClassName); |
| 2624 if(!lstrcmp(_T("#32768"), szClassName)) |
| 2625 s_pCurrentBar->m_stackMenuWnd.Push(hWndMenu); |
| 2626 } |
| 2627 else if(nCode == HCBT_DESTROYWND) |
| 2628 { |
| 2629 HWND hWndMenu = (HWND)wParam; |
| 2630 #ifdef _CMDBAR_EXTRA_TRACE |
| 2631 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - HCBT_DESTROYWND (H
WND = %8.8X)\n"), hWndMenu); |
| 2632 #endif |
| 2633 |
| 2634 ::GetClassName(hWndMenu, szClassName, cchClassName); |
| 2635 if(!lstrcmp(_T("#32768"), szClassName)) |
| 2636 { |
| 2637 ATLASSERT(hWndMenu == s_pCurrentBar->m_stackMenu
Wnd.GetCurrent()); |
| 2638 s_pCurrentBar->m_stackMenuWnd.Pop(); |
| 2639 } |
| 2640 } |
| 2641 |
| 2642 return ::CallNextHookEx(s_hCreateHook, nCode, wParam, lParam); |
| 2643 } |
| 2644 |
| 2645 static LRESULT CALLBACK MessageHookProc(int nCode, WPARAM wParam, LPARAM
lParam) |
| 2646 { |
| 2647 LPMSG pMsg = (LPMSG)lParam; |
| 2648 |
| 2649 if(nCode == HC_ACTION && wParam == PM_REMOVE && pMsg->message !=
GetGetBarMessage() && pMsg->message != WM_FORWARDMSG) |
| 2650 { |
| 2651 CCommandBarCtrlBase* pCmdBar = NULL; |
| 2652 HWND hWnd = pMsg->hwnd; |
| 2653 DWORD dwPID = 0; |
| 2654 while(pCmdBar == NULL && hWnd != NULL) |
| 2655 { |
| 2656 pCmdBar = (CCommandBarCtrlBase*)::SendMessage(hW
nd, GetGetBarMessage(), (WPARAM)&dwPID, 0L); |
| 2657 hWnd = ::GetParent(hWnd); |
| 2658 } |
| 2659 |
| 2660 if(pCmdBar != NULL && dwPID == GetCurrentProcessId()) |
| 2661 { |
| 2662 pCmdBar->m_hWndHook = pMsg->hwnd; |
| 2663 ATLASSERT(pCmdBar->IsCommandBarBase()); |
| 2664 |
| 2665 if(::IsWindow(pCmdBar->m_hWnd)) |
| 2666 pCmdBar->SendMessage(WM_FORWARDMSG, 0, (
LPARAM)pMsg); |
| 2667 else |
| 2668 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Ho
ok skipping message, can't find command bar!\n")); |
| 2669 } |
| 2670 } |
| 2671 |
| 2672 LRESULT lRet = 0; |
| 2673 ATLASSERT(s_pmapMsgHook != NULL); |
| 2674 if(s_pmapMsgHook != NULL) |
| 2675 { |
| 2676 DWORD dwThreadID = ::GetCurrentThreadId(); |
| 2677 _MsgHookData* pData = s_pmapMsgHook->Lookup(dwThreadID); |
| 2678 if(pData != NULL) |
| 2679 { |
| 2680 lRet = ::CallNextHookEx(pData->hMsgHook, nCode,
wParam, lParam); |
| 2681 } |
| 2682 } |
| 2683 return lRet; |
| 2684 } |
| 2685 |
| 2686 // Implementation |
| 2687 void DoPopupMenu(int nIndex, bool bAnimate) |
| 2688 { |
| 2689 #ifdef _CMDBAR_EXTRA_TRACE |
| 2690 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - DoPopupMenu, bAnimate = %s
\n"), bAnimate ? "true" : "false"); |
| 2691 #endif |
| 2692 |
| 2693 // Menu animation flags |
| 2694 #ifndef TPM_VERPOSANIMATION |
| 2695 const UINT TPM_VERPOSANIMATION = 0x1000L; |
| 2696 #endif |
| 2697 #ifndef TPM_NOANIMATION |
| 2698 const UINT TPM_NOANIMATION = 0x4000L; |
| 2699 #endif |
| 2700 T* pT = static_cast<T*>(this); |
| 2701 |
| 2702 // get popup menu and it's position |
| 2703 RECT rect = { 0 }; |
| 2704 GetItemRect(nIndex, &rect); |
| 2705 POINT pt = { rect.left, rect.bottom }; |
| 2706 MapWindowPoints(NULL, &pt, 1); |
| 2707 MapWindowPoints(NULL, &rect); |
| 2708 TPMPARAMS TPMParams = { 0 }; |
| 2709 TPMParams.cbSize = sizeof(TPMPARAMS); |
| 2710 TPMParams.rcExclude = rect; |
| 2711 HMENU hMenuPopup = ::GetSubMenu(m_hMenu, nIndex); |
| 2712 ATLASSERT(hMenuPopup != NULL); |
| 2713 |
| 2714 // get button ID |
| 2715 TBBUTTON tbb = { 0 }; |
| 2716 GetButton(nIndex, &tbb); |
| 2717 int nCmdID = tbb.idCommand; |
| 2718 |
| 2719 m_nPopBtn = nIndex; // remember current button's index |
| 2720 |
| 2721 // press button and display popup menu |
| 2722 PressButton(nCmdID, TRUE); |
| 2723 SetHotItem(nCmdID); |
| 2724 pT->DoTrackPopupMenu(hMenuPopup, TPM_LEFTBUTTON | TPM_VERTICAL |
TPM_LEFTALIGN | TPM_TOPALIGN | |
| 2725 (s_bW2K ? (bAnimate ? TPM_VERPOSANIMATION : TPM_NOANIMAT
ION) : 0), pt.x, pt.y, &TPMParams); |
| 2726 PressButton(nCmdID, FALSE); |
| 2727 if(::GetFocus() != m_hWnd) |
| 2728 SetHotItem(-1); |
| 2729 |
| 2730 m_nPopBtn = -1; // restore |
| 2731 |
| 2732 // eat next message if click is on the same button |
| 2733 MSG msg = { 0 }; |
| 2734 if(::PeekMessage(&msg, m_hWnd, WM_LBUTTONDOWN, WM_LBUTTONDOWN, P
M_NOREMOVE) && ::PtInRect(&rect, msg.pt)) |
| 2735 ::PeekMessage(&msg, m_hWnd, WM_LBUTTONDOWN, WM_LBUTTONDO
WN, PM_REMOVE); |
| 2736 |
| 2737 // check if another popup menu should be displayed |
| 2738 if(m_nNextPopBtn != -1) |
| 2739 { |
| 2740 PostMessage(GetAutoPopupMessage(), m_nNextPopBtn & 0xFFF
F); |
| 2741 if(!(m_nNextPopBtn & 0xFFFF0000) && !m_bPopupItem) |
| 2742 PostMessage(WM_KEYDOWN, VK_DOWN, 0); |
| 2743 m_nNextPopBtn = -1; |
| 2744 } |
| 2745 else |
| 2746 { |
| 2747 m_bContextMenu = false; |
| 2748 // If user didn't hit escape, give focus back |
| 2749 if(!m_bEscapePressed) |
| 2750 { |
| 2751 if(m_bUseKeyboardCues && m_bShowKeyboardCues) |
| 2752 m_bAllowKeyboardCues = false; |
| 2753 pT->GiveFocusBack(); |
| 2754 } |
| 2755 else |
| 2756 { |
| 2757 SetHotItem(nCmdID); |
| 2758 SetAnchorHighlight(TRUE); |
| 2759 } |
| 2760 } |
| 2761 } |
| 2762 |
| 2763 BOOL DoTrackPopupMenu(HMENU hMenu, UINT uFlags, int x, int y, LPTPMPARAM
S lpParams = NULL) |
| 2764 { |
| 2765 CMenuHandle menuPopup = hMenu; |
| 2766 |
| 2767 CWindowCreateCriticalSectionLock lock; |
| 2768 if(FAILED(lock.Lock())) |
| 2769 { |
| 2770 ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock crit
ical section in CCommandBarCtrlImpl::DoTrackPopupMenu.\n")); |
| 2771 ATLASSERT(FALSE); |
| 2772 return FALSE; |
| 2773 } |
| 2774 |
| 2775 ATLASSERT(s_hCreateHook == NULL); |
| 2776 |
| 2777 s_pCurrentBar = static_cast<CCommandBarCtrlBase*>(this); |
| 2778 |
| 2779 s_hCreateHook = ::SetWindowsHookEx(WH_CBT, CreateHookProc, Modul
eHelper::GetModuleInstance(), GetCurrentThreadId()); |
| 2780 ATLASSERT(s_hCreateHook != NULL); |
| 2781 |
| 2782 m_bPopupItem = false; |
| 2783 m_bMenuActive = true; |
| 2784 |
| 2785 BOOL bTrackRet = menuPopup.TrackPopupMenuEx(uFlags, x, y, m_hWnd
, lpParams); |
| 2786 m_bMenuActive = false; |
| 2787 |
| 2788 ::UnhookWindowsHookEx(s_hCreateHook); |
| 2789 |
| 2790 s_hCreateHook = NULL; |
| 2791 s_pCurrentBar = NULL; |
| 2792 |
| 2793 lock.Unlock(); |
| 2794 |
| 2795 // cleanup - convert menus back to original state |
| 2796 #ifdef _CMDBAR_EXTRA_TRACE |
| 2797 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - TrackPopupMenu - cleanup\n
")); |
| 2798 #endif |
| 2799 |
| 2800 ATLASSERT(m_stackMenuWnd.GetSize() == 0); |
| 2801 |
| 2802 UpdateWindow(); |
| 2803 ATL::CWindow wndTL = GetTopLevelParent(); |
| 2804 wndTL.UpdateWindow(); |
| 2805 |
| 2806 // restore the menu items to the previous state for all menus th
at were converted |
| 2807 if(m_bImagesVisible) |
| 2808 { |
| 2809 HMENU hMenuSav = NULL; |
| 2810 while((hMenuSav = m_stackMenuHandle.Pop()) != NULL) |
| 2811 { |
| 2812 menuPopup = hMenuSav; |
| 2813 BOOL bRet = FALSE; |
| 2814 // restore state and delete menu item data |
| 2815 for(int i = 0; i < menuPopup.GetMenuItemCount();
i++) |
| 2816 { |
| 2817 CMenuItemInfo mii; |
| 2818 mii.fMask = MIIM_DATA | MIIM_TYPE | MIIM
_ID; |
| 2819 bRet = menuPopup.GetMenuItemInfo(i, TRUE
, &mii); |
| 2820 ATLASSERT(bRet); |
| 2821 |
| 2822 _MenuItemData* pMI = (_MenuItemData*)mii
.dwItemData; |
| 2823 if(pMI != NULL && pMI->IsCmdBarMenuItem(
)) |
| 2824 { |
| 2825 mii.fMask = MIIM_DATA | MIIM_TYP
E | MIIM_STATE; |
| 2826 mii.fType = pMI->fType; |
| 2827 mii.fState = pMI->fState; |
| 2828 mii.dwTypeData = pMI->lpstrText; |
| 2829 mii.cch = lstrlen(pMI->lpstrText
); |
| 2830 mii.dwItemData = NULL; |
| 2831 |
| 2832 bRet = menuPopup.SetMenuItemInfo
(i, TRUE, &mii); |
| 2833 // this one triggers WM_MEASUREI
TEM |
| 2834 menuPopup.ModifyMenu(i, MF_BYPOS
ITION | mii.fType | mii.fState, mii.wID, pMI->lpstrText); |
| 2835 ATLASSERT(bRet); |
| 2836 |
| 2837 delete [] pMI->lpstrText; |
| 2838 delete pMI; |
| 2839 } |
| 2840 } |
| 2841 } |
| 2842 } |
| 2843 return bTrackRet; |
| 2844 } |
| 2845 |
| 2846 int GetPreviousMenuItem(int nBtn) const |
| 2847 { |
| 2848 if(nBtn == -1) |
| 2849 return -1; |
| 2850 #if (_WIN32_IE >= 0x0500) |
| 2851 RECT rcClient; |
| 2852 GetClientRect(&rcClient); |
| 2853 #endif // (_WIN32_IE >= 0x0500) |
| 2854 int nNextBtn; |
| 2855 for(nNextBtn = nBtn - 1; nNextBtn != nBtn; nNextBtn--) |
| 2856 { |
| 2857 if(nNextBtn < 0) |
| 2858 nNextBtn = ::GetMenuItemCount(m_hMenu) - 1; |
| 2859 TBBUTTON tbb = { 0 }; |
| 2860 GetButton(nNextBtn, &tbb); |
| 2861 #if (_WIN32_IE >= 0x0500) |
| 2862 RECT rcBtn; |
| 2863 GetItemRect(nNextBtn, &rcBtn); |
| 2864 if(rcBtn.right > rcClient.right) |
| 2865 { |
| 2866 nNextBtn = -2; // chevron |
| 2867 break; |
| 2868 } |
| 2869 #endif // (_WIN32_IE >= 0x0500) |
| 2870 if((tbb.fsState & TBSTATE_ENABLED) != 0 && (tbb.fsState
& TBSTATE_HIDDEN) == 0) |
| 2871 break; |
| 2872 } |
| 2873 return (nNextBtn != nBtn) ? nNextBtn : -1; |
| 2874 } |
| 2875 |
| 2876 int GetNextMenuItem(int nBtn) const |
| 2877 { |
| 2878 if(nBtn == -1) |
| 2879 return -1; |
| 2880 #if (_WIN32_IE >= 0x0500) |
| 2881 RECT rcClient = { 0 }; |
| 2882 GetClientRect(&rcClient); |
| 2883 #endif // (_WIN32_IE >= 0x0500) |
| 2884 int nNextBtn = 0; |
| 2885 int nCount = ::GetMenuItemCount(m_hMenu); |
| 2886 for(nNextBtn = nBtn + 1; nNextBtn != nBtn; nNextBtn++) |
| 2887 { |
| 2888 if(nNextBtn >= nCount) |
| 2889 nNextBtn = 0; |
| 2890 TBBUTTON tbb = { 0 }; |
| 2891 GetButton(nNextBtn, &tbb); |
| 2892 #if (_WIN32_IE >= 0x0500) |
| 2893 RECT rcBtn = { 0 }; |
| 2894 GetItemRect(nNextBtn, &rcBtn); |
| 2895 if(rcBtn.right > rcClient.right) |
| 2896 { |
| 2897 nNextBtn = -2; // chevron |
| 2898 break; |
| 2899 } |
| 2900 #endif // (_WIN32_IE >= 0x0500) |
| 2901 if((tbb.fsState & TBSTATE_ENABLED) != 0 && (tbb.fsState
& TBSTATE_HIDDEN) == 0) |
| 2902 break; |
| 2903 } |
| 2904 return (nNextBtn != nBtn) ? nNextBtn : -1; |
| 2905 } |
| 2906 |
| 2907 #if (_WIN32_IE >= 0x0500) |
| 2908 bool DisplayChevronMenu() |
| 2909 { |
| 2910 // assume we are in a rebar |
| 2911 HWND hWndReBar = GetParent(); |
| 2912 int nCount = (int)::SendMessage(hWndReBar, RB_GETBANDCOUNT, 0, 0
L); |
| 2913 bool bRet = false; |
| 2914 for(int i = 0; i < nCount; i++) |
| 2915 { |
| 2916 REBARBANDINFO rbbi = { RunTimeHelper::SizeOf_REBARBANDIN
FO(), RBBIM_CHILD | RBBIM_STYLE }; |
| 2917 BOOL bRetBandInfo = (BOOL)::SendMessage(hWndReBar, RB_GE
TBANDINFO, i, (LPARAM)&rbbi); |
| 2918 if(bRetBandInfo && rbbi.hwndChild == m_hWnd) |
| 2919 { |
| 2920 if((rbbi.fStyle & RBBS_USECHEVRON) != 0) |
| 2921 { |
| 2922 ::PostMessage(hWndReBar, RB_PUSHCHEVRON,
i, 0L); |
| 2923 PostMessage(WM_KEYDOWN, VK_DOWN, 0L); |
| 2924 bRet = true; |
| 2925 } |
| 2926 break; |
| 2927 } |
| 2928 } |
| 2929 return bRet; |
| 2930 } |
| 2931 #endif // (_WIN32_IE >= 0x0500) |
| 2932 |
| 2933 void GetSystemSettings() |
| 2934 { |
| 2935 // refresh our font |
| 2936 NONCLIENTMETRICS info = { RunTimeHelper::SizeOf_NONCLIENTMETRICS
() }; |
| 2937 BOOL bRet = ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, size
of(info), &info, 0); |
| 2938 ATLASSERT(bRet); |
| 2939 if(bRet) |
| 2940 { |
| 2941 LOGFONT logfont = { 0 }; |
| 2942 if(m_fontMenu.m_hFont != NULL) |
| 2943 m_fontMenu.GetLogFont(logfont); |
| 2944 if(logfont.lfHeight != info.lfMenuFont.lfHeight || |
| 2945 logfont.lfWidth != info.lfMenuFont.lfWidth || |
| 2946 logfont.lfEscapement != info.lfMenuFont.lfEscapement
|| |
| 2947 logfont.lfOrientation != info.lfMenuFont.lfOrientatio
n || |
| 2948 logfont.lfWeight != info.lfMenuFont.lfWeight || |
| 2949 logfont.lfItalic != info.lfMenuFont.lfItalic || |
| 2950 logfont.lfUnderline != info.lfMenuFont.lfUnderline || |
| 2951 logfont.lfStrikeOut != info.lfMenuFont.lfStrikeOut || |
| 2952 logfont.lfCharSet != info.lfMenuFont.lfCharSet || |
| 2953 logfont.lfOutPrecision != info.lfMenuFont.lfOutPrecis
ion || |
| 2954 logfont.lfClipPrecision != info.lfMenuFont.lfClipPrec
ision || |
| 2955 logfont.lfQuality != info.lfMenuFont.lfQuality || |
| 2956 logfont.lfPitchAndFamily != info.lfMenuFont.lfPitchAn
dFamily || |
| 2957 lstrcmp(logfont.lfFaceName, info.lfMenuFont.lfFaceNam
e) != 0) |
| 2958 { |
| 2959 HFONT hFontMenu = ::CreateFontIndirect(&info.lfM
enuFont); |
| 2960 ATLASSERT(hFontMenu != NULL); |
| 2961 if(hFontMenu != NULL) |
| 2962 { |
| 2963 if(m_fontMenu.m_hFont != NULL) |
| 2964 m_fontMenu.DeleteObject(); |
| 2965 m_fontMenu.Attach(hFontMenu); |
| 2966 SetFont(m_fontMenu); |
| 2967 AddStrings(_T("NS\0")); // for proper
item height |
| 2968 AutoSize(); |
| 2969 } |
| 2970 } |
| 2971 } |
| 2972 |
| 2973 // check if we need extra spacing for menu item text |
| 2974 CWindowDC dc(m_hWnd); |
| 2975 HFONT hFontOld = dc.SelectFont(m_fontMenu); |
| 2976 RECT rcText = { 0, 0, 0, 0 }; |
| 2977 dc.DrawText(_T("\t"), -1, &rcText, DT_SINGLELINE | DT_LEFT | DT_
VCENTER | DT_CALCRECT); |
| 2978 if((rcText.right - rcText.left) < 4) |
| 2979 { |
| 2980 ::SetRectEmpty(&rcText); |
| 2981 dc.DrawText(_T("x"), -1, &rcText, DT_SINGLELINE | DT_LEF
T | DT_VCENTER | DT_CALCRECT); |
| 2982 m_cxExtraSpacing = rcText.right - rcText.left; |
| 2983 } |
| 2984 else |
| 2985 { |
| 2986 m_cxExtraSpacing = 0; |
| 2987 } |
| 2988 dc.SelectFont(hFontOld); |
| 2989 |
| 2990 // get Windows version |
| 2991 OSVERSIONINFO ovi = { sizeof(OSVERSIONINFO) }; |
| 2992 ::GetVersionEx(&ovi); |
| 2993 |
| 2994 // query keyboard cues mode (Windows 2000 or later) |
| 2995 if(ovi.dwMajorVersion >= 5) |
| 2996 { |
| 2997 #ifndef SPI_GETKEYBOARDCUES |
| 2998 const UINT SPI_GETKEYBOARDCUES = 0x100A; |
| 2999 #endif // !SPI_GETKEYBOARDCUES |
| 3000 BOOL bRetVal = TRUE; |
| 3001 bRet = ::SystemParametersInfo(SPI_GETKEYBOARDCUES, 0, &b
RetVal, 0); |
| 3002 m_bUseKeyboardCues = (bRet && !bRetVal); |
| 3003 m_bAllowKeyboardCues = true; |
| 3004 ShowKeyboardCues(!m_bUseKeyboardCues); |
| 3005 } |
| 3006 |
| 3007 // query flat menu mode (Windows XP or later) |
| 3008 if((ovi.dwMajorVersion == 5 && ovi.dwMinorVersion >= 1) || (ovi.
dwMajorVersion > 5)) |
| 3009 { |
| 3010 #ifndef SPI_GETFLATMENU |
| 3011 const UINT SPI_GETFLATMENU = 0x1022; |
| 3012 #endif // !SPI_GETFLATMENU |
| 3013 BOOL bRetVal = FALSE; |
| 3014 bRet = ::SystemParametersInfo(SPI_GETFLATMENU, 0, &bRetV
al, 0); |
| 3015 m_bFlatMenus = (bRet && bRetVal); |
| 3016 } |
| 3017 |
| 3018 #if _WTL_CMDBAR_VISTA_MENUS |
| 3019 // check if we should use Vista menus |
| 3020 bool bVistaMenus = (RunTimeHelper::IsVista() && RunTimeHelper::I
sCommCtrl6() && ((m_dwExtendedStyle & CBR_EX_NOVISTAMENUS) == 0)); |
| 3021 |
| 3022 if(bVistaMenus) |
| 3023 { |
| 3024 HMODULE hThemeDLL = ::LoadLibrary(_T("uxtheme.dll")); |
| 3025 if(hThemeDLL != NULL) |
| 3026 { |
| 3027 typedef BOOL (STDAPICALLTYPE *PFN_IsThemeActive)
(); |
| 3028 PFN_IsThemeActive pfnIsThemeActive = (PFN_IsThem
eActive)::GetProcAddress(hThemeDLL, "IsThemeActive"); |
| 3029 ATLASSERT(pfnIsThemeActive != NULL); |
| 3030 bVistaMenus = bVistaMenus && (pfnIsThemeActive !
= NULL) && (pfnIsThemeActive() != FALSE); |
| 3031 |
| 3032 typedef BOOL (STDAPICALLTYPE *PFN_IsAppThemed)()
; |
| 3033 PFN_IsAppThemed pfnIsAppThemed = (PFN_IsAppTheme
d)::GetProcAddress(hThemeDLL, "IsAppThemed"); |
| 3034 ATLASSERT(pfnIsAppThemed != NULL); |
| 3035 bVistaMenus = bVistaMenus && (pfnIsAppThemed !=
NULL) && (pfnIsAppThemed() != FALSE); |
| 3036 |
| 3037 ::FreeLibrary(hThemeDLL); |
| 3038 } |
| 3039 } |
| 3040 |
| 3041 if(!bVistaMenus && m_bVistaMenus && (m_hMenu != NULL) && (m_arrC
ommand.GetSize() > 0)) |
| 3042 { |
| 3043 T* pT = static_cast<T*>(this); |
| 3044 pT->_RemoveVistaBitmapsFromMenu(); |
| 3045 } |
| 3046 |
| 3047 m_bVistaMenus = bVistaMenus; |
| 3048 #endif // _WTL_CMDBAR_VISTA_MENUS |
| 3049 |
| 3050 #ifdef _CMDBAR_EXTRA_TRACE |
| 3051 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - GetSystemSettings:\n m
_bFlatMenus = %s\n m_bUseKeyboardCues = %s m_bVistaMenus = %s\n"), |
| 3052 m_bFlatMenus ? "true" : "false", m_bUseKeyboardCues ? "t
rue" : "false", m_bVistaMenus ? "true" : "false"); |
| 3053 #endif |
| 3054 } |
| 3055 |
| 3056 // Implementation - alternate focus mode support |
| 3057 void TakeFocus() |
| 3058 { |
| 3059 if((m_dwExtendedStyle & CBR_EX_ALTFOCUSMODE) && m_hWndFocus == N
ULL) |
| 3060 m_hWndFocus = ::GetFocus(); |
| 3061 SetFocus(); |
| 3062 } |
| 3063 |
| 3064 void GiveFocusBack() |
| 3065 { |
| 3066 if(m_bParentActive) |
| 3067 { |
| 3068 if((m_dwExtendedStyle & CBR_EX_ALTFOCUSMODE) && ::IsWind
ow(m_hWndFocus)) |
| 3069 ::SetFocus(m_hWndFocus); |
| 3070 else if(!(m_dwExtendedStyle & CBR_EX_ALTFOCUSMODE) && m_
wndParent.IsWindow()) |
| 3071 m_wndParent.SetFocus(); |
| 3072 } |
| 3073 m_hWndFocus = NULL; |
| 3074 SetAnchorHighlight(FALSE); |
| 3075 if(m_bUseKeyboardCues && m_bShowKeyboardCues) |
| 3076 ShowKeyboardCues(false); |
| 3077 m_bSkipPostDown = false; |
| 3078 } |
| 3079 |
| 3080 void ShowKeyboardCues(bool bShow) |
| 3081 { |
| 3082 m_bShowKeyboardCues = bShow; |
| 3083 SetDrawTextFlags(DT_HIDEPREFIX, m_bShowKeyboardCues ? 0 : DT_HID
EPREFIX); |
| 3084 Invalidate(); |
| 3085 UpdateWindow(); |
| 3086 } |
| 3087 |
| 3088 // Implementation - internal message helpers |
| 3089 static UINT GetAutoPopupMessage() |
| 3090 { |
| 3091 static UINT uAutoPopupMessage = 0; |
| 3092 if(uAutoPopupMessage == 0) |
| 3093 { |
| 3094 CStaticDataInitCriticalSectionLock lock; |
| 3095 if(FAILED(lock.Lock())) |
| 3096 { |
| 3097 ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to l
ock critical section in CCommandBarCtrlImpl::GetAutoPopupMessage.\n")); |
| 3098 ATLASSERT(FALSE); |
| 3099 return 0; |
| 3100 } |
| 3101 |
| 3102 if(uAutoPopupMessage == 0) |
| 3103 uAutoPopupMessage = ::RegisterWindowMessage(_T("
WTL_CmdBar_InternalAutoPopupMsg")); |
| 3104 |
| 3105 lock.Unlock(); |
| 3106 } |
| 3107 ATLASSERT(uAutoPopupMessage != 0); |
| 3108 return uAutoPopupMessage; |
| 3109 } |
| 3110 |
| 3111 static UINT GetGetBarMessage() |
| 3112 { |
| 3113 static UINT uGetBarMessage = 0; |
| 3114 if(uGetBarMessage == 0) |
| 3115 { |
| 3116 CStaticDataInitCriticalSectionLock lock; |
| 3117 if(FAILED(lock.Lock())) |
| 3118 { |
| 3119 ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to l
ock critical section in CCommandBarCtrlImpl::GetGetBarMessage.\n")); |
| 3120 ATLASSERT(FALSE); |
| 3121 return 0; |
| 3122 } |
| 3123 |
| 3124 if(uGetBarMessage == 0) |
| 3125 uGetBarMessage = ::RegisterWindowMessage(_T("WTL
_CmdBar_InternalGetBarMsg")); |
| 3126 |
| 3127 lock.Unlock(); |
| 3128 } |
| 3129 ATLASSERT(uGetBarMessage != 0); |
| 3130 return uGetBarMessage; |
| 3131 } |
| 3132 |
| 3133 // Implementation |
| 3134 bool CreateInternalImageList(int cImages) |
| 3135 { |
| 3136 UINT uFlags = (m_bAlphaImages ? ILC_COLOR32 : ILC_COLOR24) | ILC
_MASK; |
| 3137 m_hImageList = ::ImageList_Create(m_szBitmap.cx, m_szBitmap.cy,
uFlags, cImages, 1); |
| 3138 ATLASSERT(m_hImageList != NULL); |
| 3139 return (m_hImageList != NULL); |
| 3140 } |
| 3141 |
| 3142 // Implementation - support for Vista menus |
| 3143 #if _WTL_CMDBAR_VISTA_MENUS |
| 3144 void _AddVistaBitmapsFromImageList(int nStartIndex, int nCount) |
| 3145 { |
| 3146 // Create display compatible memory DC |
| 3147 HDC hDC = ::GetDC(NULL); |
| 3148 CDC dcMem; |
| 3149 dcMem.CreateCompatibleDC(hDC); |
| 3150 HBITMAP hBitmapSave = dcMem.GetCurrentBitmap(); |
| 3151 |
| 3152 T* pT = static_cast<T*>(this); |
| 3153 // Create bitmaps for all menu items |
| 3154 for(int i = 0; i < nCount; i++) |
| 3155 { |
| 3156 HBITMAP hBitmap = pT->_CreateVistaBitmapHelper(nStartInd
ex + i, hDC, dcMem); |
| 3157 dcMem.SelectBitmap(hBitmapSave); |
| 3158 m_arrVistaBitmap.Add(hBitmap); |
| 3159 } |
| 3160 } |
| 3161 |
| 3162 void _AddVistaBitmapFromImageList(int nIndex) |
| 3163 { |
| 3164 // Create display compatible memory DC |
| 3165 HDC hDC = ::GetDC(NULL); |
| 3166 CDC dcMem; |
| 3167 dcMem.CreateCompatibleDC(hDC); |
| 3168 HBITMAP hBitmapSave = dcMem.GetCurrentBitmap(); |
| 3169 |
| 3170 // Create bitmap for menu item |
| 3171 T* pT = static_cast<T*>(this); |
| 3172 HBITMAP hBitmap = pT->_CreateVistaBitmapHelper(nIndex, hDC, dcMe
m); |
| 3173 |
| 3174 // Select saved bitmap back and add bitmap to the array |
| 3175 dcMem.SelectBitmap(hBitmapSave); |
| 3176 m_arrVistaBitmap.Add(hBitmap); |
| 3177 } |
| 3178 |
| 3179 void _ReplaceVistaBitmapFromImageList(int nIndex) |
| 3180 { |
| 3181 // Delete existing bitmap |
| 3182 if(m_arrVistaBitmap[nIndex] != NULL) |
| 3183 ::DeleteObject(m_arrVistaBitmap[nIndex]); |
| 3184 |
| 3185 // Create display compatible memory DC |
| 3186 HDC hDC = ::GetDC(NULL); |
| 3187 CDC dcMem; |
| 3188 dcMem.CreateCompatibleDC(hDC); |
| 3189 HBITMAP hBitmapSave = dcMem.GetCurrentBitmap(); |
| 3190 |
| 3191 // Create bitmap for menu item |
| 3192 T* pT = static_cast<T*>(this); |
| 3193 HBITMAP hBitmap = pT->_CreateVistaBitmapHelper(nIndex, hDC, dcMe
m); |
| 3194 |
| 3195 // Select saved bitmap back and replace bitmap in the array |
| 3196 dcMem.SelectBitmap(hBitmapSave); |
| 3197 m_arrVistaBitmap.SetAtIndex(nIndex, hBitmap); |
| 3198 } |
| 3199 |
| 3200 HBITMAP _CreateVistaBitmapHelper(int nIndex, HDC hDCSource, HDC hDCTarge
t) |
| 3201 { |
| 3202 // Create 32-bit bitmap |
| 3203 BITMAPINFO bi = { 0 }; |
| 3204 bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); |
| 3205 bi.bmiHeader.biWidth = m_szBitmap.cx; |
| 3206 bi.bmiHeader.biHeight = m_szBitmap.cy; |
| 3207 bi.bmiHeader.biPlanes = 1; |
| 3208 bi.bmiHeader.biBitCount = 32; |
| 3209 bi.bmiHeader.biCompression = BI_RGB; |
| 3210 bi.bmiHeader.biSizeImage = 0; |
| 3211 bi.bmiHeader.biXPelsPerMeter = 0; |
| 3212 bi.bmiHeader.biYPelsPerMeter = 0; |
| 3213 bi.bmiHeader.biClrUsed = 0; |
| 3214 bi.bmiHeader.biClrImportant = 0; |
| 3215 HBITMAP hBitmap = ::CreateDIBSection(hDCSource, &bi, DIB_RGB_COL
ORS, NULL, NULL, 0); |
| 3216 ATLASSERT(hBitmap != NULL); |
| 3217 |
| 3218 // Select bitmap into target DC and draw from image list to it |
| 3219 if(hBitmap != NULL) |
| 3220 { |
| 3221 ::SelectObject(hDCTarget, hBitmap); |
| 3222 |
| 3223 IMAGELISTDRAWPARAMS ildp = { 0 }; |
| 3224 ildp.cbSize = sizeof(IMAGELISTDRAWPARAMS); |
| 3225 ildp.himl = m_hImageList; |
| 3226 ildp.i = nIndex; |
| 3227 ildp.hdcDst = hDCTarget; |
| 3228 ildp.x = 0; |
| 3229 ildp.y = 0; |
| 3230 ildp.cx = 0; |
| 3231 ildp.cy = 0; |
| 3232 ildp.xBitmap = 0; |
| 3233 ildp.yBitmap = 0; |
| 3234 ildp.fStyle = ILD_TRANSPARENT; |
| 3235 ildp.fState = ILS_ALPHA; |
| 3236 ildp.Frame = 255; |
| 3237 ::ImageList_DrawIndirect(&ildp); |
| 3238 } |
| 3239 |
| 3240 return hBitmap; |
| 3241 } |
| 3242 |
| 3243 void _RemoveVistaBitmapsFromMenu() |
| 3244 { |
| 3245 CMenuHandle menu = m_hMenu; |
| 3246 for(int i = 0; i < m_arrCommand.GetSize(); i++) |
| 3247 { |
| 3248 CMenuItemInfo mii; |
| 3249 mii.fMask = MIIM_BITMAP; |
| 3250 mii.hbmpItem = NULL; |
| 3251 menu.SetMenuItemInfo(m_arrCommand[i], FALSE, &mii); |
| 3252 } |
| 3253 } |
| 3254 #endif // _WTL_CMDBAR_VISTA_MENUS |
| 3255 }; |
| 3256 |
| 3257 |
| 3258 class CCommandBarCtrl : public CCommandBarCtrlImpl<CCommandBarCtrl> |
| 3259 { |
| 3260 public: |
| 3261 DECLARE_WND_SUPERCLASS(_T("WTL_CommandBar"), GetWndClassName()) |
| 3262 }; |
| 3263 |
| 3264 |
| 3265 /////////////////////////////////////////////////////////////////////////////// |
| 3266 // CMDICommandBarCtrl - ATL implementation of Command Bars for MDI apps |
| 3267 |
| 3268 template <class T, class TBase = CCommandBarCtrlBase, class TWinTraits = ATL::CC
ontrolWinTraits> |
| 3269 class ATL_NO_VTABLE CMDICommandBarCtrlImpl : public CCommandBarCtrlImpl< T, TBas
e, TWinTraits> |
| 3270 { |
| 3271 public: |
| 3272 // Data members |
| 3273 ATL::CContainedWindow m_wndMDIClient; |
| 3274 bool m_bChildMaximized; |
| 3275 HWND m_hWndChildMaximized; |
| 3276 HICON m_hIconChildMaximized; |
| 3277 int m_nBtnPressed; |
| 3278 int m_nBtnWasPressed; |
| 3279 |
| 3280 int m_cxyOffset; // offset between nonclient elements |
| 3281 int m_cxIconWidth; // small icon width |
| 3282 int m_cyIconHeight; // small icon height |
| 3283 int m_cxBtnWidth; // nonclient button width |
| 3284 int m_cyBtnHeight; // nonclient button height |
| 3285 int m_cxLeft; // left nonclient area width |
| 3286 int m_cxRight; // right nonclient area width |
| 3287 |
| 3288 // Theme declarations and data members |
| 3289 #ifndef _WTL_NO_AUTO_THEME |
| 3290 #ifndef _UXTHEME_H_ |
| 3291 typedef HANDLE HTHEME; |
| 3292 #endif // !_UXTHEME_H_ |
| 3293 typedef HTHEME (STDAPICALLTYPE *PFN_OpenThemeData)(HWND hwnd, LPCWSTR ps
zClassList); |
| 3294 typedef HRESULT (STDAPICALLTYPE *PFN_CloseThemeData)(HTHEME hTheme); |
| 3295 typedef HRESULT (STDAPICALLTYPE *PFN_DrawThemeBackground)(HTHEME hTheme,
HDC hdc, int iPartId, int iStateId, const RECT *pRect, OPTIONAL const RECT *pCl
ipRect); |
| 3296 typedef HRESULT (STDAPICALLTYPE *PFN_DrawThemeParentBackground)(HWND hwn
d, HDC hdc, OPTIONAL RECT* prc); |
| 3297 |
| 3298 HMODULE m_hThemeDLL; |
| 3299 HTHEME m_hTheme; |
| 3300 PFN_DrawThemeBackground m_pfnDrawThemeBackground; |
| 3301 PFN_DrawThemeParentBackground m_pfnDrawThemeParentBackground; |
| 3302 #endif // !_WTL_NO_AUTO_THEME |
| 3303 |
| 3304 // Constructor/destructor |
| 3305 CMDICommandBarCtrlImpl() : |
| 3306 m_wndMDIClient(this, 2), m_bChildMaximized(false), |
| 3307 m_hWndChildMaximized(NULL), m_hIconChildMaximized(NULL),
|
| 3308 m_nBtnPressed(-1), m_nBtnWasPressed(-1), |
| 3309 #ifndef _WTL_NO_AUTO_THEME |
| 3310 m_hThemeDLL(NULL), m_hTheme(NULL), m_pfnDrawThemeBackgro
und(NULL), m_pfnDrawThemeParentBackground(NULL), |
| 3311 #endif // !_WTL_NO_AUTO_THEME |
| 3312 m_cxyOffset(2), |
| 3313 m_cxIconWidth(16), m_cyIconHeight(16), |
| 3314 m_cxBtnWidth(16), m_cyBtnHeight(14), |
| 3315 m_cxLeft(20), m_cxRight(55) |
| 3316 { } |
| 3317 |
| 3318 ~CMDICommandBarCtrlImpl() |
| 3319 { |
| 3320 if(m_wndMDIClient.IsWindow()) |
| 3321 /*scary!*/ m_wndMDIClient.UnsubclassWindow(); |
| 3322 } |
| 3323 |
| 3324 // Operations |
| 3325 BOOL SetMDIClient(HWND hWndMDIClient) |
| 3326 { |
| 3327 ATLASSERT(::IsWindow(m_hWnd)); |
| 3328 ATLASSERT(::IsWindow(hWndMDIClient)); |
| 3329 if(!::IsWindow(hWndMDIClient)) |
| 3330 return FALSE; |
| 3331 |
| 3332 #ifdef _DEBUG |
| 3333 // BLOCK: Test if the passed window is MDICLIENT |
| 3334 { |
| 3335 LPCTSTR lpszMDIClientClass = _T("MDICLIENT"); |
| 3336 const int nNameLen = 9 + 1; // "MDICLIENT" + NULL |
| 3337 TCHAR szClassName[nNameLen] = { 0 }; |
| 3338 ::GetClassName(hWndMDIClient, szClassName, nNameLen); |
| 3339 ATLASSERT(lstrcmpi(szClassName, lpszMDIClientClass) == 0
); |
| 3340 } |
| 3341 #endif // _DEBUG |
| 3342 |
| 3343 if(m_wndMDIClient.IsWindow()) |
| 3344 /*scary!*/ m_wndMDIClient.UnsubclassWindow(); |
| 3345 |
| 3346 return m_wndMDIClient.SubclassWindow(hWndMDIClient); |
| 3347 } |
| 3348 |
| 3349 // Message maps |
| 3350 typedef CCommandBarCtrlImpl< T, TBase, TWinTraits > _baseClass; |
| 3351 BEGIN_MSG_MAP(CMDICommandBarCtrlImpl) |
| 3352 MESSAGE_HANDLER(WM_CREATE, OnCreate) |
| 3353 MESSAGE_HANDLER(WM_DESTROY, OnDestroy) |
| 3354 #ifndef _WTL_NO_AUTO_THEME |
| 3355 MESSAGE_HANDLER(_GetThemeChangedMsg(), OnThemeChanged) |
| 3356 #endif // !_WTL_NO_AUTO_THEME |
| 3357 MESSAGE_HANDLER(WM_SIZE, OnSize) |
| 3358 MESSAGE_HANDLER(WM_NCCALCSIZE, OnNcCalcSize) |
| 3359 MESSAGE_HANDLER(WM_NCPAINT, OnNcPaint) |
| 3360 MESSAGE_HANDLER(WM_NCHITTEST, OnNcHitTest) |
| 3361 MESSAGE_HANDLER(WM_NCLBUTTONDOWN, OnNcLButtonDown) |
| 3362 MESSAGE_HANDLER(WM_MOUSEMOVE, OnMouseMove) |
| 3363 MESSAGE_HANDLER(WM_LBUTTONUP, OnLButtonUp) |
| 3364 MESSAGE_HANDLER(WM_NCLBUTTONDBLCLK, OnNcLButtonDblClk) |
| 3365 MESSAGE_HANDLER(WM_CAPTURECHANGED, OnCaptureChanged) |
| 3366 CHAIN_MSG_MAP(_baseClass) |
| 3367 ALT_MSG_MAP(1) // Parent window messages |
| 3368 MESSAGE_HANDLER(WM_ACTIVATE, OnParentActivate) |
| 3369 CHAIN_MSG_MAP_ALT(_baseClass, 1) |
| 3370 ALT_MSG_MAP(2) // MDI client window messages |
| 3371 MESSAGE_HANDLER(WM_MDISETMENU, OnMDISetMenu) |
| 3372 // no chaining needed since this was moved from the base class h
ere |
| 3373 ALT_MSG_MAP(3) // Message hook messages |
| 3374 MESSAGE_RANGE_HANDLER(0, 0xFFFF, OnAllHookMessages) |
| 3375 CHAIN_MSG_MAP_ALT(_baseClass, 3) |
| 3376 END_MSG_MAP() |
| 3377 |
| 3378 // Additional MDI message handlers |
| 3379 LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled
) |
| 3380 { |
| 3381 LRESULT lRet = _baseClass::OnCreate(uMsg, wParam, lParam, bHandl
ed); |
| 3382 if(lRet == (LRESULT)-1) |
| 3383 return lRet; |
| 3384 |
| 3385 #ifndef _WTL_NO_AUTO_THEME |
| 3386 // this will fail if theming is not supported |
| 3387 m_hThemeDLL = ::LoadLibrary(_T("uxtheme.dll")); |
| 3388 if(m_hThemeDLL != NULL) |
| 3389 { |
| 3390 m_pfnDrawThemeBackground = (PFN_DrawThemeBackground)::Ge
tProcAddress(m_hThemeDLL, "DrawThemeBackground"); |
| 3391 ATLASSERT(m_pfnDrawThemeBackground != NULL); |
| 3392 if(m_pfnDrawThemeBackground != NULL) |
| 3393 { |
| 3394 T* pT = static_cast<T*>(this); |
| 3395 pT->_OpenThemeData(); |
| 3396 } |
| 3397 else |
| 3398 { |
| 3399 ::FreeLibrary(m_hThemeDLL); |
| 3400 m_hThemeDLL = NULL; |
| 3401 } |
| 3402 m_pfnDrawThemeParentBackground = (PFN_DrawThemeParentBac
kground)::GetProcAddress(m_hThemeDLL, "DrawThemeParentBackground"); |
| 3403 ATLASSERT(m_pfnDrawThemeParentBackground != NULL); |
| 3404 } |
| 3405 #endif // !_WTL_NO_AUTO_THEME |
| 3406 |
| 3407 return lRet; |
| 3408 } |
| 3409 |
| 3410 LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandle
d) |
| 3411 { |
| 3412 LRESULT lRet = _baseClass::OnDestroy(uMsg, wParam, lParam, bHand
led); |
| 3413 |
| 3414 #ifndef _WTL_NO_AUTO_THEME |
| 3415 if(m_hThemeDLL != NULL) |
| 3416 { |
| 3417 T* pT = static_cast<T*>(this); |
| 3418 pT->_CloseThemeData(); |
| 3419 ::FreeLibrary(m_hThemeDLL); |
| 3420 m_hThemeDLL = NULL; |
| 3421 } |
| 3422 #endif // !_WTL_NO_AUTO_THEME |
| 3423 |
| 3424 return lRet; |
| 3425 } |
| 3426 |
| 3427 #ifndef _WTL_NO_AUTO_THEME |
| 3428 LRESULT OnThemeChanged(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam
*/, BOOL& /*bHandled*/) |
| 3429 { |
| 3430 if(m_hThemeDLL != NULL) |
| 3431 { |
| 3432 T* pT = static_cast<T*>(this); |
| 3433 pT->_CloseThemeData(); |
| 3434 pT->_OpenThemeData(); |
| 3435 } |
| 3436 return 0; |
| 3437 } |
| 3438 #endif // !_WTL_NO_AUTO_THEME |
| 3439 |
| 3440 LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled
*/) |
| 3441 { |
| 3442 LRESULT lRet = DefWindowProc(uMsg, wParam, lParam); |
| 3443 T* pT = static_cast<T*>(this); |
| 3444 pT->_AdjustBtnSize(GET_Y_LPARAM(lParam)); |
| 3445 return lRet; |
| 3446 } |
| 3447 |
| 3448 LRESULT OnNcCalcSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bH
andled*/) |
| 3449 { |
| 3450 LRESULT lRet = DefWindowProc(uMsg, wParam, lParam); |
| 3451 |
| 3452 if(m_bChildMaximized && (BOOL)wParam) |
| 3453 { |
| 3454 LPNCCALCSIZE_PARAMS lpParams = (LPNCCALCSIZE_PARAMS)lPar
am; |
| 3455 if(m_bLayoutRTL) |
| 3456 { |
| 3457 lpParams->rgrc[0].left += m_cxRight; |
| 3458 lpParams->rgrc[0].right -= m_cxLeft; |
| 3459 } |
| 3460 else |
| 3461 { |
| 3462 lpParams->rgrc[0].left += m_cxLeft; |
| 3463 lpParams->rgrc[0].right -= m_cxRight; |
| 3464 } |
| 3465 } |
| 3466 |
| 3467 return lRet; |
| 3468 } |
| 3469 |
| 3470 LRESULT OnNcPaint(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHand
led*/) |
| 3471 { |
| 3472 LRESULT lRet = DefWindowProc(uMsg, wParam, lParam); |
| 3473 |
| 3474 if(!m_bChildMaximized) |
| 3475 return lRet; |
| 3476 |
| 3477 ATLASSERT(m_hWndChildMaximized != NULL && m_hIconChildMaximized
!= NULL); |
| 3478 |
| 3479 // get DC and window rectangle |
| 3480 CWindowDC dc(m_hWnd); |
| 3481 RECT rect; |
| 3482 GetWindowRect(&rect); |
| 3483 int cxWidth = rect.right - rect.left; |
| 3484 int cyHeight = rect.bottom - rect.top; |
| 3485 |
| 3486 // paint left side nonclient background and draw icon |
| 3487 ::SetRect(&rect, 0, 0, m_cxLeft, cyHeight); |
| 3488 #ifndef _WTL_NO_AUTO_THEME |
| 3489 if(m_hTheme != NULL) |
| 3490 { |
| 3491 if(m_pfnDrawThemeParentBackground != NULL) |
| 3492 m_pfnDrawThemeParentBackground(m_hWnd, dc, &rect
); |
| 3493 else |
| 3494 dc.FillRect(&rect, COLOR_WINDOW); |
| 3495 } |
| 3496 else |
| 3497 #endif // !_WTL_NO_AUTO_THEME |
| 3498 { |
| 3499 if((m_dwExtendedStyle & CBR_EX_TRANSPARENT) != 0) |
| 3500 dc.FillRect(&rect, COLOR_3DFACE); |
| 3501 else |
| 3502 dc.FillRect(&rect, COLOR_MENU); |
| 3503 } |
| 3504 |
| 3505 RECT rcIcon = { 0 }; |
| 3506 T* pT = static_cast<T*>(this); |
| 3507 pT->_CalcIconRect(cxWidth, cyHeight, rcIcon); |
| 3508 dc.DrawIconEx(rcIcon.left, rcIcon.top, m_hIconChildMaximized, m_
cxIconWidth, m_cyIconHeight); |
| 3509 |
| 3510 // paint right side nonclient background |
| 3511 ::SetRect(&rect, cxWidth - m_cxRight, 0, cxWidth, cyHeight); |
| 3512 #ifndef _WTL_NO_AUTO_THEME |
| 3513 if(m_hTheme != NULL) |
| 3514 { |
| 3515 if(m_pfnDrawThemeParentBackground != NULL) |
| 3516 { |
| 3517 // this is to account for the left non-client ar
ea |
| 3518 POINT ptOrg = { 0, 0 }; |
| 3519 dc.GetViewportOrg(&ptOrg); |
| 3520 dc.SetViewportOrg(ptOrg.x + m_cxLeft, ptOrg.y); |
| 3521 ::OffsetRect(&rect, -m_cxLeft, 0); |
| 3522 |
| 3523 m_pfnDrawThemeParentBackground(m_hWnd, dc, &rect
); |
| 3524 |
| 3525 // restore |
| 3526 dc.SetViewportOrg(ptOrg); |
| 3527 ::OffsetRect(&rect, m_cxLeft, 0); |
| 3528 } |
| 3529 else |
| 3530 { |
| 3531 dc.FillRect(&rect, COLOR_3DFACE); |
| 3532 } |
| 3533 } |
| 3534 else |
| 3535 #endif // !_WTL_NO_AUTO_THEME |
| 3536 { |
| 3537 if((m_dwExtendedStyle & CBR_EX_TRANSPARENT) != 0) |
| 3538 dc.FillRect(&rect, COLOR_3DFACE); |
| 3539 else |
| 3540 dc.FillRect(&rect, COLOR_MENU); |
| 3541 } |
| 3542 |
| 3543 // draw buttons |
| 3544 RECT arrRect[3] = { 0 }; |
| 3545 pT->_CalcBtnRects(cxWidth, cyHeight, arrRect); |
| 3546 pT->_DrawMDIButton(dc, arrRect, -1); // draw all buttons |
| 3547 |
| 3548 return lRet; |
| 3549 } |
| 3550 |
| 3551 LRESULT OnNcHitTest(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHa
ndled*/) |
| 3552 { |
| 3553 LRESULT lRet = DefWindowProc(uMsg, wParam, lParam); |
| 3554 if(m_bChildMaximized) |
| 3555 { |
| 3556 RECT rect = { 0 }; |
| 3557 GetWindowRect(&rect); |
| 3558 POINT pt = { GET_X_LPARAM(lParam) - rect.left, GET_Y_LPA
RAM(lParam) - rect.top }; |
| 3559 if(m_bLayoutRTL) |
| 3560 { |
| 3561 if((pt.x < m_cxRight) || (pt.x > ((rect.right -
rect.left) - m_cxLeft))) |
| 3562 lRet = HTBORDER; |
| 3563 } |
| 3564 else |
| 3565 { |
| 3566 if((pt.x < m_cxLeft) || (pt.x > ((rect.right - r
ect.left) - m_cxRight))) |
| 3567 lRet = HTBORDER; |
| 3568 } |
| 3569 } |
| 3570 return lRet; |
| 3571 } |
| 3572 |
| 3573 LRESULT OnNcLButtonDown(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam,
BOOL& bHandled) |
| 3574 { |
| 3575 if(!m_bChildMaximized) |
| 3576 { |
| 3577 bHandled = FALSE; |
| 3578 return 1; |
| 3579 } |
| 3580 |
| 3581 ATLASSERT(_DebugCheckChild()); |
| 3582 |
| 3583 POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) }; |
| 3584 RECT rect = { 0 }; |
| 3585 GetWindowRect(&rect); |
| 3586 pt.x -= rect.left; |
| 3587 pt.y -= rect.top; |
| 3588 |
| 3589 RECT rcIcon = { 0 }; |
| 3590 T* pT = static_cast<T*>(this); |
| 3591 pT->_CalcIconRect(rect.right - rect.left, rect.bottom - rect.top
, rcIcon, m_bLayoutRTL); |
| 3592 RECT arrRect[3] = { 0 }; |
| 3593 pT->_CalcBtnRects(rect.right - rect.left, rect.bottom - rect.top
, arrRect, m_bLayoutRTL); |
| 3594 |
| 3595 if(::PtInRect(&rcIcon, pt)) |
| 3596 { |
| 3597 #ifdef _CMDBAR_EXTRA_TRACE |
| 3598 ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButtonDown: i
con\n")); |
| 3599 #endif |
| 3600 #ifndef TPM_VERPOSANIMATION |
| 3601 const UINT TPM_VERPOSANIMATION = 0x1000L; // Menu anim
ation flag |
| 3602 #endif |
| 3603 CMenuHandle menu = ::GetSystemMenu(m_hWndChildMaximized,
FALSE); |
| 3604 UINT uRet = (UINT)menu.TrackPopupMenu(TPM_LEFTBUTTON | T
PM_VERTICAL | TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RETURNCMD | |
| 3605 (s_bW2K ? TPM_VERPOSANIMATION : 0), m_bLayoutRTL
? rect.right : rect.left, rect.bottom, m_hWndChildMaximized); |
| 3606 |
| 3607 // eat next message if click is on the same button |
| 3608 ::OffsetRect(&rcIcon, rect.left, rect.top); |
| 3609 MSG msg = { 0 }; |
| 3610 if(::PeekMessage(&msg, m_hWnd, WM_NCLBUTTONDOWN, WM_NCLB
UTTONDOWN, PM_NOREMOVE) && ::PtInRect(&rcIcon, msg.pt)) |
| 3611 ::PeekMessage(&msg, m_hWnd, WM_NCLBUTTONDOWN, WM
_NCLBUTTONDOWN, PM_REMOVE); |
| 3612 |
| 3613 if(uRet != 0) |
| 3614 ::SendMessage(m_hWndChildMaximized, WM_SYSCOMMAN
D, uRet, 0L); |
| 3615 } |
| 3616 else if(::PtInRect(&arrRect[0], pt)) |
| 3617 { |
| 3618 #ifdef _CMDBAR_EXTRA_TRACE |
| 3619 ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButtonDown: c
lose button\n")); |
| 3620 #endif |
| 3621 m_nBtnWasPressed = m_nBtnPressed = 0; |
| 3622 } |
| 3623 else if(::PtInRect(&arrRect[1], pt)) |
| 3624 { |
| 3625 #ifdef _CMDBAR_EXTRA_TRACE |
| 3626 ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButtonDown: r
estore button\n")); |
| 3627 #endif |
| 3628 m_nBtnWasPressed = m_nBtnPressed = 1; |
| 3629 } |
| 3630 else if(::PtInRect(&arrRect[2], pt)) |
| 3631 { |
| 3632 #ifdef _CMDBAR_EXTRA_TRACE |
| 3633 ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButtonDown: m
inimize button\n")); |
| 3634 #endif |
| 3635 m_nBtnWasPressed = m_nBtnPressed = 2; |
| 3636 } |
| 3637 else |
| 3638 { |
| 3639 bHandled = FALSE; |
| 3640 } |
| 3641 |
| 3642 // draw the button state if it was pressed |
| 3643 if(m_nBtnPressed != -1) |
| 3644 { |
| 3645 SetCapture(); |
| 3646 CWindowDC dc(m_hWnd); |
| 3647 pT->_CalcBtnRects(rect.right - rect.left, rect.bottom -
rect.top, arrRect); |
| 3648 pT->_DrawMDIButton(dc, arrRect, m_nBtnPressed); |
| 3649 } |
| 3650 |
| 3651 return 0; |
| 3652 } |
| 3653 |
| 3654 LRESULT OnMouseMove(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOO
L& bHandled) |
| 3655 { |
| 3656 if(!m_bChildMaximized || ::GetCapture() != m_hWnd || m_nBtnWasPr
essed == -1) |
| 3657 { |
| 3658 bHandled = FALSE; |
| 3659 return 1; |
| 3660 } |
| 3661 |
| 3662 POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) }; |
| 3663 ClientToScreen(&pt); |
| 3664 RECT rect = { 0 }; |
| 3665 GetWindowRect(&rect); |
| 3666 pt.x -= rect.left; |
| 3667 pt.y -= rect.top; |
| 3668 RECT arrRect[3] = { 0 }; |
| 3669 T* pT = static_cast<T*>(this); |
| 3670 pT->_CalcBtnRects(rect.right - rect.left, rect.bottom - rect.top
, arrRect, m_bLayoutRTL); |
| 3671 int nOldBtnPressed = m_nBtnPressed; |
| 3672 m_nBtnPressed = ::PtInRect(&arrRect[m_nBtnWasPressed], pt) ? m_n
BtnWasPressed : -1; |
| 3673 if(nOldBtnPressed != m_nBtnPressed) |
| 3674 { |
| 3675 CWindowDC dc(m_hWnd); |
| 3676 pT->_CalcBtnRects(rect.right - rect.left, rect.bottom -
rect.top, arrRect); |
| 3677 pT->_DrawMDIButton(dc, arrRect, (m_nBtnPressed != -1) ?
m_nBtnPressed : nOldBtnPressed); |
| 3678 } |
| 3679 |
| 3680 return 0; |
| 3681 } |
| 3682 |
| 3683 LRESULT OnLButtonUp(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOO
L& bHandled) |
| 3684 { |
| 3685 if(!m_bChildMaximized || ::GetCapture() != m_hWnd || m_nBtnWasPr
essed == -1) |
| 3686 { |
| 3687 bHandled = FALSE; |
| 3688 return 1; |
| 3689 } |
| 3690 |
| 3691 ATLASSERT(_DebugCheckChild()); |
| 3692 |
| 3693 POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) }; |
| 3694 ClientToScreen(&pt); |
| 3695 RECT rect = { 0 }; |
| 3696 GetWindowRect(&rect); |
| 3697 pt.x -= rect.left; |
| 3698 pt.y -= rect.top; |
| 3699 |
| 3700 int nBtn = m_nBtnWasPressed; |
| 3701 ReleaseCapture(); |
| 3702 |
| 3703 RECT arrRect[3] = { 0 }; |
| 3704 T* pT = static_cast<T*>(this); |
| 3705 pT->_CalcBtnRects(rect.right - rect.left, rect.bottom - rect.top
, arrRect, m_bLayoutRTL); |
| 3706 if(::PtInRect(&arrRect[nBtn], pt)) |
| 3707 { |
| 3708 switch(nBtn) |
| 3709 { |
| 3710 case 0: // close |
| 3711 #ifdef _CMDBAR_EXTRA_TRACE |
| 3712 ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButto
nUp: close button\n")); |
| 3713 #endif |
| 3714 ::SendMessage(m_hWndChildMaximized, WM_SYSCOMMAN
D, SC_CLOSE, 0L); |
| 3715 break; |
| 3716 case 1: // restore |
| 3717 #ifdef _CMDBAR_EXTRA_TRACE |
| 3718 ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButto
nUp: restore button\n")); |
| 3719 #endif |
| 3720 ::SendMessage(m_hWndChildMaximized, WM_SYSCOMMAN
D, SC_RESTORE, 0L); |
| 3721 break; |
| 3722 case 2: // minimize |
| 3723 #ifdef _CMDBAR_EXTRA_TRACE |
| 3724 ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButto
nUp: minimize button\n")); |
| 3725 #endif |
| 3726 ::SendMessage(m_hWndChildMaximized, WM_SYSCOMMAN
D, SC_MINIMIZE, 0L); |
| 3727 break; |
| 3728 default: |
| 3729 break; |
| 3730 } |
| 3731 } |
| 3732 |
| 3733 return 0; |
| 3734 } |
| 3735 |
| 3736 LRESULT OnNcLButtonDblClk(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lPara
m, BOOL& bHandled) |
| 3737 { |
| 3738 if(!m_bChildMaximized || m_nBtnWasPressed != -1) |
| 3739 { |
| 3740 bHandled = FALSE; |
| 3741 return 1; |
| 3742 } |
| 3743 |
| 3744 ATLASSERT(_DebugCheckChild()); |
| 3745 |
| 3746 POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) }; |
| 3747 RECT rect = { 0 }; |
| 3748 GetWindowRect(&rect); |
| 3749 pt.x -= rect.left; |
| 3750 pt.y -= rect.top; |
| 3751 |
| 3752 RECT rcIcon = { 0 }; |
| 3753 T* pT = static_cast<T*>(this); |
| 3754 pT->_CalcIconRect(rect.right - rect.left, rect.bottom - rect.top
, rcIcon, m_bLayoutRTL); |
| 3755 RECT arrRect[3] = { 0 }; |
| 3756 pT->_CalcBtnRects(rect.right - rect.left, rect.bottom - rect.top
, arrRect, m_bLayoutRTL); |
| 3757 |
| 3758 if(::PtInRect(&rcIcon, pt)) |
| 3759 { |
| 3760 CMenuHandle menu = ::GetSystemMenu(m_hWndChildMaximized,
FALSE); |
| 3761 UINT uDefID = menu.GetMenuDefaultItem(); |
| 3762 if(uDefID == (UINT)-1) |
| 3763 uDefID = SC_CLOSE; |
| 3764 ::SendMessage(m_hWndChildMaximized, WM_SYSCOMMAND, uDefI
D, 0L); |
| 3765 } |
| 3766 |
| 3767 return 0; |
| 3768 } |
| 3769 |
| 3770 LRESULT OnCaptureChanged(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lPar
am*/, BOOL& bHandled) |
| 3771 { |
| 3772 if(m_bChildMaximized) |
| 3773 { |
| 3774 if(m_nBtnPressed != -1) |
| 3775 { |
| 3776 ATLASSERT(m_nBtnPressed == m_nBtnWasPressed);
// must be |
| 3777 m_nBtnPressed = -1; |
| 3778 RECT rect = { 0 }; |
| 3779 GetWindowRect(&rect); |
| 3780 RECT arrRect[3] = { 0 }; |
| 3781 T* pT = static_cast<T*>(this); |
| 3782 pT->_CalcBtnRects(rect.right - rect.left, rect.b
ottom - rect.top, arrRect); |
| 3783 CWindowDC dc(m_hWnd); |
| 3784 pT->_DrawMDIButton(dc, arrRect, m_nBtnWasPressed
); |
| 3785 } |
| 3786 m_nBtnWasPressed = -1; |
| 3787 } |
| 3788 else |
| 3789 { |
| 3790 bHandled = FALSE; |
| 3791 } |
| 3792 return 0; |
| 3793 } |
| 3794 |
| 3795 // Parent window message handlers |
| 3796 LRESULT OnParentActivate(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/
, BOOL& bHandled) |
| 3797 { |
| 3798 m_bParentActive = (LOWORD(wParam) != WA_INACTIVE); |
| 3799 RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_UPDATE
NOW); |
| 3800 bHandled = FALSE; |
| 3801 return 1; |
| 3802 } |
| 3803 |
| 3804 // MDI client window message handlers |
| 3805 LRESULT OnMDISetMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bH
andled*/) |
| 3806 { |
| 3807 m_wndMDIClient.DefWindowProc(uMsg, NULL, lParam); |
| 3808 HMENU hOldMenu = GetMenu(); |
| 3809 BOOL bRet = AttachMenu((HMENU)wParam); |
| 3810 bRet; // avoid level 4 warning |
| 3811 ATLASSERT(bRet); |
| 3812 |
| 3813 #if (_WIN32_IE >= 0x0400) |
| 3814 T* pT = static_cast<T*>(this); |
| 3815 pT->UpdateRebarBandIdealSize(); |
| 3816 #endif // (_WIN32_IE >= 0x0400) |
| 3817 |
| 3818 return (LRESULT)hOldMenu; |
| 3819 } |
| 3820 |
| 3821 // All messages from the message hook |
| 3822 LRESULT OnAllHookMessages(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL&
bHandled) |
| 3823 { |
| 3824 T* pT = static_cast<T*>(this); |
| 3825 pT->_ProcessAllHookMessages(uMsg, wParam, lParam); |
| 3826 |
| 3827 bHandled = FALSE; |
| 3828 return 1; |
| 3829 } |
| 3830 |
| 3831 // Overrideables |
| 3832 // override this to provide different ideal size |
| 3833 void UpdateRebarBandIdealSize() |
| 3834 { |
| 3835 // assuming we are in a rebar, change ideal size to our size |
| 3836 // we hope that if we are not in a rebar, nCount will be 0 |
| 3837 int nCount = (int)::SendMessage(GetParent(), RB_GETBANDCOUNT, 0,
0L); |
| 3838 for(int i = 0; i < nCount; i++) |
| 3839 { |
| 3840 REBARBANDINFO rbi = { RunTimeHelper::SizeOf_REBARBANDINF
O(), RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_IDEALSIZE }; |
| 3841 ::SendMessage(GetParent(), RB_GETBANDINFO, i, (LPARAM)&r
bi); |
| 3842 if(rbi.hwndChild == m_hWnd) |
| 3843 { |
| 3844 rbi.fMask = RBBIM_IDEALSIZE; |
| 3845 rbi.cxIdeal = m_bChildMaximized ? m_cxLeft + m_c
xRight : 0; |
| 3846 int nBtnCount = GetButtonCount(); |
| 3847 if(nBtnCount > 0) |
| 3848 { |
| 3849 RECT rect = { 0 }; |
| 3850 GetItemRect(nBtnCount - 1, &rect); |
| 3851 rbi.cxIdeal += rect.right; |
| 3852 } |
| 3853 ::SendMessage(GetParent(), RB_SETBANDINFO, i, (L
PARAM)&rbi); |
| 3854 break; |
| 3855 } |
| 3856 } |
| 3857 } |
| 3858 |
| 3859 // all hook messages - check for the maximized MDI child window change |
| 3860 void _ProcessAllHookMessages(UINT uMsg, WPARAM /*wParam*/, LPARAM /*lPar
am*/) |
| 3861 { |
| 3862 if(uMsg == WM_MDIGETACTIVE || uMsg == WM_MDISETMENU) |
| 3863 return; |
| 3864 |
| 3865 BOOL bMaximized = FALSE; |
| 3866 HWND hWndChild = (HWND)::SendMessage(m_wndMDIClient, WM_MDIGETAC
TIVE, 0, (LPARAM)&bMaximized); |
| 3867 bool bMaxOld = m_bChildMaximized; |
| 3868 m_bChildMaximized = (hWndChild != NULL && bMaximized); |
| 3869 HICON hIconOld = m_hIconChildMaximized; |
| 3870 |
| 3871 if(m_bChildMaximized) |
| 3872 { |
| 3873 if(m_hWndChildMaximized != hWndChild) |
| 3874 { |
| 3875 ATL::CWindow wnd = m_hWndChildMaximized = hWndCh
ild; |
| 3876 m_hIconChildMaximized = wnd.GetIcon(FALSE); |
| 3877 if(m_hIconChildMaximized == NULL) |
| 3878 { |
| 3879 m_hIconChildMaximized = wnd.GetIcon(TRUE
); |
| 3880 if(m_hIconChildMaximized == NULL) |
| 3881 { |
| 3882 // no icon set with WM_SETICON,
get the class one |
| 3883 // need conditional code because types don't match in winuser.h |
| 3884 #ifdef _WIN64 |
| 3885 m_hIconChildMaximized = (HICON):
:GetClassLongPtr(wnd, GCLP_HICONSM); |
| 3886 #else |
| 3887 m_hIconChildMaximized = (HICON)L
ongToHandle(::GetClassLongPtr(wnd, GCLP_HICONSM)); |
| 3888 #endif |
| 3889 } |
| 3890 } |
| 3891 } |
| 3892 } |
| 3893 else |
| 3894 { |
| 3895 m_hWndChildMaximized = NULL; |
| 3896 m_hIconChildMaximized = NULL; |
| 3897 } |
| 3898 |
| 3899 if(bMaxOld != m_bChildMaximized) |
| 3900 { |
| 3901 #ifdef _CMDBAR_EXTRA_TRACE |
| 3902 ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - All messages h
ook change: m_bChildMaximized = %s\n"), m_bChildMaximized ? "true" : "false"); |
| 3903 #endif |
| 3904 // assuming we are in a rebar, change our size to accomo
date new state |
| 3905 // we hope that if we are not in a rebar, nCount will be
0 |
| 3906 int nCount = (int)::SendMessage(GetParent(), RB_GETBANDC
OUNT, 0, 0L); |
| 3907 int cxDiff = (m_bChildMaximized ? 1 : -1) * (m_cxLeft +
m_cxRight); |
| 3908 for(int i = 0; i < nCount; i++) |
| 3909 { |
| 3910 #if (_WIN32_IE >= 0x0500) |
| 3911 REBARBANDINFO rbi = { RunTimeHelper::SizeOf_REBA
RBANDINFO(), RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_IDEALSIZE | RBBIM_STYLE }; |
| 3912 ::SendMessage(GetParent(), RB_GETBANDINFO, i, (L
PARAM)&rbi); |
| 3913 if(rbi.hwndChild == m_hWnd) |
| 3914 { |
| 3915 if((rbi.fStyle & RBBS_USECHEVRON) != 0) |
| 3916 { |
| 3917 rbi.fMask = RBBIM_CHILDSIZE | RB
BIM_IDEALSIZE; |
| 3918 rbi.cxMinChild += cxDiff; |
| 3919 rbi.cxIdeal += cxDiff; |
| 3920 ::SendMessage(GetParent(), RB_SE
TBANDINFO, i, (LPARAM)&rbi); |
| 3921 } |
| 3922 break; |
| 3923 } |
| 3924 #elif (_WIN32_IE >= 0x0400) |
| 3925 REBARBANDINFO rbi = { RunTimeHelper::SizeOf_REBA
RBANDINFO(), RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_IDEALSIZE }; |
| 3926 ::SendMessage(GetParent(), RB_GETBANDINFO, i, (L
PARAM)&rbi); |
| 3927 if(rbi.hwndChild == m_hWnd) |
| 3928 { |
| 3929 rbi.fMask = RBBIM_CHILDSIZE | RBBIM_IDEA
LSIZE; |
| 3930 rbi.cxMinChild += cxDiff; |
| 3931 rbi.cxIdeal += cxDiff; |
| 3932 ::SendMessage(GetParent(), RB_SETBANDINF
O, i, (LPARAM)&rbi); |
| 3933 break; |
| 3934 } |
| 3935 #else // (_WIN32_IE < 0x0400) |
| 3936 REBARBANDINFO rbi = { RunTimeHelper::SizeOf_REBA
RBANDINFO(), RBBIM_CHILD | RBBIM_CHILDSIZE }; |
| 3937 ::SendMessage(GetParent(), RB_GETBANDINFO, i, (L
PARAM)&rbi); |
| 3938 if(rbi.hwndChild == m_hWnd) |
| 3939 { |
| 3940 rbi.fMask = RBBIM_CHILDSIZE; |
| 3941 rbi.cxMinChild += cxDiff; |
| 3942 ::SendMessage(GetParent(), RB_SETBANDINF
O, i, (LPARAM)&rbi); |
| 3943 break; |
| 3944 } |
| 3945 #endif // (_WIN32_IE < 0x0400) |
| 3946 } |
| 3947 } |
| 3948 |
| 3949 if(bMaxOld != m_bChildMaximized || hIconOld != m_hIconChildMaxim
ized) |
| 3950 { |
| 3951 // force size change and redraw everything |
| 3952 RECT rect = { 0 }; |
| 3953 GetWindowRect(&rect); |
| 3954 ::MapWindowPoints(NULL, GetParent(), (LPPOINT)&rect, 2); |
| 3955 SetRedraw(FALSE); |
| 3956 SetWindowPos(NULL, 0, 0, 1, 1, SWP_NOZORDER | SWP_NOMOVE
); |
| 3957 SetWindowPos(NULL, &rect, SWP_NOZORDER | SWP_NOMOVE); |
| 3958 SetRedraw(TRUE); |
| 3959 RedrawWindow(NULL, NULL, RDW_FRAME | RDW_INVALIDATE | RD
W_UPDATENOW); |
| 3960 } |
| 3961 } |
| 3962 |
| 3963 // Implementation |
| 3964 void GetSystemSettings() |
| 3965 { |
| 3966 #ifdef _CMDBAR_EXTRA_TRACE |
| 3967 ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - GetSystemSettings\n"))
; |
| 3968 #endif |
| 3969 _baseClass::GetSystemSettings(); |
| 3970 |
| 3971 NONCLIENTMETRICS info = { RunTimeHelper::SizeOf_NONCLIENTMETRICS
() }; |
| 3972 BOOL bRet = ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, size
of(info), &info, 0); |
| 3973 ATLASSERT(bRet); |
| 3974 if(bRet) |
| 3975 { |
| 3976 m_cxIconWidth = ::GetSystemMetrics(SM_CXSMICON); |
| 3977 m_cyIconHeight = ::GetSystemMetrics(SM_CYSMICON); |
| 3978 m_cxLeft = m_cxIconWidth; |
| 3979 |
| 3980 #ifndef _WTL_NO_AUTO_THEME |
| 3981 if(m_hTheme != NULL) |
| 3982 { |
| 3983 m_cxBtnWidth = info.iCaptionWidth - 2 * m_cxyOff
set; |
| 3984 m_cyBtnHeight = info.iCaptionHeight - 2 * m_cxyO
ffset; |
| 3985 m_cxRight = 3 * m_cxBtnWidth; |
| 3986 } |
| 3987 else |
| 3988 #endif // !_WTL_NO_AUTO_THEME |
| 3989 { |
| 3990 m_cxBtnWidth = info.iCaptionWidth - m_cxyOffset; |
| 3991 m_cyBtnHeight = info.iCaptionHeight - 2 * m_cxyO
ffset; |
| 3992 m_cxRight = 3 * m_cxBtnWidth + m_cxyOffset; |
| 3993 } |
| 3994 } |
| 3995 |
| 3996 RECT rect = { 0 }; |
| 3997 GetClientRect(&rect); |
| 3998 T* pT = static_cast<T*>(this); |
| 3999 pT->_AdjustBtnSize(rect.bottom); |
| 4000 } |
| 4001 |
| 4002 void _AdjustBtnSize(int cyHeight) |
| 4003 { |
| 4004 if(cyHeight > 1 && m_cyBtnHeight > cyHeight) |
| 4005 { |
| 4006 #ifndef _WTL_NO_AUTO_THEME |
| 4007 if(m_hTheme != NULL) |
| 4008 { |
| 4009 m_cyBtnHeight = cyHeight; |
| 4010 m_cxBtnWidth = cyHeight; |
| 4011 m_cxRight = 3 * m_cxBtnWidth; |
| 4012 } |
| 4013 else |
| 4014 #endif // !_WTL_NO_AUTO_THEME |
| 4015 { |
| 4016 m_cyBtnHeight = cyHeight; |
| 4017 m_cxBtnWidth = cyHeight + m_cxyOffset; |
| 4018 m_cxRight = 3 * m_cxBtnWidth + m_cxyOffset; |
| 4019 } |
| 4020 } |
| 4021 } |
| 4022 |
| 4023 void _CalcIconRect(int cxWidth, int cyHeight, RECT& rect, bool bInvertX
= false) const |
| 4024 { |
| 4025 int xStart = (m_cxLeft - m_cxIconWidth) / 2; |
| 4026 if(xStart < 0) |
| 4027 xStart = 0; |
| 4028 int yStart = (cyHeight - m_cyIconHeight) / 2; |
| 4029 if(yStart < 0) |
| 4030 yStart = 0; |
| 4031 |
| 4032 if(bInvertX) |
| 4033 ::SetRect(&rect, cxWidth - (xStart + m_cxBtnWidth), ySta
rt, cxWidth - xStart, yStart + m_cyBtnHeight); |
| 4034 else |
| 4035 ::SetRect(&rect, xStart, yStart, xStart + m_cxBtnWidth,
yStart + m_cyBtnHeight); |
| 4036 } |
| 4037 |
| 4038 void _CalcBtnRects(int cxWidth, int cyHeight, RECT arrRect[3], bool bInv
ertX = false) const |
| 4039 { |
| 4040 int yStart = (cyHeight - m_cyBtnHeight) / 2; |
| 4041 if(yStart < 0) |
| 4042 yStart = 0; |
| 4043 |
| 4044 RECT rcBtn = { cxWidth - m_cxBtnWidth, yStart, cxWidth, yStart +
m_cyBtnHeight }; |
| 4045 int nDirection = -1; |
| 4046 if(bInvertX) |
| 4047 { |
| 4048 ::SetRect(&rcBtn, 0, yStart, m_cxBtnWidth, yStart + m_cy
BtnHeight); |
| 4049 nDirection = 1; |
| 4050 } |
| 4051 |
| 4052 arrRect[0] = rcBtn; |
| 4053 #ifndef _WTL_NO_AUTO_THEME |
| 4054 if(m_hTheme != NULL) |
| 4055 ::OffsetRect(&rcBtn, nDirection * m_cxBtnWidth, 0); |
| 4056 else |
| 4057 #endif // !_WTL_NO_AUTO_THEME |
| 4058 ::OffsetRect(&rcBtn, nDirection * (m_cxBtnWidth + m_cxyO
ffset), 0); |
| 4059 arrRect[1] = rcBtn; |
| 4060 ::OffsetRect(&rcBtn, nDirection * m_cxBtnWidth, 0); |
| 4061 arrRect[2] = rcBtn; |
| 4062 } |
| 4063 |
| 4064 void _DrawMDIButton(CWindowDC& dc, LPRECT pRects, int nBtn) |
| 4065 { |
| 4066 #ifndef _WTL_NO_AUTO_THEME |
| 4067 if(m_hTheme != NULL) |
| 4068 { |
| 4069 #ifndef TMSCHEMA_H |
| 4070 const int WP_MDICLOSEBUTTON = 20; |
| 4071 const int CBS_NORMAL = 1; |
| 4072 const int CBS_PUSHED = 3; |
| 4073 const int CBS_DISABLED = 4; |
| 4074 const int WP_MDIRESTOREBUTTON = 22; |
| 4075 const int RBS_NORMAL = 1; |
| 4076 const int RBS_PUSHED = 3; |
| 4077 const int RBS_DISABLED = 4; |
| 4078 const int WP_MDIMINBUTTON = 16; |
| 4079 const int MINBS_NORMAL = 1; |
| 4080 const int MINBS_PUSHED = 3; |
| 4081 const int MINBS_DISABLED = 4; |
| 4082 #endif // TMSCHEMA_H |
| 4083 if(nBtn == -1 || nBtn == 0) |
| 4084 m_pfnDrawThemeBackground(m_hTheme, dc, WP_MDICLO
SEBUTTON, m_bParentActive ? ((m_nBtnPressed == 0) ? CBS_PUSHED : CBS_NORMAL) : C
BS_DISABLED, &pRects[0], NULL); |
| 4085 if(nBtn == -1 || nBtn == 1) |
| 4086 m_pfnDrawThemeBackground(m_hTheme, dc, WP_MDIRES
TOREBUTTON, m_bParentActive ? ((m_nBtnPressed == 1) ? RBS_PUSHED : RBS_NORMAL) :
RBS_DISABLED, &pRects[1], NULL); |
| 4087 if(nBtn == -1 || nBtn == 2) |
| 4088 m_pfnDrawThemeBackground(m_hTheme, dc, WP_MDIMIN
BUTTON, m_bParentActive ? ((m_nBtnPressed == 2) ? MINBS_PUSHED : MINBS_NORMAL) :
MINBS_DISABLED, &pRects[2], NULL); |
| 4089 } |
| 4090 else |
| 4091 #endif // !_WTL_NO_AUTO_THEME |
| 4092 { |
| 4093 if(nBtn == -1 || nBtn == 0) |
| 4094 dc.DrawFrameControl(&pRects[0], DFC_CAPTION, DFC
S_CAPTIONCLOSE | ((m_nBtnPressed == 0) ? DFCS_PUSHED : 0)); |
| 4095 if(nBtn == -1 || nBtn == 1) |
| 4096 dc.DrawFrameControl(&pRects[1], DFC_CAPTION, DFC
S_CAPTIONRESTORE | ((m_nBtnPressed == 1) ? DFCS_PUSHED : 0)); |
| 4097 if(nBtn == -1 || nBtn == 2) |
| 4098 dc.DrawFrameControl(&pRects[2], DFC_CAPTION, DFC
S_CAPTIONMIN | ((m_nBtnPressed == 2) ? DFCS_PUSHED : 0)); |
| 4099 } |
| 4100 } |
| 4101 |
| 4102 #ifndef _WTL_NO_AUTO_THEME |
| 4103 static UINT _GetThemeChangedMsg() |
| 4104 { |
| 4105 #ifndef WM_THEMECHANGED |
| 4106 static const UINT WM_THEMECHANGED = 0x031A; |
| 4107 #endif // !WM_THEMECHANGED |
| 4108 return WM_THEMECHANGED; |
| 4109 } |
| 4110 |
| 4111 void _OpenThemeData() |
| 4112 { |
| 4113 ATLASSERT(m_hThemeDLL != NULL); |
| 4114 |
| 4115 PFN_OpenThemeData pfnOpenThemeData = (PFN_OpenThemeData)::GetPro
cAddress(m_hThemeDLL, "OpenThemeData"); |
| 4116 ATLASSERT(pfnOpenThemeData != NULL); |
| 4117 if(pfnOpenThemeData != NULL) |
| 4118 m_hTheme = pfnOpenThemeData(m_hWnd, L"Window"); |
| 4119 } |
| 4120 |
| 4121 void _CloseThemeData() |
| 4122 { |
| 4123 ATLASSERT(m_hThemeDLL != NULL); |
| 4124 |
| 4125 if(m_hTheme == NULL) |
| 4126 return; // nothing to do |
| 4127 |
| 4128 PFN_CloseThemeData pfnCloseThemeData = (PFN_CloseThemeData)::Get
ProcAddress(m_hThemeDLL, "CloseThemeData"); |
| 4129 ATLASSERT(pfnCloseThemeData != NULL); |
| 4130 if(pfnCloseThemeData != NULL) |
| 4131 { |
| 4132 pfnCloseThemeData(m_hTheme); |
| 4133 m_hTheme = NULL; |
| 4134 } |
| 4135 } |
| 4136 #endif // !_WTL_NO_AUTO_THEME |
| 4137 |
| 4138 bool _DebugCheckChild() |
| 4139 { |
| 4140 #ifdef _DEBUG |
| 4141 BOOL bMaximized = FALSE; |
| 4142 HWND hWndChild = (HWND)::SendMessage(m_wndMDIClient, WM_MDIGETAC
TIVE, 0, (LPARAM)&bMaximized); |
| 4143 return (bMaximized && hWndChild == m_hWndChildMaximized); |
| 4144 #else // !_DEBUG |
| 4145 return true; |
| 4146 #endif // !_DEBUG |
| 4147 } |
| 4148 }; |
| 4149 |
| 4150 class CMDICommandBarCtrl : public CMDICommandBarCtrlImpl<CMDICommandBarCtrl> |
| 4151 { |
| 4152 public: |
| 4153 DECLARE_WND_SUPERCLASS(_T("WTL_MDICommandBar"), GetWndClassName()) |
| 4154 }; |
| 4155 |
| 4156 }; // namespace WTL |
| 4157 |
| 4158 #endif // __ATLCTRLW_H__ |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 703753005:
More Windows build fixes. (Closed)
Base URL: https://github.com/domokit/mojo.git@master