1 // Windows Template Library - WTL version 8.0
\r
2 // Copyright (C) Microsoft Corporation. All rights reserved.
\r
4 // This file is a part of the Windows Template Library.
\r
5 // The use and distribution terms for this software are covered by the
\r
6 // Common Public License 1.0 (http://opensource.org/osi3.0/licenses/cpl1.0.php)
\r
7 // which can be found in the file CPL.TXT at the root of this distribution.
\r
8 // By using this software in any fashion, you are agreeing to be bound by
\r
9 // the terms of this license. You must not remove this notice, or
\r
10 // any other, from this software.
\r
12 #ifndef __ATLCTRLW_H__
\r
13 #define __ATLCTRLW_H__
\r
18 #error ATL requires C++ compilation (use a .cpp suffix)
\r
22 #error atlctrlw.h is not supported on Windows CE
\r
25 #ifndef __ATLAPP_H__
\r
26 #error atlctrlw.h requires atlapp.h to be included first
\r
29 #ifndef __ATLCTRLS_H__
\r
30 #error atlctrlw.h requires atlctrls.h to be included first
\r
33 #if (_WIN32_IE < 0x0400)
\r
34 #error atlctrlw.h requires _WIN32_IE >= 0x0400
\r
37 // Define _WTL_CMDBAR_VISTA_MENUS as 0 to exclude Vista menus support
\r
38 #if !defined(_WTL_CMDBAR_VISTA_MENUS) && (WINVER >= 0x0500) && (_WIN32_WINNT >= 0x0501) && (_WIN32_IE >= 0x0501)
\r
39 #define _WTL_CMDBAR_VISTA_MENUS 1
\r
42 #if _WTL_CMDBAR_VISTA_MENUS
\r
43 #if !((_WIN32_WINNT >= 0x0501) && (_WIN32_IE >= 0x0501))
\r
44 #error _WTL_CMDBAR_VISTA_MENUS requires (_WIN32_WINNT >= 0x0501) && (_WIN32_IE >= 0x0501)
\r
49 ///////////////////////////////////////////////////////////////////////////////
\r
50 // Classes in this file:
\r
52 // CCommandBarCtrlImpl<T, TBase, TWinTraits>
\r
54 // CMDICommandBarCtrlImpl<T, TBase, TWinTraits>
\r
55 // CMDICommandBarCtrl
\r
61 ///////////////////////////////////////////////////////////////////////////////
\r
65 #define CBRWS_TOP CCS_TOP
\r
66 #define CBRWS_BOTTOM CCS_BOTTOM
\r
67 #define CBRWS_NORESIZE CCS_NORESIZE
\r
68 #define CBRWS_NOPARENTALIGN CCS_NOPARENTALIGN
\r
69 #define CBRWS_NODIVIDER CCS_NODIVIDER
\r
72 #define CBR_EX_TRANSPARENT 0x00000001L
\r
73 #define CBR_EX_SHAREMENU 0x00000002L
\r
74 #define CBR_EX_ALTFOCUSMODE 0x00000004L
\r
75 #define CBR_EX_TRACKALWAYS 0x00000008L
\r
76 #define CBR_EX_NOVISTAMENUS 0x00000010L
\r
78 // standard command bar styles
\r
79 #define ATL_SIMPLE_CMDBAR_PANE_STYLE \
\r
80 (WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | CBRWS_NODIVIDER | CBRWS_NORESIZE | CBRWS_NOPARENTALIGN)
\r
82 // Messages - support chevrons for frame windows
\r
83 #define CBRM_GETCMDBAR (WM_USER + 301) // returns command bar HWND
\r
84 #define CBRM_GETMENU (WM_USER + 302) // returns loaded or attached menu
\r
85 #define CBRM_TRACKPOPUPMENU (WM_USER + 303) // displays a popup menu
\r
87 typedef struct tagCBRPOPUPMENU
\r
90 HMENU hMenu; // popup menu do display
\r
91 UINT uFlags; // TPM_* flags for ::TrackPopupMenuEx
\r
94 LPTPMPARAMS lptpm; // ptr to TPMPARAMS for ::TrackPopupMenuEx
\r
95 } CBRPOPUPMENU, *LPCBRPOPUPMENU;
\r
99 class CSimpleStack : public ATL::CSimpleArray< T >
\r
104 #ifdef _CMDBAR_EXTRA_TRACE
\r
105 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - STACK-PUSH (%8.8X) size = %i\n"), t, GetSize());
\r
112 int nLast = GetSize() - 1;
\r
114 return NULL; // must be able to convert to NULL
\r
116 #ifdef _CMDBAR_EXTRA_TRACE
\r
117 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - STACK-POP (%8.8X) size = %i\n"), t, GetSize());
\r
119 if(!RemoveAt(nLast))
\r
126 int nLast = GetSize() - 1;
\r
128 return NULL; // must be able to convert to NULL
\r
129 return m_aT[nLast];
\r
134 ///////////////////////////////////////////////////////////////////////////////
\r
135 // CCommandBarCtrlBase - base class for the Command Bar implementation
\r
137 class CCommandBarCtrlBase : public CToolBarCtrl
\r
140 struct _MsgHookData
\r
145 _MsgHookData() : hMsgHook(NULL), dwUsage(0)
\r
149 typedef ATL::CSimpleMap<DWORD, _MsgHookData*> CMsgHookMap;
\r
150 static CMsgHookMap* s_pmapMsgHook;
\r
152 static HHOOK s_hCreateHook;
\r
153 static bool s_bW2K; // For animation flag
\r
154 static CCommandBarCtrlBase* s_pCurrentBar;
\r
155 static bool s_bStaticInit;
\r
157 CSimpleStack<HWND> m_stackMenuWnd;
\r
158 CSimpleStack<HMENU> m_stackMenuHandle;
\r
164 CCommandBarCtrlBase() : m_hWndHook(NULL), m_dwMagic(1314)
\r
166 // init static variables
\r
169 CStaticDataInitCriticalSectionLock lock;
\r
170 if(FAILED(lock.Lock()))
\r
172 ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CCommandBarCtrlBase::CCommandBarCtrlBase.\n"));
\r
180 AtlInitCommonControls(ICC_COOL_CLASSES | ICC_BAR_CLASSES);
\r
181 // Animation on Win2000 only
\r
182 s_bW2K = !AtlIsOldWindows();
\r
184 s_bStaticInit = true;
\r
191 bool IsCommandBarBase() const { return m_dwMagic == 1314; }
\r
194 __declspec(selectany) CCommandBarCtrlBase::CMsgHookMap* CCommandBarCtrlBase::s_pmapMsgHook = NULL;
\r
195 __declspec(selectany) HHOOK CCommandBarCtrlBase::s_hCreateHook = NULL;
\r
196 __declspec(selectany) CCommandBarCtrlBase* CCommandBarCtrlBase::s_pCurrentBar = NULL;
\r
197 __declspec(selectany) bool CCommandBarCtrlBase::s_bW2K = false;
\r
198 __declspec(selectany) bool CCommandBarCtrlBase::s_bStaticInit = false;
\r
201 ///////////////////////////////////////////////////////////////////////////////
\r
202 // CCommandBarCtrl - ATL implementation of Command Bars
\r
204 template <class T, class TBase = CCommandBarCtrlBase, class TWinTraits = ATL::CControlWinTraits>
\r
205 class ATL_NO_VTABLE CCommandBarCtrlImpl : public ATL::CWindowImpl< T, TBase, TWinTraits >
\r
208 DECLARE_WND_SUPERCLASS(NULL, TBase::GetWndClassName())
\r
211 struct _MenuItemData // menu item data
\r
219 _MenuItemData() { dwMagic = 0x1313; }
\r
220 bool IsCmdBarMenuItem() { return (dwMagic == 0x1313); }
\r
223 struct _ToolBarData // toolbar resource data
\r
229 //WORD aItems[wItemCount]
\r
232 { return (WORD*)(this+1); }
\r
236 enum _CmdBarDrawConstants
\r
239 s_kcxTextMargin = 2,
\r
240 s_kcxButtonMargin = 3,
\r
241 s_kcyButtonMargin = 3
\r
246 _nMaxMenuItemTextLength = 100,
\r
247 _chChevronShortcut = _T('/')
\r
250 #ifndef DT_HIDEPREFIX
\r
251 enum { DT_HIDEPREFIX = 0x00100000 };
\r
252 #endif // !DT_HIDEPREFIX
\r
256 HIMAGELIST m_hImageList;
\r
257 ATL::CSimpleValArray<WORD> m_arrCommand;
\r
259 DWORD m_dwExtendedStyle; // Command Bar specific extended styles
\r
261 ATL::CContainedWindow m_wndParent;
\r
263 bool m_bMenuActive:1;
\r
264 bool m_bAttachedMenu:1;
\r
265 bool m_bImagesVisible:1;
\r
266 bool m_bPopupItem:1;
\r
267 bool m_bContextMenu:1;
\r
268 bool m_bEscapePressed:1;
\r
270 bool m_bParentActive:1;
\r
271 bool m_bFlatMenus:1;
\r
272 bool m_bUseKeyboardCues:1;
\r
273 bool m_bShowKeyboardCues:1;
\r
274 bool m_bAllowKeyboardCues:1;
\r
275 bool m_bKeyboardInput:1;
\r
276 bool m_bAlphaImages:1;
\r
277 bool m_bLayoutRTL:1;
\r
278 bool m_bSkipPostDown:1;
\r
279 bool m_bVistaMenus:1;
\r
287 COLORREF m_clrMask;
\r
288 CFont m_fontMenu; // used internally, only to measure text
\r
292 HWND m_hWndFocus; // Alternate focus mode
\r
294 int m_cxExtraSpacing;
\r
296 #if _WTL_CMDBAR_VISTA_MENUS
\r
297 ATL::CSimpleValArray<HBITMAP> m_arrVistaBitmap; // Bitmaps for Vista menus
\r
298 #endif // _WTL_CMDBAR_VISTA_MENUS
\r
300 // Constructor/destructor
\r
301 CCommandBarCtrlImpl() :
\r
303 m_hImageList(NULL),
\r
304 m_wndParent(this, 1),
\r
305 m_bMenuActive(false),
\r
306 m_bAttachedMenu(false),
\r
308 m_nNextPopBtn(-1),
\r
309 m_bPopupItem(false),
\r
310 m_bImagesVisible(true),
\r
314 m_bContextMenu(false),
\r
315 m_bEscapePressed(false),
\r
316 m_clrMask(RGB(192, 192, 192)),
\r
317 m_dwExtendedStyle(CBR_EX_TRANSPARENT | CBR_EX_SHAREMENU | CBR_EX_TRACKALWAYS),
\r
318 m_bParentActive(true),
\r
319 m_bFlatMenus(false),
\r
320 m_bUseKeyboardCues(false),
\r
321 m_bShowKeyboardCues(false),
\r
322 m_bAllowKeyboardCues(true),
\r
323 m_bKeyboardInput(false),
\r
324 m_cxExtraSpacing(0),
\r
325 m_bAlphaImages(false),
\r
326 m_bLayoutRTL(false),
\r
327 m_bSkipPostDown(false),
\r
328 m_bVistaMenus(false)
\r
330 SetImageSize(16, 15); // default
\r
333 ~CCommandBarCtrlImpl()
\r
335 if(m_wndParent.IsWindow())
\r
336 /*scary!*/ m_wndParent.UnsubclassWindow();
\r
338 if(m_hMenu != NULL && (m_dwExtendedStyle & CBR_EX_SHAREMENU) == 0)
\r
339 ::DestroyMenu(m_hMenu);
\r
341 if(m_hImageList != NULL)
\r
342 ::ImageList_Destroy(m_hImageList);
\r
346 DWORD GetCommandBarExtendedStyle() const
\r
348 return m_dwExtendedStyle;
\r
351 DWORD SetCommandBarExtendedStyle(DWORD dwExtendedStyle, DWORD dwMask = 0)
\r
353 DWORD dwPrevStyle = m_dwExtendedStyle;
\r
355 m_dwExtendedStyle = dwExtendedStyle;
\r
357 m_dwExtendedStyle = (m_dwExtendedStyle & ~dwMask) | (dwExtendedStyle & dwMask);
\r
358 return dwPrevStyle;
\r
361 CMenuHandle GetMenu() const
\r
363 ATLASSERT(::IsWindow(m_hWnd));
\r
367 COLORREF GetImageMaskColor() const
\r
372 COLORREF SetImageMaskColor(COLORREF clrMask)
\r
374 COLORREF clrOld = m_clrMask;
\r
375 m_clrMask = clrMask;
\r
379 bool GetImagesVisible() const
\r
381 return m_bImagesVisible;
\r
384 bool SetImagesVisible(bool bVisible)
\r
386 bool bOld = m_bImagesVisible;
\r
387 m_bImagesVisible = bVisible;
\r
391 void GetImageSize(SIZE& size) const
\r
396 bool SetImageSize(SIZE& size)
\r
398 return SetImageSize(size.cx, size.cy);
\r
401 bool SetImageSize(int cx, int cy)
\r
403 if(m_hImageList != NULL)
\r
405 if(::ImageList_GetImageCount(m_hImageList) == 0) // empty
\r
407 ::ImageList_Destroy(m_hImageList);
\r
408 m_hImageList = NULL;
\r
412 return false; // can't set, image list exists
\r
416 if(cx == 0 || cy == 0)
\r
419 m_szBitmap.cx = cx;
\r
420 m_szBitmap.cy = cy;
\r
421 m_szButton.cx = m_szBitmap.cx + 2 * s_kcxButtonMargin;
\r
422 m_szButton.cy = m_szBitmap.cy + 2 * s_kcyButtonMargin;
\r
427 bool GetAlphaImages() const
\r
429 return m_bAlphaImages;
\r
432 bool SetAlphaImages(bool bAlphaImages)
\r
434 if(m_hImageList != NULL)
\r
436 if(::ImageList_GetImageCount(m_hImageList) == 0) // empty
\r
438 ::ImageList_Destroy(m_hImageList);
\r
439 m_hImageList = NULL;
\r
443 return false; // can't set, image list exists
\r
447 m_bAlphaImages = bAlphaImages;
\r
451 HWND GetCmdBar() const
\r
453 ATLASSERT(::IsWindow(m_hWnd));
\r
454 return (HWND)::SendMessage(m_hWnd, CBRM_GETCMDBAR, 0, 0L);
\r
458 HWND Create(HWND hWndParent, RECT& rcPos, LPCTSTR szWindowName = NULL,
\r
459 DWORD dwStyle = 0, DWORD dwExStyle = 0,
\r
460 UINT nID = 0, LPVOID lpCreateParam = NULL)
\r
462 // These styles are required for command bars
\r
463 dwStyle |= TBSTYLE_LIST | TBSTYLE_FLAT;
\r
464 #if (_MSC_VER >= 1300)
\r
465 return ATL::CWindowImpl< T, TBase, TWinTraits >::Create(hWndParent, rcPos, szWindowName, dwStyle, dwExStyle, nID, lpCreateParam);
\r
466 #else // !(_MSC_VER >= 1300)
\r
467 typedef ATL::CWindowImpl< T, TBase, TWinTraits > _baseClass;
\r
468 return _baseClass::Create(hWndParent, rcPos, szWindowName, dwStyle, dwExStyle, nID, lpCreateParam);
\r
469 #endif // !(_MSC_VER >= 1300)
\r
472 BOOL AttachToWindow(HWND hWnd)
\r
474 ATLASSERT(m_hWnd == NULL);
\r
475 ATLASSERT(::IsWindow(hWnd));
\r
476 BOOL bRet = SubclassWindow(hWnd);
\r
479 m_bAttachedMenu = true;
\r
480 T* pT = static_cast<T*>(this);
\r
481 pT->GetSystemSettings();
\r
486 BOOL LoadMenu(ATL::_U_STRINGorID menu)
\r
488 ATLASSERT(::IsWindow(m_hWnd));
\r
490 if(m_bAttachedMenu) // doesn't work in this mode
\r
492 if(menu.m_lpstr == NULL)
\r
495 HMENU hMenu = ::LoadMenu(ModuleHelper::GetResourceInstance(), menu.m_lpstr);
\r
499 return AttachMenu(hMenu);
\r
502 BOOL AttachMenu(HMENU hMenu)
\r
504 ATLASSERT(::IsWindow(m_hWnd));
\r
505 ATLASSERT(hMenu == NULL || ::IsMenu(hMenu));
\r
506 if(hMenu != NULL && !::IsMenu(hMenu))
\r
509 #if _WTL_CMDBAR_VISTA_MENUS
\r
510 // remove Vista bitmaps if used
\r
511 if(m_bVistaMenus && (m_hMenu != NULL))
\r
513 T* pT = static_cast<T*>(this);
\r
514 pT->_RemoveVistaBitmapsFromMenu();
\r
516 #endif // _WTL_CMDBAR_VISTA_MENUS
\r
518 // destroy old menu, if needed, and set new one
\r
519 if(m_hMenu != NULL && (m_dwExtendedStyle & CBR_EX_SHAREMENU) == 0)
\r
520 ::DestroyMenu(m_hMenu);
\r
524 if(m_bAttachedMenu) // Nothing else in this mode
\r
527 // Build buttons according to menu
\r
530 // Clear all buttons
\r
531 int nCount = GetButtonCount();
\r
532 for(int i = 0; i < nCount; i++)
\r
533 ATLVERIFY(DeleteButton(0) != FALSE);
\r
535 // Add buttons for each menu item
\r
536 if(m_hMenu != NULL)
\r
538 int nItems = ::GetMenuItemCount(m_hMenu);
\r
540 T* pT = static_cast<T*>(this);
\r
541 pT; // avoid level 4 warning
\r
542 TCHAR szString[pT->_nMaxMenuItemTextLength];
\r
543 for(int i = 0; i < nItems; i++)
\r
546 mii.fMask = MIIM_TYPE | MIIM_STATE | MIIM_SUBMENU;
\r
547 mii.fType = MFT_STRING;
\r
548 mii.dwTypeData = szString;
\r
549 mii.cch = pT->_nMaxMenuItemTextLength;
\r
550 BOOL bRet = ::GetMenuItemInfo(m_hMenu, i, TRUE, &mii);
\r
552 // If we have more than the buffer, we assume we have bitmaps bits
\r
553 if(lstrlen(szString) > pT->_nMaxMenuItemTextLength - 1)
\r
555 mii.fType = MFT_BITMAP;
\r
556 ::SetMenuItemInfo(m_hMenu, i, TRUE, &mii);
\r
560 // NOTE: Command Bar currently supports only drop-down menu items
\r
561 ATLASSERT(mii.hSubMenu != NULL);
\r
563 TBBUTTON btn = { 0 };
\r
566 btn.fsState = (BYTE)(((mii.fState & MFS_DISABLED) == 0) ? TBSTATE_ENABLED : 0);
\r
567 btn.fsStyle = TBSTYLE_BUTTON | TBSTYLE_AUTOSIZE | TBSTYLE_DROPDOWN;
\r
571 bRet = InsertButton(-1, &btn);
\r
574 TBBUTTONINFO bi = { 0 };
\r
575 bi.cbSize = sizeof(TBBUTTONINFO);
\r
576 bi.dwMask = TBIF_TEXT;
\r
577 bi.pszText = szString;
\r
579 bRet = SetButtonInfo(i, &bi);
\r
591 BOOL LoadImages(ATL::_U_STRINGorID image)
\r
593 return _LoadImagesHelper(image, false);
\r
596 BOOL LoadMappedImages(UINT nIDImage, UINT nFlags = 0, LPCOLORMAP lpColorMap = NULL, int nMapSize = 0)
\r
598 return _LoadImagesHelper(nIDImage, true, nFlags , lpColorMap, nMapSize);
\r
601 BOOL _LoadImagesHelper(ATL::_U_STRINGorID image, bool bMapped, UINT nFlags = 0, LPCOLORMAP lpColorMap = NULL, int nMapSize = 0)
\r
603 ATLASSERT(::IsWindow(m_hWnd));
\r
604 HINSTANCE hInstance = ModuleHelper::GetResourceInstance();
\r
606 HRSRC hRsrc = ::FindResource(hInstance, image.m_lpstr, (LPTSTR)RT_TOOLBAR);
\r
610 HGLOBAL hGlobal = ::LoadResource(hInstance, hRsrc);
\r
611 if(hGlobal == NULL)
\r
614 _ToolBarData* pData = (_ToolBarData*)::LockResource(hGlobal);
\r
617 ATLASSERT(pData->wVersion == 1);
\r
619 WORD* pItems = pData->items();
\r
620 int nItems = pData->wItemCount;
\r
622 // Set internal data
\r
623 SetImageSize(pData->wWidth, pData->wHeight);
\r
625 // Create image list if needed
\r
626 if(m_hImageList == NULL)
\r
628 // Check if the bitmap is 32-bit (alpha channel) bitmap (valid for Windows XP only)
\r
629 T* pT = static_cast<T*>(this);
\r
630 m_bAlphaImages = AtlIsAlphaBitmapResource(image);
\r
632 if(!pT->CreateInternalImageList(pData->wItemCount))
\r
636 #if _WTL_CMDBAR_VISTA_MENUS
\r
637 int nOldImageCount = ::ImageList_GetImageCount(m_hImageList);
\r
638 #endif // _WTL_CMDBAR_VISTA_MENUS
\r
640 // Add bitmap to our image list
\r
644 ATLASSERT(HIWORD(PtrToUlong(image.m_lpstr)) == 0); // if mapped, must be a numeric ID
\r
645 int nIDImage = (int)(short)LOWORD(PtrToUlong(image.m_lpstr));
\r
646 bmp.LoadMappedBitmap(nIDImage, (WORD)nFlags, lpColorMap, nMapSize);
\r
651 bmp = (HBITMAP)::LoadImage(ModuleHelper::GetResourceInstance(), image.m_lpstr, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION | LR_DEFAULTSIZE);
\r
653 bmp.LoadBitmap(image.m_lpstr);
\r
655 ATLASSERT(bmp.m_hBitmap != NULL);
\r
656 if(bmp.m_hBitmap == NULL)
\r
658 if(::ImageList_AddMasked(m_hImageList, bmp, m_clrMask) == -1)
\r
661 // Fill the array with command IDs
\r
662 for(int i = 0; i < nItems; i++)
\r
665 m_arrCommand.Add(pItems[i]);
\r
668 int nImageCount = ::ImageList_GetImageCount(m_hImageList);
\r
669 ATLASSERT(nImageCount == m_arrCommand.GetSize());
\r
670 if(nImageCount != m_arrCommand.GetSize())
\r
673 #if _WTL_CMDBAR_VISTA_MENUS
\r
674 if(RunTimeHelper::IsVista())
\r
676 T* pT = static_cast<T*>(this);
\r
677 pT->_AddVistaBitmapsFromImageList(nOldImageCount, nImageCount - nOldImageCount);
\r
678 ATLASSERT(nImageCount == m_arrVistaBitmap.GetSize());
\r
680 #endif // _WTL_CMDBAR_VISTA_MENUS
\r
685 BOOL AddBitmap(ATL::_U_STRINGorID bitmap, int nCommandID)
\r
687 ATLASSERT(::IsWindow(m_hWnd));
\r
689 bmp.LoadBitmap(bitmap.m_lpstr);
\r
690 if(bmp.m_hBitmap == NULL)
\r
692 return AddBitmap(bmp, nCommandID);
\r
695 BOOL AddBitmap(HBITMAP hBitmap, UINT nCommandID)
\r
697 ATLASSERT(::IsWindow(m_hWnd));
\r
698 T* pT = static_cast<T*>(this);
\r
699 // Create image list if it doesn't exist
\r
700 if(m_hImageList == NULL)
\r
702 if(!pT->CreateInternalImageList(1))
\r
705 // check bitmap size
\r
706 CBitmapHandle bmp = hBitmap;
\r
707 SIZE size = { 0, 0 };
\r
709 if(size.cx != m_szBitmap.cx || size.cy != m_szBitmap.cy)
\r
711 ATLASSERT(FALSE); // must match size!
\r
715 int nRet = ::ImageList_AddMasked(m_hImageList, hBitmap, m_clrMask);
\r
718 BOOL bRet = m_arrCommand.Add((WORD)nCommandID);
\r
719 ATLASSERT(::ImageList_GetImageCount(m_hImageList) == m_arrCommand.GetSize());
\r
720 #if _WTL_CMDBAR_VISTA_MENUS
\r
721 if(RunTimeHelper::IsVista())
\r
723 pT->_AddVistaBitmapFromImageList(m_arrCommand.GetSize() - 1);
\r
724 ATLASSERT(m_arrVistaBitmap.GetSize() == m_arrCommand.GetSize());
\r
726 #endif // _WTL_CMDBAR_VISTA_MENUS
\r
730 BOOL AddIcon(ATL::_U_STRINGorID icon, UINT nCommandID)
\r
732 ATLASSERT(::IsWindow(m_hWnd));
\r
733 HICON hIcon = ::LoadIcon(ModuleHelper::GetResourceInstance(), icon.m_lpstr);
\r
736 return AddIcon(hIcon, nCommandID);
\r
739 BOOL AddIcon(HICON hIcon, UINT nCommandID)
\r
741 ATLASSERT(::IsWindow(m_hWnd));
\r
742 T* pT = static_cast<T*>(this);
\r
743 // create image list if it doesn't exist
\r
744 if(m_hImageList == NULL)
\r
746 if(!pT->CreateInternalImageList(1))
\r
750 int nRet = ::ImageList_AddIcon(m_hImageList, hIcon);
\r
753 BOOL bRet = m_arrCommand.Add((WORD)nCommandID);
\r
754 ATLASSERT(::ImageList_GetImageCount(m_hImageList) == m_arrCommand.GetSize());
\r
755 #if _WTL_CMDBAR_VISTA_MENUS
\r
756 if(RunTimeHelper::IsVista())
\r
758 pT->_AddVistaBitmapFromImageList(m_arrCommand.GetSize() - 1);
\r
759 ATLASSERT(m_arrVistaBitmap.GetSize() == m_arrCommand.GetSize());
\r
761 #endif // _WTL_CMDBAR_VISTA_MENUS
\r
765 BOOL ReplaceBitmap(ATL::_U_STRINGorID bitmap, int nCommandID)
\r
767 ATLASSERT(::IsWindow(m_hWnd));
\r
769 bmp.LoadBitmap(bitmap.m_lpstr);
\r
770 if(bmp.m_hBitmap == NULL)
\r
772 return ReplaceBitmap(bmp, nCommandID);
\r
775 BOOL ReplaceBitmap(HBITMAP hBitmap, UINT nCommandID)
\r
777 ATLASSERT(::IsWindow(m_hWnd));
\r
779 for(int i = 0; i < m_arrCommand.GetSize(); i++)
\r
781 if(m_arrCommand[i] == nCommandID)
\r
783 bRet = ::ImageList_Remove(m_hImageList, i);
\r
786 m_arrCommand.RemoveAt(i);
\r
787 #if _WTL_CMDBAR_VISTA_MENUS
\r
788 if(RunTimeHelper::IsVista())
\r
790 if(m_arrVistaBitmap[i] != NULL)
\r
791 ::DeleteObject(m_arrVistaBitmap[i]);
\r
792 m_arrVistaBitmap.RemoveAt(i);
\r
794 #endif // _WTL_CMDBAR_VISTA_MENUS
\r
800 bRet = AddBitmap(hBitmap, nCommandID);
\r
804 BOOL ReplaceIcon(ATL::_U_STRINGorID icon, UINT nCommandID)
\r
806 ATLASSERT(::IsWindow(m_hWnd));
\r
807 HICON hIcon = ::LoadIcon(ModuleHelper::GetResourceInstance(), icon.m_lpstr);
\r
810 return ReplaceIcon(hIcon, nCommandID);
\r
813 BOOL ReplaceIcon(HICON hIcon, UINT nCommandID)
\r
815 ATLASSERT(::IsWindow(m_hWnd));
\r
817 for(int i = 0; i < m_arrCommand.GetSize(); i++)
\r
819 if(m_arrCommand[i] == nCommandID)
\r
821 bRet = (::ImageList_ReplaceIcon(m_hImageList, i, hIcon) != -1);
\r
822 #if _WTL_CMDBAR_VISTA_MENUS
\r
823 if(RunTimeHelper::IsVista() && bRet != FALSE)
\r
825 T* pT = static_cast<T*>(this);
\r
826 pT->_ReplaceVistaBitmapFromImageList(i);
\r
828 #endif // _WTL_CMDBAR_VISTA_MENUS
\r
835 BOOL RemoveImage(int nCommandID)
\r
837 ATLASSERT(::IsWindow(m_hWnd));
\r
840 for(int i = 0; i < m_arrCommand.GetSize(); i++)
\r
842 if(m_arrCommand[i] == nCommandID)
\r
844 bRet = ::ImageList_Remove(m_hImageList, i);
\r
847 m_arrCommand.RemoveAt(i);
\r
848 #if _WTL_CMDBAR_VISTA_MENUS
\r
849 if(RunTimeHelper::IsVista())
\r
851 if(m_arrVistaBitmap[i] != NULL)
\r
852 ::DeleteObject(m_arrVistaBitmap[i]);
\r
853 m_arrVistaBitmap.RemoveAt(i);
\r
855 #endif // _WTL_CMDBAR_VISTA_MENUS
\r
863 BOOL RemoveAllImages()
\r
865 ATLASSERT(::IsWindow(m_hWnd));
\r
867 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Removing all images\n"));
\r
868 BOOL bRet = ::ImageList_RemoveAll(m_hImageList);
\r
871 m_arrCommand.RemoveAll();
\r
872 #if _WTL_CMDBAR_VISTA_MENUS
\r
873 for(int i = 0; i < m_arrVistaBitmap.GetSize(); i++)
\r
875 if(m_arrVistaBitmap[i] != NULL)
\r
876 ::DeleteObject(m_arrVistaBitmap[i]);
\r
878 m_arrVistaBitmap.RemoveAll();
\r
879 #endif // _WTL_CMDBAR_VISTA_MENUS
\r
884 BOOL TrackPopupMenu(HMENU hMenu, UINT uFlags, int x, int y, LPTPMPARAMS lpParams = NULL)
\r
886 ATLASSERT(::IsWindow(m_hWnd));
\r
887 ATLASSERT(::IsMenu(hMenu));
\r
888 if(!::IsMenu(hMenu))
\r
890 m_bContextMenu = true;
\r
891 if(m_bUseKeyboardCues)
\r
892 m_bShowKeyboardCues = m_bKeyboardInput;
\r
893 T* pT = static_cast<T*>(this);
\r
894 return pT->DoTrackPopupMenu(hMenu, uFlags, x, y, lpParams);
\r
897 BOOL SetMDIClient(HWND /*hWndMDIClient*/)
\r
899 // Use CMDICommandBarCtrl for MDI support
\r
904 // Message map and handlers
\r
905 BEGIN_MSG_MAP(CCommandBarCtrlImpl)
\r
906 MESSAGE_HANDLER(WM_CREATE, OnCreate)
\r
907 MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
\r
908 MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)
\r
909 MESSAGE_HANDLER(WM_INITMENU, OnInitMenu)
\r
910 MESSAGE_HANDLER(WM_INITMENUPOPUP, OnInitMenuPopup)
\r
911 MESSAGE_HANDLER(WM_MENUSELECT, OnMenuSelect)
\r
912 MESSAGE_HANDLER(GetAutoPopupMessage(), OnInternalAutoPopup)
\r
913 MESSAGE_HANDLER(GetGetBarMessage(), OnInternalGetBar)
\r
914 MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange)
\r
915 MESSAGE_HANDLER(WM_MENUCHAR, OnMenuChar)
\r
917 MESSAGE_HANDLER(WM_KEYDOWN, OnKeyDown)
\r
918 MESSAGE_HANDLER(WM_KEYUP, OnKeyUp)
\r
919 MESSAGE_HANDLER(WM_CHAR, OnChar)
\r
920 MESSAGE_HANDLER(WM_SYSKEYDOWN, OnSysKeyDown)
\r
921 MESSAGE_HANDLER(WM_SYSKEYUP, OnSysKeyUp)
\r
922 MESSAGE_HANDLER(WM_SYSCHAR, OnSysChar)
\r
923 // public API handlers - these stay to support chevrons in atlframe.h
\r
924 MESSAGE_HANDLER(CBRM_GETMENU, OnAPIGetMenu)
\r
925 MESSAGE_HANDLER(CBRM_TRACKPOPUPMENU, OnAPITrackPopupMenu)
\r
926 MESSAGE_HANDLER(CBRM_GETCMDBAR, OnAPIGetCmdBar)
\r
928 MESSAGE_HANDLER(WM_DRAWITEM, OnDrawItem)
\r
929 MESSAGE_HANDLER(WM_MEASUREITEM, OnMeasureItem)
\r
931 MESSAGE_HANDLER(WM_FORWARDMSG, OnForwardMsg)
\r
932 ALT_MSG_MAP(1) // Parent window messages
\r
933 NOTIFY_CODE_HANDLER(TBN_HOTITEMCHANGE, OnParentHotItemChange)
\r
934 NOTIFY_CODE_HANDLER(TBN_DROPDOWN, OnParentDropDown)
\r
935 MESSAGE_HANDLER(WM_INITMENUPOPUP, OnParentInitMenuPopup)
\r
936 MESSAGE_HANDLER(GetGetBarMessage(), OnParentInternalGetBar)
\r
937 MESSAGE_HANDLER(WM_SYSCOMMAND, OnParentSysCommand)
\r
938 MESSAGE_HANDLER(CBRM_GETMENU, OnParentAPIGetMenu)
\r
939 MESSAGE_HANDLER(WM_MENUCHAR, OnParentMenuChar)
\r
940 MESSAGE_HANDLER(CBRM_TRACKPOPUPMENU, OnParentAPITrackPopupMenu)
\r
941 MESSAGE_HANDLER(CBRM_GETCMDBAR, OnParentAPIGetCmdBar)
\r
942 MESSAGE_HANDLER(WM_SETTINGCHANGE, OnParentSettingChange)
\r
944 MESSAGE_HANDLER(WM_DRAWITEM, OnParentDrawItem)
\r
945 MESSAGE_HANDLER(WM_MEASUREITEM, OnParentMeasureItem)
\r
947 MESSAGE_HANDLER(WM_ACTIVATE, OnParentActivate)
\r
948 NOTIFY_CODE_HANDLER(NM_CUSTOMDRAW, OnParentCustomDraw)
\r
949 ALT_MSG_MAP(2) // MDI client window messages
\r
950 // Use CMDICommandBarCtrl for MDI support
\r
951 ALT_MSG_MAP(3) // Message hook messages
\r
952 MESSAGE_HANDLER(WM_MOUSEMOVE, OnHookMouseMove)
\r
953 MESSAGE_HANDLER(WM_SYSKEYDOWN, OnHookSysKeyDown)
\r
954 MESSAGE_HANDLER(WM_SYSKEYUP, OnHookSysKeyUp)
\r
955 MESSAGE_HANDLER(WM_SYSCHAR, OnHookSysChar)
\r
956 MESSAGE_HANDLER(WM_KEYDOWN, OnHookKeyDown)
\r
957 MESSAGE_HANDLER(WM_NEXTMENU, OnHookNextMenu)
\r
958 MESSAGE_HANDLER(WM_CHAR, OnHookChar)
\r
961 LRESULT OnForwardMsg(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/)
\r
963 LPMSG pMsg = (LPMSG)lParam;
\r
964 if(pMsg->message >= WM_MOUSEFIRST && pMsg->message <= WM_MOUSELAST)
\r
965 m_bKeyboardInput = false;
\r
966 else if(pMsg->message >= WM_KEYFIRST && pMsg->message <= WM_KEYLAST)
\r
967 m_bKeyboardInput = true;
\r
969 ProcessWindowMessage(pMsg->hwnd, pMsg->message, pMsg->wParam, pMsg->lParam, lRet, 3);
\r
973 LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
\r
975 // Let the toolbar initialize itself
\r
976 LRESULT lRet = DefWindowProc(uMsg, wParam, lParam);
\r
977 // get and use system settings
\r
978 T* pT = static_cast<T*>(this);
\r
979 pT->GetSystemSettings();
\r
981 ATL::CWindow wndParent = GetParent();
\r
982 ATL::CWindow wndTopLevelParent = wndParent.GetTopLevelParent();
\r
983 m_wndParent.SubclassWindow(wndTopLevelParent);
\r
985 SetButtonStructSize();
\r
986 SetImageList(NULL);
\r
988 // Create message hook if needed
\r
989 CWindowCreateCriticalSectionLock lock;
\r
990 if(FAILED(lock.Lock()))
\r
992 ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CCommandBarCtrlImpl::OnCreate.\n"));
\r
997 if(s_pmapMsgHook == NULL)
\r
999 ATLTRY(s_pmapMsgHook = new CMsgHookMap);
\r
1000 ATLASSERT(s_pmapMsgHook != NULL);
\r
1003 if(s_pmapMsgHook != NULL)
\r
1005 DWORD dwThreadID = ::GetCurrentThreadId();
\r
1006 _MsgHookData* pData = s_pmapMsgHook->Lookup(dwThreadID);
\r
1009 ATLTRY(pData = new _MsgHookData);
\r
1010 ATLASSERT(pData != NULL);
\r
1011 HHOOK hMsgHook = ::SetWindowsHookEx(WH_GETMESSAGE, MessageHookProc, ModuleHelper::GetModuleInstance(), dwThreadID);
\r
1012 ATLASSERT(hMsgHook != NULL);
\r
1013 if(pData != NULL && hMsgHook != NULL)
\r
1015 pData->hMsgHook = hMsgHook;
\r
1016 pData->dwUsage = 1;
\r
1017 BOOL bRet = s_pmapMsgHook->Add(dwThreadID, pData);
\r
1024 (pData->dwUsage)++;
\r
1030 #if (WINVER >= 0x0500)
\r
1031 m_bLayoutRTL = ((GetExStyle() & WS_EX_LAYOUTRTL) != 0);
\r
1032 #endif // (WINVER >= 0x0500)
\r
1037 LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
\r
1039 LRESULT lRet = DefWindowProc(uMsg, wParam, lParam);
\r
1041 #if _WTL_CMDBAR_VISTA_MENUS
\r
1042 if(m_bVistaMenus && (m_hMenu != NULL))
\r
1044 T* pT = static_cast<T*>(this);
\r
1045 pT->_RemoveVistaBitmapsFromMenu();
\r
1048 for(int i = 0; i < m_arrVistaBitmap.GetSize(); i++)
\r
1050 if(m_arrVistaBitmap[i] != NULL)
\r
1051 ::DeleteObject(m_arrVistaBitmap[i]);
\r
1053 #endif // _WTL_CMDBAR_VISTA_MENUS
\r
1055 if(m_bAttachedMenu) // nothing to do in this mode
\r
1058 CWindowCreateCriticalSectionLock lock;
\r
1059 if(FAILED(lock.Lock()))
\r
1061 ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CCommandBarCtrlImpl::OnDestroy.\n"));
\r
1066 if(s_pmapMsgHook != NULL)
\r
1068 DWORD dwThreadID = ::GetCurrentThreadId();
\r
1069 _MsgHookData* pData = s_pmapMsgHook->Lookup(dwThreadID);
\r
1072 (pData->dwUsage)--;
\r
1073 if(pData->dwUsage == 0)
\r
1075 BOOL bRet = ::UnhookWindowsHookEx(pData->hMsgHook);
\r
1077 bRet = s_pmapMsgHook->Remove(dwThreadID);
\r
1083 if(s_pmapMsgHook->GetSize() == 0)
\r
1085 delete s_pmapMsgHook;
\r
1086 s_pmapMsgHook = NULL;
\r
1096 LRESULT OnKeyDown(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
\r
1098 #ifdef _CMDBAR_EXTRA_TRACE
\r
1099 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnKeyDown\n"));
\r
1102 // Simulate Alt+Space for the parent
\r
1103 if(wParam == VK_SPACE)
\r
1105 m_wndParent.PostMessage(WM_SYSKEYDOWN, wParam, lParam | (1 << 29));
\r
1108 #if (_WIN32_IE >= 0x0500)
\r
1109 else if(wParam == VK_LEFT || wParam == VK_RIGHT)
\r
1111 WPARAM wpNext = m_bLayoutRTL ? VK_LEFT : VK_RIGHT;
\r
1113 if(!m_bMenuActive)
\r
1115 T* pT = static_cast<T*>(this);
\r
1116 int nBtn = GetHotItem();
\r
1117 int nNextBtn = (wParam == wpNext) ? pT->GetNextMenuItem(nBtn) : pT->GetPreviousMenuItem(nBtn);
\r
1118 if(nNextBtn == -2)
\r
1121 if(pT->DisplayChevronMenu())
\r
1126 #endif // (_WIN32_IE >= 0x0500)
\r
1130 LRESULT OnKeyUp(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
\r
1132 #ifdef _CMDBAR_EXTRA_TRACE
\r
1133 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnKeyUp\n"));
\r
1135 if(wParam != VK_SPACE)
\r
1140 LRESULT OnChar(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
\r
1142 #ifdef _CMDBAR_EXTRA_TRACE
\r
1143 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnChar\n"));
\r
1145 if(wParam != VK_SPACE)
\r
1150 if(!m_wndParent.IsWindowEnabled() || ::GetFocus() != m_hWnd)
\r
1153 // Handle mnemonic press when we have focus
\r
1155 if(wParam != VK_RETURN && !MapAccelerator((TCHAR)LOWORD(wParam), nBtn))
\r
1157 #if (_WIN32_IE >= 0x0500)
\r
1158 if((TCHAR)LOWORD(wParam) != _chChevronShortcut)
\r
1159 #endif // (_WIN32_IE >= 0x0500)
\r
1164 #if (_WIN32_IE >= 0x0500)
\r
1165 RECT rcClient = { 0 };
\r
1166 GetClientRect(&rcClient);
\r
1167 RECT rcBtn = { 0 };
\r
1168 GetItemRect(nBtn, &rcBtn);
\r
1169 TBBUTTON tbb = { 0 };
\r
1170 GetButton(nBtn, &tbb);
\r
1171 if((tbb.fsState & TBSTATE_ENABLED) != 0 && (tbb.fsState & TBSTATE_HIDDEN) == 0 && rcBtn.right <= rcClient.right)
\r
1173 #endif // (_WIN32_IE >= 0x0500)
\r
1174 PostMessage(WM_KEYDOWN, VK_DOWN, 0L);
\r
1175 if(wParam != VK_RETURN)
\r
1177 #if (_WIN32_IE >= 0x0500)
\r
1184 #endif // (_WIN32_IE >= 0x0500)
\r
1189 LRESULT OnSysKeyDown(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
\r
1191 #ifdef _CMDBAR_EXTRA_TRACE
\r
1192 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnSysKeyDown\n"));
\r
1198 LRESULT OnSysKeyUp(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
\r
1200 #ifdef _CMDBAR_EXTRA_TRACE
\r
1201 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnSysKeyUp\n"));
\r
1207 LRESULT OnSysChar(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
\r
1209 #ifdef _CMDBAR_EXTRA_TRACE
\r
1210 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnSysChar\n"));
\r
1216 LRESULT OnEraseBackground(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
\r
1218 if(m_bAttachedMenu || (m_dwExtendedStyle & CBR_EX_TRANSPARENT))
\r
1224 CDCHandle dc = (HDC)wParam;
\r
1225 RECT rect = { 0 };
\r
1226 GetClientRect(&rect);
\r
1227 dc.FillRect(&rect, COLOR_MENU);
\r
1229 return 1; // don't do the default erase
\r
1232 LRESULT OnInitMenu(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
\r
1234 int nIndex = GetHotItem();
\r
1235 SendMessage(WM_MENUSELECT, MAKEWPARAM(nIndex, MF_POPUP|MF_HILITE), (LPARAM)m_hMenu);
\r
1240 LRESULT OnInitMenuPopup(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
\r
1242 if((BOOL)HIWORD(lParam)) // System menu, do nothing
\r
1248 if(!(m_bAttachedMenu || m_bMenuActive)) // Not attached or ours, do nothing
\r
1254 #ifdef _CMDBAR_EXTRA_TRACE
\r
1255 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnInitMenuPopup\n"));
\r
1257 // forward to the parent or subclassed window, so it can handle update UI
\r
1259 if(m_bAttachedMenu)
\r
1260 lRet = DefWindowProc(uMsg, wParam, (lParam || m_bContextMenu) ? lParam : GetHotItem());
\r
1262 lRet = m_wndParent.DefWindowProc(uMsg, wParam, (lParam || m_bContextMenu) ? lParam : GetHotItem());
\r
1264 #if _WTL_CMDBAR_VISTA_MENUS
\r
1265 // If Vista menus are active, just set bitmaps and return
\r
1268 CMenuHandle menu = (HMENU)wParam;
\r
1269 ATLASSERT(menu.m_hMenu != NULL);
\r
1271 for(int i = 0; i < menu.GetMenuItemCount(); i++)
\r
1273 WORD nID = (WORD)menu.GetMenuItemID(i);
\r
1274 int nIndex = m_arrCommand.Find(nID);
\r
1276 CMenuItemInfo mii;
\r
1277 mii.fMask = MIIM_BITMAP;
\r
1278 mii.hbmpItem = (m_bImagesVisible && (nIndex != -1)) ? m_arrVistaBitmap[nIndex] : NULL;
\r
1279 menu.SetMenuItemInfo(i, TRUE, &mii);
\r
1284 #endif // _WTL_CMDBAR_VISTA_MENUS
\r
1286 // Convert menu items to ownerdraw, add our data
\r
1287 if(m_bImagesVisible)
\r
1289 CMenuHandle menuPopup = (HMENU)wParam;
\r
1290 ATLASSERT(menuPopup.m_hMenu != NULL);
\r
1292 T* pT = static_cast<T*>(this);
\r
1293 pT; // avoid level 4 warning
\r
1294 TCHAR szString[pT->_nMaxMenuItemTextLength];
\r
1295 BOOL bRet = FALSE;
\r
1296 for(int i = 0; i < menuPopup.GetMenuItemCount(); i++)
\r
1298 CMenuItemInfo mii;
\r
1299 mii.cch = pT->_nMaxMenuItemTextLength;
\r
1300 mii.fMask = MIIM_CHECKMARKS | MIIM_DATA | MIIM_ID | MIIM_STATE | MIIM_SUBMENU | MIIM_TYPE;
\r
1301 mii.dwTypeData = szString;
\r
1302 bRet = menuPopup.GetMenuItemInfo(i, TRUE, &mii);
\r
1305 if(!(mii.fType & MFT_OWNERDRAW)) // Not already an ownerdraw item
\r
1307 mii.fMask = MIIM_DATA | MIIM_TYPE | MIIM_STATE;
\r
1308 _MenuItemData* pMI = NULL;
\r
1309 ATLTRY(pMI = new _MenuItemData);
\r
1310 ATLASSERT(pMI != NULL);
\r
1313 pMI->fType = mii.fType;
\r
1314 pMI->fState = mii.fState;
\r
1315 mii.fType |= MFT_OWNERDRAW;
\r
1316 pMI->iButton = -1;
\r
1317 for(int j = 0; j < m_arrCommand.GetSize(); j++)
\r
1319 if(m_arrCommand[j] == mii.wID)
\r
1325 int cchLen = lstrlen(szString) + 1;
\r
1326 pMI->lpstrText = NULL;
\r
1327 ATLTRY(pMI->lpstrText = new TCHAR[cchLen]);
\r
1328 ATLASSERT(pMI->lpstrText != NULL);
\r
1329 if(pMI->lpstrText != NULL)
\r
1330 SecureHelper::strcpy_x(pMI->lpstrText, cchLen, szString);
\r
1331 mii.dwItemData = (ULONG_PTR)pMI;
\r
1332 bRet = menuPopup.SetMenuItemInfo(i, TRUE, &mii);
\r
1338 // Add it to the list
\r
1339 m_stackMenuHandle.Push(menuPopup.m_hMenu);
\r
1345 LRESULT OnMenuSelect(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
\r
1347 if(!m_bAttachedMenu) // Not attached, do nothing, forward to parent
\r
1349 m_bPopupItem = (lParam != NULL) && ((HMENU)lParam != m_hMenu) && (HIWORD(wParam) & MF_POPUP);
\r
1350 if(m_wndParent.IsWindow())
\r
1351 m_wndParent.SendMessage(uMsg, wParam, lParam);
\r
1356 // Check if a menu is closing, do a cleanup
\r
1357 if(HIWORD(wParam) == 0xFFFF && lParam == NULL) // Menu closing
\r
1359 #ifdef _CMDBAR_EXTRA_TRACE
\r
1360 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnMenuSelect - CLOSING!!!!\n"));
\r
1362 ATLASSERT(m_stackMenuWnd.GetSize() == 0);
\r
1363 // Restore the menu items to the previous state for all menus that were converted
\r
1364 if(m_bImagesVisible)
\r
1366 HMENU hMenu = NULL;
\r
1367 while((hMenu = m_stackMenuHandle.Pop()) != NULL)
\r
1369 CMenuHandle menuPopup = hMenu;
\r
1370 ATLASSERT(menuPopup.m_hMenu != NULL);
\r
1371 // Restore state and delete menu item data
\r
1372 BOOL bRet = FALSE;
\r
1373 for(int i = 0; i < menuPopup.GetMenuItemCount(); i++)
\r
1375 CMenuItemInfo mii;
\r
1376 mii.fMask = MIIM_DATA | MIIM_TYPE;
\r
1377 bRet = menuPopup.GetMenuItemInfo(i, TRUE, &mii);
\r
1380 _MenuItemData* pMI = (_MenuItemData*)mii.dwItemData;
\r
1381 if(pMI != NULL && pMI->IsCmdBarMenuItem())
\r
1383 mii.fMask = MIIM_DATA | MIIM_TYPE | MIIM_STATE;
\r
1384 mii.fType = pMI->fType;
\r
1385 mii.dwTypeData = pMI->lpstrText;
\r
1386 mii.cch = lstrlen(pMI->lpstrText);
\r
1387 mii.dwItemData = NULL;
\r
1389 bRet = menuPopup.SetMenuItemInfo(i, TRUE, &mii);
\r
1392 delete [] pMI->lpstrText;
\r
1393 pMI->dwMagic = 0x6666;
\r
1405 LRESULT OnInternalAutoPopup(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
\r
1407 int nIndex = (int)wParam;
\r
1408 T* pT = static_cast<T*>(this);
\r
1409 pT->DoPopupMenu(nIndex, false);
\r
1413 LRESULT OnInternalGetBar(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
\r
1415 // Let's make sure we're not embedded in another process
\r
1416 if((LPVOID)wParam != NULL)
\r
1417 *((DWORD*)wParam) = GetCurrentProcessId();
\r
1418 if(IsWindowVisible())
\r
1419 return (LRESULT)static_cast<CCommandBarCtrlBase*>(this);
\r
1424 LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
\r
1426 #ifndef SPI_GETKEYBOARDCUES
\r
1427 const UINT SPI_SETKEYBOARDCUES = 0x100B;
\r
1428 #endif // !SPI_GETKEYBOARDCUES
\r
1429 #ifndef SPI_GETFLATMENU
\r
1430 const UINT SPI_SETFLATMENU = 0x1023;
\r
1431 #endif // !SPI_GETFLATMENU
\r
1433 if(wParam == SPI_SETNONCLIENTMETRICS || wParam == SPI_SETKEYBOARDCUES || wParam == SPI_SETFLATMENU)
\r
1435 T* pT = static_cast<T*>(this);
\r
1436 pT->GetSystemSettings();
\r
1442 LRESULT OnWindowPosChanging(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
\r
1444 LRESULT lRet = DefWindowProc(uMsg, wParam, lParam);
\r
1446 LPWINDOWPOS lpWP = (LPWINDOWPOS)lParam;
\r
1447 int cyMin = ::GetSystemMetrics(SM_CYMENU);
\r
1448 if(lpWP->cy < cyMin)
\r
1454 LRESULT OnMenuChar(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
\r
1456 #ifdef _CMDBAR_EXTRA_TRACE
\r
1457 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnMenuChar\n"));
\r
1460 T* pT = static_cast<T*>(this);
\r
1463 if(m_bMenuActive && LOWORD(wParam) != 0x0D)
\r
1466 lRet = MAKELRESULT(1, 1);
\r
1468 if(m_bMenuActive && HIWORD(wParam) == MF_POPUP)
\r
1470 // Convert character to lower/uppercase and possibly Unicode, using current keyboard layout
\r
1471 TCHAR ch = (TCHAR)LOWORD(wParam);
\r
1472 CMenuHandle menu = (HMENU)lParam;
\r
1473 int nCount = ::GetMenuItemCount(menu);
\r
1474 int nRetCode = MNC_EXECUTE;
\r
1475 BOOL bRet = FALSE;
\r
1476 TCHAR szString[pT->_nMaxMenuItemTextLength];
\r
1478 bool bFound = false;
\r
1479 for(int i = 0; i < nCount; i++)
\r
1481 CMenuItemInfo mii;
\r
1482 mii.cch = pT->_nMaxMenuItemTextLength;
\r
1483 mii.fMask = MIIM_CHECKMARKS | MIIM_DATA | MIIM_ID | MIIM_STATE | MIIM_SUBMENU | MIIM_TYPE;
\r
1484 mii.dwTypeData = szString;
\r
1485 bRet = menu.GetMenuItemInfo(i, TRUE, &mii);
\r
1486 if(!bRet || (mii.fType & MFT_SEPARATOR))
\r
1488 _MenuItemData* pmd = (_MenuItemData*)mii.dwItemData;
\r
1489 if(pmd != NULL && pmd->IsCmdBarMenuItem())
\r
1491 LPTSTR p = pmd->lpstrText;
\r
1495 while(*p && *p != _T('&'))
\r
1496 p = ::CharNext(p);
\r
1497 if(p != NULL && *p)
\r
1499 DWORD dwP = MAKELONG(*(++p), 0);
\r
1500 DWORD dwC = MAKELONG(ch, 0);
\r
1501 if(::CharLower((LPTSTR)ULongToPtr(dwP)) == ::CharLower((LPTSTR)ULongToPtr(dwC)))
\r
1510 nRetCode = MNC_SELECT;
\r
1520 if(nRetCode == MNC_EXECUTE)
\r
1522 PostMessage(TB_SETHOTITEM, (WPARAM)-1, 0L);
\r
1523 pT->GiveFocusBack();
\r
1526 lRet = MAKELRESULT(wMnem, nRetCode);
\r
1529 else if(!m_bMenuActive)
\r
1532 if(!MapAccelerator((TCHAR)LOWORD(wParam), nBtn))
\r
1535 PostMessage(TB_SETHOTITEM, (WPARAM)-1, 0L);
\r
1536 pT->GiveFocusBack();
\r
1538 #if (_WIN32_IE >= 0x0500)
\r
1539 // check if we should display chevron menu
\r
1540 if((TCHAR)LOWORD(wParam) == pT->_chChevronShortcut)
\r
1542 if(pT->DisplayChevronMenu())
\r
1545 #endif // (_WIN32_IE >= 0x0500)
\r
1547 else if(m_wndParent.IsWindowEnabled())
\r
1549 #if (_WIN32_IE >= 0x0500)
\r
1550 RECT rcClient = { 0 };
\r
1551 GetClientRect(&rcClient);
\r
1552 RECT rcBtn = { 0 };
\r
1553 GetItemRect(nBtn, &rcBtn);
\r
1554 TBBUTTON tbb = { 0 };
\r
1555 GetButton(nBtn, &tbb);
\r
1556 if((tbb.fsState & TBSTATE_ENABLED) != 0 && (tbb.fsState & TBSTATE_HIDDEN) == 0 && rcBtn.right <= rcClient.right)
\r
1558 #endif // (_WIN32_IE >= 0x0500)
\r
1559 if(m_bUseKeyboardCues && !m_bShowKeyboardCues)
\r
1561 m_bAllowKeyboardCues = true;
\r
1562 ShowKeyboardCues(true);
\r
1565 PostMessage(WM_KEYDOWN, VK_DOWN, 0L);
\r
1567 #if (_WIN32_IE >= 0x0500)
\r
1573 #endif // (_WIN32_IE >= 0x0500)
\r
1580 LRESULT OnDrawItem(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
\r
1582 LPDRAWITEMSTRUCT lpDrawItemStruct = (LPDRAWITEMSTRUCT)lParam;
\r
1583 _MenuItemData* pmd = (_MenuItemData*)lpDrawItemStruct->itemData;
\r
1584 if(lpDrawItemStruct->CtlType == ODT_MENU && pmd != NULL && pmd->IsCmdBarMenuItem())
\r
1586 T* pT = static_cast<T*>(this);
\r
1587 pT->DrawItem(lpDrawItemStruct);
\r
1593 return (LRESULT)TRUE;
\r
1596 LRESULT OnMeasureItem(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
\r
1598 LPMEASUREITEMSTRUCT lpMeasureItemStruct = (LPMEASUREITEMSTRUCT)lParam;
\r
1599 _MenuItemData* pmd = (_MenuItemData*)lpMeasureItemStruct->itemData;
\r
1600 if(lpMeasureItemStruct->CtlType == ODT_MENU && pmd != NULL && pmd->IsCmdBarMenuItem())
\r
1602 T* pT = static_cast<T*>(this);
\r
1603 pT->MeasureItem(lpMeasureItemStruct);
\r
1609 return (LRESULT)TRUE;
\r
1612 // API message handlers
\r
1613 LRESULT OnAPIGetMenu(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
\r
1615 return (LRESULT)m_hMenu;
\r
1618 LRESULT OnAPITrackPopupMenu(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/)
\r
1620 if(lParam == NULL)
\r
1622 LPCBRPOPUPMENU lpCBRPopupMenu = (LPCBRPOPUPMENU)lParam;
\r
1623 if(lpCBRPopupMenu->cbSize != sizeof(CBRPOPUPMENU))
\r
1626 T* pT = static_cast<T*>(this);
\r
1627 return pT->TrackPopupMenu(lpCBRPopupMenu->hMenu, lpCBRPopupMenu->uFlags, lpCBRPopupMenu->x, lpCBRPopupMenu->y, lpCBRPopupMenu->lptpm);
\r
1630 LRESULT OnAPIGetCmdBar(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
\r
1632 return (LRESULT)m_hWnd;
\r
1635 // Parent window message handlers
\r
1636 LRESULT OnParentHotItemChange(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled)
\r
1638 LPNMTBHOTITEM lpNMHT = (LPNMTBHOTITEM)pnmh;
\r
1640 // Check if this comes from us
\r
1641 if(pnmh->hwndFrom != m_hWnd)
\r
1647 bool bBlockTracking = false;
\r
1648 if((m_dwExtendedStyle & CBR_EX_TRACKALWAYS) == 0)
\r
1650 DWORD dwProcessID;
\r
1651 ::GetWindowThreadProcessId(::GetActiveWindow(), &dwProcessID);
\r
1652 bBlockTracking = (::GetCurrentProcessId() != dwProcessID);
\r
1655 if((!m_wndParent.IsWindowEnabled() || bBlockTracking) && (lpNMHT->dwFlags & HICF_MOUSE))
\r
1661 #ifndef HICF_LMOUSE
\r
1662 const DWORD HICF_LMOUSE = 0x00000080; // left mouse button selected
\r
1666 // Send WM_MENUSELECT to the app if it needs to display a status text
\r
1667 if(!(lpNMHT->dwFlags & HICF_MOUSE)
\r
1668 && !(lpNMHT->dwFlags & HICF_ACCELERATOR)
\r
1669 && !(lpNMHT->dwFlags & HICF_LMOUSE))
\r
1671 if(lpNMHT->dwFlags & HICF_ENTERING)
\r
1672 m_wndParent.SendMessage(WM_MENUSELECT, 0, (LPARAM)m_hMenu);
\r
1673 if(lpNMHT->dwFlags & HICF_LEAVING)
\r
1674 m_wndParent.SendMessage(WM_MENUSELECT, MAKEWPARAM(0, 0xFFFF), NULL);
\r
1681 LRESULT OnParentDropDown(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled)
\r
1683 // Check if this comes from us
\r
1684 if(pnmh->hwndFrom != m_hWnd)
\r
1690 T* pT = static_cast<T*>(this);
\r
1691 if(::GetFocus() != m_hWnd)
\r
1693 LPNMTOOLBAR pNMToolBar = (LPNMTOOLBAR)pnmh;
\r
1694 int nIndex = CommandToIndex(pNMToolBar->iItem);
\r
1695 m_bContextMenu = false;
\r
1696 m_bEscapePressed = false;
\r
1697 pT->DoPopupMenu(nIndex, true);
\r
1699 return TBDDRET_DEFAULT;
\r
1702 LRESULT OnParentInitMenuPopup(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
\r
1704 return OnInitMenuPopup(uMsg, wParam, lParam, bHandled);
\r
1707 LRESULT OnParentInternalGetBar(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
\r
1709 return OnInternalGetBar(uMsg, wParam, lParam, bHandled);
\r
1712 LRESULT OnParentSysCommand(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
\r
1715 if((m_uSysKey == VK_MENU
\r
1716 || (m_uSysKey == VK_F10 && !(::GetKeyState(VK_SHIFT) & 0x80))
\r
1717 || m_uSysKey == VK_SPACE)
\r
1718 && wParam == SC_KEYMENU)
\r
1720 T* pT = static_cast<T*>(this);
\r
1721 if(::GetFocus() == m_hWnd)
\r
1723 pT->GiveFocusBack(); // exit menu "loop"
\r
1724 PostMessage(TB_SETHOTITEM, (WPARAM)-1, 0L);
\r
1726 else if(m_uSysKey != VK_SPACE && !m_bSkipMsg)
\r
1728 if(m_bUseKeyboardCues && !m_bShowKeyboardCues && m_bAllowKeyboardCues)
\r
1729 ShowKeyboardCues(true);
\r
1731 pT->TakeFocus(); // enter menu "loop"
\r
1734 else if(m_uSysKey != VK_SPACE)
\r
1739 m_bSkipMsg = false;
\r
1743 LRESULT OnParentAPIGetMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
\r
1745 return OnAPIGetMenu(uMsg, wParam, lParam, bHandled);
\r
1748 LRESULT OnParentMenuChar(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
\r
1750 return OnMenuChar(uMsg, wParam, lParam, bHandled);
\r
1753 LRESULT OnParentAPITrackPopupMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
\r
1755 return OnAPITrackPopupMenu(uMsg, wParam, lParam, bHandled);
\r
1758 LRESULT OnParentAPIGetCmdBar(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
\r
1760 return OnAPIGetCmdBar(uMsg, wParam, lParam, bHandled);
\r
1763 LRESULT OnParentSettingChange(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
\r
1765 OnSettingChange(uMsg, wParam, lParam, bHandled);
\r
1770 LRESULT OnParentDrawItem(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
\r
1772 return OnDrawItem(uMsg, wParam, lParam, bHandled);
\r
1775 LRESULT OnParentMeasureItem(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
\r
1777 return OnMeasureItem(uMsg, wParam, lParam, bHandled);
\r
1780 LRESULT OnParentActivate(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
\r
1782 m_bParentActive = (LOWORD(wParam) != WA_INACTIVE);
\r
1783 if(!m_bParentActive && m_bUseKeyboardCues && m_bShowKeyboardCues)
\r
1785 ShowKeyboardCues(false); // this will repaint our window
\r
1796 LRESULT OnParentCustomDraw(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled)
\r
1798 LRESULT lRet = CDRF_DODEFAULT;
\r
1800 if(pnmh->hwndFrom == m_hWnd)
\r
1802 LPNMTBCUSTOMDRAW lpTBCustomDraw = (LPNMTBCUSTOMDRAW)pnmh;
\r
1803 if(lpTBCustomDraw->nmcd.dwDrawStage == CDDS_PREPAINT)
\r
1805 lRet = CDRF_NOTIFYITEMDRAW;
\r
1808 else if(lpTBCustomDraw->nmcd.dwDrawStage == CDDS_ITEMPREPAINT)
\r
1812 #ifndef COLOR_MENUHILIGHT
\r
1813 const int COLOR_MENUHILIGHT = 29;
\r
1814 #endif // !COLOR_MENUHILIGHT
\r
1815 bool bDisabled = ((lpTBCustomDraw->nmcd.uItemState & CDIS_DISABLED) == CDIS_DISABLED);
\r
1816 if(!bDisabled && ((lpTBCustomDraw->nmcd.uItemState & CDIS_HOT) == CDIS_HOT ||
\r
1817 (lpTBCustomDraw->nmcd.uItemState & CDIS_SELECTED) == CDIS_SELECTED))
\r
1819 ::FillRect(lpTBCustomDraw->nmcd.hdc, &lpTBCustomDraw->nmcd.rc, ::GetSysColorBrush(COLOR_MENUHILIGHT));
\r
1820 ::FrameRect(lpTBCustomDraw->nmcd.hdc, &lpTBCustomDraw->nmcd.rc, ::GetSysColorBrush(COLOR_HIGHLIGHT));
\r
1821 lpTBCustomDraw->clrText = ::GetSysColor(m_bParentActive ? COLOR_HIGHLIGHTTEXT : COLOR_GRAYTEXT);
\r
1823 else if(bDisabled || !m_bParentActive)
\r
1825 lpTBCustomDraw->clrText = ::GetSysColor(COLOR_GRAYTEXT);
\r
1827 CDCHandle dc = lpTBCustomDraw->nmcd.hdc;
\r
1828 dc.SetTextColor(lpTBCustomDraw->clrText);
\r
1829 dc.SetBkMode(lpTBCustomDraw->nStringBkMode);
\r
1830 HFONT hFont = GetFont();
\r
1831 HFONT hFontOld = NULL;
\r
1833 hFontOld = dc.SelectFont(hFont);
\r
1834 const int cchText = 200;
\r
1835 TCHAR szText[cchText] = { 0 };
\r
1836 TBBUTTONINFO tbbi = { 0 };
\r
1837 tbbi.cbSize = sizeof(TBBUTTONINFO);
\r
1838 tbbi.dwMask = TBIF_TEXT;
\r
1839 tbbi.pszText = szText;
\r
1840 tbbi.cchText = cchText;
\r
1841 GetButtonInfo((int)lpTBCustomDraw->nmcd.dwItemSpec, &tbbi);
\r
1842 dc.DrawText(szText, -1, &lpTBCustomDraw->nmcd.rc, DT_SINGLELINE | DT_CENTER | DT_VCENTER | (m_bShowKeyboardCues ? 0 : DT_HIDEPREFIX));
\r
1844 dc.SelectFont(hFontOld);
\r
1845 lRet = CDRF_SKIPDEFAULT;
\r
1848 else if(!m_bParentActive)
\r
1850 lpTBCustomDraw->clrText = ::GetSysColor(COLOR_GRAYTEXT);
\r
1858 // Message hook handlers
\r
1859 LRESULT OnHookMouseMove(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
\r
1861 static POINT s_point = { -1, -1 };
\r
1862 DWORD dwPoint = ::GetMessagePos();
\r
1863 POINT point = { GET_X_LPARAM(dwPoint), GET_Y_LPARAM(dwPoint) };
\r
1868 if(::WindowFromPoint(point) == m_hWnd)
\r
1870 ScreenToClient(&point);
\r
1871 int nHit = HitTest(&point);
\r
1873 if((point.x != s_point.x || point.y != s_point.y) && nHit >= 0 && nHit < ::GetMenuItemCount(m_hMenu) && nHit != m_nPopBtn && m_nPopBtn != -1)
\r
1875 TBBUTTON tbb = { 0 };
\r
1876 GetButton(nHit, &tbb);
\r
1877 if((tbb.fsState & TBSTATE_ENABLED) != 0)
\r
1879 m_nNextPopBtn = nHit | 0xFFFF0000;
\r
1880 HWND hWndMenu = m_stackMenuWnd.GetCurrent();
\r
1881 ATLASSERT(hWndMenu != NULL);
\r
1883 // this one is needed to close a menu if mouse button was down
\r
1884 ::PostMessage(hWndMenu, WM_LBUTTONUP, 0, MAKELPARAM(point.x, point.y));
\r
1885 // this one closes a popup menu
\r
1886 ::PostMessage(hWndMenu, WM_KEYDOWN, VK_ESCAPE, 0L);
\r
1895 ScreenToClient(&point);
\r
1902 LRESULT OnHookSysKeyDown(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
\r
1905 #ifdef _CMDBAR_EXTRA_TRACE
\r
1906 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook WM_SYSKEYDOWN (0x%2.2X)\n"), wParam);
\r
1909 if(wParam == VK_MENU && m_bParentActive && m_bUseKeyboardCues && !m_bShowKeyboardCues && m_bAllowKeyboardCues)
\r
1910 ShowKeyboardCues(true);
\r
1912 if(wParam != VK_SPACE && !m_bMenuActive && ::GetFocus() == m_hWnd)
\r
1914 m_bAllowKeyboardCues = false;
\r
1915 PostMessage(TB_SETHOTITEM, (WPARAM)-1, 0L);
\r
1916 T* pT = static_cast<T*>(this);
\r
1917 pT->GiveFocusBack();
\r
1918 m_bSkipMsg = true;
\r
1922 if(wParam == VK_SPACE && m_bUseKeyboardCues && m_bShowKeyboardCues)
\r
1924 m_bAllowKeyboardCues = true;
\r
1925 ShowKeyboardCues(false);
\r
1927 m_uSysKey = (UINT)wParam;
\r
1932 LRESULT OnHookSysKeyUp(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
\r
1934 if(!m_bAllowKeyboardCues)
\r
1935 m_bAllowKeyboardCues = true;
\r
1938 #ifdef _CMDBAR_EXTRA_TRACE
\r
1939 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook WM_SYSKEYUP (0x%2.2X)\n"), wParam);
\r
1944 LRESULT OnHookSysChar(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
\r
1947 #ifdef _CMDBAR_EXTRA_TRACE
\r
1948 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook WM_SYSCHAR (0x%2.2X)\n"), wParam);
\r
1951 if(!m_bMenuActive && m_hWndHook != m_hWnd && wParam != VK_SPACE)
\r
1956 LRESULT OnHookKeyDown(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
\r
1958 #ifdef _CMDBAR_EXTRA_TRACE
\r
1959 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook WM_KEYDOWN (0x%2.2X)\n"), wParam);
\r
1962 T* pT = static_cast<T*>(this);
\r
1964 if(wParam == VK_ESCAPE && m_stackMenuWnd.GetSize() <= 1)
\r
1966 if(m_bMenuActive && !m_bContextMenu)
\r
1968 int nHot = GetHotItem();
\r
1976 m_bEscapePressed = true; // To keep focus
\r
1977 m_bSkipPostDown = false;
\r
1979 else if(::GetFocus() == m_hWnd && m_wndParent.IsWindow())
\r
1982 pT->GiveFocusBack();
\r
1986 else if(wParam == VK_RETURN || wParam == VK_UP || wParam == VK_DOWN)
\r
1988 if(!m_bMenuActive && ::GetFocus() == m_hWnd && m_wndParent.IsWindow())
\r
1990 int nHot = GetHotItem();
\r
1993 if(wParam != VK_RETURN)
\r
1995 if(!m_bSkipPostDown)
\r
1997 // IE4 only: WM_KEYDOWN doesn't generate TBN_DROPDOWN, we need to simulate a mouse click
\r
1998 #if (_WIN32_IE < 0x0500)
\r
1999 DWORD dwMajor = 0, dwMinor = 0;
\r
2000 ATL::AtlGetCommCtrlVersion(&dwMajor, &dwMinor);
\r
2001 if(dwMajor <= 4 || (dwMajor == 5 && dwMinor < 80))
\r
2004 GetItemRect(nHot, &rect);
\r
2005 PostMessage(WM_LBUTTONDOWN, MK_LBUTTON, MAKELPARAM(rect.left, rect.top));
\r
2007 #endif // (_WIN32_IE < 0x0500)
\r
2008 PostMessage(WM_KEYDOWN, VK_DOWN, 0L);
\r
2009 m_bSkipPostDown = true;
\r
2013 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - skipping posting another VK_DOWN\n"));
\r
2014 m_bSkipPostDown = false;
\r
2020 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Can't find hot button\n"));
\r
2023 if(wParam == VK_RETURN && m_bMenuActive)
\r
2025 PostMessage(TB_SETHOTITEM, (WPARAM)-1, 0L);
\r
2026 m_nNextPopBtn = -1;
\r
2027 pT->GiveFocusBack();
\r
2030 else if(wParam == VK_LEFT || wParam == VK_RIGHT)
\r
2032 WPARAM wpNext = m_bLayoutRTL ? VK_LEFT : VK_RIGHT;
\r
2033 WPARAM wpPrev = m_bLayoutRTL ? VK_RIGHT : VK_LEFT;
\r
2035 if(m_bMenuActive && !m_bContextMenu && !(wParam == wpNext && m_bPopupItem))
\r
2037 bool bAction = false;
\r
2038 if(wParam == wpPrev && s_pCurrentBar->m_stackMenuWnd.GetSize() == 1)
\r
2040 m_nNextPopBtn = pT->GetPreviousMenuItem(m_nPopBtn);
\r
2041 if(m_nNextPopBtn != -1)
\r
2044 else if(wParam == wpNext)
\r
2046 m_nNextPopBtn = pT->GetNextMenuItem(m_nPopBtn);
\r
2047 if(m_nNextPopBtn != -1)
\r
2050 HWND hWndMenu = m_stackMenuWnd.GetCurrent();
\r
2051 ATLASSERT(hWndMenu != NULL);
\r
2053 // Close the popup menu
\r
2056 ::PostMessage(hWndMenu, WM_KEYDOWN, VK_ESCAPE, 0L);
\r
2057 if(wParam == wpNext)
\r
2059 int cItem = m_stackMenuWnd.GetSize() - 1;
\r
2062 hWndMenu = m_stackMenuWnd[cItem];
\r
2063 if(hWndMenu != NULL)
\r
2064 ::PostMessage(hWndMenu, WM_KEYDOWN, VK_ESCAPE, 0L);
\r
2068 #if (_WIN32_IE >= 0x0500)
\r
2069 if(m_nNextPopBtn == -2)
\r
2071 m_nNextPopBtn = -1;
\r
2072 pT->DisplayChevronMenu();
\r
2074 #endif // (_WIN32_IE >= 0x0500)
\r
2082 LRESULT OnHookNextMenu(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
\r
2084 #ifdef _CMDBAR_EXTRA_TRACE
\r
2085 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook WM_NEXTMENU\n"));
\r
2091 LRESULT OnHookChar(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
\r
2093 #ifdef _CMDBAR_EXTRA_TRACE
\r
2094 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook WM_CHAR (0x%2.2X)\n"), wParam);
\r
2096 bHandled = (wParam == VK_ESCAPE);
\r
2100 // Implementation - ownerdraw overrideables and helpers
\r
2101 void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
\r
2103 T* pT = static_cast<T*>(this);
\r
2105 pT->DrawItemFlat(lpDrawItemStruct);
\r
2107 pT->DrawItem3D(lpDrawItemStruct);
\r
2111 void DrawItem3D(LPDRAWITEMSTRUCT lpDrawItemStruct)
\r
2113 _MenuItemData* pmd = (_MenuItemData*)lpDrawItemStruct->itemData;
\r
2114 CDCHandle dc = lpDrawItemStruct->hDC;
\r
2115 const RECT& rcItem = lpDrawItemStruct->rcItem;
\r
2116 T* pT = static_cast<T*>(this);
\r
2118 if(pmd->fType & MFT_SEPARATOR)
\r
2122 rc.top += (rc.bottom - rc.top) / 2; // vertical center
\r
2123 dc.DrawEdge(&rc, EDGE_ETCHED, BF_TOP); // draw separator line
\r
2125 else // not a separator
\r
2127 BOOL bDisabled = lpDrawItemStruct->itemState & ODS_GRAYED;
\r
2128 BOOL bSelected = lpDrawItemStruct->itemState & ODS_SELECTED;
\r
2129 BOOL bChecked = lpDrawItemStruct->itemState & ODS_CHECKED;
\r
2130 BOOL bHasImage = FALSE;
\r
2132 if(LOWORD(lpDrawItemStruct->itemID) == (WORD)-1)
\r
2133 bSelected = FALSE;
\r
2134 RECT rcButn = { rcItem.left, rcItem.top, rcItem.left + m_szButton.cx, rcItem.top + m_szButton.cy }; // button rect
\r
2135 ::OffsetRect(&rcButn, 0, ((rcItem.bottom - rcItem.top) - (rcButn.bottom - rcButn.top)) / 2); // center vertically
\r
2137 int iButton = pmd->iButton;
\r
2142 // calc drawing point
\r
2143 SIZE sz = { rcButn.right - rcButn.left - m_szBitmap.cx, rcButn.bottom - rcButn.top - m_szBitmap.cy };
\r
2146 POINT point = { rcButn.left + sz.cx, rcButn.top + sz.cy };
\r
2148 // fill background depending on state
\r
2149 if(!bChecked || (bSelected && !bDisabled))
\r
2152 dc.FillRect(&rcButn, (bChecked && !bSelected) ? COLOR_3DLIGHT : COLOR_MENU);
\r
2154 dc.FillRect(&rcButn, COLOR_MENU);
\r
2158 COLORREF crTxt = dc.SetTextColor(::GetSysColor(COLOR_BTNFACE));
\r
2159 COLORREF crBk = dc.SetBkColor(::GetSysColor(COLOR_BTNHILIGHT));
\r
2160 CBrush hbr(CDCHandle::GetHalftoneBrush());
\r
2161 dc.SetBrushOrg(rcButn.left, rcButn.top);
\r
2162 dc.FillRect(&rcButn, hbr);
\r
2163 dc.SetTextColor(crTxt);
\r
2164 dc.SetBkColor(crBk);
\r
2167 // draw disabled or normal
\r
2170 // draw pushed-in or popped-out edge
\r
2171 if(bSelected || bChecked)
\r
2173 RECT rc2 = rcButn;
\r
2174 dc.DrawEdge(&rc2, bChecked ? BDR_SUNKENOUTER : BDR_RAISEDINNER, BF_RECT);
\r
2177 ::ImageList_Draw(m_hImageList, iButton, dc, point.x, point.y, ILD_TRANSPARENT);
\r
2181 HBRUSH hBrushBackground = bChecked ? NULL : ::GetSysColorBrush(COLOR_MENU);
\r
2182 pT->DrawBitmapDisabled(dc, iButton, point, hBrushBackground);
\r
2187 // no image - look for custom checked/unchecked bitmaps
\r
2188 CMenuItemInfo info;
\r
2189 info.fMask = MIIM_CHECKMARKS | MIIM_TYPE;
\r
2190 ::GetMenuItemInfo((HMENU)lpDrawItemStruct->hwndItem, lpDrawItemStruct->itemID, MF_BYCOMMAND, &info);
\r
2191 if(bChecked || info.hbmpUnchecked != NULL)
\r
2193 BOOL bRadio = ((info.fType & MFT_RADIOCHECK) != 0);
\r
2194 bHasImage = pT->DrawCheckmark(dc, rcButn, bSelected, bDisabled, bRadio, bChecked ? info.hbmpChecked : info.hbmpUnchecked);
\r
2199 int cxButn = m_szButton.cx;
\r
2200 COLORREF colorBG = ::GetSysColor(bSelected ? COLOR_HIGHLIGHT : COLOR_MENU);
\r
2201 if(bSelected || lpDrawItemStruct->itemAction == ODA_SELECT)
\r
2203 RECT rcBG = rcItem;
\r
2205 rcBG.left += cxButn + s_kcxGap;
\r
2206 dc.FillRect(&rcBG, bSelected ? COLOR_HIGHLIGHT : COLOR_MENU);
\r
2209 // calc text rectangle and colors
\r
2210 RECT rcText = rcItem;
\r
2211 rcText.left += cxButn + s_kcxGap + s_kcxTextMargin;
\r
2212 rcText.right -= cxButn;
\r
2213 dc.SetBkMode(TRANSPARENT);
\r
2214 COLORREF colorText = ::GetSysColor(bDisabled ? (bSelected ? COLOR_GRAYTEXT : COLOR_3DSHADOW) : (bSelected ? COLOR_HIGHLIGHTTEXT : COLOR_MENUTEXT));
\r
2216 // font already selected by Windows
\r
2217 if(bDisabled && (!bSelected || colorText == colorBG))
\r
2219 // disabled - draw shadow text shifted down and right 1 pixel (unles selected)
\r
2220 RECT rcDisabled = rcText;
\r
2221 ::OffsetRect(&rcDisabled, 1, 1);
\r
2222 pT->DrawMenuText(dc, rcDisabled, pmd->lpstrText, ::GetSysColor(COLOR_3DHILIGHT));
\r
2224 pT->DrawMenuText(dc, rcText, pmd->lpstrText, colorText); // finally!
\r
2228 void DrawItemFlat(LPDRAWITEMSTRUCT lpDrawItemStruct)
\r
2230 _MenuItemData* pmd = (_MenuItemData*)lpDrawItemStruct->itemData;
\r
2231 CDCHandle dc = lpDrawItemStruct->hDC;
\r
2232 const RECT& rcItem = lpDrawItemStruct->rcItem;
\r
2233 T* pT = static_cast<T*>(this);
\r
2235 #ifndef COLOR_MENUHILIGHT
\r
2236 const int COLOR_MENUHILIGHT = 29;
\r
2237 #endif // !COLOR_MENUHILIGHT
\r
2239 BOOL bDisabled = lpDrawItemStruct->itemState & ODS_GRAYED;
\r
2240 BOOL bSelected = lpDrawItemStruct->itemState & ODS_SELECTED;
\r
2241 BOOL bChecked = lpDrawItemStruct->itemState & ODS_CHECKED;
\r
2243 // paint background
\r
2244 if(bSelected || lpDrawItemStruct->itemAction == ODA_SELECT)
\r
2248 dc.FillRect(&rcItem, ::GetSysColorBrush(COLOR_MENUHILIGHT));
\r
2249 dc.FrameRect(&rcItem, ::GetSysColorBrush(COLOR_HIGHLIGHT));
\r
2253 dc.FillRect(&rcItem, ::GetSysColorBrush(COLOR_MENU));
\r
2257 if(pmd->fType & MFT_SEPARATOR)
\r
2261 rc.top += (rc.bottom - rc.top) / 2; // vertical center
\r
2262 dc.DrawEdge(&rc, EDGE_ETCHED, BF_TOP); // draw separator line
\r
2264 else // not a separator
\r
2266 if(LOWORD(lpDrawItemStruct->itemID) == (WORD)-1)
\r
2267 bSelected = FALSE;
\r
2268 RECT rcButn = { rcItem.left, rcItem.top, rcItem.left + m_szButton.cx, rcItem.top + m_szButton.cy }; // button rect
\r
2269 ::OffsetRect(&rcButn, 0, ((rcItem.bottom - rcItem.top) - (rcButn.bottom - rcButn.top)) / 2); // center vertically
\r
2271 // draw background and border for checked items
\r
2274 RECT rcCheck = rcButn;
\r
2275 ::InflateRect(&rcCheck, -1, -1);
\r
2277 dc.FillRect(&rcCheck, ::GetSysColorBrush(COLOR_MENU));
\r
2278 dc.FrameRect(&rcCheck, ::GetSysColorBrush(COLOR_HIGHLIGHT));
\r
2281 int iButton = pmd->iButton;
\r
2284 // calc drawing point
\r
2285 SIZE sz = { rcButn.right - rcButn.left - m_szBitmap.cx, rcButn.bottom - rcButn.top - m_szBitmap.cy };
\r
2288 POINT point = { rcButn.left + sz.cx, rcButn.top + sz.cy };
\r
2290 // draw disabled or normal
\r
2293 ::ImageList_Draw(m_hImageList, iButton, dc, point.x, point.y, ILD_TRANSPARENT);
\r
2297 HBRUSH hBrushBackground = ::GetSysColorBrush((bSelected && !(bDisabled && bChecked)) ? COLOR_MENUHILIGHT : COLOR_MENU);
\r
2298 HBRUSH hBrushDisabledImage = ::GetSysColorBrush(COLOR_3DSHADOW);
\r
2299 pT->DrawBitmapDisabled(dc, iButton, point, hBrushBackground, hBrushBackground, hBrushDisabledImage);
\r
2304 // no image - look for custom checked/unchecked bitmaps
\r
2305 CMenuItemInfo info;
\r
2306 info.fMask = MIIM_CHECKMARKS | MIIM_TYPE;
\r
2307 ::GetMenuItemInfo((HMENU)lpDrawItemStruct->hwndItem, lpDrawItemStruct->itemID, MF_BYCOMMAND, &info);
\r
2308 if(bChecked || info.hbmpUnchecked != NULL)
\r
2310 BOOL bRadio = ((info.fType & MFT_RADIOCHECK) != 0);
\r
2311 pT->DrawCheckmark(dc, rcButn, bSelected, bDisabled, bRadio, bChecked ? info.hbmpChecked : info.hbmpUnchecked);
\r
2316 int cxButn = m_szButton.cx;
\r
2317 // calc text rectangle and colors
\r
2318 RECT rcText = rcItem;
\r
2319 rcText.left += cxButn + s_kcxGap + s_kcxTextMargin;
\r
2320 rcText.right -= cxButn;
\r
2321 dc.SetBkMode(TRANSPARENT);
\r
2322 COLORREF colorText = ::GetSysColor(bDisabled ? (bSelected ? COLOR_GRAYTEXT : COLOR_3DSHADOW) : (bSelected ? COLOR_HIGHLIGHTTEXT : COLOR_MENUTEXT));
\r
2324 pT->DrawMenuText(dc, rcText, pmd->lpstrText, colorText); // finally!
\r
2328 void DrawMenuText(CDCHandle& dc, RECT& rc, LPCTSTR lpstrText, COLORREF color)
\r
2331 for(int i = 0; i < lstrlen(lpstrText); i++)
\r
2333 if(lpstrText[i] == _T('\t'))
\r
2339 dc.SetTextColor(color);
\r
2340 dc.DrawText(lpstrText, nTab, &rc, DT_SINGLELINE | DT_LEFT | DT_VCENTER | (m_bShowKeyboardCues ? 0 : DT_HIDEPREFIX));
\r
2342 dc.DrawText(&lpstrText[nTab + 1], -1, &rc, DT_SINGLELINE | DT_RIGHT | DT_VCENTER | (m_bShowKeyboardCues ? 0 : DT_HIDEPREFIX));
\r
2345 void DrawBitmapDisabled(CDCHandle& dc, int nImage, POINT point,
\r
2346 HBRUSH hBrushBackground = ::GetSysColorBrush(COLOR_3DFACE),
\r
2347 HBRUSH hBrush3DEffect = ::GetSysColorBrush(COLOR_3DHILIGHT),
\r
2348 HBRUSH hBrushDisabledImage = ::GetSysColorBrush(COLOR_3DSHADOW))
\r
2350 #if (_WIN32_WINNT >= 0x0501) && (_WIN32_IE >= 0x0501)
\r
2351 if(m_bAlphaImages)
\r
2353 IMAGELISTDRAWPARAMS ildp = { 0 };
\r
2354 ildp.cbSize = sizeof(IMAGELISTDRAWPARAMS);
\r
2355 ildp.himl = m_hImageList;
\r
2364 ildp.fStyle = ILD_TRANSPARENT;
\r
2365 ildp.fState = ILS_SATURATE;
\r
2367 ::ImageList_DrawIndirect(&ildp);
\r
2370 #endif // (_WIN32_WINNT >= 0x0501) && (_WIN32_IE >= 0x0501)
\r
2372 // create memory DC
\r
2374 dcMem.CreateCompatibleDC(dc);
\r
2375 // create mono or color bitmap
\r
2377 bmp.CreateCompatibleBitmap(dc, m_szBitmap.cx, m_szBitmap.cy);
\r
2378 ATLASSERT(bmp.m_hBitmap != NULL);
\r
2379 // draw image into memory DC--fill BG white first
\r
2380 HBITMAP hBmpOld = dcMem.SelectBitmap(bmp);
\r
2381 dcMem.PatBlt(0, 0, m_szBitmap.cx, m_szBitmap.cy, WHITENESS);
\r
2382 // If white is the text color, we can't use the normal painting since
\r
2383 // it would blend with the WHITENESS, but the mask is OK
\r
2384 UINT uDrawStyle = (::GetSysColor(COLOR_BTNTEXT) == RGB(255, 255, 255)) ? ILD_MASK : ILD_NORMAL;
\r
2385 ::ImageList_Draw(m_hImageList, nImage, dcMem, 0, 0, uDrawStyle);
\r
2386 dc.DitherBlt(point.x, point.y, m_szBitmap.cx, m_szBitmap.cy, dcMem, NULL, 0, 0, hBrushBackground, hBrush3DEffect, hBrushDisabledImage);
\r
2387 dcMem.SelectBitmap(hBmpOld); // restore
\r
2392 BOOL Draw3DCheckmark(CDCHandle& dc, const RECT& rc, BOOL bSelected, BOOL bDisabled, BOOL bRadio, HBITMAP hBmpCheck)
\r
2394 return DrawCheckmark(dc, rc, bSelected, bDisabled, bRadio, hBmpCheck);
\r
2397 BOOL DrawCheckmark(CDCHandle& dc, const RECT& rc, BOOL bSelected, BOOL bDisabled, BOOL bRadio, HBITMAP hBmpCheck)
\r
2399 // get checkmark bitmap, if none, use Windows standard
\r
2400 SIZE size = { 0, 0 };
\r
2401 CBitmapHandle bmp = hBmpCheck;
\r
2402 if(hBmpCheck != NULL)
\r
2404 bmp.GetSize(size);
\r
2408 size.cx = ::GetSystemMetrics(SM_CXMENUCHECK);
\r
2409 size.cy = ::GetSystemMetrics(SM_CYMENUCHECK);
\r
2410 bmp.CreateCompatibleBitmap(dc, size.cx, size.cy);
\r
2411 ATLASSERT(bmp.m_hBitmap != NULL);
\r
2413 // center bitmap in caller's rectangle
\r
2415 if((rc.right - rc.left) > size.cx)
\r
2417 rcDest.left = rc.left + (rc.right - rc.left - size.cx) / 2;
\r
2418 rcDest.right = rcDest.left + size.cx;
\r
2420 if((rc.bottom - rc.top) > size.cy)
\r
2422 rcDest.top = rc.top + (rc.bottom - rc.top - size.cy) / 2;
\r
2423 rcDest.bottom = rcDest.top + size.cy;
\r
2425 // paint background
\r
2428 if(bSelected && !bDisabled)
\r
2430 dc.FillRect(&rcDest, COLOR_MENU);
\r
2434 COLORREF clrTextOld = dc.SetTextColor(::GetSysColor(COLOR_BTNFACE));
\r
2435 COLORREF clrBkOld = dc.SetBkColor(::GetSysColor(COLOR_BTNHILIGHT));
\r
2436 CBrush hbr(CDCHandle::GetHalftoneBrush());
\r
2437 dc.SetBrushOrg(rcDest.left, rcDest.top);
\r
2438 dc.FillRect(&rcDest, hbr);
\r
2439 dc.SetTextColor(clrTextOld);
\r
2440 dc.SetBkColor(clrBkOld);
\r
2444 // create source image
\r
2446 dcSource.CreateCompatibleDC(dc);
\r
2447 HBITMAP hBmpOld = dcSource.SelectBitmap(bmp);
\r
2449 const COLORREF clrBlack = RGB(0, 0, 0);
\r
2450 const COLORREF clrWhite = RGB(255, 255, 255);
\r
2451 COLORREF clrTextOld = dc.SetTextColor(clrBlack);
\r
2452 COLORREF clrBkOld = dc.SetBkColor(clrWhite);
\r
2455 dcMask.CreateCompatibleDC(dc);
\r
2457 bmpMask.CreateBitmap(size.cx, size.cy, 1, 1, NULL);
\r
2458 HBITMAP hBmpOld1 = dcMask.SelectBitmap(bmpMask);
\r
2460 // draw the checkmark transparently
\r
2461 int cx = rcDest.right - rcDest.left;
\r
2462 int cy = rcDest.bottom - rcDest.top;
\r
2463 if(hBmpCheck != NULL)
\r
2465 // build mask based on transparent color
\r
2466 dcSource.SetBkColor(m_clrMask);
\r
2467 dcMask.SetBkColor(clrBlack);
\r
2468 dcMask.SetTextColor(clrWhite);
\r
2469 dcMask.BitBlt(0, 0, size.cx, size.cy, dcSource, 0, 0, SRCCOPY);
\r
2470 // draw bitmap using the mask
\r
2471 dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcSource, 0, 0, SRCINVERT);
\r
2472 dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcMask, 0, 0, SRCAND);
\r
2473 dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcSource, 0, 0, SRCINVERT);
\r
2477 const DWORD ROP_DSno = 0x00BB0226L;
\r
2478 const DWORD ROP_DSa = 0x008800C6L;
\r
2479 const DWORD ROP_DSo = 0x00EE0086L;
\r
2480 const DWORD ROP_DSna = 0x00220326L;
\r
2483 RECT rcSource = { 0, 0, min(size.cx, rc.right - rc.left), min(size.cy, rc.bottom - rc.top) };
\r
2484 dcMask.DrawFrameControl(&rcSource, DFC_MENU, bRadio ? DFCS_MENUBULLET : DFCS_MENUCHECK);
\r
2486 // draw shadow if disabled
\r
2487 if(!m_bFlatMenus && bDisabled)
\r
2489 // offset by one pixel
\r
2490 int x = rcDest.left + 1;
\r
2491 int y = rcDest.top + 1;
\r
2492 // paint source bitmap
\r
2493 const int nColor = COLOR_3DHILIGHT;
\r
2494 dcSource.FillRect(&rcSource, nColor);
\r
2495 // draw checkmark - special case black and white colors
\r
2496 COLORREF clrCheck = ::GetSysColor(nColor);
\r
2497 if(clrCheck == clrWhite)
\r
2499 dc.BitBlt(x, y, cx, cy, dcMask, 0, 0, ROP_DSno);
\r
2500 dc.BitBlt(x, y, cx, cy, dcSource, 0, 0, ROP_DSa);
\r
2504 if(clrCheck != clrBlack)
\r
2506 ATLASSERT(dcSource.GetTextColor() == clrBlack);
\r
2507 ATLASSERT(dcSource.GetBkColor() == clrWhite);
\r
2508 dcSource.BitBlt(0, 0, size.cx, size.cy, dcMask, 0, 0, ROP_DSna);
\r
2510 dc.BitBlt(x, y, cx, cy, dcMask, 0, 0, ROP_DSa);
\r
2511 dc.BitBlt(x, y, cx, cy, dcSource, 0, 0, ROP_DSo);
\r
2515 // paint source bitmap
\r
2516 const int nColor = bDisabled ? COLOR_BTNSHADOW : COLOR_MENUTEXT;
\r
2517 dcSource.FillRect(&rcSource, nColor);
\r
2518 // draw checkmark - special case black and white colors
\r
2519 COLORREF clrCheck = ::GetSysColor(nColor);
\r
2520 if(clrCheck == clrWhite)
\r
2522 dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcMask, 0, 0, ROP_DSno);
\r
2523 dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcSource, 0, 0, ROP_DSa);
\r
2527 if(clrCheck != clrBlack)
\r
2529 ATLASSERT(dcSource.GetTextColor() == clrBlack);
\r
2530 ATLASSERT(dcSource.GetBkColor() == clrWhite);
\r
2531 dcSource.BitBlt(0, 0, size.cx, size.cy, dcMask, 0, 0, ROP_DSna);
\r
2533 dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcMask, 0, 0, ROP_DSa);
\r
2534 dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcSource, 0, 0, ROP_DSo);
\r
2538 dc.SetTextColor(clrTextOld);
\r
2539 dc.SetBkColor(clrBkOld);
\r
2540 dcSource.SelectBitmap(hBmpOld);
\r
2541 dcMask.SelectBitmap(hBmpOld1);
\r
2542 if(hBmpCheck == NULL)
\r
2543 bmp.DeleteObject();
\r
2544 // draw pushed-in hilight
\r
2545 if(!m_bFlatMenus && !bDisabled)
\r
2547 if(rc.right - rc.left > size.cx)
\r
2548 ::InflateRect(&rcDest, 1,1); // inflate checkmark by one pixel all around
\r
2549 dc.DrawEdge(&rcDest, BDR_SUNKENOUTER, BF_RECT);
\r
2555 void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct)
\r
2557 _MenuItemData* pmd = (_MenuItemData*)lpMeasureItemStruct->itemData;
\r
2559 if(pmd->fType & MFT_SEPARATOR) // separator - use half system height and zero width
\r
2561 lpMeasureItemStruct->itemHeight = ::GetSystemMetrics(SM_CYMENU) / 2;
\r
2562 lpMeasureItemStruct->itemWidth = 0;
\r
2566 // compute size of text - use DrawText with DT_CALCRECT
\r
2567 CWindowDC dc(NULL);
\r
2569 HFONT hOldFont = NULL;
\r
2570 if(pmd->fState & MFS_DEFAULT)
\r
2572 // need bold version of font
\r
2573 LOGFONT lf = { 0 };
\r
2574 m_fontMenu.GetLogFont(lf);
\r
2575 lf.lfWeight += 200;
\r
2576 fontBold.CreateFontIndirect(&lf);
\r
2577 ATLASSERT(fontBold.m_hFont != NULL);
\r
2578 hOldFont = dc.SelectFont(fontBold);
\r
2582 hOldFont = dc.SelectFont(m_fontMenu);
\r
2585 RECT rcText = { 0, 0, 0, 0 };
\r
2586 dc.DrawText(pmd->lpstrText, -1, &rcText, DT_SINGLELINE | DT_LEFT | DT_VCENTER | DT_CALCRECT);
\r
2587 int cx = rcText.right - rcText.left;
\r
2588 dc.SelectFont(hOldFont);
\r
2590 LOGFONT lf = { 0 };
\r
2591 m_fontMenu.GetLogFont(lf);
\r
2592 int cy = lf.lfHeight;
\r
2595 const int cyMargin = 8;
\r
2598 // height of item is the bigger of these two
\r
2599 lpMeasureItemStruct->itemHeight = max(cy, (int)m_szButton.cy);
\r
2601 // width is width of text plus a bunch of stuff
\r
2602 cx += 2 * s_kcxTextMargin; // L/R margin for readability
\r
2603 cx += s_kcxGap; // space between button and menu text
\r
2604 cx += 2 * m_szButton.cx; // button width (L=button; R=empty margin)
\r
2605 cx += m_cxExtraSpacing; // extra between item text and accelerator keys
\r
2607 // Windows adds 1 to returned value
\r
2608 cx -= ::GetSystemMetrics(SM_CXMENUCHECK) - 1;
\r
2609 lpMeasureItemStruct->itemWidth = cx; // done deal
\r
2613 // Implementation - Hook procs
\r
2614 static LRESULT CALLBACK CreateHookProc(int nCode, WPARAM wParam, LPARAM lParam)
\r
2616 const int cchClassName = 7;
\r
2617 TCHAR szClassName[cchClassName] = { 0 };
\r
2619 if(nCode == HCBT_CREATEWND)
\r
2621 HWND hWndMenu = (HWND)wParam;
\r
2622 #ifdef _CMDBAR_EXTRA_TRACE
\r
2623 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - HCBT_CREATEWND (HWND = %8.8X)\n"), hWndMenu);
\r
2626 ::GetClassName(hWndMenu, szClassName, cchClassName);
\r
2627 if(!lstrcmp(_T("#32768"), szClassName))
\r
2628 s_pCurrentBar->m_stackMenuWnd.Push(hWndMenu);
\r
2630 else if(nCode == HCBT_DESTROYWND)
\r
2632 HWND hWndMenu = (HWND)wParam;
\r
2633 #ifdef _CMDBAR_EXTRA_TRACE
\r
2634 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - HCBT_DESTROYWND (HWND = %8.8X)\n"), hWndMenu);
\r
2637 ::GetClassName(hWndMenu, szClassName, cchClassName);
\r
2638 if(!lstrcmp(_T("#32768"), szClassName))
\r
2640 ATLASSERT(hWndMenu == s_pCurrentBar->m_stackMenuWnd.GetCurrent());
\r
2641 s_pCurrentBar->m_stackMenuWnd.Pop();
\r
2645 return ::CallNextHookEx(s_hCreateHook, nCode, wParam, lParam);
\r
2648 static LRESULT CALLBACK MessageHookProc(int nCode, WPARAM wParam, LPARAM lParam)
\r
2650 LPMSG pMsg = (LPMSG)lParam;
\r
2652 if(nCode == HC_ACTION && wParam == PM_REMOVE && pMsg->message != GetGetBarMessage() && pMsg->message != WM_FORWARDMSG)
\r
2654 CCommandBarCtrlBase* pCmdBar = NULL;
\r
2655 HWND hWnd = pMsg->hwnd;
\r
2657 while(pCmdBar == NULL && hWnd != NULL)
\r
2659 pCmdBar = (CCommandBarCtrlBase*)::SendMessage(hWnd, GetGetBarMessage(), (WPARAM)&dwPID, 0L);
\r
2660 hWnd = ::GetParent(hWnd);
\r
2663 if(pCmdBar != NULL && dwPID == GetCurrentProcessId())
\r
2665 pCmdBar->m_hWndHook = pMsg->hwnd;
\r
2666 ATLASSERT(pCmdBar->IsCommandBarBase());
\r
2668 if(::IsWindow(pCmdBar->m_hWnd))
\r
2669 pCmdBar->SendMessage(WM_FORWARDMSG, 0, (LPARAM)pMsg);
\r
2671 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook skipping message, can't find command bar!\n"));
\r
2676 ATLASSERT(s_pmapMsgHook != NULL);
\r
2677 if(s_pmapMsgHook != NULL)
\r
2679 DWORD dwThreadID = ::GetCurrentThreadId();
\r
2680 _MsgHookData* pData = s_pmapMsgHook->Lookup(dwThreadID);
\r
2683 lRet = ::CallNextHookEx(pData->hMsgHook, nCode, wParam, lParam);
\r
2690 void DoPopupMenu(int nIndex, bool bAnimate)
\r
2692 #ifdef _CMDBAR_EXTRA_TRACE
\r
2693 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - DoPopupMenu, bAnimate = %s\n"), bAnimate ? "true" : "false");
\r
2696 // Menu animation flags
\r
2697 #ifndef TPM_VERPOSANIMATION
\r
2698 const UINT TPM_VERPOSANIMATION = 0x1000L;
\r
2700 #ifndef TPM_NOANIMATION
\r
2701 const UINT TPM_NOANIMATION = 0x4000L;
\r
2703 T* pT = static_cast<T*>(this);
\r
2705 // get popup menu and it's position
\r
2706 RECT rect = { 0 };
\r
2707 GetItemRect(nIndex, &rect);
\r
2708 POINT pt = { rect.left, rect.bottom };
\r
2709 MapWindowPoints(NULL, &pt, 1);
\r
2710 MapWindowPoints(NULL, &rect);
\r
2711 TPMPARAMS TPMParams = { 0 };
\r
2712 TPMParams.cbSize = sizeof(TPMPARAMS);
\r
2713 TPMParams.rcExclude = rect;
\r
2714 HMENU hMenuPopup = ::GetSubMenu(m_hMenu, nIndex);
\r
2715 ATLASSERT(hMenuPopup != NULL);
\r
2718 TBBUTTON tbb = { 0 };
\r
2719 GetButton(nIndex, &tbb);
\r
2720 int nCmdID = tbb.idCommand;
\r
2722 m_nPopBtn = nIndex; // remember current button's index
\r
2724 // press button and display popup menu
\r
2725 PressButton(nCmdID, TRUE);
\r
2726 SetHotItem(nCmdID);
\r
2727 pT->DoTrackPopupMenu(hMenuPopup, TPM_LEFTBUTTON | TPM_VERTICAL | TPM_LEFTALIGN | TPM_TOPALIGN |
\r
2728 (s_bW2K ? (bAnimate ? TPM_VERPOSANIMATION : TPM_NOANIMATION) : 0), pt.x, pt.y, &TPMParams);
\r
2729 PressButton(nCmdID, FALSE);
\r
2730 if(::GetFocus() != m_hWnd)
\r
2733 m_nPopBtn = -1; // restore
\r
2735 // eat next message if click is on the same button
\r
2737 if(::PeekMessage(&msg, m_hWnd, WM_LBUTTONDOWN, WM_LBUTTONDOWN, PM_NOREMOVE) && ::PtInRect(&rect, msg.pt))
\r
2738 ::PeekMessage(&msg, m_hWnd, WM_LBUTTONDOWN, WM_LBUTTONDOWN, PM_REMOVE);
\r
2740 // check if another popup menu should be displayed
\r
2741 if(m_nNextPopBtn != -1)
\r
2743 PostMessage(GetAutoPopupMessage(), m_nNextPopBtn & 0xFFFF);
\r
2744 if(!(m_nNextPopBtn & 0xFFFF0000) && !m_bPopupItem)
\r
2745 PostMessage(WM_KEYDOWN, VK_DOWN, 0);
\r
2746 m_nNextPopBtn = -1;
\r
2750 m_bContextMenu = false;
\r
2751 // If user didn't hit escape, give focus back
\r
2752 if(!m_bEscapePressed)
\r
2754 if(m_bUseKeyboardCues && m_bShowKeyboardCues)
\r
2755 m_bAllowKeyboardCues = false;
\r
2756 pT->GiveFocusBack();
\r
2760 SetHotItem(nCmdID);
\r
2761 SetAnchorHighlight(TRUE);
\r
2766 BOOL DoTrackPopupMenu(HMENU hMenu, UINT uFlags, int x, int y, LPTPMPARAMS lpParams = NULL)
\r
2768 CMenuHandle menuPopup = hMenu;
\r
2770 CWindowCreateCriticalSectionLock lock;
\r
2771 if(FAILED(lock.Lock()))
\r
2773 ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CCommandBarCtrlImpl::DoTrackPopupMenu.\n"));
\r
2778 ATLASSERT(s_hCreateHook == NULL);
\r
2780 s_pCurrentBar = static_cast<CCommandBarCtrlBase*>(this);
\r
2782 s_hCreateHook = ::SetWindowsHookEx(WH_CBT, CreateHookProc, ModuleHelper::GetModuleInstance(), GetCurrentThreadId());
\r
2783 ATLASSERT(s_hCreateHook != NULL);
\r
2785 m_bPopupItem = false;
\r
2786 m_bMenuActive = true;
\r
2788 BOOL bTrackRet = menuPopup.TrackPopupMenuEx(uFlags, x, y, m_hWnd, lpParams);
\r
2789 m_bMenuActive = false;
\r
2791 ::UnhookWindowsHookEx(s_hCreateHook);
\r
2793 s_hCreateHook = NULL;
\r
2794 s_pCurrentBar = NULL;
\r
2798 // cleanup - convert menus back to original state
\r
2799 #ifdef _CMDBAR_EXTRA_TRACE
\r
2800 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - TrackPopupMenu - cleanup\n"));
\r
2803 ATLASSERT(m_stackMenuWnd.GetSize() == 0);
\r
2806 ATL::CWindow wndTL = GetTopLevelParent();
\r
2807 wndTL.UpdateWindow();
\r
2809 // restore the menu items to the previous state for all menus that were converted
\r
2810 if(m_bImagesVisible)
\r
2812 HMENU hMenuSav = NULL;
\r
2813 while((hMenuSav = m_stackMenuHandle.Pop()) != NULL)
\r
2815 menuPopup = hMenuSav;
\r
2816 BOOL bRet = FALSE;
\r
2817 // restore state and delete menu item data
\r
2818 for(int i = 0; i < menuPopup.GetMenuItemCount(); i++)
\r
2820 CMenuItemInfo mii;
\r
2821 mii.fMask = MIIM_DATA | MIIM_TYPE | MIIM_ID;
\r
2822 bRet = menuPopup.GetMenuItemInfo(i, TRUE, &mii);
\r
2825 _MenuItemData* pMI = (_MenuItemData*)mii.dwItemData;
\r
2826 if(pMI != NULL && pMI->IsCmdBarMenuItem())
\r
2828 mii.fMask = MIIM_DATA | MIIM_TYPE | MIIM_STATE;
\r
2829 mii.fType = pMI->fType;
\r
2830 mii.fState = pMI->fState;
\r
2831 mii.dwTypeData = pMI->lpstrText;
\r
2832 mii.cch = lstrlen(pMI->lpstrText);
\r
2833 mii.dwItemData = NULL;
\r
2835 bRet = menuPopup.SetMenuItemInfo(i, TRUE, &mii);
\r
2836 // this one triggers WM_MEASUREITEM
\r
2837 menuPopup.ModifyMenu(i, MF_BYPOSITION | mii.fType | mii.fState, mii.wID, pMI->lpstrText);
\r
2840 delete [] pMI->lpstrText;
\r
2849 int GetPreviousMenuItem(int nBtn) const
\r
2853 #if (_WIN32_IE >= 0x0500)
\r
2855 GetClientRect(&rcClient);
\r
2856 #endif // (_WIN32_IE >= 0x0500)
\r
2858 for(nNextBtn = nBtn - 1; nNextBtn != nBtn; nNextBtn--)
\r
2861 nNextBtn = ::GetMenuItemCount(m_hMenu) - 1;
\r
2862 TBBUTTON tbb = { 0 };
\r
2863 GetButton(nNextBtn, &tbb);
\r
2864 #if (_WIN32_IE >= 0x0500)
\r
2866 GetItemRect(nNextBtn, &rcBtn);
\r
2867 if(rcBtn.right > rcClient.right)
\r
2869 nNextBtn = -2; // chevron
\r
2872 #endif // (_WIN32_IE >= 0x0500)
\r
2873 if((tbb.fsState & TBSTATE_ENABLED) != 0 && (tbb.fsState & TBSTATE_HIDDEN) == 0)
\r
2876 return (nNextBtn != nBtn) ? nNextBtn : -1;
\r
2879 int GetNextMenuItem(int nBtn) const
\r
2883 #if (_WIN32_IE >= 0x0500)
\r
2884 RECT rcClient = { 0 };
\r
2885 GetClientRect(&rcClient);
\r
2886 #endif // (_WIN32_IE >= 0x0500)
\r
2888 int nCount = ::GetMenuItemCount(m_hMenu);
\r
2889 for(nNextBtn = nBtn + 1; nNextBtn != nBtn; nNextBtn++)
\r
2891 if(nNextBtn >= nCount)
\r
2893 TBBUTTON tbb = { 0 };
\r
2894 GetButton(nNextBtn, &tbb);
\r
2895 #if (_WIN32_IE >= 0x0500)
\r
2896 RECT rcBtn = { 0 };
\r
2897 GetItemRect(nNextBtn, &rcBtn);
\r
2898 if(rcBtn.right > rcClient.right)
\r
2900 nNextBtn = -2; // chevron
\r
2903 #endif // (_WIN32_IE >= 0x0500)
\r
2904 if((tbb.fsState & TBSTATE_ENABLED) != 0 && (tbb.fsState & TBSTATE_HIDDEN) == 0)
\r
2907 return (nNextBtn != nBtn) ? nNextBtn : -1;
\r
2910 #if (_WIN32_IE >= 0x0500)
\r
2911 bool DisplayChevronMenu()
\r
2913 // assume we are in a rebar
\r
2914 HWND hWndReBar = GetParent();
\r
2915 int nCount = (int)::SendMessage(hWndReBar, RB_GETBANDCOUNT, 0, 0L);
\r
2916 bool bRet = false;
\r
2917 for(int i = 0; i < nCount; i++)
\r
2919 REBARBANDINFO rbbi = { RunTimeHelper::SizeOf_REBARBANDINFO(), RBBIM_CHILD | RBBIM_STYLE };
\r
2920 BOOL bRetBandInfo = (BOOL)::SendMessage(hWndReBar, RB_GETBANDINFO, i, (LPARAM)&rbbi);
\r
2921 if(bRetBandInfo && rbbi.hwndChild == m_hWnd)
\r
2923 if((rbbi.fStyle & RBBS_USECHEVRON) != 0)
\r
2925 ::PostMessage(hWndReBar, RB_PUSHCHEVRON, i, 0L);
\r
2926 PostMessage(WM_KEYDOWN, VK_DOWN, 0L);
\r
2934 #endif // (_WIN32_IE >= 0x0500)
\r
2936 void GetSystemSettings()
\r
2938 // refresh our font
\r
2939 NONCLIENTMETRICS info = { RunTimeHelper::SizeOf_NONCLIENTMETRICS() };
\r
2940 BOOL bRet = ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(info), &info, 0);
\r
2944 LOGFONT logfont = { 0 };
\r
2945 if(m_fontMenu.m_hFont != NULL)
\r
2946 m_fontMenu.GetLogFont(logfont);
\r
2947 if(logfont.lfHeight != info.lfMenuFont.lfHeight ||
\r
2948 logfont.lfWidth != info.lfMenuFont.lfWidth ||
\r
2949 logfont.lfEscapement != info.lfMenuFont.lfEscapement ||
\r
2950 logfont.lfOrientation != info.lfMenuFont.lfOrientation ||
\r
2951 logfont.lfWeight != info.lfMenuFont.lfWeight ||
\r
2952 logfont.lfItalic != info.lfMenuFont.lfItalic ||
\r
2953 logfont.lfUnderline != info.lfMenuFont.lfUnderline ||
\r
2954 logfont.lfStrikeOut != info.lfMenuFont.lfStrikeOut ||
\r
2955 logfont.lfCharSet != info.lfMenuFont.lfCharSet ||
\r
2956 logfont.lfOutPrecision != info.lfMenuFont.lfOutPrecision ||
\r
2957 logfont.lfClipPrecision != info.lfMenuFont.lfClipPrecision ||
\r
2958 logfont.lfQuality != info.lfMenuFont.lfQuality ||
\r
2959 logfont.lfPitchAndFamily != info.lfMenuFont.lfPitchAndFamily ||
\r
2960 lstrcmp(logfont.lfFaceName, info.lfMenuFont.lfFaceName) != 0)
\r
2962 HFONT hFontMenu = ::CreateFontIndirect(&info.lfMenuFont);
\r
2963 ATLASSERT(hFontMenu != NULL);
\r
2964 if(hFontMenu != NULL)
\r
2966 if(m_fontMenu.m_hFont != NULL)
\r
2967 m_fontMenu.DeleteObject();
\r
2968 m_fontMenu.Attach(hFontMenu);
\r
2969 SetFont(m_fontMenu);
\r
2970 AddStrings(_T("NS\0")); // for proper item height
\r
2976 // check if we need extra spacing for menu item text
\r
2977 CWindowDC dc(m_hWnd);
\r
2978 HFONT hFontOld = dc.SelectFont(m_fontMenu);
\r
2979 RECT rcText = { 0, 0, 0, 0 };
\r
2980 dc.DrawText(_T("\t"), -1, &rcText, DT_SINGLELINE | DT_LEFT | DT_VCENTER | DT_CALCRECT);
\r
2981 if((rcText.right - rcText.left) < 4)
\r
2983 ::SetRectEmpty(&rcText);
\r
2984 dc.DrawText(_T("x"), -1, &rcText, DT_SINGLELINE | DT_LEFT | DT_VCENTER | DT_CALCRECT);
\r
2985 m_cxExtraSpacing = rcText.right - rcText.left;
\r
2989 m_cxExtraSpacing = 0;
\r
2991 dc.SelectFont(hFontOld);
\r
2993 // get Windows version
\r
2994 OSVERSIONINFO ovi = { sizeof(OSVERSIONINFO) };
\r
2995 ::GetVersionEx(&ovi);
\r
2997 // query keyboard cues mode (Windows 2000 or later)
\r
2998 if(ovi.dwMajorVersion >= 5)
\r
3000 #ifndef SPI_GETKEYBOARDCUES
\r
3001 const UINT SPI_GETKEYBOARDCUES = 0x100A;
\r
3002 #endif // !SPI_GETKEYBOARDCUES
\r
3003 BOOL bRetVal = TRUE;
\r
3004 bRet = ::SystemParametersInfo(SPI_GETKEYBOARDCUES, 0, &bRetVal, 0);
\r
3005 m_bUseKeyboardCues = (bRet && !bRetVal);
\r
3006 m_bAllowKeyboardCues = true;
\r
3007 ShowKeyboardCues(!m_bUseKeyboardCues);
\r
3010 // query flat menu mode (Windows XP or later)
\r
3011 if((ovi.dwMajorVersion == 5 && ovi.dwMinorVersion >= 1) || (ovi.dwMajorVersion > 5))
\r
3013 #ifndef SPI_GETFLATMENU
\r
3014 const UINT SPI_GETFLATMENU = 0x1022;
\r
3015 #endif // !SPI_GETFLATMENU
\r
3016 BOOL bRetVal = FALSE;
\r
3017 bRet = ::SystemParametersInfo(SPI_GETFLATMENU, 0, &bRetVal, 0);
\r
3018 m_bFlatMenus = (bRet && bRetVal);
\r
3021 #if _WTL_CMDBAR_VISTA_MENUS
\r
3022 // check if we should use Vista menus
\r
3023 bool bVistaMenus = (RunTimeHelper::IsVista() && RunTimeHelper::IsCommCtrl6() && ((m_dwExtendedStyle & CBR_EX_NOVISTAMENUS) == 0));
\r
3027 HMODULE hThemeDLL = ::LoadLibrary(_T("uxtheme.dll"));
\r
3028 if(hThemeDLL != NULL)
\r
3030 typedef BOOL (STDAPICALLTYPE *PFN_IsThemeActive)();
\r
3031 PFN_IsThemeActive pfnIsThemeActive = (PFN_IsThemeActive)::GetProcAddress(hThemeDLL, "IsThemeActive");
\r
3032 ATLASSERT(pfnIsThemeActive != NULL);
\r
3033 bVistaMenus = bVistaMenus && (pfnIsThemeActive != NULL) && (pfnIsThemeActive() != FALSE);
\r
3035 typedef BOOL (STDAPICALLTYPE *PFN_IsAppThemed)();
\r
3036 PFN_IsAppThemed pfnIsAppThemed = (PFN_IsAppThemed)::GetProcAddress(hThemeDLL, "IsAppThemed");
\r
3037 ATLASSERT(pfnIsAppThemed != NULL);
\r
3038 bVistaMenus = bVistaMenus && (pfnIsAppThemed != NULL) && (pfnIsAppThemed() != FALSE);
\r
3040 ::FreeLibrary(hThemeDLL);
\r
3044 if(!bVistaMenus && m_bVistaMenus && (m_hMenu != NULL) && (m_arrCommand.GetSize() > 0))
\r
3046 T* pT = static_cast<T*>(this);
\r
3047 pT->_RemoveVistaBitmapsFromMenu();
\r
3050 m_bVistaMenus = bVistaMenus;
\r
3051 #endif // _WTL_CMDBAR_VISTA_MENUS
\r
3053 #ifdef _CMDBAR_EXTRA_TRACE
\r
3054 ATLTRACE2(atlTraceUI, 0, _T("CmdBar - GetSystemSettings:\n m_bFlatMenus = %s\n m_bUseKeyboardCues = %s m_bVistaMenus = %s\n"),
\r
3055 m_bFlatMenus ? "true" : "false", m_bUseKeyboardCues ? "true" : "false", m_bVistaMenus ? "true" : "false");
\r
3059 // Implementation - alternate focus mode support
\r
3062 if((m_dwExtendedStyle & CBR_EX_ALTFOCUSMODE) && m_hWndFocus == NULL)
\r
3063 m_hWndFocus = ::GetFocus();
\r
3067 void GiveFocusBack()
\r
3069 if(m_bParentActive)
\r
3071 if((m_dwExtendedStyle & CBR_EX_ALTFOCUSMODE) && ::IsWindow(m_hWndFocus))
\r
3072 ::SetFocus(m_hWndFocus);
\r
3073 else if(!(m_dwExtendedStyle & CBR_EX_ALTFOCUSMODE) && m_wndParent.IsWindow())
\r
3074 m_wndParent.SetFocus();
\r
3076 m_hWndFocus = NULL;
\r
3077 SetAnchorHighlight(FALSE);
\r
3078 if(m_bUseKeyboardCues && m_bShowKeyboardCues)
\r
3079 ShowKeyboardCues(false);
\r
3080 m_bSkipPostDown = false;
\r
3083 void ShowKeyboardCues(bool bShow)
\r
3085 m_bShowKeyboardCues = bShow;
\r
3086 SetDrawTextFlags(DT_HIDEPREFIX, m_bShowKeyboardCues ? 0 : DT_HIDEPREFIX);
\r
3091 // Implementation - internal message helpers
\r
3092 static UINT GetAutoPopupMessage()
\r
3094 static UINT uAutoPopupMessage = 0;
\r
3095 if(uAutoPopupMessage == 0)
\r
3097 CStaticDataInitCriticalSectionLock lock;
\r
3098 if(FAILED(lock.Lock()))
\r
3100 ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CCommandBarCtrlImpl::GetAutoPopupMessage.\n"));
\r
3105 if(uAutoPopupMessage == 0)
\r
3106 uAutoPopupMessage = ::RegisterWindowMessage(_T("WTL_CmdBar_InternalAutoPopupMsg"));
\r
3110 ATLASSERT(uAutoPopupMessage != 0);
\r
3111 return uAutoPopupMessage;
\r
3114 static UINT GetGetBarMessage()
\r
3116 static UINT uGetBarMessage = 0;
\r
3117 if(uGetBarMessage == 0)
\r
3119 CStaticDataInitCriticalSectionLock lock;
\r
3120 if(FAILED(lock.Lock()))
\r
3122 ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CCommandBarCtrlImpl::GetGetBarMessage.\n"));
\r
3127 if(uGetBarMessage == 0)
\r
3128 uGetBarMessage = ::RegisterWindowMessage(_T("WTL_CmdBar_InternalGetBarMsg"));
\r
3132 ATLASSERT(uGetBarMessage != 0);
\r
3133 return uGetBarMessage;
\r
3137 bool CreateInternalImageList(int cImages)
\r
3139 UINT uFlags = (m_bAlphaImages ? ILC_COLOR32 : ILC_COLOR24) | ILC_MASK;
\r
3140 m_hImageList = ::ImageList_Create(m_szBitmap.cx, m_szBitmap.cy, uFlags, cImages, 1);
\r
3141 ATLASSERT(m_hImageList != NULL);
\r
3142 return (m_hImageList != NULL);
\r
3145 // Implementation - support for Vista menus
\r
3146 #if _WTL_CMDBAR_VISTA_MENUS
\r
3147 void _AddVistaBitmapsFromImageList(int nStartIndex, int nCount)
\r
3149 // Create display compatible memory DC
\r
3150 HDC hDC = ::GetDC(NULL);
\r
3152 dcMem.CreateCompatibleDC(hDC);
\r
3153 HBITMAP hBitmapSave = dcMem.GetCurrentBitmap();
\r
3155 T* pT = static_cast<T*>(this);
\r
3156 // Create bitmaps for all menu items
\r
3157 for(int i = 0; i < nCount; i++)
\r
3159 HBITMAP hBitmap = pT->_CreateVistaBitmapHelper(nStartIndex + i, hDC, dcMem);
\r
3160 dcMem.SelectBitmap(hBitmapSave);
\r
3161 m_arrVistaBitmap.Add(hBitmap);
\r
3165 void _AddVistaBitmapFromImageList(int nIndex)
\r
3167 // Create display compatible memory DC
\r
3168 HDC hDC = ::GetDC(NULL);
\r
3170 dcMem.CreateCompatibleDC(hDC);
\r
3171 HBITMAP hBitmapSave = dcMem.GetCurrentBitmap();
\r
3173 // Create bitmap for menu item
\r
3174 T* pT = static_cast<T*>(this);
\r
3175 HBITMAP hBitmap = pT->_CreateVistaBitmapHelper(nIndex, hDC, dcMem);
\r
3177 // Select saved bitmap back and add bitmap to the array
\r
3178 dcMem.SelectBitmap(hBitmapSave);
\r
3179 m_arrVistaBitmap.Add(hBitmap);
\r
3182 void _ReplaceVistaBitmapFromImageList(int nIndex)
\r
3184 // Delete existing bitmap
\r
3185 if(m_arrVistaBitmap[nIndex] != NULL)
\r
3186 ::DeleteObject(m_arrVistaBitmap[nIndex]);
\r
3188 // Create display compatible memory DC
\r
3189 HDC hDC = ::GetDC(NULL);
\r
3191 dcMem.CreateCompatibleDC(hDC);
\r
3192 HBITMAP hBitmapSave = dcMem.GetCurrentBitmap();
\r
3194 // Create bitmap for menu item
\r
3195 T* pT = static_cast<T*>(this);
\r
3196 HBITMAP hBitmap = pT->_CreateVistaBitmapHelper(nIndex, hDC, dcMem);
\r
3198 // Select saved bitmap back and replace bitmap in the array
\r
3199 dcMem.SelectBitmap(hBitmapSave);
\r
3200 m_arrVistaBitmap.SetAtIndex(nIndex, hBitmap);
\r
3203 HBITMAP _CreateVistaBitmapHelper(int nIndex, HDC hDCSource, HDC hDCTarget)
\r
3205 // Create 32-bit bitmap
\r
3206 BITMAPINFO bi = { 0 };
\r
3207 bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
\r
3208 bi.bmiHeader.biWidth = m_szBitmap.cx;
\r
3209 bi.bmiHeader.biHeight = m_szBitmap.cy;
\r
3210 bi.bmiHeader.biPlanes = 1;
\r
3211 bi.bmiHeader.biBitCount = 32;
\r
3212 bi.bmiHeader.biCompression = BI_RGB;
\r
3213 bi.bmiHeader.biSizeImage = 0;
\r
3214 bi.bmiHeader.biXPelsPerMeter = 0;
\r
3215 bi.bmiHeader.biYPelsPerMeter = 0;
\r
3216 bi.bmiHeader.biClrUsed = 0;
\r
3217 bi.bmiHeader.biClrImportant = 0;
\r
3218 HBITMAP hBitmap = ::CreateDIBSection(hDCSource, &bi, DIB_RGB_COLORS, NULL, NULL, 0);
\r
3219 ATLASSERT(hBitmap != NULL);
\r
3221 // Select bitmap into target DC and draw from image list to it
\r
3222 if(hBitmap != NULL)
\r
3224 ::SelectObject(hDCTarget, hBitmap);
\r
3226 IMAGELISTDRAWPARAMS ildp = { 0 };
\r
3227 ildp.cbSize = sizeof(IMAGELISTDRAWPARAMS);
\r
3228 ildp.himl = m_hImageList;
\r
3230 ildp.hdcDst = hDCTarget;
\r
3237 ildp.fStyle = ILD_TRANSPARENT;
\r
3238 ildp.fState = ILS_ALPHA;
\r
3240 ::ImageList_DrawIndirect(&ildp);
\r
3246 void _RemoveVistaBitmapsFromMenu()
\r
3248 CMenuHandle menu = m_hMenu;
\r
3249 for(int i = 0; i < m_arrCommand.GetSize(); i++)
\r
3251 CMenuItemInfo mii;
\r
3252 mii.fMask = MIIM_BITMAP;
\r
3253 mii.hbmpItem = NULL;
\r
3254 menu.SetMenuItemInfo(m_arrCommand[i], FALSE, &mii);
\r
3257 #endif // _WTL_CMDBAR_VISTA_MENUS
\r
3261 class CCommandBarCtrl : public CCommandBarCtrlImpl<CCommandBarCtrl>
\r
3264 DECLARE_WND_SUPERCLASS(_T("WTL_CommandBar"), GetWndClassName())
\r
3268 ///////////////////////////////////////////////////////////////////////////////
\r
3269 // CMDICommandBarCtrl - ATL implementation of Command Bars for MDI apps
\r
3271 template <class T, class TBase = CCommandBarCtrlBase, class TWinTraits = ATL::CControlWinTraits>
\r
3272 class ATL_NO_VTABLE CMDICommandBarCtrlImpl : public CCommandBarCtrlImpl< T, TBase, TWinTraits>
\r
3276 ATL::CContainedWindow m_wndMDIClient;
\r
3277 bool m_bChildMaximized;
\r
3278 HWND m_hWndChildMaximized;
\r
3279 HICON m_hIconChildMaximized;
\r
3280 int m_nBtnPressed;
\r
3281 int m_nBtnWasPressed;
\r
3283 int m_cxyOffset; // offset between nonclient elements
\r
3284 int m_cxIconWidth; // small icon width
\r
3285 int m_cyIconHeight; // small icon height
\r
3286 int m_cxBtnWidth; // nonclient button width
\r
3287 int m_cyBtnHeight; // nonclient button height
\r
3288 int m_cxLeft; // left nonclient area width
\r
3289 int m_cxRight; // right nonclient area width
\r
3291 // Theme declarations and data members
\r
3292 #ifndef _WTL_NO_AUTO_THEME
\r
3293 #ifndef _UXTHEME_H_
\r
3294 typedef HANDLE HTHEME;
\r
3295 #endif // !_UXTHEME_H_
\r
3296 typedef HTHEME (STDAPICALLTYPE *PFN_OpenThemeData)(HWND hwnd, LPCWSTR pszClassList);
\r
3297 typedef HRESULT (STDAPICALLTYPE *PFN_CloseThemeData)(HTHEME hTheme);
\r
3298 typedef HRESULT (STDAPICALLTYPE *PFN_DrawThemeBackground)(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, OPTIONAL const RECT *pClipRect);
\r
3299 typedef HRESULT (STDAPICALLTYPE *PFN_DrawThemeParentBackground)(HWND hwnd, HDC hdc, OPTIONAL RECT* prc);
\r
3301 HMODULE m_hThemeDLL;
\r
3303 PFN_DrawThemeBackground m_pfnDrawThemeBackground;
\r
3304 PFN_DrawThemeParentBackground m_pfnDrawThemeParentBackground;
\r
3305 #endif // !_WTL_NO_AUTO_THEME
\r
3307 // Constructor/destructor
\r
3308 CMDICommandBarCtrlImpl() :
\r
3309 m_wndMDIClient(this, 2), m_bChildMaximized(false),
\r
3310 m_hWndChildMaximized(NULL), m_hIconChildMaximized(NULL),
\r
3311 m_nBtnPressed(-1), m_nBtnWasPressed(-1),
\r
3312 #ifndef _WTL_NO_AUTO_THEME
\r
3313 m_hThemeDLL(NULL), m_hTheme(NULL), m_pfnDrawThemeBackground(NULL), m_pfnDrawThemeParentBackground(NULL),
\r
3314 #endif // !_WTL_NO_AUTO_THEME
\r
3316 m_cxIconWidth(16), m_cyIconHeight(16),
\r
3317 m_cxBtnWidth(16), m_cyBtnHeight(14),
\r
3318 m_cxLeft(20), m_cxRight(55)
\r
3321 ~CMDICommandBarCtrlImpl()
\r
3323 if(m_wndMDIClient.IsWindow())
\r
3324 /*scary!*/ m_wndMDIClient.UnsubclassWindow();
\r
3328 BOOL SetMDIClient(HWND hWndMDIClient)
\r
3330 ATLASSERT(::IsWindow(m_hWnd));
\r
3331 ATLASSERT(::IsWindow(hWndMDIClient));
\r
3332 if(!::IsWindow(hWndMDIClient))
\r
3336 // BLOCK: Test if the passed window is MDICLIENT
\r
3338 LPCTSTR lpszMDIClientClass = _T("MDICLIENT");
\r
3339 const int nNameLen = 9 + 1; // "MDICLIENT" + NULL
\r
3340 TCHAR szClassName[nNameLen] = { 0 };
\r
3341 ::GetClassName(hWndMDIClient, szClassName, nNameLen);
\r
3342 ATLASSERT(lstrcmpi(szClassName, lpszMDIClientClass) == 0);
\r
3346 if(m_wndMDIClient.IsWindow())
\r
3347 /*scary!*/ m_wndMDIClient.UnsubclassWindow();
\r
3349 return m_wndMDIClient.SubclassWindow(hWndMDIClient);
\r
3353 typedef CCommandBarCtrlImpl< T, TBase, TWinTraits > _baseClass;
\r
3354 BEGIN_MSG_MAP(CMDICommandBarCtrlImpl)
\r
3355 MESSAGE_HANDLER(WM_CREATE, OnCreate)
\r
3356 MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
\r
3357 #ifndef _WTL_NO_AUTO_THEME
\r
3358 MESSAGE_HANDLER(_GetThemeChangedMsg(), OnThemeChanged)
\r
3359 #endif // !_WTL_NO_AUTO_THEME
\r
3360 MESSAGE_HANDLER(WM_SIZE, OnSize)
\r
3361 MESSAGE_HANDLER(WM_NCCALCSIZE, OnNcCalcSize)
\r
3362 MESSAGE_HANDLER(WM_NCPAINT, OnNcPaint)
\r
3363 MESSAGE_HANDLER(WM_NCHITTEST, OnNcHitTest)
\r
3364 MESSAGE_HANDLER(WM_NCLBUTTONDOWN, OnNcLButtonDown)
\r
3365 MESSAGE_HANDLER(WM_MOUSEMOVE, OnMouseMove)
\r
3366 MESSAGE_HANDLER(WM_LBUTTONUP, OnLButtonUp)
\r
3367 MESSAGE_HANDLER(WM_NCLBUTTONDBLCLK, OnNcLButtonDblClk)
\r
3368 MESSAGE_HANDLER(WM_CAPTURECHANGED, OnCaptureChanged)
\r
3369 CHAIN_MSG_MAP(_baseClass)
\r
3370 ALT_MSG_MAP(1) // Parent window messages
\r
3371 MESSAGE_HANDLER(WM_ACTIVATE, OnParentActivate)
\r
3372 CHAIN_MSG_MAP_ALT(_baseClass, 1)
\r
3373 ALT_MSG_MAP(2) // MDI client window messages
\r
3374 MESSAGE_HANDLER(WM_MDISETMENU, OnMDISetMenu)
\r
3375 // no chaining needed since this was moved from the base class here
\r
3376 ALT_MSG_MAP(3) // Message hook messages
\r
3377 MESSAGE_RANGE_HANDLER(0, 0xFFFF, OnAllHookMessages)
\r
3378 CHAIN_MSG_MAP_ALT(_baseClass, 3)
\r
3381 // Additional MDI message handlers
\r
3382 LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
\r
3384 LRESULT lRet = _baseClass::OnCreate(uMsg, wParam, lParam, bHandled);
\r
3385 if(lRet == (LRESULT)-1)
\r
3388 #ifndef _WTL_NO_AUTO_THEME
\r
3389 // this will fail if theming is not supported
\r
3390 m_hThemeDLL = ::LoadLibrary(_T("uxtheme.dll"));
\r
3391 if(m_hThemeDLL != NULL)
\r
3393 m_pfnDrawThemeBackground = (PFN_DrawThemeBackground)::GetProcAddress(m_hThemeDLL, "DrawThemeBackground");
\r
3394 ATLASSERT(m_pfnDrawThemeBackground != NULL);
\r
3395 if(m_pfnDrawThemeBackground != NULL)
\r
3397 T* pT = static_cast<T*>(this);
\r
3398 pT->_OpenThemeData();
\r
3402 ::FreeLibrary(m_hThemeDLL);
\r
3403 m_hThemeDLL = NULL;
\r
3405 m_pfnDrawThemeParentBackground = (PFN_DrawThemeParentBackground)::GetProcAddress(m_hThemeDLL, "DrawThemeParentBackground");
\r
3406 ATLASSERT(m_pfnDrawThemeParentBackground != NULL);
\r
3408 #endif // !_WTL_NO_AUTO_THEME
\r
3413 LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
\r
3415 LRESULT lRet = _baseClass::OnDestroy(uMsg, wParam, lParam, bHandled);
\r
3417 #ifndef _WTL_NO_AUTO_THEME
\r
3418 if(m_hThemeDLL != NULL)
\r
3420 T* pT = static_cast<T*>(this);
\r
3421 pT->_CloseThemeData();
\r
3422 ::FreeLibrary(m_hThemeDLL);
\r
3423 m_hThemeDLL = NULL;
\r
3425 #endif // !_WTL_NO_AUTO_THEME
\r
3430 #ifndef _WTL_NO_AUTO_THEME
\r
3431 LRESULT OnThemeChanged(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
\r
3433 if(m_hThemeDLL != NULL)
\r
3435 T* pT = static_cast<T*>(this);
\r
3436 pT->_CloseThemeData();
\r
3437 pT->_OpenThemeData();
\r
3441 #endif // !_WTL_NO_AUTO_THEME
\r
3443 LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
\r
3445 LRESULT lRet = DefWindowProc(uMsg, wParam, lParam);
\r
3446 T* pT = static_cast<T*>(this);
\r
3447 pT->_AdjustBtnSize(GET_Y_LPARAM(lParam));
\r
3451 LRESULT OnNcCalcSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
\r
3453 LRESULT lRet = DefWindowProc(uMsg, wParam, lParam);
\r
3455 if(m_bChildMaximized && (BOOL)wParam)
\r
3457 LPNCCALCSIZE_PARAMS lpParams = (LPNCCALCSIZE_PARAMS)lParam;
\r
3460 lpParams->rgrc[0].left += m_cxRight;
\r
3461 lpParams->rgrc[0].right -= m_cxLeft;
\r
3465 lpParams->rgrc[0].left += m_cxLeft;
\r
3466 lpParams->rgrc[0].right -= m_cxRight;
\r
3473 LRESULT OnNcPaint(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
\r
3475 LRESULT lRet = DefWindowProc(uMsg, wParam, lParam);
\r
3477 if(!m_bChildMaximized)
\r
3480 ATLASSERT(m_hWndChildMaximized != NULL && m_hIconChildMaximized != NULL);
\r
3482 // get DC and window rectangle
\r
3483 CWindowDC dc(m_hWnd);
\r
3485 GetWindowRect(&rect);
\r
3486 int cxWidth = rect.right - rect.left;
\r
3487 int cyHeight = rect.bottom - rect.top;
\r
3489 // paint left side nonclient background and draw icon
\r
3490 ::SetRect(&rect, 0, 0, m_cxLeft, cyHeight);
\r
3491 #ifndef _WTL_NO_AUTO_THEME
\r
3492 if(m_hTheme != NULL)
\r
3494 if(m_pfnDrawThemeParentBackground != NULL)
\r
3495 m_pfnDrawThemeParentBackground(m_hWnd, dc, &rect);
\r
3497 dc.FillRect(&rect, COLOR_WINDOW);
\r
3500 #endif // !_WTL_NO_AUTO_THEME
\r
3502 if((m_dwExtendedStyle & CBR_EX_TRANSPARENT) != 0)
\r
3503 dc.FillRect(&rect, COLOR_3DFACE);
\r
3505 dc.FillRect(&rect, COLOR_MENU);
\r
3508 RECT rcIcon = { 0 };
\r
3509 T* pT = static_cast<T*>(this);
\r
3510 pT->_CalcIconRect(cxWidth, cyHeight, rcIcon);
\r
3511 dc.DrawIconEx(rcIcon.left, rcIcon.top, m_hIconChildMaximized, m_cxIconWidth, m_cyIconHeight);
\r
3513 // paint right side nonclient background
\r
3514 ::SetRect(&rect, cxWidth - m_cxRight, 0, cxWidth, cyHeight);
\r
3515 #ifndef _WTL_NO_AUTO_THEME
\r
3516 if(m_hTheme != NULL)
\r
3518 if(m_pfnDrawThemeParentBackground != NULL)
\r
3520 // this is to account for the left non-client area
\r
3521 POINT ptOrg = { 0, 0 };
\r
3522 dc.GetViewportOrg(&ptOrg);
\r
3523 dc.SetViewportOrg(ptOrg.x + m_cxLeft, ptOrg.y);
\r
3524 ::OffsetRect(&rect, -m_cxLeft, 0);
\r
3526 m_pfnDrawThemeParentBackground(m_hWnd, dc, &rect);
\r
3529 dc.SetViewportOrg(ptOrg);
\r
3530 ::OffsetRect(&rect, m_cxLeft, 0);
\r
3534 dc.FillRect(&rect, COLOR_3DFACE);
\r
3538 #endif // !_WTL_NO_AUTO_THEME
\r
3540 if((m_dwExtendedStyle & CBR_EX_TRANSPARENT) != 0)
\r
3541 dc.FillRect(&rect, COLOR_3DFACE);
\r
3543 dc.FillRect(&rect, COLOR_MENU);
\r
3547 RECT arrRect[3] = { 0 };
\r
3548 pT->_CalcBtnRects(cxWidth, cyHeight, arrRect);
\r
3549 pT->_DrawMDIButton(dc, arrRect, -1); // draw all buttons
\r
3554 LRESULT OnNcHitTest(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
\r
3556 LRESULT lRet = DefWindowProc(uMsg, wParam, lParam);
\r
3557 if(m_bChildMaximized)
\r
3559 RECT rect = { 0 };
\r
3560 GetWindowRect(&rect);
\r
3561 POINT pt = { GET_X_LPARAM(lParam) - rect.left, GET_Y_LPARAM(lParam) - rect.top };
\r
3564 if((pt.x < m_cxRight) || (pt.x > ((rect.right - rect.left) - m_cxLeft)))
\r
3569 if((pt.x < m_cxLeft) || (pt.x > ((rect.right - rect.left) - m_cxRight)))
\r
3576 LRESULT OnNcLButtonDown(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
\r
3578 if(!m_bChildMaximized)
\r
3584 ATLASSERT(_DebugCheckChild());
\r
3586 POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
\r
3587 RECT rect = { 0 };
\r
3588 GetWindowRect(&rect);
\r
3589 pt.x -= rect.left;
\r
3592 RECT rcIcon = { 0 };
\r
3593 T* pT = static_cast<T*>(this);
\r
3594 pT->_CalcIconRect(rect.right - rect.left, rect.bottom - rect.top, rcIcon, m_bLayoutRTL);
\r
3595 RECT arrRect[3] = { 0 };
\r
3596 pT->_CalcBtnRects(rect.right - rect.left, rect.bottom - rect.top, arrRect, m_bLayoutRTL);
\r
3598 if(::PtInRect(&rcIcon, pt))
\r
3600 #ifdef _CMDBAR_EXTRA_TRACE
\r
3601 ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButtonDown: icon\n"));
\r
3603 #ifndef TPM_VERPOSANIMATION
\r
3604 const UINT TPM_VERPOSANIMATION = 0x1000L; // Menu animation flag
\r
3606 CMenuHandle menu = ::GetSystemMenu(m_hWndChildMaximized, FALSE);
\r
3607 UINT uRet = (UINT)menu.TrackPopupMenu(TPM_LEFTBUTTON | TPM_VERTICAL | TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RETURNCMD |
\r
3608 (s_bW2K ? TPM_VERPOSANIMATION : 0), m_bLayoutRTL ? rect.right : rect.left, rect.bottom, m_hWndChildMaximized);
\r
3610 // eat next message if click is on the same button
\r
3611 ::OffsetRect(&rcIcon, rect.left, rect.top);
\r
3613 if(::PeekMessage(&msg, m_hWnd, WM_NCLBUTTONDOWN, WM_NCLBUTTONDOWN, PM_NOREMOVE) && ::PtInRect(&rcIcon, msg.pt))
\r
3614 ::PeekMessage(&msg, m_hWnd, WM_NCLBUTTONDOWN, WM_NCLBUTTONDOWN, PM_REMOVE);
\r
3617 ::SendMessage(m_hWndChildMaximized, WM_SYSCOMMAND, uRet, 0L);
\r
3619 else if(::PtInRect(&arrRect[0], pt))
\r
3621 #ifdef _CMDBAR_EXTRA_TRACE
\r
3622 ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButtonDown: close button\n"));
\r
3624 m_nBtnWasPressed = m_nBtnPressed = 0;
\r
3626 else if(::PtInRect(&arrRect[1], pt))
\r
3628 #ifdef _CMDBAR_EXTRA_TRACE
\r
3629 ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButtonDown: restore button\n"));
\r
3631 m_nBtnWasPressed = m_nBtnPressed = 1;
\r
3633 else if(::PtInRect(&arrRect[2], pt))
\r
3635 #ifdef _CMDBAR_EXTRA_TRACE
\r
3636 ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButtonDown: minimize button\n"));
\r
3638 m_nBtnWasPressed = m_nBtnPressed = 2;
\r
3645 // draw the button state if it was pressed
\r
3646 if(m_nBtnPressed != -1)
\r
3649 CWindowDC dc(m_hWnd);
\r
3650 pT->_CalcBtnRects(rect.right - rect.left, rect.bottom - rect.top, arrRect);
\r
3651 pT->_DrawMDIButton(dc, arrRect, m_nBtnPressed);
\r
3657 LRESULT OnMouseMove(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
\r
3659 if(!m_bChildMaximized || ::GetCapture() != m_hWnd || m_nBtnWasPressed == -1)
\r
3665 POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
\r
3666 ClientToScreen(&pt);
\r
3667 RECT rect = { 0 };
\r
3668 GetWindowRect(&rect);
\r
3669 pt.x -= rect.left;
\r
3671 RECT arrRect[3] = { 0 };
\r
3672 T* pT = static_cast<T*>(this);
\r
3673 pT->_CalcBtnRects(rect.right - rect.left, rect.bottom - rect.top, arrRect, m_bLayoutRTL);
\r
3674 int nOldBtnPressed = m_nBtnPressed;
\r
3675 m_nBtnPressed = ::PtInRect(&arrRect[m_nBtnWasPressed], pt) ? m_nBtnWasPressed : -1;
\r
3676 if(nOldBtnPressed != m_nBtnPressed)
\r
3678 CWindowDC dc(m_hWnd);
\r
3679 pT->_CalcBtnRects(rect.right - rect.left, rect.bottom - rect.top, arrRect);
\r
3680 pT->_DrawMDIButton(dc, arrRect, (m_nBtnPressed != -1) ? m_nBtnPressed : nOldBtnPressed);
\r
3686 LRESULT OnLButtonUp(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
\r
3688 if(!m_bChildMaximized || ::GetCapture() != m_hWnd || m_nBtnWasPressed == -1)
\r
3694 ATLASSERT(_DebugCheckChild());
\r
3696 POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
\r
3697 ClientToScreen(&pt);
\r
3698 RECT rect = { 0 };
\r
3699 GetWindowRect(&rect);
\r
3700 pt.x -= rect.left;
\r
3703 int nBtn = m_nBtnWasPressed;
\r
3706 RECT arrRect[3] = { 0 };
\r
3707 T* pT = static_cast<T*>(this);
\r
3708 pT->_CalcBtnRects(rect.right - rect.left, rect.bottom - rect.top, arrRect, m_bLayoutRTL);
\r
3709 if(::PtInRect(&arrRect[nBtn], pt))
\r
3714 #ifdef _CMDBAR_EXTRA_TRACE
\r
3715 ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButtonUp: close button\n"));
\r
3717 ::SendMessage(m_hWndChildMaximized, WM_SYSCOMMAND, SC_CLOSE, 0L);
\r
3719 case 1: // restore
\r
3720 #ifdef _CMDBAR_EXTRA_TRACE
\r
3721 ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButtonUp: restore button\n"));
\r
3723 ::SendMessage(m_hWndChildMaximized, WM_SYSCOMMAND, SC_RESTORE, 0L);
\r
3725 case 2: // minimize
\r
3726 #ifdef _CMDBAR_EXTRA_TRACE
\r
3727 ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButtonUp: minimize button\n"));
\r
3729 ::SendMessage(m_hWndChildMaximized, WM_SYSCOMMAND, SC_MINIMIZE, 0L);
\r
3739 LRESULT OnNcLButtonDblClk(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
\r
3741 if(!m_bChildMaximized || m_nBtnWasPressed != -1)
\r
3747 ATLASSERT(_DebugCheckChild());
\r
3749 POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
\r
3750 RECT rect = { 0 };
\r
3751 GetWindowRect(&rect);
\r
3752 pt.x -= rect.left;
\r
3755 RECT rcIcon = { 0 };
\r
3756 T* pT = static_cast<T*>(this);
\r
3757 pT->_CalcIconRect(rect.right - rect.left, rect.bottom - rect.top, rcIcon, m_bLayoutRTL);
\r
3758 RECT arrRect[3] = { 0 };
\r
3759 pT->_CalcBtnRects(rect.right - rect.left, rect.bottom - rect.top, arrRect, m_bLayoutRTL);
\r
3761 if(::PtInRect(&rcIcon, pt))
\r
3763 CMenuHandle menu = ::GetSystemMenu(m_hWndChildMaximized, FALSE);
\r
3764 UINT uDefID = menu.GetMenuDefaultItem();
\r
3765 if(uDefID == (UINT)-1)
\r
3766 uDefID = SC_CLOSE;
\r
3767 ::SendMessage(m_hWndChildMaximized, WM_SYSCOMMAND, uDefID, 0L);
\r
3773 LRESULT OnCaptureChanged(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
\r
3775 if(m_bChildMaximized)
\r
3777 if(m_nBtnPressed != -1)
\r
3779 ATLASSERT(m_nBtnPressed == m_nBtnWasPressed); // must be
\r
3780 m_nBtnPressed = -1;
\r
3781 RECT rect = { 0 };
\r
3782 GetWindowRect(&rect);
\r
3783 RECT arrRect[3] = { 0 };
\r
3784 T* pT = static_cast<T*>(this);
\r
3785 pT->_CalcBtnRects(rect.right - rect.left, rect.bottom - rect.top, arrRect);
\r
3786 CWindowDC dc(m_hWnd);
\r
3787 pT->_DrawMDIButton(dc, arrRect, m_nBtnWasPressed);
\r
3789 m_nBtnWasPressed = -1;
\r
3798 // Parent window message handlers
\r
3799 LRESULT OnParentActivate(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
\r
3801 m_bParentActive = (LOWORD(wParam) != WA_INACTIVE);
\r
3802 RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_UPDATENOW);
\r
3807 // MDI client window message handlers
\r
3808 LRESULT OnMDISetMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
\r
3810 m_wndMDIClient.DefWindowProc(uMsg, NULL, lParam);
\r
3811 HMENU hOldMenu = GetMenu();
\r
3812 BOOL bRet = AttachMenu((HMENU)wParam);
\r
3813 bRet; // avoid level 4 warning
\r
3816 #if (_WIN32_IE >= 0x0400)
\r
3817 T* pT = static_cast<T*>(this);
\r
3818 pT->UpdateRebarBandIdealSize();
\r
3819 #endif // (_WIN32_IE >= 0x0400)
\r
3821 return (LRESULT)hOldMenu;
\r
3824 // All messages from the message hook
\r
3825 LRESULT OnAllHookMessages(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
\r
3827 T* pT = static_cast<T*>(this);
\r
3828 pT->_ProcessAllHookMessages(uMsg, wParam, lParam);
\r
3835 // override this to provide different ideal size
\r
3836 void UpdateRebarBandIdealSize()
\r
3838 // assuming we are in a rebar, change ideal size to our size
\r
3839 // we hope that if we are not in a rebar, nCount will be 0
\r
3840 int nCount = (int)::SendMessage(GetParent(), RB_GETBANDCOUNT, 0, 0L);
\r
3841 for(int i = 0; i < nCount; i++)
\r
3843 REBARBANDINFO rbi = { RunTimeHelper::SizeOf_REBARBANDINFO(), RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_IDEALSIZE };
\r
3844 ::SendMessage(GetParent(), RB_GETBANDINFO, i, (LPARAM)&rbi);
\r
3845 if(rbi.hwndChild == m_hWnd)
\r
3847 rbi.fMask = RBBIM_IDEALSIZE;
\r
3848 rbi.cxIdeal = m_bChildMaximized ? m_cxLeft + m_cxRight : 0;
\r
3849 int nBtnCount = GetButtonCount();
\r
3852 RECT rect = { 0 };
\r
3853 GetItemRect(nBtnCount - 1, &rect);
\r
3854 rbi.cxIdeal += rect.right;
\r
3856 ::SendMessage(GetParent(), RB_SETBANDINFO, i, (LPARAM)&rbi);
\r
3862 // all hook messages - check for the maximized MDI child window change
\r
3863 void _ProcessAllHookMessages(UINT uMsg, WPARAM /*wParam*/, LPARAM /*lParam*/)
\r
3865 if(uMsg == WM_MDIGETACTIVE || uMsg == WM_MDISETMENU)
\r
3868 BOOL bMaximized = FALSE;
\r
3869 HWND hWndChild = (HWND)::SendMessage(m_wndMDIClient, WM_MDIGETACTIVE, 0, (LPARAM)&bMaximized);
\r
3870 bool bMaxOld = m_bChildMaximized;
\r
3871 m_bChildMaximized = (hWndChild != NULL && bMaximized);
\r
3872 HICON hIconOld = m_hIconChildMaximized;
\r
3874 if(m_bChildMaximized)
\r
3876 if(m_hWndChildMaximized != hWndChild)
\r
3878 ATL::CWindow wnd = m_hWndChildMaximized = hWndChild;
\r
3879 m_hIconChildMaximized = wnd.GetIcon(FALSE);
\r
3880 if(m_hIconChildMaximized == NULL)
\r
3882 m_hIconChildMaximized = wnd.GetIcon(TRUE);
\r
3883 if(m_hIconChildMaximized == NULL)
\r
3885 // no icon set with WM_SETICON, get the class one
\r
3886 // need conditional code because types don't match in winuser.h
\r
3888 m_hIconChildMaximized = (HICON)::GetClassLongPtr(wnd, GCLP_HICONSM);
\r
3890 m_hIconChildMaximized = (HICON)LongToHandle(::GetClassLongPtr(wnd, GCLP_HICONSM));
\r
3898 m_hWndChildMaximized = NULL;
\r
3899 m_hIconChildMaximized = NULL;
\r
3902 if(bMaxOld != m_bChildMaximized)
\r
3904 #ifdef _CMDBAR_EXTRA_TRACE
\r
3905 ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - All messages hook change: m_bChildMaximized = %s\n"), m_bChildMaximized ? "true" : "false");
\r
3907 // assuming we are in a rebar, change our size to accomodate new state
\r
3908 // we hope that if we are not in a rebar, nCount will be 0
\r
3909 int nCount = (int)::SendMessage(GetParent(), RB_GETBANDCOUNT, 0, 0L);
\r
3910 int cxDiff = (m_bChildMaximized ? 1 : -1) * (m_cxLeft + m_cxRight);
\r
3911 for(int i = 0; i < nCount; i++)
\r
3913 #if (_WIN32_IE >= 0x0500)
\r
3914 REBARBANDINFO rbi = { RunTimeHelper::SizeOf_REBARBANDINFO(), RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_IDEALSIZE | RBBIM_STYLE };
\r
3915 ::SendMessage(GetParent(), RB_GETBANDINFO, i, (LPARAM)&rbi);
\r
3916 if(rbi.hwndChild == m_hWnd)
\r
3918 if((rbi.fStyle & RBBS_USECHEVRON) != 0)
\r
3920 rbi.fMask = RBBIM_CHILDSIZE | RBBIM_IDEALSIZE;
\r
3921 rbi.cxMinChild += cxDiff;
\r
3922 rbi.cxIdeal += cxDiff;
\r
3923 ::SendMessage(GetParent(), RB_SETBANDINFO, i, (LPARAM)&rbi);
\r
3927 #elif (_WIN32_IE >= 0x0400)
\r
3928 REBARBANDINFO rbi = { RunTimeHelper::SizeOf_REBARBANDINFO(), RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_IDEALSIZE };
\r
3929 ::SendMessage(GetParent(), RB_GETBANDINFO, i, (LPARAM)&rbi);
\r
3930 if(rbi.hwndChild == m_hWnd)
\r
3932 rbi.fMask = RBBIM_CHILDSIZE | RBBIM_IDEALSIZE;
\r
3933 rbi.cxMinChild += cxDiff;
\r
3934 rbi.cxIdeal += cxDiff;
\r
3935 ::SendMessage(GetParent(), RB_SETBANDINFO, i, (LPARAM)&rbi);
\r
3938 #else // (_WIN32_IE < 0x0400)
\r
3939 REBARBANDINFO rbi = { RunTimeHelper::SizeOf_REBARBANDINFO(), RBBIM_CHILD | RBBIM_CHILDSIZE };
\r
3940 ::SendMessage(GetParent(), RB_GETBANDINFO, i, (LPARAM)&rbi);
\r
3941 if(rbi.hwndChild == m_hWnd)
\r
3943 rbi.fMask = RBBIM_CHILDSIZE;
\r
3944 rbi.cxMinChild += cxDiff;
\r
3945 ::SendMessage(GetParent(), RB_SETBANDINFO, i, (LPARAM)&rbi);
\r
3948 #endif // (_WIN32_IE < 0x0400)
\r
3952 if(bMaxOld != m_bChildMaximized || hIconOld != m_hIconChildMaximized)
\r
3954 // force size change and redraw everything
\r
3955 RECT rect = { 0 };
\r
3956 GetWindowRect(&rect);
\r
3957 ::MapWindowPoints(NULL, GetParent(), (LPPOINT)&rect, 2);
\r
3959 SetWindowPos(NULL, 0, 0, 1, 1, SWP_NOZORDER | SWP_NOMOVE);
\r
3960 SetWindowPos(NULL, &rect, SWP_NOZORDER | SWP_NOMOVE);
\r
3962 RedrawWindow(NULL, NULL, RDW_FRAME | RDW_INVALIDATE | RDW_UPDATENOW);
\r
3967 void GetSystemSettings()
\r
3969 #ifdef _CMDBAR_EXTRA_TRACE
\r
3970 ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - GetSystemSettings\n"));
\r
3972 _baseClass::GetSystemSettings();
\r
3974 NONCLIENTMETRICS info = { RunTimeHelper::SizeOf_NONCLIENTMETRICS() };
\r
3975 BOOL bRet = ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(info), &info, 0);
\r
3979 m_cxIconWidth = ::GetSystemMetrics(SM_CXSMICON);
\r
3980 m_cyIconHeight = ::GetSystemMetrics(SM_CYSMICON);
\r
3981 m_cxLeft = m_cxIconWidth;
\r
3983 #ifndef _WTL_NO_AUTO_THEME
\r
3984 if(m_hTheme != NULL)
\r
3986 m_cxBtnWidth = info.iCaptionWidth - 2 * m_cxyOffset;
\r
3987 m_cyBtnHeight = info.iCaptionHeight - 2 * m_cxyOffset;
\r
3988 m_cxRight = 3 * m_cxBtnWidth;
\r
3991 #endif // !_WTL_NO_AUTO_THEME
\r
3993 m_cxBtnWidth = info.iCaptionWidth - m_cxyOffset;
\r
3994 m_cyBtnHeight = info.iCaptionHeight - 2 * m_cxyOffset;
\r
3995 m_cxRight = 3 * m_cxBtnWidth + m_cxyOffset;
\r
3999 RECT rect = { 0 };
\r
4000 GetClientRect(&rect);
\r
4001 T* pT = static_cast<T*>(this);
\r
4002 pT->_AdjustBtnSize(rect.bottom);
\r
4005 void _AdjustBtnSize(int cyHeight)
\r
4007 if(cyHeight > 1 && m_cyBtnHeight > cyHeight)
\r
4009 #ifndef _WTL_NO_AUTO_THEME
\r
4010 if(m_hTheme != NULL)
\r
4012 m_cyBtnHeight = cyHeight;
\r
4013 m_cxBtnWidth = cyHeight;
\r
4014 m_cxRight = 3 * m_cxBtnWidth;
\r
4017 #endif // !_WTL_NO_AUTO_THEME
\r
4019 m_cyBtnHeight = cyHeight;
\r
4020 m_cxBtnWidth = cyHeight + m_cxyOffset;
\r
4021 m_cxRight = 3 * m_cxBtnWidth + m_cxyOffset;
\r
4026 void _CalcIconRect(int cxWidth, int cyHeight, RECT& rect, bool bInvertX = false) const
\r
4028 int xStart = (m_cxLeft - m_cxIconWidth) / 2;
\r
4031 int yStart = (cyHeight - m_cyIconHeight) / 2;
\r
4036 ::SetRect(&rect, cxWidth - (xStart + m_cxBtnWidth), yStart, cxWidth - xStart, yStart + m_cyBtnHeight);
\r
4038 ::SetRect(&rect, xStart, yStart, xStart + m_cxBtnWidth, yStart + m_cyBtnHeight);
\r
4041 void _CalcBtnRects(int cxWidth, int cyHeight, RECT arrRect[3], bool bInvertX = false) const
\r
4043 int yStart = (cyHeight - m_cyBtnHeight) / 2;
\r
4047 RECT rcBtn = { cxWidth - m_cxBtnWidth, yStart, cxWidth, yStart + m_cyBtnHeight };
\r
4048 int nDirection = -1;
\r
4051 ::SetRect(&rcBtn, 0, yStart, m_cxBtnWidth, yStart + m_cyBtnHeight);
\r
4055 arrRect[0] = rcBtn;
\r
4056 #ifndef _WTL_NO_AUTO_THEME
\r
4057 if(m_hTheme != NULL)
\r
4058 ::OffsetRect(&rcBtn, nDirection * m_cxBtnWidth, 0);
\r
4060 #endif // !_WTL_NO_AUTO_THEME
\r
4061 ::OffsetRect(&rcBtn, nDirection * (m_cxBtnWidth + m_cxyOffset), 0);
\r
4062 arrRect[1] = rcBtn;
\r
4063 ::OffsetRect(&rcBtn, nDirection * m_cxBtnWidth, 0);
\r
4064 arrRect[2] = rcBtn;
\r
4067 void _DrawMDIButton(CWindowDC& dc, LPRECT pRects, int nBtn)
\r
4069 #ifndef _WTL_NO_AUTO_THEME
\r
4070 if(m_hTheme != NULL)
\r
4072 #ifndef TMSCHEMA_H
\r
4073 const int WP_MDICLOSEBUTTON = 20;
\r
4074 const int CBS_NORMAL = 1;
\r
4075 const int CBS_PUSHED = 3;
\r
4076 const int CBS_DISABLED = 4;
\r
4077 const int WP_MDIRESTOREBUTTON = 22;
\r
4078 const int RBS_NORMAL = 1;
\r
4079 const int RBS_PUSHED = 3;
\r
4080 const int RBS_DISABLED = 4;
\r
4081 const int WP_MDIMINBUTTON = 16;
\r
4082 const int MINBS_NORMAL = 1;
\r
4083 const int MINBS_PUSHED = 3;
\r
4084 const int MINBS_DISABLED = 4;
\r
4085 #endif // TMSCHEMA_H
\r
4086 if(nBtn == -1 || nBtn == 0)
\r
4087 m_pfnDrawThemeBackground(m_hTheme, dc, WP_MDICLOSEBUTTON, m_bParentActive ? ((m_nBtnPressed == 0) ? CBS_PUSHED : CBS_NORMAL) : CBS_DISABLED, &pRects[0], NULL);
\r
4088 if(nBtn == -1 || nBtn == 1)
\r
4089 m_pfnDrawThemeBackground(m_hTheme, dc, WP_MDIRESTOREBUTTON, m_bParentActive ? ((m_nBtnPressed == 1) ? RBS_PUSHED : RBS_NORMAL) : RBS_DISABLED, &pRects[1], NULL);
\r
4090 if(nBtn == -1 || nBtn == 2)
\r
4091 m_pfnDrawThemeBackground(m_hTheme, dc, WP_MDIMINBUTTON, m_bParentActive ? ((m_nBtnPressed == 2) ? MINBS_PUSHED : MINBS_NORMAL) : MINBS_DISABLED, &pRects[2], NULL);
\r
4094 #endif // !_WTL_NO_AUTO_THEME
\r
4096 if(nBtn == -1 || nBtn == 0)
\r
4097 dc.DrawFrameControl(&pRects[0], DFC_CAPTION, DFCS_CAPTIONCLOSE | ((m_nBtnPressed == 0) ? DFCS_PUSHED : 0));
\r
4098 if(nBtn == -1 || nBtn == 1)
\r
4099 dc.DrawFrameControl(&pRects[1], DFC_CAPTION, DFCS_CAPTIONRESTORE | ((m_nBtnPressed == 1) ? DFCS_PUSHED : 0));
\r
4100 if(nBtn == -1 || nBtn == 2)
\r
4101 dc.DrawFrameControl(&pRects[2], DFC_CAPTION, DFCS_CAPTIONMIN | ((m_nBtnPressed == 2) ? DFCS_PUSHED : 0));
\r
4105 #ifndef _WTL_NO_AUTO_THEME
\r
4106 static UINT _GetThemeChangedMsg()
\r
4108 #ifndef WM_THEMECHANGED
\r
4109 static const UINT WM_THEMECHANGED = 0x031A;
\r
4110 #endif // !WM_THEMECHANGED
\r
4111 return WM_THEMECHANGED;
\r
4114 void _OpenThemeData()
\r
4116 ATLASSERT(m_hThemeDLL != NULL);
\r
4118 PFN_OpenThemeData pfnOpenThemeData = (PFN_OpenThemeData)::GetProcAddress(m_hThemeDLL, "OpenThemeData");
\r
4119 ATLASSERT(pfnOpenThemeData != NULL);
\r
4120 if(pfnOpenThemeData != NULL)
\r
4121 m_hTheme = pfnOpenThemeData(m_hWnd, L"Window");
\r
4124 void _CloseThemeData()
\r
4126 ATLASSERT(m_hThemeDLL != NULL);
\r
4128 if(m_hTheme == NULL)
\r
4129 return; // nothing to do
\r
4131 PFN_CloseThemeData pfnCloseThemeData = (PFN_CloseThemeData)::GetProcAddress(m_hThemeDLL, "CloseThemeData");
\r
4132 ATLASSERT(pfnCloseThemeData != NULL);
\r
4133 if(pfnCloseThemeData != NULL)
\r
4135 pfnCloseThemeData(m_hTheme);
\r
4139 #endif // !_WTL_NO_AUTO_THEME
\r
4141 bool _DebugCheckChild()
\r
4144 BOOL bMaximized = FALSE;
\r
4145 HWND hWndChild = (HWND)::SendMessage(m_wndMDIClient, WM_MDIGETACTIVE, 0, (LPARAM)&bMaximized);
\r
4146 return (bMaximized && hWndChild == m_hWndChildMaximized);
\r
4153 class CMDICommandBarCtrl : public CMDICommandBarCtrlImpl<CMDICommandBarCtrl>
\r
4156 DECLARE_WND_SUPERCLASS(_T("WTL_MDICommandBar"), GetWndClassName())
\r
4159 }; // namespace WTL
\r
4161 #endif // __ATLCTRLW_H__
\r