| Index: third_party/wtl/include/atlctrlw.h
|
| diff --git a/third_party/wtl/include/atlctrlw.h b/third_party/wtl/include/atlctrlw.h
|
| deleted file mode 100644
|
| index 9cce23054fce5b8f436563fa0a13791cd39faa11..0000000000000000000000000000000000000000
|
| --- a/third_party/wtl/include/atlctrlw.h
|
| +++ /dev/null
|
| @@ -1,4158 +0,0 @@
|
| -// 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__
|
|
|