| // Windows Template Library - WTL version 8.0 |
| // Copyright (C) Microsoft Corporation. All rights reserved. |
| // |
| // This file is a part of the Windows Template Library. |
| // The use and distribution terms for this software are covered by the |
| // Microsoft Permissive License (Ms-PL) which can be found in the file |
| // Ms-PL.txt at the root of this distribution. |
| |
| #ifndef __ATLCTRLW_H__ |
| #define __ATLCTRLW_H__ |
| |
| #pragma once |
| |
| #ifndef __cplusplus |
| #error ATL requires C++ compilation (use a .cpp suffix) |
| #endif |
| |
| #ifdef _WIN32_WCE |
| #error atlctrlw.h is not supported on Windows CE |
| #endif |
| |
| #ifndef __ATLAPP_H__ |
| #error atlctrlw.h requires atlapp.h to be included first |
| #endif |
| |
| #ifndef __ATLCTRLS_H__ |
| #error atlctrlw.h requires atlctrls.h to be included first |
| #endif |
| |
| #if (_WIN32_IE < 0x0400) |
| #error atlctrlw.h requires _WIN32_IE >= 0x0400 |
| #endif |
| |
| // Define _WTL_CMDBAR_VISTA_MENUS as 0 to exclude Vista menus support |
| #if !defined(_WTL_CMDBAR_VISTA_MENUS) && (WINVER >= 0x0500) && (_WIN32_WINNT >= 0x0501) && (_WIN32_IE >= 0x0501) |
| #define _WTL_CMDBAR_VISTA_MENUS 1 |
| #endif |
| |
| #if _WTL_CMDBAR_VISTA_MENUS |
| #if !((_WIN32_WINNT >= 0x0501) && (_WIN32_IE >= 0x0501)) |
| #error _WTL_CMDBAR_VISTA_MENUS requires (_WIN32_WINNT >= 0x0501) && (_WIN32_IE >= 0x0501) |
| #endif |
| #endif |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Classes in this file: |
| // |
| // CCommandBarCtrlImpl<T, TBase, TWinTraits> |
| // CCommandBarCtrl |
| // CMDICommandBarCtrlImpl<T, TBase, TWinTraits> |
| // CMDICommandBarCtrl |
| |
| |
| namespace WTL |
| { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Command Bars |
| |
| // Window Styles: |
| #define CBRWS_TOP CCS_TOP |
| #define CBRWS_BOTTOM CCS_BOTTOM |
| #define CBRWS_NORESIZE CCS_NORESIZE |
| #define CBRWS_NOPARENTALIGN CCS_NOPARENTALIGN |
| #define CBRWS_NODIVIDER CCS_NODIVIDER |
| |
| // Extended styles |
| #define CBR_EX_TRANSPARENT 0x00000001L |
| #define CBR_EX_SHAREMENU 0x00000002L |
| #define CBR_EX_ALTFOCUSMODE 0x00000004L |
| #define CBR_EX_TRACKALWAYS 0x00000008L |
| #define CBR_EX_NOVISTAMENUS 0x00000010L |
| |
| // standard command bar styles |
| #define ATL_SIMPLE_CMDBAR_PANE_STYLE \ |
| (WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | CBRWS_NODIVIDER | CBRWS_NORESIZE | CBRWS_NOPARENTALIGN) |
| |
| // Messages - support chevrons for frame windows |
| #define CBRM_GETCMDBAR (WM_USER + 301) // returns command bar HWND |
| #define CBRM_GETMENU (WM_USER + 302) // returns loaded or attached menu |
| #define CBRM_TRACKPOPUPMENU (WM_USER + 303) // displays a popup menu |
| |
| typedef struct tagCBRPOPUPMENU |
| { |
| int cbSize; |
| HMENU hMenu; // popup menu do display |
| UINT uFlags; // TPM_* flags for ::TrackPopupMenuEx |
| int x; |
| int y; |
| LPTPMPARAMS lptpm; // ptr to TPMPARAMS for ::TrackPopupMenuEx |
| } CBRPOPUPMENU, *LPCBRPOPUPMENU; |
| |
| // helper class |
| template <class T> |
| class CSimpleStack : public ATL::CSimpleArray< T > |
| { |
| public: |
| BOOL Push(T t) |
| { |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - STACK-PUSH (%8.8X) size = %i\n"), t, GetSize()); |
| #endif |
| return Add(t); |
| } |
| |
| T Pop() |
| { |
| int nLast = GetSize() - 1; |
| if(nLast < 0) |
| return NULL; // must be able to convert to NULL |
| T t = m_aT[nLast]; |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - STACK-POP (%8.8X) size = %i\n"), t, GetSize()); |
| #endif |
| if(!RemoveAt(nLast)) |
| return NULL; |
| return t; |
| } |
| |
| T GetCurrent() |
| { |
| int nLast = GetSize() - 1; |
| if(nLast < 0) |
| return NULL; // must be able to convert to NULL |
| return m_aT[nLast]; |
| } |
| }; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CCommandBarCtrlBase - base class for the Command Bar implementation |
| |
| class CCommandBarCtrlBase : public CToolBarCtrl |
| { |
| public: |
| struct _MsgHookData |
| { |
| HHOOK hMsgHook; |
| DWORD dwUsage; |
| |
| _MsgHookData() : hMsgHook(NULL), dwUsage(0) |
| { } |
| }; |
| |
| typedef ATL::CSimpleMap<DWORD, _MsgHookData*> CMsgHookMap; |
| static CMsgHookMap* s_pmapMsgHook; |
| |
| static HHOOK s_hCreateHook; |
| static bool s_bW2K; // For animation flag |
| static CCommandBarCtrlBase* s_pCurrentBar; |
| static bool s_bStaticInit; |
| |
| CSimpleStack<HWND> m_stackMenuWnd; |
| CSimpleStack<HMENU> m_stackMenuHandle; |
| |
| HWND m_hWndHook; |
| DWORD m_dwMagic; |
| |
| |
| CCommandBarCtrlBase() : m_hWndHook(NULL), m_dwMagic(1314) |
| { |
| // init static variables |
| if(!s_bStaticInit) |
| { |
| CStaticDataInitCriticalSectionLock lock; |
| if(FAILED(lock.Lock())) |
| { |
| ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CCommandBarCtrlBase::CCommandBarCtrlBase.\n")); |
| ATLASSERT(FALSE); |
| return; |
| } |
| |
| if(!s_bStaticInit) |
| { |
| // Just in case... |
| AtlInitCommonControls(ICC_COOL_CLASSES | ICC_BAR_CLASSES); |
| // Animation on Win2000 only |
| s_bW2K = !AtlIsOldWindows(); |
| // done |
| s_bStaticInit = true; |
| } |
| |
| lock.Unlock(); |
| } |
| } |
| |
| bool IsCommandBarBase() const { return m_dwMagic == 1314; } |
| }; |
| |
| __declspec(selectany) CCommandBarCtrlBase::CMsgHookMap* CCommandBarCtrlBase::s_pmapMsgHook = NULL; |
| __declspec(selectany) HHOOK CCommandBarCtrlBase::s_hCreateHook = NULL; |
| __declspec(selectany) CCommandBarCtrlBase* CCommandBarCtrlBase::s_pCurrentBar = NULL; |
| __declspec(selectany) bool CCommandBarCtrlBase::s_bW2K = false; |
| __declspec(selectany) bool CCommandBarCtrlBase::s_bStaticInit = false; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CCommandBarCtrl - ATL implementation of Command Bars |
| |
| template <class T, class TBase = CCommandBarCtrlBase, class TWinTraits = ATL::CControlWinTraits> |
| class ATL_NO_VTABLE CCommandBarCtrlImpl : public ATL::CWindowImpl< T, TBase, TWinTraits > |
| { |
| public: |
| DECLARE_WND_SUPERCLASS(NULL, TBase::GetWndClassName()) |
| |
| // Declarations |
| struct _MenuItemData // menu item data |
| { |
| DWORD dwMagic; |
| LPTSTR lpstrText; |
| UINT fType; |
| UINT fState; |
| int iButton; |
| |
| _MenuItemData() { dwMagic = 0x1313; } |
| bool IsCmdBarMenuItem() { return (dwMagic == 0x1313); } |
| }; |
| |
| struct _ToolBarData // toolbar resource data |
| { |
| WORD wVersion; |
| WORD wWidth; |
| WORD wHeight; |
| WORD wItemCount; |
| //WORD aItems[wItemCount] |
| |
| WORD* items() |
| { return (WORD*)(this+1); } |
| }; |
| |
| // Constants |
| enum _CmdBarDrawConstants |
| { |
| s_kcxGap = 1, |
| s_kcxTextMargin = 2, |
| s_kcxButtonMargin = 3, |
| s_kcyButtonMargin = 3 |
| }; |
| |
| enum |
| { |
| _nMaxMenuItemTextLength = 100, |
| _chChevronShortcut = _T('/') |
| }; |
| |
| #ifndef DT_HIDEPREFIX |
| enum { DT_HIDEPREFIX = 0x00100000 }; |
| #endif // !DT_HIDEPREFIX |
| |
| // Data members |
| HMENU m_hMenu; |
| HIMAGELIST m_hImageList; |
| ATL::CSimpleValArray<WORD> m_arrCommand; |
| |
| DWORD m_dwExtendedStyle; // Command Bar specific extended styles |
| |
| ATL::CContainedWindow m_wndParent; |
| |
| bool m_bMenuActive:1; |
| bool m_bAttachedMenu:1; |
| bool m_bImagesVisible:1; |
| bool m_bPopupItem:1; |
| bool m_bContextMenu:1; |
| bool m_bEscapePressed:1; |
| bool m_bSkipMsg:1; |
| bool m_bParentActive:1; |
| bool m_bFlatMenus:1; |
| bool m_bUseKeyboardCues:1; |
| bool m_bShowKeyboardCues:1; |
| bool m_bAllowKeyboardCues:1; |
| bool m_bKeyboardInput:1; |
| bool m_bAlphaImages:1; |
| bool m_bLayoutRTL:1; |
| bool m_bSkipPostDown:1; |
| bool m_bVistaMenus:1; |
| |
| int m_nPopBtn; |
| int m_nNextPopBtn; |
| |
| SIZE m_szBitmap; |
| SIZE m_szButton; |
| |
| COLORREF m_clrMask; |
| CFont m_fontMenu; // used internally, only to measure text |
| |
| UINT m_uSysKey; |
| |
| HWND m_hWndFocus; // Alternate focus mode |
| |
| int m_cxExtraSpacing; |
| |
| #if _WTL_CMDBAR_VISTA_MENUS |
| ATL::CSimpleValArray<HBITMAP> m_arrVistaBitmap; // Bitmaps for Vista menus |
| #endif // _WTL_CMDBAR_VISTA_MENUS |
| |
| // Constructor/destructor |
| CCommandBarCtrlImpl() : |
| m_hMenu(NULL), |
| m_hImageList(NULL), |
| m_wndParent(this, 1), |
| m_bMenuActive(false), |
| m_bAttachedMenu(false), |
| m_nPopBtn(-1), |
| m_nNextPopBtn(-1), |
| m_bPopupItem(false), |
| m_bImagesVisible(true), |
| m_bSkipMsg(false), |
| m_uSysKey(0), |
| m_hWndFocus(NULL), |
| m_bContextMenu(false), |
| m_bEscapePressed(false), |
| m_clrMask(RGB(192, 192, 192)), |
| m_dwExtendedStyle(CBR_EX_TRANSPARENT | CBR_EX_SHAREMENU | CBR_EX_TRACKALWAYS), |
| m_bParentActive(true), |
| m_bFlatMenus(false), |
| m_bUseKeyboardCues(false), |
| m_bShowKeyboardCues(false), |
| m_bAllowKeyboardCues(true), |
| m_bKeyboardInput(false), |
| m_cxExtraSpacing(0), |
| m_bAlphaImages(false), |
| m_bLayoutRTL(false), |
| m_bSkipPostDown(false), |
| m_bVistaMenus(false) |
| { |
| SetImageSize(16, 15); // default |
| } |
| |
| ~CCommandBarCtrlImpl() |
| { |
| if(m_wndParent.IsWindow()) |
| /*scary!*/ m_wndParent.UnsubclassWindow(); |
| |
| if(m_hMenu != NULL && (m_dwExtendedStyle & CBR_EX_SHAREMENU) == 0) |
| ::DestroyMenu(m_hMenu); |
| |
| if(m_hImageList != NULL) |
| ::ImageList_Destroy(m_hImageList); |
| } |
| |
| // Attributes |
| DWORD GetCommandBarExtendedStyle() const |
| { |
| return m_dwExtendedStyle; |
| } |
| |
| DWORD SetCommandBarExtendedStyle(DWORD dwExtendedStyle, DWORD dwMask = 0) |
| { |
| DWORD dwPrevStyle = m_dwExtendedStyle; |
| if(dwMask == 0) |
| m_dwExtendedStyle = dwExtendedStyle; |
| else |
| m_dwExtendedStyle = (m_dwExtendedStyle & ~dwMask) | (dwExtendedStyle & dwMask); |
| return dwPrevStyle; |
| } |
| |
| CMenuHandle GetMenu() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return m_hMenu; |
| } |
| |
| COLORREF GetImageMaskColor() const |
| { |
| return m_clrMask; |
| } |
| |
| COLORREF SetImageMaskColor(COLORREF clrMask) |
| { |
| COLORREF clrOld = m_clrMask; |
| m_clrMask = clrMask; |
| return clrOld; |
| } |
| |
| bool GetImagesVisible() const |
| { |
| return m_bImagesVisible; |
| } |
| |
| bool SetImagesVisible(bool bVisible) |
| { |
| bool bOld = m_bImagesVisible; |
| m_bImagesVisible = bVisible; |
| return bOld; |
| } |
| |
| void GetImageSize(SIZE& size) const |
| { |
| size = m_szBitmap; |
| } |
| |
| bool SetImageSize(SIZE& size) |
| { |
| return SetImageSize(size.cx, size.cy); |
| } |
| |
| bool SetImageSize(int cx, int cy) |
| { |
| if(m_hImageList != NULL) |
| { |
| if(::ImageList_GetImageCount(m_hImageList) == 0) // empty |
| { |
| ::ImageList_Destroy(m_hImageList); |
| m_hImageList = NULL; |
| } |
| else |
| { |
| return false; // can't set, image list exists |
| } |
| } |
| |
| if(cx == 0 || cy == 0) |
| return false; |
| |
| m_szBitmap.cx = cx; |
| m_szBitmap.cy = cy; |
| m_szButton.cx = m_szBitmap.cx + 2 * s_kcxButtonMargin; |
| m_szButton.cy = m_szBitmap.cy + 2 * s_kcyButtonMargin; |
| |
| return true; |
| } |
| |
| bool GetAlphaImages() const |
| { |
| return m_bAlphaImages; |
| } |
| |
| bool SetAlphaImages(bool bAlphaImages) |
| { |
| if(m_hImageList != NULL) |
| { |
| if(::ImageList_GetImageCount(m_hImageList) == 0) // empty |
| { |
| ::ImageList_Destroy(m_hImageList); |
| m_hImageList = NULL; |
| } |
| else |
| { |
| return false; // can't set, image list exists |
| } |
| } |
| |
| m_bAlphaImages = bAlphaImages; |
| return true; |
| } |
| |
| HWND GetCmdBar() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (HWND)::SendMessage(m_hWnd, CBRM_GETCMDBAR, 0, 0L); |
| } |
| |
| // Methods |
| HWND Create(HWND hWndParent, RECT& rcPos, LPCTSTR szWindowName = NULL, |
| DWORD dwStyle = 0, DWORD dwExStyle = 0, |
| UINT nID = 0, LPVOID lpCreateParam = NULL) |
| { |
| // These styles are required for command bars |
| dwStyle |= TBSTYLE_LIST | TBSTYLE_FLAT; |
| #if (_MSC_VER >= 1300) |
| return ATL::CWindowImpl< T, TBase, TWinTraits >::Create(hWndParent, rcPos, szWindowName, dwStyle, dwExStyle, nID, lpCreateParam); |
| #else // !(_MSC_VER >= 1300) |
| typedef ATL::CWindowImpl< T, TBase, TWinTraits > _baseClass; |
| return _baseClass::Create(hWndParent, rcPos, szWindowName, dwStyle, dwExStyle, nID, lpCreateParam); |
| #endif // !(_MSC_VER >= 1300) |
| } |
| |
| BOOL AttachToWindow(HWND hWnd) |
| { |
| ATLASSERT(m_hWnd == NULL); |
| ATLASSERT(::IsWindow(hWnd)); |
| BOOL bRet = SubclassWindow(hWnd); |
| if(bRet) |
| { |
| m_bAttachedMenu = true; |
| T* pT = static_cast<T*>(this); |
| pT->GetSystemSettings(); |
| } |
| return bRet; |
| } |
| |
| BOOL LoadMenu(ATL::_U_STRINGorID menu) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| |
| if(m_bAttachedMenu) // doesn't work in this mode |
| return FALSE; |
| if(menu.m_lpstr == NULL) |
| return FALSE; |
| |
| HMENU hMenu = ::LoadMenu(ModuleHelper::GetResourceInstance(), menu.m_lpstr); |
| if(hMenu == NULL) |
| return FALSE; |
| |
| return AttachMenu(hMenu); |
| } |
| |
| BOOL AttachMenu(HMENU hMenu) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(hMenu == NULL || ::IsMenu(hMenu)); |
| if(hMenu != NULL && !::IsMenu(hMenu)) |
| return FALSE; |
| |
| #if _WTL_CMDBAR_VISTA_MENUS |
| // remove Vista bitmaps if used |
| if(m_bVistaMenus && (m_hMenu != NULL)) |
| { |
| T* pT = static_cast<T*>(this); |
| pT->_RemoveVistaBitmapsFromMenu(); |
| } |
| #endif // _WTL_CMDBAR_VISTA_MENUS |
| |
| // destroy old menu, if needed, and set new one |
| if(m_hMenu != NULL && (m_dwExtendedStyle & CBR_EX_SHAREMENU) == 0) |
| ::DestroyMenu(m_hMenu); |
| |
| m_hMenu = hMenu; |
| |
| if(m_bAttachedMenu) // Nothing else in this mode |
| return TRUE; |
| |
| // Build buttons according to menu |
| SetRedraw(FALSE); |
| |
| // Clear all buttons |
| int nCount = GetButtonCount(); |
| for(int i = 0; i < nCount; i++) |
| ATLVERIFY(DeleteButton(0) != FALSE); |
| |
| // Add buttons for each menu item |
| if(m_hMenu != NULL) |
| { |
| int nItems = ::GetMenuItemCount(m_hMenu); |
| |
| T* pT = static_cast<T*>(this); |
| pT; // avoid level 4 warning |
| TCHAR szString[pT->_nMaxMenuItemTextLength]; |
| for(int i = 0; i < nItems; i++) |
| { |
| CMenuItemInfo mii; |
| mii.fMask = MIIM_TYPE | MIIM_STATE | MIIM_SUBMENU; |
| mii.fType = MFT_STRING; |
| mii.dwTypeData = szString; |
| mii.cch = pT->_nMaxMenuItemTextLength; |
| BOOL bRet = ::GetMenuItemInfo(m_hMenu, i, TRUE, &mii); |
| ATLASSERT(bRet); |
| // If we have more than the buffer, we assume we have bitmaps bits |
| if(lstrlen(szString) > pT->_nMaxMenuItemTextLength - 1) |
| { |
| mii.fType = MFT_BITMAP; |
| ::SetMenuItemInfo(m_hMenu, i, TRUE, &mii); |
| szString[0] = 0; |
| } |
| |
| // NOTE: Command Bar currently supports only drop-down menu items |
| ATLASSERT(mii.hSubMenu != NULL); |
| |
| TBBUTTON btn = { 0 }; |
| btn.iBitmap = 0; |
| btn.idCommand = i; |
| btn.fsState = (BYTE)(((mii.fState & MFS_DISABLED) == 0) ? TBSTATE_ENABLED : 0); |
| btn.fsStyle = TBSTYLE_BUTTON | TBSTYLE_AUTOSIZE | TBSTYLE_DROPDOWN; |
| btn.dwData = 0; |
| btn.iString = 0; |
| |
| bRet = InsertButton(-1, &btn); |
| ATLASSERT(bRet); |
| |
| TBBUTTONINFO bi = { 0 }; |
| bi.cbSize = sizeof(TBBUTTONINFO); |
| bi.dwMask = TBIF_TEXT; |
| bi.pszText = szString; |
| |
| bRet = SetButtonInfo(i, &bi); |
| ATLASSERT(bRet); |
| } |
| } |
| |
| SetRedraw(TRUE); |
| Invalidate(); |
| UpdateWindow(); |
| |
| return TRUE; |
| } |
| |
| BOOL LoadImages(ATL::_U_STRINGorID image) |
| { |
| return _LoadImagesHelper(image, false); |
| } |
| |
| BOOL LoadMappedImages(UINT nIDImage, UINT nFlags = 0, LPCOLORMAP lpColorMap = NULL, int nMapSize = 0) |
| { |
| return _LoadImagesHelper(nIDImage, true, nFlags , lpColorMap, nMapSize); |
| } |
| |
| BOOL _LoadImagesHelper(ATL::_U_STRINGorID image, bool bMapped, UINT nFlags = 0, LPCOLORMAP lpColorMap = NULL, int nMapSize = 0) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| HINSTANCE hInstance = ModuleHelper::GetResourceInstance(); |
| |
| HRSRC hRsrc = ::FindResource(hInstance, image.m_lpstr, (LPTSTR)RT_TOOLBAR); |
| if(hRsrc == NULL) |
| return FALSE; |
| |
| HGLOBAL hGlobal = ::LoadResource(hInstance, hRsrc); |
| if(hGlobal == NULL) |
| return FALSE; |
| |
| _ToolBarData* pData = (_ToolBarData*)::LockResource(hGlobal); |
| if(pData == NULL) |
| return FALSE; |
| ATLASSERT(pData->wVersion == 1); |
| |
| WORD* pItems = pData->items(); |
| int nItems = pData->wItemCount; |
| |
| // Set internal data |
| SetImageSize(pData->wWidth, pData->wHeight); |
| |
| // Create image list if needed |
| if(m_hImageList == NULL) |
| { |
| // Check if the bitmap is 32-bit (alpha channel) bitmap (valid for Windows XP only) |
| T* pT = static_cast<T*>(this); |
| m_bAlphaImages = AtlIsAlphaBitmapResource(image); |
| |
| if(!pT->CreateInternalImageList(pData->wItemCount)) |
| return FALSE; |
| } |
| |
| #if _WTL_CMDBAR_VISTA_MENUS |
| int nOldImageCount = ::ImageList_GetImageCount(m_hImageList); |
| #endif // _WTL_CMDBAR_VISTA_MENUS |
| |
| // Add bitmap to our image list |
| CBitmap bmp; |
| if(bMapped) |
| { |
| ATLASSERT(HIWORD(PtrToUlong(image.m_lpstr)) == 0); // if mapped, must be a numeric ID |
| int nIDImage = (int)(short)LOWORD(PtrToUlong(image.m_lpstr)); |
| bmp.LoadMappedBitmap(nIDImage, (WORD)nFlags, lpColorMap, nMapSize); |
| } |
| else |
| { |
| if(m_bAlphaImages) |
| bmp = (HBITMAP)::LoadImage(ModuleHelper::GetResourceInstance(), image.m_lpstr, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION | LR_DEFAULTSIZE); |
| else |
| bmp.LoadBitmap(image.m_lpstr); |
| } |
| ATLASSERT(bmp.m_hBitmap != NULL); |
| if(bmp.m_hBitmap == NULL) |
| return FALSE; |
| if(::ImageList_AddMasked(m_hImageList, bmp, m_clrMask) == -1) |
| return FALSE; |
| |
| // Fill the array with command IDs |
| for(int i = 0; i < nItems; i++) |
| { |
| if(pItems[i] != 0) |
| m_arrCommand.Add(pItems[i]); |
| } |
| |
| int nImageCount = ::ImageList_GetImageCount(m_hImageList); |
| ATLASSERT(nImageCount == m_arrCommand.GetSize()); |
| if(nImageCount != m_arrCommand.GetSize()) |
| return FALSE; |
| |
| #if _WTL_CMDBAR_VISTA_MENUS |
| if(RunTimeHelper::IsVista()) |
| { |
| T* pT = static_cast<T*>(this); |
| pT->_AddVistaBitmapsFromImageList(nOldImageCount, nImageCount - nOldImageCount); |
| ATLASSERT(nImageCount == m_arrVistaBitmap.GetSize()); |
| } |
| #endif // _WTL_CMDBAR_VISTA_MENUS |
| |
| return TRUE; |
| } |
| |
| BOOL AddBitmap(ATL::_U_STRINGorID bitmap, int nCommandID) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| CBitmap bmp; |
| bmp.LoadBitmap(bitmap.m_lpstr); |
| if(bmp.m_hBitmap == NULL) |
| return FALSE; |
| return AddBitmap(bmp, nCommandID); |
| } |
| |
| BOOL AddBitmap(HBITMAP hBitmap, UINT nCommandID) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| T* pT = static_cast<T*>(this); |
| // Create image list if it doesn't exist |
| if(m_hImageList == NULL) |
| { |
| if(!pT->CreateInternalImageList(1)) |
| return FALSE; |
| } |
| // check bitmap size |
| CBitmapHandle bmp = hBitmap; |
| SIZE size = { 0, 0 }; |
| bmp.GetSize(size); |
| if(size.cx != m_szBitmap.cx || size.cy != m_szBitmap.cy) |
| { |
| ATLASSERT(FALSE); // must match size! |
| return FALSE; |
| } |
| // add bitmap |
| int nRet = ::ImageList_AddMasked(m_hImageList, hBitmap, m_clrMask); |
| if(nRet == -1) |
| return FALSE; |
| BOOL bRet = m_arrCommand.Add((WORD)nCommandID); |
| ATLASSERT(::ImageList_GetImageCount(m_hImageList) == m_arrCommand.GetSize()); |
| #if _WTL_CMDBAR_VISTA_MENUS |
| if(RunTimeHelper::IsVista()) |
| { |
| pT->_AddVistaBitmapFromImageList(m_arrCommand.GetSize() - 1); |
| ATLASSERT(m_arrVistaBitmap.GetSize() == m_arrCommand.GetSize()); |
| } |
| #endif // _WTL_CMDBAR_VISTA_MENUS |
| return bRet; |
| } |
| |
| BOOL AddIcon(ATL::_U_STRINGorID icon, UINT nCommandID) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| HICON hIcon = ::LoadIcon(ModuleHelper::GetResourceInstance(), icon.m_lpstr); |
| if(hIcon == NULL) |
| return FALSE; |
| return AddIcon(hIcon, nCommandID); |
| } |
| |
| BOOL AddIcon(HICON hIcon, UINT nCommandID) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| T* pT = static_cast<T*>(this); |
| // create image list if it doesn't exist |
| if(m_hImageList == NULL) |
| { |
| if(!pT->CreateInternalImageList(1)) |
| return FALSE; |
| } |
| |
| int nRet = ::ImageList_AddIcon(m_hImageList, hIcon); |
| if(nRet == -1) |
| return FALSE; |
| BOOL bRet = m_arrCommand.Add((WORD)nCommandID); |
| ATLASSERT(::ImageList_GetImageCount(m_hImageList) == m_arrCommand.GetSize()); |
| #if _WTL_CMDBAR_VISTA_MENUS |
| if(RunTimeHelper::IsVista()) |
| { |
| pT->_AddVistaBitmapFromImageList(m_arrCommand.GetSize() - 1); |
| ATLASSERT(m_arrVistaBitmap.GetSize() == m_arrCommand.GetSize()); |
| } |
| #endif // _WTL_CMDBAR_VISTA_MENUS |
| return bRet; |
| } |
| |
| BOOL ReplaceBitmap(ATL::_U_STRINGorID bitmap, int nCommandID) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| CBitmap bmp; |
| bmp.LoadBitmap(bitmap.m_lpstr); |
| if(bmp.m_hBitmap == NULL) |
| return FALSE; |
| return ReplaceBitmap(bmp, nCommandID); |
| } |
| |
| BOOL ReplaceBitmap(HBITMAP hBitmap, UINT nCommandID) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| BOOL bRet = FALSE; |
| for(int i = 0; i < m_arrCommand.GetSize(); i++) |
| { |
| if(m_arrCommand[i] == nCommandID) |
| { |
| bRet = ::ImageList_Remove(m_hImageList, i); |
| if(bRet) |
| { |
| m_arrCommand.RemoveAt(i); |
| #if _WTL_CMDBAR_VISTA_MENUS |
| if(RunTimeHelper::IsVista()) |
| { |
| if(m_arrVistaBitmap[i] != NULL) |
| ::DeleteObject(m_arrVistaBitmap[i]); |
| m_arrVistaBitmap.RemoveAt(i); |
| } |
| #endif // _WTL_CMDBAR_VISTA_MENUS |
| } |
| break; |
| } |
| } |
| if(bRet) |
| bRet = AddBitmap(hBitmap, nCommandID); |
| return bRet; |
| } |
| |
| BOOL ReplaceIcon(ATL::_U_STRINGorID icon, UINT nCommandID) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| HICON hIcon = ::LoadIcon(ModuleHelper::GetResourceInstance(), icon.m_lpstr); |
| if(hIcon == NULL) |
| return FALSE; |
| return ReplaceIcon(hIcon, nCommandID); |
| } |
| |
| BOOL ReplaceIcon(HICON hIcon, UINT nCommandID) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| BOOL bRet = FALSE; |
| for(int i = 0; i < m_arrCommand.GetSize(); i++) |
| { |
| if(m_arrCommand[i] == nCommandID) |
| { |
| bRet = (::ImageList_ReplaceIcon(m_hImageList, i, hIcon) != -1); |
| #if _WTL_CMDBAR_VISTA_MENUS |
| if(RunTimeHelper::IsVista() && bRet != FALSE) |
| { |
| T* pT = static_cast<T*>(this); |
| pT->_ReplaceVistaBitmapFromImageList(i); |
| } |
| #endif // _WTL_CMDBAR_VISTA_MENUS |
| break; |
| } |
| } |
| return bRet; |
| } |
| |
| BOOL RemoveImage(int nCommandID) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| |
| BOOL bRet = FALSE; |
| for(int i = 0; i < m_arrCommand.GetSize(); i++) |
| { |
| if(m_arrCommand[i] == nCommandID) |
| { |
| bRet = ::ImageList_Remove(m_hImageList, i); |
| if(bRet) |
| { |
| m_arrCommand.RemoveAt(i); |
| #if _WTL_CMDBAR_VISTA_MENUS |
| if(RunTimeHelper::IsVista()) |
| { |
| if(m_arrVistaBitmap[i] != NULL) |
| ::DeleteObject(m_arrVistaBitmap[i]); |
| m_arrVistaBitmap.RemoveAt(i); |
| } |
| #endif // _WTL_CMDBAR_VISTA_MENUS |
| } |
| break; |
| } |
| } |
| return bRet; |
| } |
| |
| BOOL RemoveAllImages() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Removing all images\n")); |
| BOOL bRet = ::ImageList_RemoveAll(m_hImageList); |
| if(bRet) |
| { |
| m_arrCommand.RemoveAll(); |
| #if _WTL_CMDBAR_VISTA_MENUS |
| for(int i = 0; i < m_arrVistaBitmap.GetSize(); i++) |
| { |
| if(m_arrVistaBitmap[i] != NULL) |
| ::DeleteObject(m_arrVistaBitmap[i]); |
| } |
| m_arrVistaBitmap.RemoveAll(); |
| #endif // _WTL_CMDBAR_VISTA_MENUS |
| } |
| return bRet; |
| } |
| |
| BOOL TrackPopupMenu(HMENU hMenu, UINT uFlags, int x, int y, LPTPMPARAMS lpParams = NULL) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(::IsMenu(hMenu)); |
| if(!::IsMenu(hMenu)) |
| return FALSE; |
| m_bContextMenu = true; |
| if(m_bUseKeyboardCues) |
| m_bShowKeyboardCues = m_bKeyboardInput; |
| T* pT = static_cast<T*>(this); |
| return pT->DoTrackPopupMenu(hMenu, uFlags, x, y, lpParams); |
| } |
| |
| BOOL SetMDIClient(HWND /*hWndMDIClient*/) |
| { |
| // Use CMDICommandBarCtrl for MDI support |
| ATLASSERT(FALSE); |
| return FALSE; |
| } |
| |
| // Message map and handlers |
| BEGIN_MSG_MAP(CCommandBarCtrlImpl) |
| MESSAGE_HANDLER(WM_CREATE, OnCreate) |
| MESSAGE_HANDLER(WM_DESTROY, OnDestroy) |
| MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground) |
| MESSAGE_HANDLER(WM_INITMENU, OnInitMenu) |
| MESSAGE_HANDLER(WM_INITMENUPOPUP, OnInitMenuPopup) |
| MESSAGE_HANDLER(WM_MENUSELECT, OnMenuSelect) |
| MESSAGE_HANDLER(GetAutoPopupMessage(), OnInternalAutoPopup) |
| MESSAGE_HANDLER(GetGetBarMessage(), OnInternalGetBar) |
| MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange) |
| MESSAGE_HANDLER(WM_MENUCHAR, OnMenuChar) |
| |
| MESSAGE_HANDLER(WM_KEYDOWN, OnKeyDown) |
| MESSAGE_HANDLER(WM_KEYUP, OnKeyUp) |
| MESSAGE_HANDLER(WM_CHAR, OnChar) |
| MESSAGE_HANDLER(WM_SYSKEYDOWN, OnSysKeyDown) |
| MESSAGE_HANDLER(WM_SYSKEYUP, OnSysKeyUp) |
| MESSAGE_HANDLER(WM_SYSCHAR, OnSysChar) |
| // public API handlers - these stay to support chevrons in atlframe.h |
| MESSAGE_HANDLER(CBRM_GETMENU, OnAPIGetMenu) |
| MESSAGE_HANDLER(CBRM_TRACKPOPUPMENU, OnAPITrackPopupMenu) |
| MESSAGE_HANDLER(CBRM_GETCMDBAR, OnAPIGetCmdBar) |
| |
| MESSAGE_HANDLER(WM_DRAWITEM, OnDrawItem) |
| MESSAGE_HANDLER(WM_MEASUREITEM, OnMeasureItem) |
| |
| MESSAGE_HANDLER(WM_FORWARDMSG, OnForwardMsg) |
| ALT_MSG_MAP(1) // Parent window messages |
| NOTIFY_CODE_HANDLER(TBN_HOTITEMCHANGE, OnParentHotItemChange) |
| NOTIFY_CODE_HANDLER(TBN_DROPDOWN, OnParentDropDown) |
| MESSAGE_HANDLER(WM_INITMENUPOPUP, OnParentInitMenuPopup) |
| MESSAGE_HANDLER(GetGetBarMessage(), OnParentInternalGetBar) |
| MESSAGE_HANDLER(WM_SYSCOMMAND, OnParentSysCommand) |
| MESSAGE_HANDLER(CBRM_GETMENU, OnParentAPIGetMenu) |
| MESSAGE_HANDLER(WM_MENUCHAR, OnParentMenuChar) |
| MESSAGE_HANDLER(CBRM_TRACKPOPUPMENU, OnParentAPITrackPopupMenu) |
| MESSAGE_HANDLER(CBRM_GETCMDBAR, OnParentAPIGetCmdBar) |
| MESSAGE_HANDLER(WM_SETTINGCHANGE, OnParentSettingChange) |
| |
| MESSAGE_HANDLER(WM_DRAWITEM, OnParentDrawItem) |
| MESSAGE_HANDLER(WM_MEASUREITEM, OnParentMeasureItem) |
| |
| MESSAGE_HANDLER(WM_ACTIVATE, OnParentActivate) |
| NOTIFY_CODE_HANDLER(NM_CUSTOMDRAW, OnParentCustomDraw) |
| ALT_MSG_MAP(2) // MDI client window messages |
| // Use CMDICommandBarCtrl for MDI support |
| ALT_MSG_MAP(3) // Message hook messages |
| MESSAGE_HANDLER(WM_MOUSEMOVE, OnHookMouseMove) |
| MESSAGE_HANDLER(WM_SYSKEYDOWN, OnHookSysKeyDown) |
| MESSAGE_HANDLER(WM_SYSKEYUP, OnHookSysKeyUp) |
| MESSAGE_HANDLER(WM_SYSCHAR, OnHookSysChar) |
| MESSAGE_HANDLER(WM_KEYDOWN, OnHookKeyDown) |
| MESSAGE_HANDLER(WM_NEXTMENU, OnHookNextMenu) |
| MESSAGE_HANDLER(WM_CHAR, OnHookChar) |
| END_MSG_MAP() |
| |
| LRESULT OnForwardMsg(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/) |
| { |
| LPMSG pMsg = (LPMSG)lParam; |
| if(pMsg->message >= WM_MOUSEFIRST && pMsg->message <= WM_MOUSELAST) |
| m_bKeyboardInput = false; |
| else if(pMsg->message >= WM_KEYFIRST && pMsg->message <= WM_KEYLAST) |
| m_bKeyboardInput = true; |
| LRESULT lRet = 0; |
| ProcessWindowMessage(pMsg->hwnd, pMsg->message, pMsg->wParam, pMsg->lParam, lRet, 3); |
| return lRet; |
| } |
| |
| LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/) |
| { |
| // Let the toolbar initialize itself |
| LRESULT lRet = DefWindowProc(uMsg, wParam, lParam); |
| // get and use system settings |
| T* pT = static_cast<T*>(this); |
| pT->GetSystemSettings(); |
| // Parent init |
| ATL::CWindow wndParent = GetParent(); |
| ATL::CWindow wndTopLevelParent = wndParent.GetTopLevelParent(); |
| m_wndParent.SubclassWindow(wndTopLevelParent); |
| // Toolbar Init |
| SetButtonStructSize(); |
| SetImageList(NULL); |
| |
| // Create message hook if needed |
| CWindowCreateCriticalSectionLock lock; |
| if(FAILED(lock.Lock())) |
| { |
| ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CCommandBarCtrlImpl::OnCreate.\n")); |
| ATLASSERT(FALSE); |
| return -1; |
| } |
| |
| if(s_pmapMsgHook == NULL) |
| { |
| ATLTRY(s_pmapMsgHook = new CMsgHookMap); |
| ATLASSERT(s_pmapMsgHook != NULL); |
| } |
| |
| if(s_pmapMsgHook != NULL) |
| { |
| DWORD dwThreadID = ::GetCurrentThreadId(); |
| _MsgHookData* pData = s_pmapMsgHook->Lookup(dwThreadID); |
| if(pData == NULL) |
| { |
| ATLTRY(pData = new _MsgHookData); |
| ATLASSERT(pData != NULL); |
| HHOOK hMsgHook = ::SetWindowsHookEx(WH_GETMESSAGE, MessageHookProc, ModuleHelper::GetModuleInstance(), dwThreadID); |
| ATLASSERT(hMsgHook != NULL); |
| if(pData != NULL && hMsgHook != NULL) |
| { |
| pData->hMsgHook = hMsgHook; |
| pData->dwUsage = 1; |
| BOOL bRet = s_pmapMsgHook->Add(dwThreadID, pData); |
| bRet; |
| ATLASSERT(bRet); |
| } |
| } |
| else |
| { |
| (pData->dwUsage)++; |
| } |
| } |
| lock.Unlock(); |
| |
| // Get layout |
| #if (WINVER >= 0x0500) |
| m_bLayoutRTL = ((GetExStyle() & WS_EX_LAYOUTRTL) != 0); |
| #endif // (WINVER >= 0x0500) |
| |
| return lRet; |
| } |
| |
| LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/) |
| { |
| LRESULT lRet = DefWindowProc(uMsg, wParam, lParam); |
| |
| #if _WTL_CMDBAR_VISTA_MENUS |
| if(m_bVistaMenus && (m_hMenu != NULL)) |
| { |
| T* pT = static_cast<T*>(this); |
| pT->_RemoveVistaBitmapsFromMenu(); |
| } |
| |
| for(int i = 0; i < m_arrVistaBitmap.GetSize(); i++) |
| { |
| if(m_arrVistaBitmap[i] != NULL) |
| ::DeleteObject(m_arrVistaBitmap[i]); |
| } |
| #endif // _WTL_CMDBAR_VISTA_MENUS |
| |
| if(m_bAttachedMenu) // nothing to do in this mode |
| return lRet; |
| |
| CWindowCreateCriticalSectionLock lock; |
| if(FAILED(lock.Lock())) |
| { |
| ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CCommandBarCtrlImpl::OnDestroy.\n")); |
| ATLASSERT(FALSE); |
| return lRet; |
| } |
| |
| if(s_pmapMsgHook != NULL) |
| { |
| DWORD dwThreadID = ::GetCurrentThreadId(); |
| _MsgHookData* pData = s_pmapMsgHook->Lookup(dwThreadID); |
| if(pData != NULL) |
| { |
| (pData->dwUsage)--; |
| if(pData->dwUsage == 0) |
| { |
| BOOL bRet = ::UnhookWindowsHookEx(pData->hMsgHook); |
| ATLASSERT(bRet); |
| bRet = s_pmapMsgHook->Remove(dwThreadID); |
| ATLASSERT(bRet); |
| if(bRet) |
| delete pData; |
| } |
| |
| if(s_pmapMsgHook->GetSize() == 0) |
| { |
| delete s_pmapMsgHook; |
| s_pmapMsgHook = NULL; |
| } |
| } |
| } |
| |
| lock.Unlock(); |
| |
| return lRet; |
| } |
| |
| LRESULT OnKeyDown(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnKeyDown\n")); |
| #endif |
| bHandled = FALSE; |
| // Simulate Alt+Space for the parent |
| if(wParam == VK_SPACE) |
| { |
| m_wndParent.PostMessage(WM_SYSKEYDOWN, wParam, lParam | (1 << 29)); |
| bHandled = TRUE; |
| } |
| #if (_WIN32_IE >= 0x0500) |
| else if(wParam == VK_LEFT || wParam == VK_RIGHT) |
| { |
| WPARAM wpNext = m_bLayoutRTL ? VK_LEFT : VK_RIGHT; |
| |
| if(!m_bMenuActive) |
| { |
| T* pT = static_cast<T*>(this); |
| int nBtn = GetHotItem(); |
| int nNextBtn = (wParam == wpNext) ? pT->GetNextMenuItem(nBtn) : pT->GetPreviousMenuItem(nBtn); |
| if(nNextBtn == -2) |
| { |
| SetHotItem(-1); |
| if(pT->DisplayChevronMenu()) |
| bHandled = TRUE; |
| } |
| } |
| } |
| #endif // (_WIN32_IE >= 0x0500) |
| return 0; |
| } |
| |
| LRESULT OnKeyUp(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnKeyUp\n")); |
| #endif |
| if(wParam != VK_SPACE) |
| bHandled = FALSE; |
| return 0; |
| } |
| |
| LRESULT OnChar(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnChar\n")); |
| #endif |
| if(wParam != VK_SPACE) |
| bHandled = FALSE; |
| else |
| return 0; |
| // Security |
| if(!m_wndParent.IsWindowEnabled() || ::GetFocus() != m_hWnd) |
| return 0; |
| |
| // Handle mnemonic press when we have focus |
| int nBtn = 0; |
| if(wParam != VK_RETURN && !MapAccelerator((TCHAR)LOWORD(wParam), nBtn)) |
| { |
| #if (_WIN32_IE >= 0x0500) |
| if((TCHAR)LOWORD(wParam) != _chChevronShortcut) |
| #endif // (_WIN32_IE >= 0x0500) |
| ::MessageBeep(0); |
| } |
| else |
| { |
| #if (_WIN32_IE >= 0x0500) |
| RECT rcClient = { 0 }; |
| GetClientRect(&rcClient); |
| RECT rcBtn = { 0 }; |
| GetItemRect(nBtn, &rcBtn); |
| TBBUTTON tbb = { 0 }; |
| GetButton(nBtn, &tbb); |
| if((tbb.fsState & TBSTATE_ENABLED) != 0 && (tbb.fsState & TBSTATE_HIDDEN) == 0 && rcBtn.right <= rcClient.right) |
| { |
| #endif // (_WIN32_IE >= 0x0500) |
| PostMessage(WM_KEYDOWN, VK_DOWN, 0L); |
| if(wParam != VK_RETURN) |
| SetHotItem(nBtn); |
| #if (_WIN32_IE >= 0x0500) |
| } |
| else |
| { |
| ::MessageBeep(0); |
| bHandled = TRUE; |
| } |
| #endif // (_WIN32_IE >= 0x0500) |
| } |
| return 0; |
| } |
| |
| LRESULT OnSysKeyDown(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnSysKeyDown\n")); |
| #endif |
| bHandled = FALSE; |
| return 0; |
| } |
| |
| LRESULT OnSysKeyUp(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnSysKeyUp\n")); |
| #endif |
| bHandled = FALSE; |
| return 0; |
| } |
| |
| LRESULT OnSysChar(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnSysChar\n")); |
| #endif |
| bHandled = FALSE; |
| return 0; |
| } |
| |
| LRESULT OnEraseBackground(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| if(m_bAttachedMenu || (m_dwExtendedStyle & CBR_EX_TRANSPARENT)) |
| { |
| bHandled = FALSE; |
| return 0; |
| } |
| |
| CDCHandle dc = (HDC)wParam; |
| RECT rect = { 0 }; |
| GetClientRect(&rect); |
| dc.FillRect(&rect, COLOR_MENU); |
| |
| return 1; // don't do the default erase |
| } |
| |
| LRESULT OnInitMenu(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| int nIndex = GetHotItem(); |
| SendMessage(WM_MENUSELECT, MAKEWPARAM(nIndex, MF_POPUP|MF_HILITE), (LPARAM)m_hMenu); |
| bHandled = FALSE; |
| return 1; |
| } |
| |
| LRESULT OnInitMenuPopup(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| if((BOOL)HIWORD(lParam)) // System menu, do nothing |
| { |
| bHandled = FALSE; |
| return 1; |
| } |
| |
| if(!(m_bAttachedMenu || m_bMenuActive)) // Not attached or ours, do nothing |
| { |
| bHandled = FALSE; |
| return 1; |
| } |
| |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnInitMenuPopup\n")); |
| #endif |
| // forward to the parent or subclassed window, so it can handle update UI |
| LRESULT lRet = 0; |
| if(m_bAttachedMenu) |
| lRet = DefWindowProc(uMsg, wParam, (lParam || m_bContextMenu) ? lParam : GetHotItem()); |
| else |
| lRet = m_wndParent.DefWindowProc(uMsg, wParam, (lParam || m_bContextMenu) ? lParam : GetHotItem()); |
| |
| #if _WTL_CMDBAR_VISTA_MENUS |
| // If Vista menus are active, just set bitmaps and return |
| if(m_bVistaMenus) |
| { |
| CMenuHandle menu = (HMENU)wParam; |
| ATLASSERT(menu.m_hMenu != NULL); |
| |
| for(int i = 0; i < menu.GetMenuItemCount(); i++) |
| { |
| WORD nID = (WORD)menu.GetMenuItemID(i); |
| int nIndex = m_arrCommand.Find(nID); |
| |
| CMenuItemInfo mii; |
| mii.fMask = MIIM_BITMAP; |
| mii.hbmpItem = (m_bImagesVisible && (nIndex != -1)) ? m_arrVistaBitmap[nIndex] : NULL; |
| menu.SetMenuItemInfo(i, TRUE, &mii); |
| } |
| |
| return lRet; |
| } |
| #endif // _WTL_CMDBAR_VISTA_MENUS |
| |
| // Convert menu items to ownerdraw, add our data |
| if(m_bImagesVisible) |
| { |
| CMenuHandle menuPopup = (HMENU)wParam; |
| ATLASSERT(menuPopup.m_hMenu != NULL); |
| |
| T* pT = static_cast<T*>(this); |
| pT; // avoid level 4 warning |
| TCHAR szString[pT->_nMaxMenuItemTextLength]; |
| BOOL bRet = FALSE; |
| for(int i = 0; i < menuPopup.GetMenuItemCount(); i++) |
| { |
| CMenuItemInfo mii; |
| mii.cch = pT->_nMaxMenuItemTextLength; |
| mii.fMask = MIIM_CHECKMARKS | MIIM_DATA | MIIM_ID | MIIM_STATE | MIIM_SUBMENU | MIIM_TYPE; |
| mii.dwTypeData = szString; |
| bRet = menuPopup.GetMenuItemInfo(i, TRUE, &mii); |
| ATLASSERT(bRet); |
| |
| if(!(mii.fType & MFT_OWNERDRAW)) // Not already an ownerdraw item |
| { |
| mii.fMask = MIIM_DATA | MIIM_TYPE | MIIM_STATE; |
| _MenuItemData* pMI = NULL; |
| ATLTRY(pMI = new _MenuItemData); |
| ATLASSERT(pMI != NULL); |
| if(pMI != NULL) |
| { |
| pMI->fType = mii.fType; |
| pMI->fState = mii.fState; |
| mii.fType |= MFT_OWNERDRAW; |
| pMI->iButton = -1; |
| for(int j = 0; j < m_arrCommand.GetSize(); j++) |
| { |
| if(m_arrCommand[j] == mii.wID) |
| { |
| pMI->iButton = j; |
| break; |
| } |
| } |
| int cchLen = lstrlen(szString) + 1; |
| pMI->lpstrText = NULL; |
| ATLTRY(pMI->lpstrText = new TCHAR[cchLen]); |
| ATLASSERT(pMI->lpstrText != NULL); |
| if(pMI->lpstrText != NULL) |
| SecureHelper::strcpy_x(pMI->lpstrText, cchLen, szString); |
| mii.dwItemData = (ULONG_PTR)pMI; |
| bRet = menuPopup.SetMenuItemInfo(i, TRUE, &mii); |
| ATLASSERT(bRet); |
| } |
| } |
| } |
| |
| // Add it to the list |
| m_stackMenuHandle.Push(menuPopup.m_hMenu); |
| } |
| |
| return lRet; |
| } |
| |
| LRESULT OnMenuSelect(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| if(!m_bAttachedMenu) // Not attached, do nothing, forward to parent |
| { |
| m_bPopupItem = (lParam != NULL) && ((HMENU)lParam != m_hMenu) && (HIWORD(wParam) & MF_POPUP); |
| if(m_wndParent.IsWindow()) |
| m_wndParent.SendMessage(uMsg, wParam, lParam); |
| bHandled = FALSE; |
| return 1; |
| } |
| |
| // Check if a menu is closing, do a cleanup |
| if(HIWORD(wParam) == 0xFFFF && lParam == NULL) // Menu closing |
| { |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnMenuSelect - CLOSING!!!!\n")); |
| #endif |
| ATLASSERT(m_stackMenuWnd.GetSize() == 0); |
| // Restore the menu items to the previous state for all menus that were converted |
| if(m_bImagesVisible) |
| { |
| HMENU hMenu = NULL; |
| while((hMenu = m_stackMenuHandle.Pop()) != NULL) |
| { |
| CMenuHandle menuPopup = hMenu; |
| ATLASSERT(menuPopup.m_hMenu != NULL); |
| // Restore state and delete menu item data |
| BOOL bRet = FALSE; |
| for(int i = 0; i < menuPopup.GetMenuItemCount(); i++) |
| { |
| CMenuItemInfo mii; |
| mii.fMask = MIIM_DATA | MIIM_TYPE; |
| bRet = menuPopup.GetMenuItemInfo(i, TRUE, &mii); |
| ATLASSERT(bRet); |
| |
| _MenuItemData* pMI = (_MenuItemData*)mii.dwItemData; |
| if(pMI != NULL && pMI->IsCmdBarMenuItem()) |
| { |
| mii.fMask = MIIM_DATA | MIIM_TYPE | MIIM_STATE; |
| mii.fType = pMI->fType; |
| mii.dwTypeData = pMI->lpstrText; |
| mii.cch = lstrlen(pMI->lpstrText); |
| mii.dwItemData = NULL; |
| |
| bRet = menuPopup.SetMenuItemInfo(i, TRUE, &mii); |
| ATLASSERT(bRet); |
| |
| delete [] pMI->lpstrText; |
| pMI->dwMagic = 0x6666; |
| delete pMI; |
| } |
| } |
| } |
| } |
| } |
| |
| bHandled = FALSE; |
| return 1; |
| } |
| |
| LRESULT OnInternalAutoPopup(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/) |
| { |
| int nIndex = (int)wParam; |
| T* pT = static_cast<T*>(this); |
| pT->DoPopupMenu(nIndex, false); |
| return 0; |
| } |
| |
| LRESULT OnInternalGetBar(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/) |
| { |
| // Let's make sure we're not embedded in another process |
| if((LPVOID)wParam != NULL) |
| *((DWORD*)wParam) = GetCurrentProcessId(); |
| if(IsWindowVisible()) |
| return (LRESULT)static_cast<CCommandBarCtrlBase*>(this); |
| else |
| return NULL; |
| } |
| |
| LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/) |
| { |
| #ifndef SPI_GETKEYBOARDCUES |
| const UINT SPI_SETKEYBOARDCUES = 0x100B; |
| #endif // !SPI_GETKEYBOARDCUES |
| #ifndef SPI_GETFLATMENU |
| const UINT SPI_SETFLATMENU = 0x1023; |
| #endif // !SPI_GETFLATMENU |
| |
| if(wParam == SPI_SETNONCLIENTMETRICS || wParam == SPI_SETKEYBOARDCUES || wParam == SPI_SETFLATMENU) |
| { |
| T* pT = static_cast<T*>(this); |
| pT->GetSystemSettings(); |
| } |
| |
| return 0; |
| } |
| |
| LRESULT OnWindowPosChanging(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/) |
| { |
| LRESULT lRet = DefWindowProc(uMsg, wParam, lParam); |
| |
| LPWINDOWPOS lpWP = (LPWINDOWPOS)lParam; |
| int cyMin = ::GetSystemMetrics(SM_CYMENU); |
| if(lpWP->cy < cyMin) |
| lpWP->cy = cyMin; |
| |
| return lRet; |
| } |
| |
| LRESULT OnMenuChar(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - OnMenuChar\n")); |
| #endif |
| bHandled = TRUE; |
| T* pT = static_cast<T*>(this); |
| |
| LRESULT lRet; |
| if(m_bMenuActive && LOWORD(wParam) != 0x0D) |
| lRet = 0; |
| else |
| lRet = MAKELRESULT(1, 1); |
| |
| if(m_bMenuActive && HIWORD(wParam) == MF_POPUP) |
| { |
| // Convert character to lower/uppercase and possibly Unicode, using current keyboard layout |
| TCHAR ch = (TCHAR)LOWORD(wParam); |
| CMenuHandle menu = (HMENU)lParam; |
| int nCount = ::GetMenuItemCount(menu); |
| int nRetCode = MNC_EXECUTE; |
| BOOL bRet = FALSE; |
| TCHAR szString[pT->_nMaxMenuItemTextLength]; |
| WORD wMnem = 0; |
| bool bFound = false; |
| for(int i = 0; i < nCount; i++) |
| { |
| CMenuItemInfo mii; |
| mii.cch = pT->_nMaxMenuItemTextLength; |
| mii.fMask = MIIM_CHECKMARKS | MIIM_DATA | MIIM_ID | MIIM_STATE | MIIM_SUBMENU | MIIM_TYPE; |
| mii.dwTypeData = szString; |
| bRet = menu.GetMenuItemInfo(i, TRUE, &mii); |
| if(!bRet || (mii.fType & MFT_SEPARATOR)) |
| continue; |
| _MenuItemData* pmd = (_MenuItemData*)mii.dwItemData; |
| if(pmd != NULL && pmd->IsCmdBarMenuItem()) |
| { |
| LPTSTR p = pmd->lpstrText; |
| |
| if(p != NULL) |
| { |
| while(*p && *p != _T('&')) |
| p = ::CharNext(p); |
| if(p != NULL && *p) |
| { |
| DWORD dwP = MAKELONG(*(++p), 0); |
| DWORD dwC = MAKELONG(ch, 0); |
| if(::CharLower((LPTSTR)ULongToPtr(dwP)) == ::CharLower((LPTSTR)ULongToPtr(dwC))) |
| { |
| if(!bFound) |
| { |
| wMnem = (WORD)i; |
| bFound = true; |
| } |
| else |
| { |
| nRetCode = MNC_SELECT; |
| break; |
| } |
| } |
| } |
| } |
| } |
| } |
| if(bFound) |
| { |
| if(nRetCode == MNC_EXECUTE) |
| { |
| PostMessage(TB_SETHOTITEM, (WPARAM)-1, 0L); |
| pT->GiveFocusBack(); |
| } |
| bHandled = TRUE; |
| lRet = MAKELRESULT(wMnem, nRetCode); |
| } |
| } |
| else if(!m_bMenuActive) |
| { |
| int nBtn = 0; |
| if(!MapAccelerator((TCHAR)LOWORD(wParam), nBtn)) |
| { |
| bHandled = FALSE; |
| PostMessage(TB_SETHOTITEM, (WPARAM)-1, 0L); |
| pT->GiveFocusBack(); |
| |
| #if (_WIN32_IE >= 0x0500) |
| // check if we should display chevron menu |
| if((TCHAR)LOWORD(wParam) == pT->_chChevronShortcut) |
| { |
| if(pT->DisplayChevronMenu()) |
| bHandled = TRUE; |
| } |
| #endif // (_WIN32_IE >= 0x0500) |
| } |
| else if(m_wndParent.IsWindowEnabled()) |
| { |
| #if (_WIN32_IE >= 0x0500) |
| RECT rcClient = { 0 }; |
| GetClientRect(&rcClient); |
| RECT rcBtn = { 0 }; |
| GetItemRect(nBtn, &rcBtn); |
| TBBUTTON tbb = { 0 }; |
| GetButton(nBtn, &tbb); |
| if((tbb.fsState & TBSTATE_ENABLED) != 0 && (tbb.fsState & TBSTATE_HIDDEN) == 0 && rcBtn.right <= rcClient.right) |
| { |
| #endif // (_WIN32_IE >= 0x0500) |
| if(m_bUseKeyboardCues && !m_bShowKeyboardCues) |
| { |
| m_bAllowKeyboardCues = true; |
| ShowKeyboardCues(true); |
| } |
| pT->TakeFocus(); |
| PostMessage(WM_KEYDOWN, VK_DOWN, 0L); |
| SetHotItem(nBtn); |
| #if (_WIN32_IE >= 0x0500) |
| } |
| else |
| { |
| ::MessageBeep(0); |
| } |
| #endif // (_WIN32_IE >= 0x0500) |
| } |
| } |
| |
| return lRet; |
| } |
| |
| LRESULT OnDrawItem(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled) |
| { |
| LPDRAWITEMSTRUCT lpDrawItemStruct = (LPDRAWITEMSTRUCT)lParam; |
| _MenuItemData* pmd = (_MenuItemData*)lpDrawItemStruct->itemData; |
| if(lpDrawItemStruct->CtlType == ODT_MENU && pmd != NULL && pmd->IsCmdBarMenuItem()) |
| { |
| T* pT = static_cast<T*>(this); |
| pT->DrawItem(lpDrawItemStruct); |
| } |
| else |
| { |
| bHandled = FALSE; |
| } |
| return (LRESULT)TRUE; |
| } |
| |
| LRESULT OnMeasureItem(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled) |
| { |
| LPMEASUREITEMSTRUCT lpMeasureItemStruct = (LPMEASUREITEMSTRUCT)lParam; |
| _MenuItemData* pmd = (_MenuItemData*)lpMeasureItemStruct->itemData; |
| if(lpMeasureItemStruct->CtlType == ODT_MENU && pmd != NULL && pmd->IsCmdBarMenuItem()) |
| { |
| T* pT = static_cast<T*>(this); |
| pT->MeasureItem(lpMeasureItemStruct); |
| } |
| else |
| { |
| bHandled = FALSE; |
| } |
| return (LRESULT)TRUE; |
| } |
| |
| // API message handlers |
| LRESULT OnAPIGetMenu(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) |
| { |
| return (LRESULT)m_hMenu; |
| } |
| |
| LRESULT OnAPITrackPopupMenu(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/) |
| { |
| if(lParam == NULL) |
| return FALSE; |
| LPCBRPOPUPMENU lpCBRPopupMenu = (LPCBRPOPUPMENU)lParam; |
| if(lpCBRPopupMenu->cbSize != sizeof(CBRPOPUPMENU)) |
| return FALSE; |
| |
| T* pT = static_cast<T*>(this); |
| return pT->TrackPopupMenu(lpCBRPopupMenu->hMenu, lpCBRPopupMenu->uFlags, lpCBRPopupMenu->x, lpCBRPopupMenu->y, lpCBRPopupMenu->lptpm); |
| } |
| |
| LRESULT OnAPIGetCmdBar(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) |
| { |
| return (LRESULT)m_hWnd; |
| } |
| |
| // Parent window message handlers |
| LRESULT OnParentHotItemChange(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled) |
| { |
| LPNMTBHOTITEM lpNMHT = (LPNMTBHOTITEM)pnmh; |
| |
| // Check if this comes from us |
| if(pnmh->hwndFrom != m_hWnd) |
| { |
| bHandled = FALSE; |
| return 0; |
| } |
| |
| bool bBlockTracking = false; |
| if((m_dwExtendedStyle & CBR_EX_TRACKALWAYS) == 0) |
| { |
| DWORD dwProcessID; |
| ::GetWindowThreadProcessId(::GetActiveWindow(), &dwProcessID); |
| bBlockTracking = (::GetCurrentProcessId() != dwProcessID); |
| } |
| |
| if((!m_wndParent.IsWindowEnabled() || bBlockTracking) && (lpNMHT->dwFlags & HICF_MOUSE)) |
| { |
| return 1; |
| } |
| else |
| { |
| #ifndef HICF_LMOUSE |
| const DWORD HICF_LMOUSE = 0x00000080; // left mouse button selected |
| #endif |
| bHandled = FALSE; |
| |
| // Send WM_MENUSELECT to the app if it needs to display a status text |
| if(!(lpNMHT->dwFlags & HICF_MOUSE) |
| && !(lpNMHT->dwFlags & HICF_ACCELERATOR) |
| && !(lpNMHT->dwFlags & HICF_LMOUSE)) |
| { |
| if(lpNMHT->dwFlags & HICF_ENTERING) |
| m_wndParent.SendMessage(WM_MENUSELECT, 0, (LPARAM)m_hMenu); |
| if(lpNMHT->dwFlags & HICF_LEAVING) |
| m_wndParent.SendMessage(WM_MENUSELECT, MAKEWPARAM(0, 0xFFFF), NULL); |
| } |
| |
| return 0; |
| } |
| } |
| |
| LRESULT OnParentDropDown(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled) |
| { |
| // Check if this comes from us |
| if(pnmh->hwndFrom != m_hWnd) |
| { |
| bHandled = FALSE; |
| return 1; |
| } |
| |
| T* pT = static_cast<T*>(this); |
| if(::GetFocus() != m_hWnd) |
| pT->TakeFocus(); |
| LPNMTOOLBAR pNMToolBar = (LPNMTOOLBAR)pnmh; |
| int nIndex = CommandToIndex(pNMToolBar->iItem); |
| m_bContextMenu = false; |
| m_bEscapePressed = false; |
| pT->DoPopupMenu(nIndex, true); |
| |
| return TBDDRET_DEFAULT; |
| } |
| |
| LRESULT OnParentInitMenuPopup(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| return OnInitMenuPopup(uMsg, wParam, lParam, bHandled); |
| } |
| |
| LRESULT OnParentInternalGetBar(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| return OnInternalGetBar(uMsg, wParam, lParam, bHandled); |
| } |
| |
| LRESULT OnParentSysCommand(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| bHandled = FALSE; |
| if((m_uSysKey == VK_MENU |
| || (m_uSysKey == VK_F10 && !(::GetKeyState(VK_SHIFT) & 0x80)) |
| || m_uSysKey == VK_SPACE) |
| && wParam == SC_KEYMENU) |
| { |
| T* pT = static_cast<T*>(this); |
| if(::GetFocus() == m_hWnd) |
| { |
| pT->GiveFocusBack(); // exit menu "loop" |
| PostMessage(TB_SETHOTITEM, (WPARAM)-1, 0L); |
| } |
| else if(m_uSysKey != VK_SPACE && !m_bSkipMsg) |
| { |
| if(m_bUseKeyboardCues && !m_bShowKeyboardCues && m_bAllowKeyboardCues) |
| ShowKeyboardCues(true); |
| |
| pT->TakeFocus(); // enter menu "loop" |
| bHandled = TRUE; |
| } |
| else if(m_uSysKey != VK_SPACE) |
| { |
| bHandled = TRUE; |
| } |
| } |
| m_bSkipMsg = false; |
| return 0; |
| } |
| |
| LRESULT OnParentAPIGetMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| return OnAPIGetMenu(uMsg, wParam, lParam, bHandled); |
| } |
| |
| LRESULT OnParentMenuChar(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| return OnMenuChar(uMsg, wParam, lParam, bHandled); |
| } |
| |
| LRESULT OnParentAPITrackPopupMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| return OnAPITrackPopupMenu(uMsg, wParam, lParam, bHandled); |
| } |
| |
| LRESULT OnParentAPIGetCmdBar(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| return OnAPIGetCmdBar(uMsg, wParam, lParam, bHandled); |
| } |
| |
| LRESULT OnParentSettingChange(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| OnSettingChange(uMsg, wParam, lParam, bHandled); |
| bHandled = FALSE; |
| return 1; |
| } |
| |
| LRESULT OnParentDrawItem(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| return OnDrawItem(uMsg, wParam, lParam, bHandled); |
| } |
| |
| LRESULT OnParentMeasureItem(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| return OnMeasureItem(uMsg, wParam, lParam, bHandled); |
| } |
| |
| LRESULT OnParentActivate(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| m_bParentActive = (LOWORD(wParam) != WA_INACTIVE); |
| if(!m_bParentActive && m_bUseKeyboardCues && m_bShowKeyboardCues) |
| { |
| ShowKeyboardCues(false); // this will repaint our window |
| } |
| else |
| { |
| Invalidate(); |
| UpdateWindow(); |
| } |
| bHandled = FALSE; |
| return 1; |
| } |
| |
| LRESULT OnParentCustomDraw(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled) |
| { |
| LRESULT lRet = CDRF_DODEFAULT; |
| bHandled = FALSE; |
| if(pnmh->hwndFrom == m_hWnd) |
| { |
| LPNMTBCUSTOMDRAW lpTBCustomDraw = (LPNMTBCUSTOMDRAW)pnmh; |
| if(lpTBCustomDraw->nmcd.dwDrawStage == CDDS_PREPAINT) |
| { |
| lRet = CDRF_NOTIFYITEMDRAW; |
| bHandled = TRUE; |
| } |
| else if(lpTBCustomDraw->nmcd.dwDrawStage == CDDS_ITEMPREPAINT) |
| { |
| if(m_bFlatMenus) |
| { |
| #ifndef COLOR_MENUHILIGHT |
| const int COLOR_MENUHILIGHT = 29; |
| #endif // !COLOR_MENUHILIGHT |
| bool bDisabled = ((lpTBCustomDraw->nmcd.uItemState & CDIS_DISABLED) == CDIS_DISABLED); |
| if(!bDisabled && ((lpTBCustomDraw->nmcd.uItemState & CDIS_HOT) == CDIS_HOT || |
| (lpTBCustomDraw->nmcd.uItemState & CDIS_SELECTED) == CDIS_SELECTED)) |
| { |
| ::FillRect(lpTBCustomDraw->nmcd.hdc, &lpTBCustomDraw->nmcd.rc, ::GetSysColorBrush(COLOR_MENUHILIGHT)); |
| ::FrameRect(lpTBCustomDraw->nmcd.hdc, &lpTBCustomDraw->nmcd.rc, ::GetSysColorBrush(COLOR_HIGHLIGHT)); |
| lpTBCustomDraw->clrText = ::GetSysColor(m_bParentActive ? COLOR_HIGHLIGHTTEXT : COLOR_GRAYTEXT); |
| } |
| else if(bDisabled || !m_bParentActive) |
| { |
| lpTBCustomDraw->clrText = ::GetSysColor(COLOR_GRAYTEXT); |
| } |
| CDCHandle dc = lpTBCustomDraw->nmcd.hdc; |
| dc.SetTextColor(lpTBCustomDraw->clrText); |
| dc.SetBkMode(lpTBCustomDraw->nStringBkMode); |
| HFONT hFont = GetFont(); |
| HFONT hFontOld = NULL; |
| if(hFont != NULL) |
| hFontOld = dc.SelectFont(hFont); |
| const int cchText = 200; |
| TCHAR szText[cchText] = { 0 }; |
| TBBUTTONINFO tbbi = { 0 }; |
| tbbi.cbSize = sizeof(TBBUTTONINFO); |
| tbbi.dwMask = TBIF_TEXT; |
| tbbi.pszText = szText; |
| tbbi.cchText = cchText; |
| GetButtonInfo((int)lpTBCustomDraw->nmcd.dwItemSpec, &tbbi); |
| dc.DrawText(szText, -1, &lpTBCustomDraw->nmcd.rc, DT_SINGLELINE | DT_CENTER | DT_VCENTER | (m_bShowKeyboardCues ? 0 : DT_HIDEPREFIX)); |
| if(hFont != NULL) |
| dc.SelectFont(hFontOld); |
| lRet = CDRF_SKIPDEFAULT; |
| bHandled = TRUE; |
| } |
| else if(!m_bParentActive) |
| { |
| lpTBCustomDraw->clrText = ::GetSysColor(COLOR_GRAYTEXT); |
| bHandled = TRUE; |
| } |
| } |
| } |
| return lRet; |
| } |
| |
| // Message hook handlers |
| LRESULT OnHookMouseMove(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| static POINT s_point = { -1, -1 }; |
| DWORD dwPoint = ::GetMessagePos(); |
| POINT point = { GET_X_LPARAM(dwPoint), GET_Y_LPARAM(dwPoint) }; |
| |
| bHandled = FALSE; |
| if(m_bMenuActive) |
| { |
| if(::WindowFromPoint(point) == m_hWnd) |
| { |
| ScreenToClient(&point); |
| int nHit = HitTest(&point); |
| |
| if((point.x != s_point.x || point.y != s_point.y) && nHit >= 0 && nHit < ::GetMenuItemCount(m_hMenu) && nHit != m_nPopBtn && m_nPopBtn != -1) |
| { |
| TBBUTTON tbb = { 0 }; |
| GetButton(nHit, &tbb); |
| if((tbb.fsState & TBSTATE_ENABLED) != 0) |
| { |
| m_nNextPopBtn = nHit | 0xFFFF0000; |
| HWND hWndMenu = m_stackMenuWnd.GetCurrent(); |
| ATLASSERT(hWndMenu != NULL); |
| |
| // this one is needed to close a menu if mouse button was down |
| ::PostMessage(hWndMenu, WM_LBUTTONUP, 0, MAKELPARAM(point.x, point.y)); |
| // this one closes a popup menu |
| ::PostMessage(hWndMenu, WM_KEYDOWN, VK_ESCAPE, 0L); |
| |
| bHandled = TRUE; |
| } |
| } |
| } |
| } |
| else |
| { |
| ScreenToClient(&point); |
| } |
| |
| s_point = point; |
| return 0; |
| } |
| |
| LRESULT OnHookSysKeyDown(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| bHandled = FALSE; |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook WM_SYSKEYDOWN (0x%2.2X)\n"), wParam); |
| #endif |
| |
| if(wParam == VK_MENU && m_bParentActive && m_bUseKeyboardCues && !m_bShowKeyboardCues && m_bAllowKeyboardCues) |
| ShowKeyboardCues(true); |
| |
| if(wParam != VK_SPACE && !m_bMenuActive && ::GetFocus() == m_hWnd) |
| { |
| m_bAllowKeyboardCues = false; |
| PostMessage(TB_SETHOTITEM, (WPARAM)-1, 0L); |
| T* pT = static_cast<T*>(this); |
| pT->GiveFocusBack(); |
| m_bSkipMsg = true; |
| } |
| else |
| { |
| if(wParam == VK_SPACE && m_bUseKeyboardCues && m_bShowKeyboardCues) |
| { |
| m_bAllowKeyboardCues = true; |
| ShowKeyboardCues(false); |
| } |
| m_uSysKey = (UINT)wParam; |
| } |
| return 0; |
| } |
| |
| LRESULT OnHookSysKeyUp(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| if(!m_bAllowKeyboardCues) |
| m_bAllowKeyboardCues = true; |
| bHandled = FALSE; |
| wParam; |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook WM_SYSKEYUP (0x%2.2X)\n"), wParam); |
| #endif |
| return 0; |
| } |
| |
| LRESULT OnHookSysChar(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| bHandled = FALSE; |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook WM_SYSCHAR (0x%2.2X)\n"), wParam); |
| #endif |
| |
| if(!m_bMenuActive && m_hWndHook != m_hWnd && wParam != VK_SPACE) |
| bHandled = TRUE; |
| return 0; |
| } |
| |
| LRESULT OnHookKeyDown(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook WM_KEYDOWN (0x%2.2X)\n"), wParam); |
| #endif |
| bHandled = FALSE; |
| T* pT = static_cast<T*>(this); |
| |
| if(wParam == VK_ESCAPE && m_stackMenuWnd.GetSize() <= 1) |
| { |
| if(m_bMenuActive && !m_bContextMenu) |
| { |
| int nHot = GetHotItem(); |
| if(nHot == -1) |
| nHot = m_nPopBtn; |
| if(nHot == -1) |
| nHot = 0; |
| SetHotItem(nHot); |
| bHandled = TRUE; |
| pT->TakeFocus(); |
| m_bEscapePressed = true; // To keep focus |
| m_bSkipPostDown = false; |
| } |
| else if(::GetFocus() == m_hWnd && m_wndParent.IsWindow()) |
| { |
| SetHotItem(-1); |
| pT->GiveFocusBack(); |
| bHandled = TRUE; |
| } |
| } |
| else if(wParam == VK_RETURN || wParam == VK_UP || wParam == VK_DOWN) |
| { |
| if(!m_bMenuActive && ::GetFocus() == m_hWnd && m_wndParent.IsWindow()) |
| { |
| int nHot = GetHotItem(); |
| if(nHot != -1) |
| { |
| if(wParam != VK_RETURN) |
| { |
| if(!m_bSkipPostDown) |
| { |
| // IE4 only: WM_KEYDOWN doesn't generate TBN_DROPDOWN, we need to simulate a mouse click |
| #if (_WIN32_IE < 0x0500) |
| DWORD dwMajor = 0, dwMinor = 0; |
| ATL::AtlGetCommCtrlVersion(&dwMajor, &dwMinor); |
| if(dwMajor <= 4 || (dwMajor == 5 && dwMinor < 80)) |
| { |
| RECT rect; |
| GetItemRect(nHot, &rect); |
| PostMessage(WM_LBUTTONDOWN, MK_LBUTTON, MAKELPARAM(rect.left, rect.top)); |
| } |
| #endif // (_WIN32_IE < 0x0500) |
| PostMessage(WM_KEYDOWN, VK_DOWN, 0L); |
| m_bSkipPostDown = true; |
| } |
| else |
| { |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - skipping posting another VK_DOWN\n")); |
| m_bSkipPostDown = false; |
| } |
| } |
| } |
| else |
| { |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Can't find hot button\n")); |
| } |
| } |
| if(wParam == VK_RETURN && m_bMenuActive) |
| { |
| PostMessage(TB_SETHOTITEM, (WPARAM)-1, 0L); |
| m_nNextPopBtn = -1; |
| pT->GiveFocusBack(); |
| } |
| } |
| else if(wParam == VK_LEFT || wParam == VK_RIGHT) |
| { |
| WPARAM wpNext = m_bLayoutRTL ? VK_LEFT : VK_RIGHT; |
| WPARAM wpPrev = m_bLayoutRTL ? VK_RIGHT : VK_LEFT; |
| |
| if(m_bMenuActive && !m_bContextMenu && !(wParam == wpNext && m_bPopupItem)) |
| { |
| bool bAction = false; |
| if(wParam == wpPrev && s_pCurrentBar->m_stackMenuWnd.GetSize() == 1) |
| { |
| m_nNextPopBtn = pT->GetPreviousMenuItem(m_nPopBtn); |
| if(m_nNextPopBtn != -1) |
| bAction = true; |
| } |
| else if(wParam == wpNext) |
| { |
| m_nNextPopBtn = pT->GetNextMenuItem(m_nPopBtn); |
| if(m_nNextPopBtn != -1) |
| bAction = true; |
| } |
| HWND hWndMenu = m_stackMenuWnd.GetCurrent(); |
| ATLASSERT(hWndMenu != NULL); |
| |
| // Close the popup menu |
| if(bAction) |
| { |
| ::PostMessage(hWndMenu, WM_KEYDOWN, VK_ESCAPE, 0L); |
| if(wParam == wpNext) |
| { |
| int cItem = m_stackMenuWnd.GetSize() - 1; |
| while(cItem >= 0) |
| { |
| hWndMenu = m_stackMenuWnd[cItem]; |
| if(hWndMenu != NULL) |
| ::PostMessage(hWndMenu, WM_KEYDOWN, VK_ESCAPE, 0L); |
| cItem--; |
| } |
| } |
| #if (_WIN32_IE >= 0x0500) |
| if(m_nNextPopBtn == -2) |
| { |
| m_nNextPopBtn = -1; |
| pT->DisplayChevronMenu(); |
| } |
| #endif // (_WIN32_IE >= 0x0500) |
| bHandled = TRUE; |
| } |
| } |
| } |
| return 0; |
| } |
| |
| LRESULT OnHookNextMenu(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook WM_NEXTMENU\n")); |
| #endif |
| bHandled = FALSE; |
| return 1; |
| } |
| |
| LRESULT OnHookChar(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook WM_CHAR (0x%2.2X)\n"), wParam); |
| #endif |
| bHandled = (wParam == VK_ESCAPE); |
| return 0; |
| } |
| |
| // Implementation - ownerdraw overrideables and helpers |
| void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct) |
| { |
| T* pT = static_cast<T*>(this); |
| if(m_bFlatMenus) |
| pT->DrawItemFlat(lpDrawItemStruct); |
| else |
| pT->DrawItem3D(lpDrawItemStruct); |
| |
| } |
| |
| void DrawItem3D(LPDRAWITEMSTRUCT lpDrawItemStruct) |
| { |
| _MenuItemData* pmd = (_MenuItemData*)lpDrawItemStruct->itemData; |
| CDCHandle dc = lpDrawItemStruct->hDC; |
| const RECT& rcItem = lpDrawItemStruct->rcItem; |
| T* pT = static_cast<T*>(this); |
| |
| if(pmd->fType & MFT_SEPARATOR) |
| { |
| // draw separator |
| RECT rc = rcItem; |
| rc.top += (rc.bottom - rc.top) / 2; // vertical center |
| dc.DrawEdge(&rc, EDGE_ETCHED, BF_TOP); // draw separator line |
| } |
| else // not a separator |
| { |
| BOOL bDisabled = lpDrawItemStruct->itemState & ODS_GRAYED; |
| BOOL bSelected = lpDrawItemStruct->itemState & ODS_SELECTED; |
| BOOL bChecked = lpDrawItemStruct->itemState & ODS_CHECKED; |
| BOOL bHasImage = FALSE; |
| |
| if(LOWORD(lpDrawItemStruct->itemID) == (WORD)-1) |
| bSelected = FALSE; |
| RECT rcButn = { rcItem.left, rcItem.top, rcItem.left + m_szButton.cx, rcItem.top + m_szButton.cy }; // button rect |
| ::OffsetRect(&rcButn, 0, ((rcItem.bottom - rcItem.top) - (rcButn.bottom - rcButn.top)) / 2); // center vertically |
| |
| int iButton = pmd->iButton; |
| if(iButton >= 0) |
| { |
| bHasImage = TRUE; |
| |
| // calc drawing point |
| SIZE sz = { rcButn.right - rcButn.left - m_szBitmap.cx, rcButn.bottom - rcButn.top - m_szBitmap.cy }; |
| sz.cx /= 2; |
| sz.cy /= 2; |
| POINT point = { rcButn.left + sz.cx, rcButn.top + sz.cy }; |
| |
| // fill background depending on state |
| if(!bChecked || (bSelected && !bDisabled)) |
| { |
| if(!bDisabled) |
| dc.FillRect(&rcButn, (bChecked && !bSelected) ? COLOR_3DLIGHT : COLOR_MENU); |
| else |
| dc.FillRect(&rcButn, COLOR_MENU); |
| } |
| else |
| { |
| COLORREF crTxt = dc.SetTextColor(::GetSysColor(COLOR_BTNFACE)); |
| COLORREF crBk = dc.SetBkColor(::GetSysColor(COLOR_BTNHILIGHT)); |
| CBrush hbr(CDCHandle::GetHalftoneBrush()); |
| dc.SetBrushOrg(rcButn.left, rcButn.top); |
| dc.FillRect(&rcButn, hbr); |
| dc.SetTextColor(crTxt); |
| dc.SetBkColor(crBk); |
| } |
| |
| // draw disabled or normal |
| if(!bDisabled) |
| { |
| // draw pushed-in or popped-out edge |
| if(bSelected || bChecked) |
| { |
| RECT rc2 = rcButn; |
| dc.DrawEdge(&rc2, bChecked ? BDR_SUNKENOUTER : BDR_RAISEDINNER, BF_RECT); |
| } |
| // draw the image |
| ::ImageList_Draw(m_hImageList, iButton, dc, point.x, point.y, ILD_TRANSPARENT); |
| } |
| else |
| { |
| HBRUSH hBrushBackground = bChecked ? NULL : ::GetSysColorBrush(COLOR_MENU); |
| pT->DrawBitmapDisabled(dc, iButton, point, hBrushBackground); |
| } |
| } |
| else |
| { |
| // no image - look for custom checked/unchecked bitmaps |
| CMenuItemInfo info; |
| info.fMask = MIIM_CHECKMARKS | MIIM_TYPE; |
| ::GetMenuItemInfo((HMENU)lpDrawItemStruct->hwndItem, lpDrawItemStruct->itemID, MF_BYCOMMAND, &info); |
| if(bChecked || info.hbmpUnchecked != NULL) |
| { |
| BOOL bRadio = ((info.fType & MFT_RADIOCHECK) != 0); |
| bHasImage = pT->DrawCheckmark(dc, rcButn, bSelected, bDisabled, bRadio, bChecked ? info.hbmpChecked : info.hbmpUnchecked); |
| } |
| } |
| |
| // draw item text |
| int cxButn = m_szButton.cx; |
| COLORREF colorBG = ::GetSysColor(bSelected ? COLOR_HIGHLIGHT : COLOR_MENU); |
| if(bSelected || lpDrawItemStruct->itemAction == ODA_SELECT) |
| { |
| RECT rcBG = rcItem; |
| if(bHasImage) |
| rcBG.left += cxButn + s_kcxGap; |
| dc.FillRect(&rcBG, bSelected ? COLOR_HIGHLIGHT : COLOR_MENU); |
| } |
| |
| // calc text rectangle and colors |
| RECT rcText = rcItem; |
| rcText.left += cxButn + s_kcxGap + s_kcxTextMargin; |
| rcText.right -= cxButn; |
| dc.SetBkMode(TRANSPARENT); |
| COLORREF colorText = ::GetSysColor(bDisabled ? (bSelected ? COLOR_GRAYTEXT : COLOR_3DSHADOW) : (bSelected ? COLOR_HIGHLIGHTTEXT : COLOR_MENUTEXT)); |
| |
| // font already selected by Windows |
| if(bDisabled && (!bSelected || colorText == colorBG)) |
| { |
| // disabled - draw shadow text shifted down and right 1 pixel (unles selected) |
| RECT rcDisabled = rcText; |
| ::OffsetRect(&rcDisabled, 1, 1); |
| pT->DrawMenuText(dc, rcDisabled, pmd->lpstrText, ::GetSysColor(COLOR_3DHILIGHT)); |
| } |
| pT->DrawMenuText(dc, rcText, pmd->lpstrText, colorText); // finally! |
| } |
| } |
| |
| void DrawItemFlat(LPDRAWITEMSTRUCT lpDrawItemStruct) |
| { |
| _MenuItemData* pmd = (_MenuItemData*)lpDrawItemStruct->itemData; |
| CDCHandle dc = lpDrawItemStruct->hDC; |
| const RECT& rcItem = lpDrawItemStruct->rcItem; |
| T* pT = static_cast<T*>(this); |
| |
| #ifndef COLOR_MENUHILIGHT |
| const int COLOR_MENUHILIGHT = 29; |
| #endif // !COLOR_MENUHILIGHT |
| |
| BOOL bDisabled = lpDrawItemStruct->itemState & ODS_GRAYED; |
| BOOL bSelected = lpDrawItemStruct->itemState & ODS_SELECTED; |
| BOOL bChecked = lpDrawItemStruct->itemState & ODS_CHECKED; |
| |
| // paint background |
| if(bSelected || lpDrawItemStruct->itemAction == ODA_SELECT) |
| { |
| if(bSelected) |
| { |
| dc.FillRect(&rcItem, ::GetSysColorBrush(COLOR_MENUHILIGHT)); |
| dc.FrameRect(&rcItem, ::GetSysColorBrush(COLOR_HIGHLIGHT)); |
| } |
| else |
| { |
| dc.FillRect(&rcItem, ::GetSysColorBrush(COLOR_MENU)); |
| } |
| } |
| |
| if(pmd->fType & MFT_SEPARATOR) |
| { |
| // draw separator |
| RECT rc = rcItem; |
| rc.top += (rc.bottom - rc.top) / 2; // vertical center |
| dc.DrawEdge(&rc, EDGE_ETCHED, BF_TOP); // draw separator line |
| } |
| else // not a separator |
| { |
| if(LOWORD(lpDrawItemStruct->itemID) == (WORD)-1) |
| bSelected = FALSE; |
| RECT rcButn = { rcItem.left, rcItem.top, rcItem.left + m_szButton.cx, rcItem.top + m_szButton.cy }; // button rect |
| ::OffsetRect(&rcButn, 0, ((rcItem.bottom - rcItem.top) - (rcButn.bottom - rcButn.top)) / 2); // center vertically |
| |
| // draw background and border for checked items |
| if(bChecked) |
| { |
| RECT rcCheck = rcButn; |
| ::InflateRect(&rcCheck, -1, -1); |
| if(bSelected) |
| dc.FillRect(&rcCheck, ::GetSysColorBrush(COLOR_MENU)); |
| dc.FrameRect(&rcCheck, ::GetSysColorBrush(COLOR_HIGHLIGHT)); |
| } |
| |
| int iButton = pmd->iButton; |
| if(iButton >= 0) |
| { |
| // calc drawing point |
| SIZE sz = { rcButn.right - rcButn.left - m_szBitmap.cx, rcButn.bottom - rcButn.top - m_szBitmap.cy }; |
| sz.cx /= 2; |
| sz.cy /= 2; |
| POINT point = { rcButn.left + sz.cx, rcButn.top + sz.cy }; |
| |
| // draw disabled or normal |
| if(!bDisabled) |
| { |
| ::ImageList_Draw(m_hImageList, iButton, dc, point.x, point.y, ILD_TRANSPARENT); |
| } |
| else |
| { |
| HBRUSH hBrushBackground = ::GetSysColorBrush((bSelected && !(bDisabled && bChecked)) ? COLOR_MENUHILIGHT : COLOR_MENU); |
| HBRUSH hBrushDisabledImage = ::GetSysColorBrush(COLOR_3DSHADOW); |
| pT->DrawBitmapDisabled(dc, iButton, point, hBrushBackground, hBrushBackground, hBrushDisabledImage); |
| } |
| } |
| else |
| { |
| // no image - look for custom checked/unchecked bitmaps |
| CMenuItemInfo info; |
| info.fMask = MIIM_CHECKMARKS | MIIM_TYPE; |
| ::GetMenuItemInfo((HMENU)lpDrawItemStruct->hwndItem, lpDrawItemStruct->itemID, MF_BYCOMMAND, &info); |
| if(bChecked || info.hbmpUnchecked != NULL) |
| { |
| BOOL bRadio = ((info.fType & MFT_RADIOCHECK) != 0); |
| pT->DrawCheckmark(dc, rcButn, bSelected, bDisabled, bRadio, bChecked ? info.hbmpChecked : info.hbmpUnchecked); |
| } |
| } |
| |
| // draw item text |
| int cxButn = m_szButton.cx; |
| // calc text rectangle and colors |
| RECT rcText = rcItem; |
| rcText.left += cxButn + s_kcxGap + s_kcxTextMargin; |
| rcText.right -= cxButn; |
| dc.SetBkMode(TRANSPARENT); |
| COLORREF colorText = ::GetSysColor(bDisabled ? (bSelected ? COLOR_GRAYTEXT : COLOR_3DSHADOW) : (bSelected ? COLOR_HIGHLIGHTTEXT : COLOR_MENUTEXT)); |
| |
| pT->DrawMenuText(dc, rcText, pmd->lpstrText, colorText); // finally! |
| } |
| } |
| |
| void DrawMenuText(CDCHandle& dc, RECT& rc, LPCTSTR lpstrText, COLORREF color) |
| { |
| int nTab = -1; |
| for(int i = 0; i < lstrlen(lpstrText); i++) |
| { |
| if(lpstrText[i] == _T('\t')) |
| { |
| nTab = i; |
| break; |
| } |
| } |
| dc.SetTextColor(color); |
| dc.DrawText(lpstrText, nTab, &rc, DT_SINGLELINE | DT_LEFT | DT_VCENTER | (m_bShowKeyboardCues ? 0 : DT_HIDEPREFIX)); |
| if(nTab != -1) |
| dc.DrawText(&lpstrText[nTab + 1], -1, &rc, DT_SINGLELINE | DT_RIGHT | DT_VCENTER | (m_bShowKeyboardCues ? 0 : DT_HIDEPREFIX)); |
| } |
| |
| void DrawBitmapDisabled(CDCHandle& dc, int nImage, POINT point, |
| HBRUSH hBrushBackground = ::GetSysColorBrush(COLOR_3DFACE), |
| HBRUSH hBrush3DEffect = ::GetSysColorBrush(COLOR_3DHILIGHT), |
| HBRUSH hBrushDisabledImage = ::GetSysColorBrush(COLOR_3DSHADOW)) |
| { |
| #if (_WIN32_WINNT >= 0x0501) && (_WIN32_IE >= 0x0501) |
| if(m_bAlphaImages) |
| { |
| IMAGELISTDRAWPARAMS ildp = { 0 }; |
| ildp.cbSize = sizeof(IMAGELISTDRAWPARAMS); |
| ildp.himl = m_hImageList; |
| ildp.i = nImage; |
| ildp.hdcDst = dc; |
| ildp.x = point.x; |
| ildp.y = point.y; |
| ildp.cx = 0; |
| ildp.cy = 0; |
| ildp.xBitmap = 0; |
| ildp.yBitmap = 0; |
| ildp.fStyle = ILD_TRANSPARENT; |
| ildp.fState = ILS_SATURATE; |
| ildp.Frame = 0; |
| ::ImageList_DrawIndirect(&ildp); |
| } |
| else |
| #endif // (_WIN32_WINNT >= 0x0501) && (_WIN32_IE >= 0x0501) |
| { |
| // create memory DC |
| CDC dcMem; |
| dcMem.CreateCompatibleDC(dc); |
| // create mono or color bitmap |
| CBitmap bmp; |
| bmp.CreateCompatibleBitmap(dc, m_szBitmap.cx, m_szBitmap.cy); |
| ATLASSERT(bmp.m_hBitmap != NULL); |
| // draw image into memory DC--fill BG white first |
| HBITMAP hBmpOld = dcMem.SelectBitmap(bmp); |
| dcMem.PatBlt(0, 0, m_szBitmap.cx, m_szBitmap.cy, WHITENESS); |
| // If white is the text color, we can't use the normal painting since |
| // it would blend with the WHITENESS, but the mask is OK |
| UINT uDrawStyle = (::GetSysColor(COLOR_BTNTEXT) == RGB(255, 255, 255)) ? ILD_MASK : ILD_NORMAL; |
| ::ImageList_Draw(m_hImageList, nImage, dcMem, 0, 0, uDrawStyle); |
| dc.DitherBlt(point.x, point.y, m_szBitmap.cx, m_szBitmap.cy, dcMem, NULL, 0, 0, hBrushBackground, hBrush3DEffect, hBrushDisabledImage); |
| dcMem.SelectBitmap(hBmpOld); // restore |
| } |
| } |
| |
| // old name |
| BOOL Draw3DCheckmark(CDCHandle& dc, const RECT& rc, BOOL bSelected, BOOL bDisabled, BOOL bRadio, HBITMAP hBmpCheck) |
| { |
| return DrawCheckmark(dc, rc, bSelected, bDisabled, bRadio, hBmpCheck); |
| } |
| |
| BOOL DrawCheckmark(CDCHandle& dc, const RECT& rc, BOOL bSelected, BOOL bDisabled, BOOL bRadio, HBITMAP hBmpCheck) |
| { |
| // get checkmark bitmap, if none, use Windows standard |
| SIZE size = { 0, 0 }; |
| CBitmapHandle bmp = hBmpCheck; |
| if(hBmpCheck != NULL) |
| { |
| bmp.GetSize(size); |
| } |
| else |
| { |
| size.cx = ::GetSystemMetrics(SM_CXMENUCHECK); |
| size.cy = ::GetSystemMetrics(SM_CYMENUCHECK); |
| bmp.CreateCompatibleBitmap(dc, size.cx, size.cy); |
| ATLASSERT(bmp.m_hBitmap != NULL); |
| } |
| // center bitmap in caller's rectangle |
| RECT rcDest = rc; |
| if((rc.right - rc.left) > size.cx) |
| { |
| rcDest.left = rc.left + (rc.right - rc.left - size.cx) / 2; |
| rcDest.right = rcDest.left + size.cx; |
| } |
| if((rc.bottom - rc.top) > size.cy) |
| { |
| rcDest.top = rc.top + (rc.bottom - rc.top - size.cy) / 2; |
| rcDest.bottom = rcDest.top + size.cy; |
| } |
| // paint background |
| if(!m_bFlatMenus) |
| { |
| if(bSelected && !bDisabled) |
| { |
| dc.FillRect(&rcDest, COLOR_MENU); |
| } |
| else |
| { |
| COLORREF clrTextOld = dc.SetTextColor(::GetSysColor(COLOR_BTNFACE)); |
| COLORREF clrBkOld = dc.SetBkColor(::GetSysColor(COLOR_BTNHILIGHT)); |
| CBrush hbr(CDCHandle::GetHalftoneBrush()); |
| dc.SetBrushOrg(rcDest.left, rcDest.top); |
| dc.FillRect(&rcDest, hbr); |
| dc.SetTextColor(clrTextOld); |
| dc.SetBkColor(clrBkOld); |
| } |
| } |
| |
| // create source image |
| CDC dcSource; |
| dcSource.CreateCompatibleDC(dc); |
| HBITMAP hBmpOld = dcSource.SelectBitmap(bmp); |
| // set colors |
| const COLORREF clrBlack = RGB(0, 0, 0); |
| const COLORREF clrWhite = RGB(255, 255, 255); |
| COLORREF clrTextOld = dc.SetTextColor(clrBlack); |
| COLORREF clrBkOld = dc.SetBkColor(clrWhite); |
| // create mask |
| CDC dcMask; |
| dcMask.CreateCompatibleDC(dc); |
| CBitmap bmpMask; |
| bmpMask.CreateBitmap(size.cx, size.cy, 1, 1, NULL); |
| HBITMAP hBmpOld1 = dcMask.SelectBitmap(bmpMask); |
| |
| // draw the checkmark transparently |
| int cx = rcDest.right - rcDest.left; |
| int cy = rcDest.bottom - rcDest.top; |
| if(hBmpCheck != NULL) |
| { |
| // build mask based on transparent color |
| dcSource.SetBkColor(m_clrMask); |
| dcMask.SetBkColor(clrBlack); |
| dcMask.SetTextColor(clrWhite); |
| dcMask.BitBlt(0, 0, size.cx, size.cy, dcSource, 0, 0, SRCCOPY); |
| // draw bitmap using the mask |
| dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcSource, 0, 0, SRCINVERT); |
| dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcMask, 0, 0, SRCAND); |
| dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcSource, 0, 0, SRCINVERT); |
| } |
| else |
| { |
| const DWORD ROP_DSno = 0x00BB0226L; |
| const DWORD ROP_DSa = 0x008800C6L; |
| const DWORD ROP_DSo = 0x00EE0086L; |
| const DWORD ROP_DSna = 0x00220326L; |
| |
| // draw mask |
| RECT rcSource = { 0, 0, __min(size.cx, rc.right - rc.left), __min(size.cy, rc.bottom - rc.top) }; |
| dcMask.DrawFrameControl(&rcSource, DFC_MENU, bRadio ? DFCS_MENUBULLET : DFCS_MENUCHECK); |
| |
| // draw shadow if disabled |
| if(!m_bFlatMenus && bDisabled) |
| { |
| // offset by one pixel |
| int x = rcDest.left + 1; |
| int y = rcDest.top + 1; |
| // paint source bitmap |
| const int nColor = COLOR_3DHILIGHT; |
| dcSource.FillRect(&rcSource, nColor); |
| // draw checkmark - special case black and white colors |
| COLORREF clrCheck = ::GetSysColor(nColor); |
| if(clrCheck == clrWhite) |
| { |
| dc.BitBlt(x, y, cx, cy, dcMask, 0, 0, ROP_DSno); |
| dc.BitBlt(x, y, cx, cy, dcSource, 0, 0, ROP_DSa); |
| } |
| else |
| { |
| if(clrCheck != clrBlack) |
| { |
| ATLASSERT(dcSource.GetTextColor() == clrBlack); |
| ATLASSERT(dcSource.GetBkColor() == clrWhite); |
| dcSource.BitBlt(0, 0, size.cx, size.cy, dcMask, 0, 0, ROP_DSna); |
| } |
| dc.BitBlt(x, y, cx, cy, dcMask, 0, 0, ROP_DSa); |
| dc.BitBlt(x, y, cx, cy, dcSource, 0, 0, ROP_DSo); |
| } |
| } |
| |
| // paint source bitmap |
| const int nColor = bDisabled ? COLOR_BTNSHADOW : COLOR_MENUTEXT; |
| dcSource.FillRect(&rcSource, nColor); |
| // draw checkmark - special case black and white colors |
| COLORREF clrCheck = ::GetSysColor(nColor); |
| if(clrCheck == clrWhite) |
| { |
| dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcMask, 0, 0, ROP_DSno); |
| dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcSource, 0, 0, ROP_DSa); |
| } |
| else |
| { |
| if(clrCheck != clrBlack) |
| { |
| ATLASSERT(dcSource.GetTextColor() == clrBlack); |
| ATLASSERT(dcSource.GetBkColor() == clrWhite); |
| dcSource.BitBlt(0, 0, size.cx, size.cy, dcMask, 0, 0, ROP_DSna); |
| } |
| dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcMask, 0, 0, ROP_DSa); |
| dc.BitBlt(rcDest.left, rcDest.top, cx, cy, dcSource, 0, 0, ROP_DSo); |
| } |
| } |
| // restore all |
| dc.SetTextColor(clrTextOld); |
| dc.SetBkColor(clrBkOld); |
| dcSource.SelectBitmap(hBmpOld); |
| dcMask.SelectBitmap(hBmpOld1); |
| if(hBmpCheck == NULL) |
| bmp.DeleteObject(); |
| // draw pushed-in hilight |
| if(!m_bFlatMenus && !bDisabled) |
| { |
| if(rc.right - rc.left > size.cx) |
| ::InflateRect(&rcDest, 1,1); // inflate checkmark by one pixel all around |
| dc.DrawEdge(&rcDest, BDR_SUNKENOUTER, BF_RECT); |
| } |
| |
| return TRUE; |
| } |
| |
| void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct) |
| { |
| _MenuItemData* pmd = (_MenuItemData*)lpMeasureItemStruct->itemData; |
| |
| if(pmd->fType & MFT_SEPARATOR) // separator - use half system height and zero width |
| { |
| lpMeasureItemStruct->itemHeight = ::GetSystemMetrics(SM_CYMENU) / 2; |
| lpMeasureItemStruct->itemWidth = 0; |
| } |
| else |
| { |
| // compute size of text - use DrawText with DT_CALCRECT |
| CWindowDC dc(NULL); |
| CFont fontBold; |
| HFONT hOldFont = NULL; |
| if(pmd->fState & MFS_DEFAULT) |
| { |
| // need bold version of font |
| LOGFONT lf = { 0 }; |
| m_fontMenu.GetLogFont(lf); |
| lf.lfWeight += 200; |
| fontBold.CreateFontIndirect(&lf); |
| ATLASSERT(fontBold.m_hFont != NULL); |
| hOldFont = dc.SelectFont(fontBold); |
| } |
| else |
| { |
| hOldFont = dc.SelectFont(m_fontMenu); |
| } |
| |
| RECT rcText = { 0, 0, 0, 0 }; |
| dc.DrawText(pmd->lpstrText, -1, &rcText, DT_SINGLELINE | DT_LEFT | DT_VCENTER | DT_CALCRECT); |
| int cx = rcText.right - rcText.left; |
| dc.SelectFont(hOldFont); |
| |
| LOGFONT lf = { 0 }; |
| m_fontMenu.GetLogFont(lf); |
| int cy = lf.lfHeight; |
| if(cy < 0) |
| cy = -cy; |
| const int cyMargin = 8; |
| cy += cyMargin; |
| |
| // height of item is the bigger of these two |
| lpMeasureItemStruct->itemHeight = __max(cy, (int)m_szButton.cy); |
| |
| // width is width of text plus a bunch of stuff |
| cx += 2 * s_kcxTextMargin; // L/R margin for readability |
| cx += s_kcxGap; // space between button and menu text |
| cx += 2 * m_szButton.cx; // button width (L=button; R=empty margin) |
| cx += m_cxExtraSpacing; // extra between item text and accelerator keys |
| |
| // Windows adds 1 to returned value |
| cx -= ::GetSystemMetrics(SM_CXMENUCHECK) - 1; |
| lpMeasureItemStruct->itemWidth = cx; // done deal |
| } |
| } |
| |
| // Implementation - Hook procs |
| static LRESULT CALLBACK CreateHookProc(int nCode, WPARAM wParam, LPARAM lParam) |
| { |
| const int cchClassName = 7; |
| TCHAR szClassName[cchClassName] = { 0 }; |
| |
| if(nCode == HCBT_CREATEWND) |
| { |
| HWND hWndMenu = (HWND)wParam; |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - HCBT_CREATEWND (HWND = %8.8X)\n"), hWndMenu); |
| #endif |
| |
| ::GetClassName(hWndMenu, szClassName, cchClassName); |
| if(!lstrcmp(_T("#32768"), szClassName)) |
| s_pCurrentBar->m_stackMenuWnd.Push(hWndMenu); |
| } |
| else if(nCode == HCBT_DESTROYWND) |
| { |
| HWND hWndMenu = (HWND)wParam; |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - HCBT_DESTROYWND (HWND = %8.8X)\n"), hWndMenu); |
| #endif |
| |
| ::GetClassName(hWndMenu, szClassName, cchClassName); |
| if(!lstrcmp(_T("#32768"), szClassName)) |
| { |
| ATLASSERT(hWndMenu == s_pCurrentBar->m_stackMenuWnd.GetCurrent()); |
| s_pCurrentBar->m_stackMenuWnd.Pop(); |
| } |
| } |
| |
| return ::CallNextHookEx(s_hCreateHook, nCode, wParam, lParam); |
| } |
| |
| static LRESULT CALLBACK MessageHookProc(int nCode, WPARAM wParam, LPARAM lParam) |
| { |
| LPMSG pMsg = (LPMSG)lParam; |
| |
| if(nCode == HC_ACTION && wParam == PM_REMOVE && pMsg->message != GetGetBarMessage() && pMsg->message != WM_FORWARDMSG) |
| { |
| CCommandBarCtrlBase* pCmdBar = NULL; |
| HWND hWnd = pMsg->hwnd; |
| DWORD dwPID = 0; |
| while(pCmdBar == NULL && hWnd != NULL) |
| { |
| pCmdBar = (CCommandBarCtrlBase*)::SendMessage(hWnd, GetGetBarMessage(), (WPARAM)&dwPID, 0L); |
| hWnd = ::GetParent(hWnd); |
| } |
| |
| if(pCmdBar != NULL && dwPID == GetCurrentProcessId()) |
| { |
| pCmdBar->m_hWndHook = pMsg->hwnd; |
| ATLASSERT(pCmdBar->IsCommandBarBase()); |
| |
| if(::IsWindow(pCmdBar->m_hWnd)) |
| pCmdBar->SendMessage(WM_FORWARDMSG, 0, (LPARAM)pMsg); |
| else |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - Hook skipping message, can't find command bar!\n")); |
| } |
| } |
| |
| LRESULT lRet = 0; |
| ATLASSERT(s_pmapMsgHook != NULL); |
| if(s_pmapMsgHook != NULL) |
| { |
| DWORD dwThreadID = ::GetCurrentThreadId(); |
| _MsgHookData* pData = s_pmapMsgHook->Lookup(dwThreadID); |
| if(pData != NULL) |
| { |
| lRet = ::CallNextHookEx(pData->hMsgHook, nCode, wParam, lParam); |
| } |
| } |
| return lRet; |
| } |
| |
| // Implementation |
| void DoPopupMenu(int nIndex, bool bAnimate) |
| { |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - DoPopupMenu, bAnimate = %s\n"), bAnimate ? "true" : "false"); |
| #endif |
| |
| // Menu animation flags |
| #ifndef TPM_VERPOSANIMATION |
| const UINT TPM_VERPOSANIMATION = 0x1000L; |
| #endif |
| #ifndef TPM_NOANIMATION |
| const UINT TPM_NOANIMATION = 0x4000L; |
| #endif |
| T* pT = static_cast<T*>(this); |
| |
| // get popup menu and it's position |
| RECT rect = { 0 }; |
| GetItemRect(nIndex, &rect); |
| POINT pt = { rect.left, rect.bottom }; |
| MapWindowPoints(NULL, &pt, 1); |
| MapWindowPoints(NULL, &rect); |
| TPMPARAMS TPMParams = { 0 }; |
| TPMParams.cbSize = sizeof(TPMPARAMS); |
| TPMParams.rcExclude = rect; |
| HMENU hMenuPopup = ::GetSubMenu(m_hMenu, nIndex); |
| ATLASSERT(hMenuPopup != NULL); |
| |
| // get button ID |
| TBBUTTON tbb = { 0 }; |
| GetButton(nIndex, &tbb); |
| int nCmdID = tbb.idCommand; |
| |
| m_nPopBtn = nIndex; // remember current button's index |
| |
| // press button and display popup menu |
| PressButton(nCmdID, TRUE); |
| SetHotItem(nCmdID); |
| pT->DoTrackPopupMenu(hMenuPopup, TPM_LEFTBUTTON | TPM_VERTICAL | TPM_LEFTALIGN | TPM_TOPALIGN | |
| (s_bW2K ? (bAnimate ? TPM_VERPOSANIMATION : TPM_NOANIMATION) : 0), pt.x, pt.y, &TPMParams); |
| PressButton(nCmdID, FALSE); |
| if(::GetFocus() != m_hWnd) |
| SetHotItem(-1); |
| |
| m_nPopBtn = -1; // restore |
| |
| // eat next message if click is on the same button |
| MSG msg = { 0 }; |
| if(::PeekMessage(&msg, m_hWnd, WM_LBUTTONDOWN, WM_LBUTTONDOWN, PM_NOREMOVE) && ::PtInRect(&rect, msg.pt)) |
| ::PeekMessage(&msg, m_hWnd, WM_LBUTTONDOWN, WM_LBUTTONDOWN, PM_REMOVE); |
| |
| // check if another popup menu should be displayed |
| if(m_nNextPopBtn != -1) |
| { |
| PostMessage(GetAutoPopupMessage(), m_nNextPopBtn & 0xFFFF); |
| if(!(m_nNextPopBtn & 0xFFFF0000) && !m_bPopupItem) |
| PostMessage(WM_KEYDOWN, VK_DOWN, 0); |
| m_nNextPopBtn = -1; |
| } |
| else |
| { |
| m_bContextMenu = false; |
| // If user didn't hit escape, give focus back |
| if(!m_bEscapePressed) |
| { |
| if(m_bUseKeyboardCues && m_bShowKeyboardCues) |
| m_bAllowKeyboardCues = false; |
| pT->GiveFocusBack(); |
| } |
| else |
| { |
| SetHotItem(nCmdID); |
| SetAnchorHighlight(TRUE); |
| } |
| } |
| } |
| |
| BOOL DoTrackPopupMenu(HMENU hMenu, UINT uFlags, int x, int y, LPTPMPARAMS lpParams = NULL) |
| { |
| CMenuHandle menuPopup = hMenu; |
| |
| CWindowCreateCriticalSectionLock lock; |
| if(FAILED(lock.Lock())) |
| { |
| ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CCommandBarCtrlImpl::DoTrackPopupMenu.\n")); |
| ATLASSERT(FALSE); |
| return FALSE; |
| } |
| |
| ATLASSERT(s_hCreateHook == NULL); |
| |
| s_pCurrentBar = static_cast<CCommandBarCtrlBase*>(this); |
| |
| s_hCreateHook = ::SetWindowsHookEx(WH_CBT, CreateHookProc, ModuleHelper::GetModuleInstance(), GetCurrentThreadId()); |
| ATLASSERT(s_hCreateHook != NULL); |
| |
| m_bPopupItem = false; |
| m_bMenuActive = true; |
| |
| BOOL bTrackRet = menuPopup.TrackPopupMenuEx(uFlags, x, y, m_hWnd, lpParams); |
| m_bMenuActive = false; |
| |
| ::UnhookWindowsHookEx(s_hCreateHook); |
| |
| s_hCreateHook = NULL; |
| s_pCurrentBar = NULL; |
| |
| lock.Unlock(); |
| |
| // cleanup - convert menus back to original state |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - TrackPopupMenu - cleanup\n")); |
| #endif |
| |
| ATLASSERT(m_stackMenuWnd.GetSize() == 0); |
| |
| UpdateWindow(); |
| ATL::CWindow wndTL = GetTopLevelParent(); |
| wndTL.UpdateWindow(); |
| |
| // restore the menu items to the previous state for all menus that were converted |
| if(m_bImagesVisible) |
| { |
| HMENU hMenuSav = NULL; |
| while((hMenuSav = m_stackMenuHandle.Pop()) != NULL) |
| { |
| menuPopup = hMenuSav; |
| BOOL bRet = FALSE; |
| // restore state and delete menu item data |
| for(int i = 0; i < menuPopup.GetMenuItemCount(); i++) |
| { |
| CMenuItemInfo mii; |
| mii.fMask = MIIM_DATA | MIIM_TYPE | MIIM_ID; |
| bRet = menuPopup.GetMenuItemInfo(i, TRUE, &mii); |
| ATLASSERT(bRet); |
| |
| _MenuItemData* pMI = (_MenuItemData*)mii.dwItemData; |
| if(pMI != NULL && pMI->IsCmdBarMenuItem()) |
| { |
| mii.fMask = MIIM_DATA | MIIM_TYPE | MIIM_STATE; |
| mii.fType = pMI->fType; |
| mii.fState = pMI->fState; |
| mii.dwTypeData = pMI->lpstrText; |
| mii.cch = lstrlen(pMI->lpstrText); |
| mii.dwItemData = NULL; |
| |
| bRet = menuPopup.SetMenuItemInfo(i, TRUE, &mii); |
| // this one triggers WM_MEASUREITEM |
| menuPopup.ModifyMenu(i, MF_BYPOSITION | mii.fType | mii.fState, mii.wID, pMI->lpstrText); |
| ATLASSERT(bRet); |
| |
| delete [] pMI->lpstrText; |
| delete pMI; |
| } |
| } |
| } |
| } |
| return bTrackRet; |
| } |
| |
| int GetPreviousMenuItem(int nBtn) const |
| { |
| if(nBtn == -1) |
| return -1; |
| #if (_WIN32_IE >= 0x0500) |
| RECT rcClient; |
| GetClientRect(&rcClient); |
| #endif // (_WIN32_IE >= 0x0500) |
| int nNextBtn; |
| for(nNextBtn = nBtn - 1; nNextBtn != nBtn; nNextBtn--) |
| { |
| if(nNextBtn < 0) |
| nNextBtn = ::GetMenuItemCount(m_hMenu) - 1; |
| TBBUTTON tbb = { 0 }; |
| GetButton(nNextBtn, &tbb); |
| #if (_WIN32_IE >= 0x0500) |
| RECT rcBtn; |
| GetItemRect(nNextBtn, &rcBtn); |
| if(rcBtn.right > rcClient.right) |
| { |
| nNextBtn = -2; // chevron |
| break; |
| } |
| #endif // (_WIN32_IE >= 0x0500) |
| if((tbb.fsState & TBSTATE_ENABLED) != 0 && (tbb.fsState & TBSTATE_HIDDEN) == 0) |
| break; |
| } |
| return (nNextBtn != nBtn) ? nNextBtn : -1; |
| } |
| |
| int GetNextMenuItem(int nBtn) const |
| { |
| if(nBtn == -1) |
| return -1; |
| #if (_WIN32_IE >= 0x0500) |
| RECT rcClient = { 0 }; |
| GetClientRect(&rcClient); |
| #endif // (_WIN32_IE >= 0x0500) |
| int nNextBtn = 0; |
| int nCount = ::GetMenuItemCount(m_hMenu); |
| for(nNextBtn = nBtn + 1; nNextBtn != nBtn; nNextBtn++) |
| { |
| if(nNextBtn >= nCount) |
| nNextBtn = 0; |
| TBBUTTON tbb = { 0 }; |
| GetButton(nNextBtn, &tbb); |
| #if (_WIN32_IE >= 0x0500) |
| RECT rcBtn = { 0 }; |
| GetItemRect(nNextBtn, &rcBtn); |
| if(rcBtn.right > rcClient.right) |
| { |
| nNextBtn = -2; // chevron |
| break; |
| } |
| #endif // (_WIN32_IE >= 0x0500) |
| if((tbb.fsState & TBSTATE_ENABLED) != 0 && (tbb.fsState & TBSTATE_HIDDEN) == 0) |
| break; |
| } |
| return (nNextBtn != nBtn) ? nNextBtn : -1; |
| } |
| |
| #if (_WIN32_IE >= 0x0500) |
| bool DisplayChevronMenu() |
| { |
| // assume we are in a rebar |
| HWND hWndReBar = GetParent(); |
| int nCount = (int)::SendMessage(hWndReBar, RB_GETBANDCOUNT, 0, 0L); |
| bool bRet = false; |
| for(int i = 0; i < nCount; i++) |
| { |
| REBARBANDINFO rbbi = { RunTimeHelper::SizeOf_REBARBANDINFO(), RBBIM_CHILD | RBBIM_STYLE }; |
| BOOL bRetBandInfo = (BOOL)::SendMessage(hWndReBar, RB_GETBANDINFO, i, (LPARAM)&rbbi); |
| if(bRetBandInfo && rbbi.hwndChild == m_hWnd) |
| { |
| if((rbbi.fStyle & RBBS_USECHEVRON) != 0) |
| { |
| ::PostMessage(hWndReBar, RB_PUSHCHEVRON, i, 0L); |
| PostMessage(WM_KEYDOWN, VK_DOWN, 0L); |
| bRet = true; |
| } |
| break; |
| } |
| } |
| return bRet; |
| } |
| #endif // (_WIN32_IE >= 0x0500) |
| |
| void GetSystemSettings() |
| { |
| // refresh our font |
| NONCLIENTMETRICS info = { RunTimeHelper::SizeOf_NONCLIENTMETRICS() }; |
| BOOL bRet = ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(info), &info, 0); |
| ATLASSERT(bRet); |
| if(bRet) |
| { |
| LOGFONT logfont = { 0 }; |
| if(m_fontMenu.m_hFont != NULL) |
| m_fontMenu.GetLogFont(logfont); |
| if(logfont.lfHeight != info.lfMenuFont.lfHeight || |
| logfont.lfWidth != info.lfMenuFont.lfWidth || |
| logfont.lfEscapement != info.lfMenuFont.lfEscapement || |
| logfont.lfOrientation != info.lfMenuFont.lfOrientation || |
| logfont.lfWeight != info.lfMenuFont.lfWeight || |
| logfont.lfItalic != info.lfMenuFont.lfItalic || |
| logfont.lfUnderline != info.lfMenuFont.lfUnderline || |
| logfont.lfStrikeOut != info.lfMenuFont.lfStrikeOut || |
| logfont.lfCharSet != info.lfMenuFont.lfCharSet || |
| logfont.lfOutPrecision != info.lfMenuFont.lfOutPrecision || |
| logfont.lfClipPrecision != info.lfMenuFont.lfClipPrecision || |
| logfont.lfQuality != info.lfMenuFont.lfQuality || |
| logfont.lfPitchAndFamily != info.lfMenuFont.lfPitchAndFamily || |
| lstrcmp(logfont.lfFaceName, info.lfMenuFont.lfFaceName) != 0) |
| { |
| HFONT hFontMenu = ::CreateFontIndirect(&info.lfMenuFont); |
| ATLASSERT(hFontMenu != NULL); |
| if(hFontMenu != NULL) |
| { |
| if(m_fontMenu.m_hFont != NULL) |
| m_fontMenu.DeleteObject(); |
| m_fontMenu.Attach(hFontMenu); |
| SetFont(m_fontMenu); |
| AddStrings(_T("NS\0")); // for proper item height |
| AutoSize(); |
| } |
| } |
| } |
| |
| // check if we need extra spacing for menu item text |
| CWindowDC dc(m_hWnd); |
| HFONT hFontOld = dc.SelectFont(m_fontMenu); |
| RECT rcText = { 0, 0, 0, 0 }; |
| dc.DrawText(_T("\t"), -1, &rcText, DT_SINGLELINE | DT_LEFT | DT_VCENTER | DT_CALCRECT); |
| if((rcText.right - rcText.left) < 4) |
| { |
| ::SetRectEmpty(&rcText); |
| dc.DrawText(_T("x"), -1, &rcText, DT_SINGLELINE | DT_LEFT | DT_VCENTER | DT_CALCRECT); |
| m_cxExtraSpacing = rcText.right - rcText.left; |
| } |
| else |
| { |
| m_cxExtraSpacing = 0; |
| } |
| dc.SelectFont(hFontOld); |
| |
| // get Windows version |
| OSVERSIONINFO ovi = { sizeof(OSVERSIONINFO) }; |
| ::GetVersionEx(&ovi); |
| |
| // query keyboard cues mode (Windows 2000 or later) |
| if(ovi.dwMajorVersion >= 5) |
| { |
| #ifndef SPI_GETKEYBOARDCUES |
| const UINT SPI_GETKEYBOARDCUES = 0x100A; |
| #endif // !SPI_GETKEYBOARDCUES |
| BOOL bRetVal = TRUE; |
| bRet = ::SystemParametersInfo(SPI_GETKEYBOARDCUES, 0, &bRetVal, 0); |
| m_bUseKeyboardCues = (bRet && !bRetVal); |
| m_bAllowKeyboardCues = true; |
| ShowKeyboardCues(!m_bUseKeyboardCues); |
| } |
| |
| // query flat menu mode (Windows XP or later) |
| if((ovi.dwMajorVersion == 5 && ovi.dwMinorVersion >= 1) || (ovi.dwMajorVersion > 5)) |
| { |
| #ifndef SPI_GETFLATMENU |
| const UINT SPI_GETFLATMENU = 0x1022; |
| #endif // !SPI_GETFLATMENU |
| BOOL bRetVal = FALSE; |
| bRet = ::SystemParametersInfo(SPI_GETFLATMENU, 0, &bRetVal, 0); |
| m_bFlatMenus = (bRet && bRetVal); |
| } |
| |
| #if _WTL_CMDBAR_VISTA_MENUS |
| // check if we should use Vista menus |
| bool bVistaMenus = (RunTimeHelper::IsVista() && RunTimeHelper::IsCommCtrl6() && ((m_dwExtendedStyle & CBR_EX_NOVISTAMENUS) == 0)); |
| |
| if(bVistaMenus) |
| { |
| HMODULE hThemeDLL = ::LoadLibrary(_T("uxtheme.dll")); |
| if(hThemeDLL != NULL) |
| { |
| typedef BOOL (STDAPICALLTYPE *PFN_IsThemeActive)(); |
| PFN_IsThemeActive pfnIsThemeActive = (PFN_IsThemeActive)::GetProcAddress(hThemeDLL, "IsThemeActive"); |
| ATLASSERT(pfnIsThemeActive != NULL); |
| bVistaMenus = bVistaMenus && (pfnIsThemeActive != NULL) && (pfnIsThemeActive() != FALSE); |
| |
| typedef BOOL (STDAPICALLTYPE *PFN_IsAppThemed)(); |
| PFN_IsAppThemed pfnIsAppThemed = (PFN_IsAppThemed)::GetProcAddress(hThemeDLL, "IsAppThemed"); |
| ATLASSERT(pfnIsAppThemed != NULL); |
| bVistaMenus = bVistaMenus && (pfnIsAppThemed != NULL) && (pfnIsAppThemed() != FALSE); |
| |
| ::FreeLibrary(hThemeDLL); |
| } |
| } |
| |
| if(!bVistaMenus && m_bVistaMenus && (m_hMenu != NULL) && (m_arrCommand.GetSize() > 0)) |
| { |
| T* pT = static_cast<T*>(this); |
| pT->_RemoveVistaBitmapsFromMenu(); |
| } |
| |
| m_bVistaMenus = bVistaMenus; |
| #endif // _WTL_CMDBAR_VISTA_MENUS |
| |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("CmdBar - GetSystemSettings:\n m_bFlatMenus = %s\n m_bUseKeyboardCues = %s m_bVistaMenus = %s\n"), |
| m_bFlatMenus ? "true" : "false", m_bUseKeyboardCues ? "true" : "false", m_bVistaMenus ? "true" : "false"); |
| #endif |
| } |
| |
| // Implementation - alternate focus mode support |
| void TakeFocus() |
| { |
| if((m_dwExtendedStyle & CBR_EX_ALTFOCUSMODE) && m_hWndFocus == NULL) |
| m_hWndFocus = ::GetFocus(); |
| SetFocus(); |
| } |
| |
| void GiveFocusBack() |
| { |
| if(m_bParentActive) |
| { |
| if((m_dwExtendedStyle & CBR_EX_ALTFOCUSMODE) && ::IsWindow(m_hWndFocus)) |
| ::SetFocus(m_hWndFocus); |
| else if(!(m_dwExtendedStyle & CBR_EX_ALTFOCUSMODE) && m_wndParent.IsWindow()) |
| m_wndParent.SetFocus(); |
| } |
| m_hWndFocus = NULL; |
| SetAnchorHighlight(FALSE); |
| if(m_bUseKeyboardCues && m_bShowKeyboardCues) |
| ShowKeyboardCues(false); |
| m_bSkipPostDown = false; |
| } |
| |
| void ShowKeyboardCues(bool bShow) |
| { |
| m_bShowKeyboardCues = bShow; |
| SetDrawTextFlags(DT_HIDEPREFIX, m_bShowKeyboardCues ? 0 : DT_HIDEPREFIX); |
| Invalidate(); |
| UpdateWindow(); |
| } |
| |
| // Implementation - internal message helpers |
| static UINT GetAutoPopupMessage() |
| { |
| static UINT uAutoPopupMessage = 0; |
| if(uAutoPopupMessage == 0) |
| { |
| CStaticDataInitCriticalSectionLock lock; |
| if(FAILED(lock.Lock())) |
| { |
| ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CCommandBarCtrlImpl::GetAutoPopupMessage.\n")); |
| ATLASSERT(FALSE); |
| return 0; |
| } |
| |
| if(uAutoPopupMessage == 0) |
| uAutoPopupMessage = ::RegisterWindowMessage(_T("WTL_CmdBar_InternalAutoPopupMsg")); |
| |
| lock.Unlock(); |
| } |
| ATLASSERT(uAutoPopupMessage != 0); |
| return uAutoPopupMessage; |
| } |
| |
| static UINT GetGetBarMessage() |
| { |
| static UINT uGetBarMessage = 0; |
| if(uGetBarMessage == 0) |
| { |
| CStaticDataInitCriticalSectionLock lock; |
| if(FAILED(lock.Lock())) |
| { |
| ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CCommandBarCtrlImpl::GetGetBarMessage.\n")); |
| ATLASSERT(FALSE); |
| return 0; |
| } |
| |
| if(uGetBarMessage == 0) |
| uGetBarMessage = ::RegisterWindowMessage(_T("WTL_CmdBar_InternalGetBarMsg")); |
| |
| lock.Unlock(); |
| } |
| ATLASSERT(uGetBarMessage != 0); |
| return uGetBarMessage; |
| } |
| |
| // Implementation |
| bool CreateInternalImageList(int cImages) |
| { |
| UINT uFlags = (m_bAlphaImages ? ILC_COLOR32 : ILC_COLOR24) | ILC_MASK; |
| m_hImageList = ::ImageList_Create(m_szBitmap.cx, m_szBitmap.cy, uFlags, cImages, 1); |
| ATLASSERT(m_hImageList != NULL); |
| return (m_hImageList != NULL); |
| } |
| |
| // Implementation - support for Vista menus |
| #if _WTL_CMDBAR_VISTA_MENUS |
| void _AddVistaBitmapsFromImageList(int nStartIndex, int nCount) |
| { |
| // Create display compatible memory DC |
| HDC hDC = ::GetDC(NULL); |
| CDC dcMem; |
| dcMem.CreateCompatibleDC(hDC); |
| HBITMAP hBitmapSave = dcMem.GetCurrentBitmap(); |
| |
| T* pT = static_cast<T*>(this); |
| // Create bitmaps for all menu items |
| for(int i = 0; i < nCount; i++) |
| { |
| HBITMAP hBitmap = pT->_CreateVistaBitmapHelper(nStartIndex + i, hDC, dcMem); |
| dcMem.SelectBitmap(hBitmapSave); |
| m_arrVistaBitmap.Add(hBitmap); |
| } |
| } |
| |
| void _AddVistaBitmapFromImageList(int nIndex) |
| { |
| // Create display compatible memory DC |
| HDC hDC = ::GetDC(NULL); |
| CDC dcMem; |
| dcMem.CreateCompatibleDC(hDC); |
| HBITMAP hBitmapSave = dcMem.GetCurrentBitmap(); |
| |
| // Create bitmap for menu item |
| T* pT = static_cast<T*>(this); |
| HBITMAP hBitmap = pT->_CreateVistaBitmapHelper(nIndex, hDC, dcMem); |
| |
| // Select saved bitmap back and add bitmap to the array |
| dcMem.SelectBitmap(hBitmapSave); |
| m_arrVistaBitmap.Add(hBitmap); |
| } |
| |
| void _ReplaceVistaBitmapFromImageList(int nIndex) |
| { |
| // Delete existing bitmap |
| if(m_arrVistaBitmap[nIndex] != NULL) |
| ::DeleteObject(m_arrVistaBitmap[nIndex]); |
| |
| // Create display compatible memory DC |
| HDC hDC = ::GetDC(NULL); |
| CDC dcMem; |
| dcMem.CreateCompatibleDC(hDC); |
| HBITMAP hBitmapSave = dcMem.GetCurrentBitmap(); |
| |
| // Create bitmap for menu item |
| T* pT = static_cast<T*>(this); |
| HBITMAP hBitmap = pT->_CreateVistaBitmapHelper(nIndex, hDC, dcMem); |
| |
| // Select saved bitmap back and replace bitmap in the array |
| dcMem.SelectBitmap(hBitmapSave); |
| m_arrVistaBitmap.SetAtIndex(nIndex, hBitmap); |
| } |
| |
| HBITMAP _CreateVistaBitmapHelper(int nIndex, HDC hDCSource, HDC hDCTarget) |
| { |
| // Create 32-bit bitmap |
| BITMAPINFO bi = { 0 }; |
| bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); |
| bi.bmiHeader.biWidth = m_szBitmap.cx; |
| bi.bmiHeader.biHeight = m_szBitmap.cy; |
| bi.bmiHeader.biPlanes = 1; |
| bi.bmiHeader.biBitCount = 32; |
| bi.bmiHeader.biCompression = BI_RGB; |
| bi.bmiHeader.biSizeImage = 0; |
| bi.bmiHeader.biXPelsPerMeter = 0; |
| bi.bmiHeader.biYPelsPerMeter = 0; |
| bi.bmiHeader.biClrUsed = 0; |
| bi.bmiHeader.biClrImportant = 0; |
| HBITMAP hBitmap = ::CreateDIBSection(hDCSource, &bi, DIB_RGB_COLORS, NULL, NULL, 0); |
| ATLASSERT(hBitmap != NULL); |
| |
| // Select bitmap into target DC and draw from image list to it |
| if(hBitmap != NULL) |
| { |
| ::SelectObject(hDCTarget, hBitmap); |
| |
| IMAGELISTDRAWPARAMS ildp = { 0 }; |
| ildp.cbSize = sizeof(IMAGELISTDRAWPARAMS); |
| ildp.himl = m_hImageList; |
| ildp.i = nIndex; |
| ildp.hdcDst = hDCTarget; |
| ildp.x = 0; |
| ildp.y = 0; |
| ildp.cx = 0; |
| ildp.cy = 0; |
| ildp.xBitmap = 0; |
| ildp.yBitmap = 0; |
| ildp.fStyle = ILD_TRANSPARENT; |
| ildp.fState = ILS_ALPHA; |
| ildp.Frame = 255; |
| ::ImageList_DrawIndirect(&ildp); |
| } |
| |
| return hBitmap; |
| } |
| |
| void _RemoveVistaBitmapsFromMenu() |
| { |
| CMenuHandle menu = m_hMenu; |
| for(int i = 0; i < m_arrCommand.GetSize(); i++) |
| { |
| CMenuItemInfo mii; |
| mii.fMask = MIIM_BITMAP; |
| mii.hbmpItem = NULL; |
| menu.SetMenuItemInfo(m_arrCommand[i], FALSE, &mii); |
| } |
| } |
| #endif // _WTL_CMDBAR_VISTA_MENUS |
| }; |
| |
| |
| class CCommandBarCtrl : public CCommandBarCtrlImpl<CCommandBarCtrl> |
| { |
| public: |
| DECLARE_WND_SUPERCLASS(_T("WTL_CommandBar"), GetWndClassName()) |
| }; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CMDICommandBarCtrl - ATL implementation of Command Bars for MDI apps |
| |
| template <class T, class TBase = CCommandBarCtrlBase, class TWinTraits = ATL::CControlWinTraits> |
| class ATL_NO_VTABLE CMDICommandBarCtrlImpl : public CCommandBarCtrlImpl< T, TBase, TWinTraits> |
| { |
| public: |
| // Data members |
| ATL::CContainedWindow m_wndMDIClient; |
| bool m_bChildMaximized; |
| HWND m_hWndChildMaximized; |
| HICON m_hIconChildMaximized; |
| int m_nBtnPressed; |
| int m_nBtnWasPressed; |
| |
| int m_cxyOffset; // offset between nonclient elements |
| int m_cxIconWidth; // small icon width |
| int m_cyIconHeight; // small icon height |
| int m_cxBtnWidth; // nonclient button width |
| int m_cyBtnHeight; // nonclient button height |
| int m_cxLeft; // left nonclient area width |
| int m_cxRight; // right nonclient area width |
| |
| // Theme declarations and data members |
| #ifndef _WTL_NO_AUTO_THEME |
| #ifndef _UXTHEME_H_ |
| typedef HANDLE HTHEME; |
| #endif // !_UXTHEME_H_ |
| typedef HTHEME (STDAPICALLTYPE *PFN_OpenThemeData)(HWND hwnd, LPCWSTR pszClassList); |
| typedef HRESULT (STDAPICALLTYPE *PFN_CloseThemeData)(HTHEME hTheme); |
| typedef HRESULT (STDAPICALLTYPE *PFN_DrawThemeBackground)(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, OPTIONAL const RECT *pClipRect); |
| typedef HRESULT (STDAPICALLTYPE *PFN_DrawThemeParentBackground)(HWND hwnd, HDC hdc, OPTIONAL RECT* prc); |
| |
| HMODULE m_hThemeDLL; |
| HTHEME m_hTheme; |
| PFN_DrawThemeBackground m_pfnDrawThemeBackground; |
| PFN_DrawThemeParentBackground m_pfnDrawThemeParentBackground; |
| #endif // !_WTL_NO_AUTO_THEME |
| |
| // Constructor/destructor |
| CMDICommandBarCtrlImpl() : |
| m_wndMDIClient(this, 2), m_bChildMaximized(false), |
| m_hWndChildMaximized(NULL), m_hIconChildMaximized(NULL), |
| m_nBtnPressed(-1), m_nBtnWasPressed(-1), |
| #ifndef _WTL_NO_AUTO_THEME |
| m_hThemeDLL(NULL), m_hTheme(NULL), m_pfnDrawThemeBackground(NULL), m_pfnDrawThemeParentBackground(NULL), |
| #endif // !_WTL_NO_AUTO_THEME |
| m_cxyOffset(2), |
| m_cxIconWidth(16), m_cyIconHeight(16), |
| m_cxBtnWidth(16), m_cyBtnHeight(14), |
| m_cxLeft(20), m_cxRight(55) |
| { } |
| |
| ~CMDICommandBarCtrlImpl() |
| { |
| if(m_wndMDIClient.IsWindow()) |
| /*scary!*/ m_wndMDIClient.UnsubclassWindow(); |
| } |
| |
| // Operations |
| BOOL SetMDIClient(HWND hWndMDIClient) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(::IsWindow(hWndMDIClient)); |
| if(!::IsWindow(hWndMDIClient)) |
| return FALSE; |
| |
| #ifdef _DEBUG |
| // BLOCK: Test if the passed window is MDICLIENT |
| { |
| LPCTSTR lpszMDIClientClass = _T("MDICLIENT"); |
| const int nNameLen = 9 + 1; // "MDICLIENT" + NULL |
| TCHAR szClassName[nNameLen] = { 0 }; |
| ::GetClassName(hWndMDIClient, szClassName, nNameLen); |
| ATLASSERT(lstrcmpi(szClassName, lpszMDIClientClass) == 0); |
| } |
| #endif // _DEBUG |
| |
| if(m_wndMDIClient.IsWindow()) |
| /*scary!*/ m_wndMDIClient.UnsubclassWindow(); |
| |
| return m_wndMDIClient.SubclassWindow(hWndMDIClient); |
| } |
| |
| // Message maps |
| typedef CCommandBarCtrlImpl< T, TBase, TWinTraits > _baseClass; |
| BEGIN_MSG_MAP(CMDICommandBarCtrlImpl) |
| MESSAGE_HANDLER(WM_CREATE, OnCreate) |
| MESSAGE_HANDLER(WM_DESTROY, OnDestroy) |
| #ifndef _WTL_NO_AUTO_THEME |
| MESSAGE_HANDLER(_GetThemeChangedMsg(), OnThemeChanged) |
| #endif // !_WTL_NO_AUTO_THEME |
| MESSAGE_HANDLER(WM_SIZE, OnSize) |
| MESSAGE_HANDLER(WM_NCCALCSIZE, OnNcCalcSize) |
| MESSAGE_HANDLER(WM_NCPAINT, OnNcPaint) |
| MESSAGE_HANDLER(WM_NCHITTEST, OnNcHitTest) |
| MESSAGE_HANDLER(WM_NCLBUTTONDOWN, OnNcLButtonDown) |
| MESSAGE_HANDLER(WM_MOUSEMOVE, OnMouseMove) |
| MESSAGE_HANDLER(WM_LBUTTONUP, OnLButtonUp) |
| MESSAGE_HANDLER(WM_NCLBUTTONDBLCLK, OnNcLButtonDblClk) |
| MESSAGE_HANDLER(WM_CAPTURECHANGED, OnCaptureChanged) |
| CHAIN_MSG_MAP(_baseClass) |
| ALT_MSG_MAP(1) // Parent window messages |
| MESSAGE_HANDLER(WM_ACTIVATE, OnParentActivate) |
| CHAIN_MSG_MAP_ALT(_baseClass, 1) |
| ALT_MSG_MAP(2) // MDI client window messages |
| MESSAGE_HANDLER(WM_MDISETMENU, OnMDISetMenu) |
| // no chaining needed since this was moved from the base class here |
| ALT_MSG_MAP(3) // Message hook messages |
| MESSAGE_RANGE_HANDLER(0, 0xFFFF, OnAllHookMessages) |
| CHAIN_MSG_MAP_ALT(_baseClass, 3) |
| END_MSG_MAP() |
| |
| // Additional MDI message handlers |
| LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| LRESULT lRet = _baseClass::OnCreate(uMsg, wParam, lParam, bHandled); |
| if(lRet == (LRESULT)-1) |
| return lRet; |
| |
| #ifndef _WTL_NO_AUTO_THEME |
| // this will fail if theming is not supported |
| m_hThemeDLL = ::LoadLibrary(_T("uxtheme.dll")); |
| if(m_hThemeDLL != NULL) |
| { |
| m_pfnDrawThemeBackground = (PFN_DrawThemeBackground)::GetProcAddress(m_hThemeDLL, "DrawThemeBackground"); |
| ATLASSERT(m_pfnDrawThemeBackground != NULL); |
| if(m_pfnDrawThemeBackground != NULL) |
| { |
| T* pT = static_cast<T*>(this); |
| pT->_OpenThemeData(); |
| } |
| else |
| { |
| ::FreeLibrary(m_hThemeDLL); |
| m_hThemeDLL = NULL; |
| } |
| m_pfnDrawThemeParentBackground = (PFN_DrawThemeParentBackground)::GetProcAddress(m_hThemeDLL, "DrawThemeParentBackground"); |
| ATLASSERT(m_pfnDrawThemeParentBackground != NULL); |
| } |
| #endif // !_WTL_NO_AUTO_THEME |
| |
| return lRet; |
| } |
| |
| LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| LRESULT lRet = _baseClass::OnDestroy(uMsg, wParam, lParam, bHandled); |
| |
| #ifndef _WTL_NO_AUTO_THEME |
| if(m_hThemeDLL != NULL) |
| { |
| T* pT = static_cast<T*>(this); |
| pT->_CloseThemeData(); |
| ::FreeLibrary(m_hThemeDLL); |
| m_hThemeDLL = NULL; |
| } |
| #endif // !_WTL_NO_AUTO_THEME |
| |
| return lRet; |
| } |
| |
| #ifndef _WTL_NO_AUTO_THEME |
| LRESULT OnThemeChanged(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) |
| { |
| if(m_hThemeDLL != NULL) |
| { |
| T* pT = static_cast<T*>(this); |
| pT->_CloseThemeData(); |
| pT->_OpenThemeData(); |
| } |
| return 0; |
| } |
| #endif // !_WTL_NO_AUTO_THEME |
| |
| LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/) |
| { |
| LRESULT lRet = DefWindowProc(uMsg, wParam, lParam); |
| T* pT = static_cast<T*>(this); |
| pT->_AdjustBtnSize(GET_Y_LPARAM(lParam)); |
| return lRet; |
| } |
| |
| LRESULT OnNcCalcSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/) |
| { |
| LRESULT lRet = DefWindowProc(uMsg, wParam, lParam); |
| |
| if(m_bChildMaximized && (BOOL)wParam) |
| { |
| LPNCCALCSIZE_PARAMS lpParams = (LPNCCALCSIZE_PARAMS)lParam; |
| if(m_bLayoutRTL) |
| { |
| lpParams->rgrc[0].left += m_cxRight; |
| lpParams->rgrc[0].right -= m_cxLeft; |
| } |
| else |
| { |
| lpParams->rgrc[0].left += m_cxLeft; |
| lpParams->rgrc[0].right -= m_cxRight; |
| } |
| } |
| |
| return lRet; |
| } |
| |
| LRESULT OnNcPaint(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/) |
| { |
| LRESULT lRet = DefWindowProc(uMsg, wParam, lParam); |
| |
| if(!m_bChildMaximized) |
| return lRet; |
| |
| ATLASSERT(m_hWndChildMaximized != NULL && m_hIconChildMaximized != NULL); |
| |
| // get DC and window rectangle |
| CWindowDC dc(m_hWnd); |
| RECT rect; |
| GetWindowRect(&rect); |
| int cxWidth = rect.right - rect.left; |
| int cyHeight = rect.bottom - rect.top; |
| |
| // paint left side nonclient background and draw icon |
| ::SetRect(&rect, 0, 0, m_cxLeft, cyHeight); |
| #ifndef _WTL_NO_AUTO_THEME |
| if(m_hTheme != NULL) |
| { |
| if(m_pfnDrawThemeParentBackground != NULL) |
| m_pfnDrawThemeParentBackground(m_hWnd, dc, &rect); |
| else |
| dc.FillRect(&rect, COLOR_WINDOW); |
| } |
| else |
| #endif // !_WTL_NO_AUTO_THEME |
| { |
| if((m_dwExtendedStyle & CBR_EX_TRANSPARENT) != 0) |
| dc.FillRect(&rect, COLOR_3DFACE); |
| else |
| dc.FillRect(&rect, COLOR_MENU); |
| } |
| |
| RECT rcIcon = { 0 }; |
| T* pT = static_cast<T*>(this); |
| pT->_CalcIconRect(cxWidth, cyHeight, rcIcon); |
| dc.DrawIconEx(rcIcon.left, rcIcon.top, m_hIconChildMaximized, m_cxIconWidth, m_cyIconHeight); |
| |
| // paint right side nonclient background |
| ::SetRect(&rect, cxWidth - m_cxRight, 0, cxWidth, cyHeight); |
| #ifndef _WTL_NO_AUTO_THEME |
| if(m_hTheme != NULL) |
| { |
| if(m_pfnDrawThemeParentBackground != NULL) |
| { |
| // this is to account for the left non-client area |
| POINT ptOrg = { 0, 0 }; |
| dc.GetViewportOrg(&ptOrg); |
| dc.SetViewportOrg(ptOrg.x + m_cxLeft, ptOrg.y); |
| ::OffsetRect(&rect, -m_cxLeft, 0); |
| |
| m_pfnDrawThemeParentBackground(m_hWnd, dc, &rect); |
| |
| // restore |
| dc.SetViewportOrg(ptOrg); |
| ::OffsetRect(&rect, m_cxLeft, 0); |
| } |
| else |
| { |
| dc.FillRect(&rect, COLOR_3DFACE); |
| } |
| } |
| else |
| #endif // !_WTL_NO_AUTO_THEME |
| { |
| if((m_dwExtendedStyle & CBR_EX_TRANSPARENT) != 0) |
| dc.FillRect(&rect, COLOR_3DFACE); |
| else |
| dc.FillRect(&rect, COLOR_MENU); |
| } |
| |
| // draw buttons |
| RECT arrRect[3] = { 0 }; |
| pT->_CalcBtnRects(cxWidth, cyHeight, arrRect); |
| pT->_DrawMDIButton(dc, arrRect, -1); // draw all buttons |
| |
| return lRet; |
| } |
| |
| LRESULT OnNcHitTest(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/) |
| { |
| LRESULT lRet = DefWindowProc(uMsg, wParam, lParam); |
| if(m_bChildMaximized) |
| { |
| RECT rect = { 0 }; |
| GetWindowRect(&rect); |
| POINT pt = { GET_X_LPARAM(lParam) - rect.left, GET_Y_LPARAM(lParam) - rect.top }; |
| if(m_bLayoutRTL) |
| { |
| if((pt.x < m_cxRight) || (pt.x > ((rect.right - rect.left) - m_cxLeft))) |
| lRet = HTBORDER; |
| } |
| else |
| { |
| if((pt.x < m_cxLeft) || (pt.x > ((rect.right - rect.left) - m_cxRight))) |
| lRet = HTBORDER; |
| } |
| } |
| return lRet; |
| } |
| |
| LRESULT OnNcLButtonDown(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled) |
| { |
| if(!m_bChildMaximized) |
| { |
| bHandled = FALSE; |
| return 1; |
| } |
| |
| ATLASSERT(_DebugCheckChild()); |
| |
| POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) }; |
| RECT rect = { 0 }; |
| GetWindowRect(&rect); |
| pt.x -= rect.left; |
| pt.y -= rect.top; |
| |
| RECT rcIcon = { 0 }; |
| T* pT = static_cast<T*>(this); |
| pT->_CalcIconRect(rect.right - rect.left, rect.bottom - rect.top, rcIcon, m_bLayoutRTL); |
| RECT arrRect[3] = { 0 }; |
| pT->_CalcBtnRects(rect.right - rect.left, rect.bottom - rect.top, arrRect, m_bLayoutRTL); |
| |
| if(::PtInRect(&rcIcon, pt)) |
| { |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButtonDown: icon\n")); |
| #endif |
| #ifndef TPM_VERPOSANIMATION |
| const UINT TPM_VERPOSANIMATION = 0x1000L; // Menu animation flag |
| #endif |
| CMenuHandle menu = ::GetSystemMenu(m_hWndChildMaximized, FALSE); |
| UINT uRet = (UINT)menu.TrackPopupMenu(TPM_LEFTBUTTON | TPM_VERTICAL | TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RETURNCMD | |
| (s_bW2K ? TPM_VERPOSANIMATION : 0), m_bLayoutRTL ? rect.right : rect.left, rect.bottom, m_hWndChildMaximized); |
| |
| // eat next message if click is on the same button |
| ::OffsetRect(&rcIcon, rect.left, rect.top); |
| MSG msg = { 0 }; |
| if(::PeekMessage(&msg, m_hWnd, WM_NCLBUTTONDOWN, WM_NCLBUTTONDOWN, PM_NOREMOVE) && ::PtInRect(&rcIcon, msg.pt)) |
| ::PeekMessage(&msg, m_hWnd, WM_NCLBUTTONDOWN, WM_NCLBUTTONDOWN, PM_REMOVE); |
| |
| if(uRet != 0) |
| ::SendMessage(m_hWndChildMaximized, WM_SYSCOMMAND, uRet, 0L); |
| } |
| else if(::PtInRect(&arrRect[0], pt)) |
| { |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButtonDown: close button\n")); |
| #endif |
| m_nBtnWasPressed = m_nBtnPressed = 0; |
| } |
| else if(::PtInRect(&arrRect[1], pt)) |
| { |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButtonDown: restore button\n")); |
| #endif |
| m_nBtnWasPressed = m_nBtnPressed = 1; |
| } |
| else if(::PtInRect(&arrRect[2], pt)) |
| { |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButtonDown: minimize button\n")); |
| #endif |
| m_nBtnWasPressed = m_nBtnPressed = 2; |
| } |
| else |
| { |
| bHandled = FALSE; |
| } |
| |
| // draw the button state if it was pressed |
| if(m_nBtnPressed != -1) |
| { |
| SetCapture(); |
| CWindowDC dc(m_hWnd); |
| pT->_CalcBtnRects(rect.right - rect.left, rect.bottom - rect.top, arrRect); |
| pT->_DrawMDIButton(dc, arrRect, m_nBtnPressed); |
| } |
| |
| return 0; |
| } |
| |
| LRESULT OnMouseMove(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled) |
| { |
| if(!m_bChildMaximized || ::GetCapture() != m_hWnd || m_nBtnWasPressed == -1) |
| { |
| bHandled = FALSE; |
| return 1; |
| } |
| |
| POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) }; |
| ClientToScreen(&pt); |
| RECT rect = { 0 }; |
| GetWindowRect(&rect); |
| pt.x -= rect.left; |
| pt.y -= rect.top; |
| RECT arrRect[3] = { 0 }; |
| T* pT = static_cast<T*>(this); |
| pT->_CalcBtnRects(rect.right - rect.left, rect.bottom - rect.top, arrRect, m_bLayoutRTL); |
| int nOldBtnPressed = m_nBtnPressed; |
| m_nBtnPressed = ::PtInRect(&arrRect[m_nBtnWasPressed], pt) ? m_nBtnWasPressed : -1; |
| if(nOldBtnPressed != m_nBtnPressed) |
| { |
| CWindowDC dc(m_hWnd); |
| pT->_CalcBtnRects(rect.right - rect.left, rect.bottom - rect.top, arrRect); |
| pT->_DrawMDIButton(dc, arrRect, (m_nBtnPressed != -1) ? m_nBtnPressed : nOldBtnPressed); |
| } |
| |
| return 0; |
| } |
| |
| LRESULT OnLButtonUp(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled) |
| { |
| if(!m_bChildMaximized || ::GetCapture() != m_hWnd || m_nBtnWasPressed == -1) |
| { |
| bHandled = FALSE; |
| return 1; |
| } |
| |
| ATLASSERT(_DebugCheckChild()); |
| |
| POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) }; |
| ClientToScreen(&pt); |
| RECT rect = { 0 }; |
| GetWindowRect(&rect); |
| pt.x -= rect.left; |
| pt.y -= rect.top; |
| |
| int nBtn = m_nBtnWasPressed; |
| ReleaseCapture(); |
| |
| RECT arrRect[3] = { 0 }; |
| T* pT = static_cast<T*>(this); |
| pT->_CalcBtnRects(rect.right - rect.left, rect.bottom - rect.top, arrRect, m_bLayoutRTL); |
| if(::PtInRect(&arrRect[nBtn], pt)) |
| { |
| switch(nBtn) |
| { |
| case 0: // close |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButtonUp: close button\n")); |
| #endif |
| ::SendMessage(m_hWndChildMaximized, WM_SYSCOMMAND, SC_CLOSE, 0L); |
| break; |
| case 1: // restore |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButtonUp: restore button\n")); |
| #endif |
| ::SendMessage(m_hWndChildMaximized, WM_SYSCOMMAND, SC_RESTORE, 0L); |
| break; |
| case 2: // minimize |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - LButtonUp: minimize button\n")); |
| #endif |
| ::SendMessage(m_hWndChildMaximized, WM_SYSCOMMAND, SC_MINIMIZE, 0L); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| return 0; |
| } |
| |
| LRESULT OnNcLButtonDblClk(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled) |
| { |
| if(!m_bChildMaximized || m_nBtnWasPressed != -1) |
| { |
| bHandled = FALSE; |
| return 1; |
| } |
| |
| ATLASSERT(_DebugCheckChild()); |
| |
| POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) }; |
| RECT rect = { 0 }; |
| GetWindowRect(&rect); |
| pt.x -= rect.left; |
| pt.y -= rect.top; |
| |
| RECT rcIcon = { 0 }; |
| T* pT = static_cast<T*>(this); |
| pT->_CalcIconRect(rect.right - rect.left, rect.bottom - rect.top, rcIcon, m_bLayoutRTL); |
| RECT arrRect[3] = { 0 }; |
| pT->_CalcBtnRects(rect.right - rect.left, rect.bottom - rect.top, arrRect, m_bLayoutRTL); |
| |
| if(::PtInRect(&rcIcon, pt)) |
| { |
| CMenuHandle menu = ::GetSystemMenu(m_hWndChildMaximized, FALSE); |
| UINT uDefID = menu.GetMenuDefaultItem(); |
| if(uDefID == (UINT)-1) |
| uDefID = SC_CLOSE; |
| ::SendMessage(m_hWndChildMaximized, WM_SYSCOMMAND, uDefID, 0L); |
| } |
| |
| return 0; |
| } |
| |
| LRESULT OnCaptureChanged(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| if(m_bChildMaximized) |
| { |
| if(m_nBtnPressed != -1) |
| { |
| ATLASSERT(m_nBtnPressed == m_nBtnWasPressed); // must be |
| m_nBtnPressed = -1; |
| RECT rect = { 0 }; |
| GetWindowRect(&rect); |
| RECT arrRect[3] = { 0 }; |
| T* pT = static_cast<T*>(this); |
| pT->_CalcBtnRects(rect.right - rect.left, rect.bottom - rect.top, arrRect); |
| CWindowDC dc(m_hWnd); |
| pT->_DrawMDIButton(dc, arrRect, m_nBtnWasPressed); |
| } |
| m_nBtnWasPressed = -1; |
| } |
| else |
| { |
| bHandled = FALSE; |
| } |
| return 0; |
| } |
| |
| // Parent window message handlers |
| LRESULT OnParentActivate(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| m_bParentActive = (LOWORD(wParam) != WA_INACTIVE); |
| RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_UPDATENOW); |
| bHandled = FALSE; |
| return 1; |
| } |
| |
| // MDI client window message handlers |
| LRESULT OnMDISetMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/) |
| { |
| m_wndMDIClient.DefWindowProc(uMsg, NULL, lParam); |
| HMENU hOldMenu = GetMenu(); |
| BOOL bRet = AttachMenu((HMENU)wParam); |
| bRet; // avoid level 4 warning |
| ATLASSERT(bRet); |
| |
| #if (_WIN32_IE >= 0x0400) |
| T* pT = static_cast<T*>(this); |
| pT->UpdateRebarBandIdealSize(); |
| #endif // (_WIN32_IE >= 0x0400) |
| |
| return (LRESULT)hOldMenu; |
| } |
| |
| // All messages from the message hook |
| LRESULT OnAllHookMessages(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| T* pT = static_cast<T*>(this); |
| pT->_ProcessAllHookMessages(uMsg, wParam, lParam); |
| |
| bHandled = FALSE; |
| return 1; |
| } |
| |
| // Overrideables |
| // override this to provide different ideal size |
| void UpdateRebarBandIdealSize() |
| { |
| // assuming we are in a rebar, change ideal size to our size |
| // we hope that if we are not in a rebar, nCount will be 0 |
| int nCount = (int)::SendMessage(GetParent(), RB_GETBANDCOUNT, 0, 0L); |
| for(int i = 0; i < nCount; i++) |
| { |
| REBARBANDINFO rbi = { RunTimeHelper::SizeOf_REBARBANDINFO(), RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_IDEALSIZE }; |
| ::SendMessage(GetParent(), RB_GETBANDINFO, i, (LPARAM)&rbi); |
| if(rbi.hwndChild == m_hWnd) |
| { |
| rbi.fMask = RBBIM_IDEALSIZE; |
| rbi.cxIdeal = m_bChildMaximized ? m_cxLeft + m_cxRight : 0; |
| int nBtnCount = GetButtonCount(); |
| if(nBtnCount > 0) |
| { |
| RECT rect = { 0 }; |
| GetItemRect(nBtnCount - 1, &rect); |
| rbi.cxIdeal += rect.right; |
| } |
| ::SendMessage(GetParent(), RB_SETBANDINFO, i, (LPARAM)&rbi); |
| break; |
| } |
| } |
| } |
| |
| // all hook messages - check for the maximized MDI child window change |
| void _ProcessAllHookMessages(UINT uMsg, WPARAM /*wParam*/, LPARAM /*lParam*/) |
| { |
| if(uMsg == WM_MDIGETACTIVE || uMsg == WM_MDISETMENU) |
| return; |
| |
| BOOL bMaximized = FALSE; |
| HWND hWndChild = (HWND)::SendMessage(m_wndMDIClient, WM_MDIGETACTIVE, 0, (LPARAM)&bMaximized); |
| bool bMaxOld = m_bChildMaximized; |
| m_bChildMaximized = (hWndChild != NULL && bMaximized); |
| HICON hIconOld = m_hIconChildMaximized; |
| |
| if(m_bChildMaximized) |
| { |
| if(m_hWndChildMaximized != hWndChild) |
| { |
| ATL::CWindow wnd = m_hWndChildMaximized = hWndChild; |
| m_hIconChildMaximized = wnd.GetIcon(FALSE); |
| if(m_hIconChildMaximized == NULL) |
| { |
| m_hIconChildMaximized = wnd.GetIcon(TRUE); |
| if(m_hIconChildMaximized == NULL) |
| { |
| // no icon set with WM_SETICON, get the class one |
| // need conditional code because types don't match in winuser.h |
| #ifdef _WIN64 |
| m_hIconChildMaximized = (HICON)::GetClassLongPtr(wnd, GCLP_HICONSM); |
| #else |
| m_hIconChildMaximized = (HICON)LongToHandle(::GetClassLongPtr(wnd, GCLP_HICONSM)); |
| #endif |
| } |
| } |
| } |
| } |
| else |
| { |
| m_hWndChildMaximized = NULL; |
| m_hIconChildMaximized = NULL; |
| } |
| |
| if(bMaxOld != m_bChildMaximized) |
| { |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - All messages hook change: m_bChildMaximized = %s\n"), m_bChildMaximized ? "true" : "false"); |
| #endif |
| // assuming we are in a rebar, change our size to accomodate new state |
| // we hope that if we are not in a rebar, nCount will be 0 |
| int nCount = (int)::SendMessage(GetParent(), RB_GETBANDCOUNT, 0, 0L); |
| int cxDiff = (m_bChildMaximized ? 1 : -1) * (m_cxLeft + m_cxRight); |
| for(int i = 0; i < nCount; i++) |
| { |
| #if (_WIN32_IE >= 0x0500) |
| REBARBANDINFO rbi = { RunTimeHelper::SizeOf_REBARBANDINFO(), RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_IDEALSIZE | RBBIM_STYLE }; |
| ::SendMessage(GetParent(), RB_GETBANDINFO, i, (LPARAM)&rbi); |
| if(rbi.hwndChild == m_hWnd) |
| { |
| if((rbi.fStyle & RBBS_USECHEVRON) != 0) |
| { |
| rbi.fMask = RBBIM_CHILDSIZE | RBBIM_IDEALSIZE; |
| rbi.cxMinChild += cxDiff; |
| rbi.cxIdeal += cxDiff; |
| ::SendMessage(GetParent(), RB_SETBANDINFO, i, (LPARAM)&rbi); |
| } |
| break; |
| } |
| #elif (_WIN32_IE >= 0x0400) |
| REBARBANDINFO rbi = { RunTimeHelper::SizeOf_REBARBANDINFO(), RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_IDEALSIZE }; |
| ::SendMessage(GetParent(), RB_GETBANDINFO, i, (LPARAM)&rbi); |
| if(rbi.hwndChild == m_hWnd) |
| { |
| rbi.fMask = RBBIM_CHILDSIZE | RBBIM_IDEALSIZE; |
| rbi.cxMinChild += cxDiff; |
| rbi.cxIdeal += cxDiff; |
| ::SendMessage(GetParent(), RB_SETBANDINFO, i, (LPARAM)&rbi); |
| break; |
| } |
| #else // (_WIN32_IE < 0x0400) |
| REBARBANDINFO rbi = { RunTimeHelper::SizeOf_REBARBANDINFO(), RBBIM_CHILD | RBBIM_CHILDSIZE }; |
| ::SendMessage(GetParent(), RB_GETBANDINFO, i, (LPARAM)&rbi); |
| if(rbi.hwndChild == m_hWnd) |
| { |
| rbi.fMask = RBBIM_CHILDSIZE; |
| rbi.cxMinChild += cxDiff; |
| ::SendMessage(GetParent(), RB_SETBANDINFO, i, (LPARAM)&rbi); |
| break; |
| } |
| #endif // (_WIN32_IE < 0x0400) |
| } |
| } |
| |
| if(bMaxOld != m_bChildMaximized || hIconOld != m_hIconChildMaximized) |
| { |
| // force size change and redraw everything |
| RECT rect = { 0 }; |
| GetWindowRect(&rect); |
| ::MapWindowPoints(NULL, GetParent(), (LPPOINT)&rect, 2); |
| SetRedraw(FALSE); |
| SetWindowPos(NULL, 0, 0, 1, 1, SWP_NOZORDER | SWP_NOMOVE); |
| SetWindowPos(NULL, &rect, SWP_NOZORDER | SWP_NOMOVE); |
| SetRedraw(TRUE); |
| RedrawWindow(NULL, NULL, RDW_FRAME | RDW_INVALIDATE | RDW_UPDATENOW); |
| } |
| } |
| |
| // Implementation |
| void GetSystemSettings() |
| { |
| #ifdef _CMDBAR_EXTRA_TRACE |
| ATLTRACE2(atlTraceUI, 0, _T("MDI CmdBar - GetSystemSettings\n")); |
| #endif |
| _baseClass::GetSystemSettings(); |
| |
| NONCLIENTMETRICS info = { RunTimeHelper::SizeOf_NONCLIENTMETRICS() }; |
| BOOL bRet = ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(info), &info, 0); |
| ATLASSERT(bRet); |
| if(bRet) |
| { |
| m_cxIconWidth = ::GetSystemMetrics(SM_CXSMICON); |
| m_cyIconHeight = ::GetSystemMetrics(SM_CYSMICON); |
| m_cxLeft = m_cxIconWidth; |
| |
| #ifndef _WTL_NO_AUTO_THEME |
| if(m_hTheme != NULL) |
| { |
| m_cxBtnWidth = info.iCaptionWidth - 2 * m_cxyOffset; |
| m_cyBtnHeight = info.iCaptionHeight - 2 * m_cxyOffset; |
| m_cxRight = 3 * m_cxBtnWidth; |
| } |
| else |
| #endif // !_WTL_NO_AUTO_THEME |
| { |
| m_cxBtnWidth = info.iCaptionWidth - m_cxyOffset; |
| m_cyBtnHeight = info.iCaptionHeight - 2 * m_cxyOffset; |
| m_cxRight = 3 * m_cxBtnWidth + m_cxyOffset; |
| } |
| } |
| |
| RECT rect = { 0 }; |
| GetClientRect(&rect); |
| T* pT = static_cast<T*>(this); |
| pT->_AdjustBtnSize(rect.bottom); |
| } |
| |
| void _AdjustBtnSize(int cyHeight) |
| { |
| if(cyHeight > 1 && m_cyBtnHeight > cyHeight) |
| { |
| #ifndef _WTL_NO_AUTO_THEME |
| if(m_hTheme != NULL) |
| { |
| m_cyBtnHeight = cyHeight; |
| m_cxBtnWidth = cyHeight; |
| m_cxRight = 3 * m_cxBtnWidth; |
| } |
| else |
| #endif // !_WTL_NO_AUTO_THEME |
| { |
| m_cyBtnHeight = cyHeight; |
| m_cxBtnWidth = cyHeight + m_cxyOffset; |
| m_cxRight = 3 * m_cxBtnWidth + m_cxyOffset; |
| } |
| } |
| } |
| |
| void _CalcIconRect(int cxWidth, int cyHeight, RECT& rect, bool bInvertX = false) const |
| { |
| int xStart = (m_cxLeft - m_cxIconWidth) / 2; |
| if(xStart < 0) |
| xStart = 0; |
| int yStart = (cyHeight - m_cyIconHeight) / 2; |
| if(yStart < 0) |
| yStart = 0; |
| |
| if(bInvertX) |
| ::SetRect(&rect, cxWidth - (xStart + m_cxBtnWidth), yStart, cxWidth - xStart, yStart + m_cyBtnHeight); |
| else |
| ::SetRect(&rect, xStart, yStart, xStart + m_cxBtnWidth, yStart + m_cyBtnHeight); |
| } |
| |
| void _CalcBtnRects(int cxWidth, int cyHeight, RECT arrRect[3], bool bInvertX = false) const |
| { |
| int yStart = (cyHeight - m_cyBtnHeight) / 2; |
| if(yStart < 0) |
| yStart = 0; |
| |
| RECT rcBtn = { cxWidth - m_cxBtnWidth, yStart, cxWidth, yStart + m_cyBtnHeight }; |
| int nDirection = -1; |
| if(bInvertX) |
| { |
| ::SetRect(&rcBtn, 0, yStart, m_cxBtnWidth, yStart + m_cyBtnHeight); |
| nDirection = 1; |
| } |
| |
| arrRect[0] = rcBtn; |
| #ifndef _WTL_NO_AUTO_THEME |
| if(m_hTheme != NULL) |
| ::OffsetRect(&rcBtn, nDirection * m_cxBtnWidth, 0); |
| else |
| #endif // !_WTL_NO_AUTO_THEME |
| ::OffsetRect(&rcBtn, nDirection * (m_cxBtnWidth + m_cxyOffset), 0); |
| arrRect[1] = rcBtn; |
| ::OffsetRect(&rcBtn, nDirection * m_cxBtnWidth, 0); |
| arrRect[2] = rcBtn; |
| } |
| |
| void _DrawMDIButton(CWindowDC& dc, LPRECT pRects, int nBtn) |
| { |
| #ifndef _WTL_NO_AUTO_THEME |
| if(m_hTheme != NULL) |
| { |
| #ifndef TMSCHEMA_H |
| const int WP_MDICLOSEBUTTON = 20; |
| const int CBS_NORMAL = 1; |
| const int CBS_PUSHED = 3; |
| const int CBS_DISABLED = 4; |
| const int WP_MDIRESTOREBUTTON = 22; |
| const int RBS_NORMAL = 1; |
| const int RBS_PUSHED = 3; |
| const int RBS_DISABLED = 4; |
| const int WP_MDIMINBUTTON = 16; |
| const int MINBS_NORMAL = 1; |
| const int MINBS_PUSHED = 3; |
| const int MINBS_DISABLED = 4; |
| #endif // TMSCHEMA_H |
| if(nBtn == -1 || nBtn == 0) |
| m_pfnDrawThemeBackground(m_hTheme, dc, WP_MDICLOSEBUTTON, m_bParentActive ? ((m_nBtnPressed == 0) ? CBS_PUSHED : CBS_NORMAL) : CBS_DISABLED, &pRects[0], NULL); |
| if(nBtn == -1 || nBtn == 1) |
| m_pfnDrawThemeBackground(m_hTheme, dc, WP_MDIRESTOREBUTTON, m_bParentActive ? ((m_nBtnPressed == 1) ? RBS_PUSHED : RBS_NORMAL) : RBS_DISABLED, &pRects[1], NULL); |
| if(nBtn == -1 || nBtn == 2) |
| m_pfnDrawThemeBackground(m_hTheme, dc, WP_MDIMINBUTTON, m_bParentActive ? ((m_nBtnPressed == 2) ? MINBS_PUSHED : MINBS_NORMAL) : MINBS_DISABLED, &pRects[2], NULL); |
| } |
| else |
| #endif // !_WTL_NO_AUTO_THEME |
| { |
| if(nBtn == -1 || nBtn == 0) |
| dc.DrawFrameControl(&pRects[0], DFC_CAPTION, DFCS_CAPTIONCLOSE | ((m_nBtnPressed == 0) ? DFCS_PUSHED : 0)); |
| if(nBtn == -1 || nBtn == 1) |
| dc.DrawFrameControl(&pRects[1], DFC_CAPTION, DFCS_CAPTIONRESTORE | ((m_nBtnPressed == 1) ? DFCS_PUSHED : 0)); |
| if(nBtn == -1 || nBtn == 2) |
| dc.DrawFrameControl(&pRects[2], DFC_CAPTION, DFCS_CAPTIONMIN | ((m_nBtnPressed == 2) ? DFCS_PUSHED : 0)); |
| } |
| } |
| |
| #ifndef _WTL_NO_AUTO_THEME |
| static UINT _GetThemeChangedMsg() |
| { |
| #ifndef WM_THEMECHANGED |
| static const UINT WM_THEMECHANGED = 0x031A; |
| #endif // !WM_THEMECHANGED |
| return WM_THEMECHANGED; |
| } |
| |
| void _OpenThemeData() |
| { |
| ATLASSERT(m_hThemeDLL != NULL); |
| |
| PFN_OpenThemeData pfnOpenThemeData = (PFN_OpenThemeData)::GetProcAddress(m_hThemeDLL, "OpenThemeData"); |
| ATLASSERT(pfnOpenThemeData != NULL); |
| if(pfnOpenThemeData != NULL) |
| m_hTheme = pfnOpenThemeData(m_hWnd, L"Window"); |
| } |
| |
| void _CloseThemeData() |
| { |
| ATLASSERT(m_hThemeDLL != NULL); |
| |
| if(m_hTheme == NULL) |
| return; // nothing to do |
| |
| PFN_CloseThemeData pfnCloseThemeData = (PFN_CloseThemeData)::GetProcAddress(m_hThemeDLL, "CloseThemeData"); |
| ATLASSERT(pfnCloseThemeData != NULL); |
| if(pfnCloseThemeData != NULL) |
| { |
| pfnCloseThemeData(m_hTheme); |
| m_hTheme = NULL; |
| } |
| } |
| #endif // !_WTL_NO_AUTO_THEME |
| |
| bool _DebugCheckChild() |
| { |
| #ifdef _DEBUG |
| BOOL bMaximized = FALSE; |
| HWND hWndChild = (HWND)::SendMessage(m_wndMDIClient, WM_MDIGETACTIVE, 0, (LPARAM)&bMaximized); |
| return (bMaximized && hWndChild == m_hWndChildMaximized); |
| #else // !_DEBUG |
| return true; |
| #endif // !_DEBUG |
| } |
| }; |
| |
| class CMDICommandBarCtrl : public CMDICommandBarCtrlImpl<CMDICommandBarCtrl> |
| { |
| public: |
| DECLARE_WND_SUPERCLASS(_T("WTL_MDICommandBar"), GetWndClassName()) |
| }; |
| |
| }; // namespace WTL |
| |
| #endif // __ATLCTRLW_H__ |