ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
dolphin/Externals/WTL80/atlframe.h

3466 lines
101 KiB
C
Raw Normal View History

Initial megacommit. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4 8ced0084-cf51-0410-be5f-012b33b47a6e
2008-07-12 17:40:22 +00:00
// 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
// Common Public License 1.0 (http://opensource.org/osi3.0/licenses/cpl1.0.php)
// which can be found in the file CPL.TXT at the root of this distribution.
// By using this software in any fashion, you are agreeing to be bound by
// the terms of this license. You must not remove this notice, or
// any other, from this software.
#ifndef __ATLFRAME_H__
#define __ATLFRAME_H__
#pragma once
#ifndef __cplusplus
#error ATL requires C++ compilation (use a .cpp suffix)
#endif
#ifndef __ATLAPP_H__
#error atlframe.h requires atlapp.h to be included first
#endif
#ifndef __ATLWIN_H__
#error atlframe.h requires atlwin.h to be included first
#endif
///////////////////////////////////////////////////////////////////////////////
// Classes in this file:
//
// CFrameWindowImpl<T, TBase, TWinTraits>
// CMDIWindow
// CMDIFrameWindowImpl<T, TBase, TWinTraits>
// CMDIChildWindowImpl<T, TBase, TWinTraits>
// COwnerDraw<T>
// CUpdateUIBase
// CUpdateUI<T>
// CDynamicUpdateUI<T>
// CDialogResize<T>
// CDoubleBufferImpl<T>
// CDoubleBufferWindowImpl<T, TBase, TWinTraits>
//
// Global functions:
// AtlCreateSimpleToolBar()
namespace WTL
{
///////////////////////////////////////////////////////////////////////////////
// CFrameWndClassInfo - Manages frame window Windows class information
class CFrameWndClassInfo
{
public:
#ifndef _WIN32_WCE
enum { cchAutoName = 5 + sizeof(void*) * 2 }; // sizeof(void*) * 2 is the number of digits %p outputs
WNDCLASSEX m_wc;
#else // CE specific
enum { cchAutoName = MAX_PATH }; // MAX_PATH because this can be set in the wizard generated CMainFrame::ActivatePreviousInstance to a user defined string.
WNDCLASS m_wc;
#endif // !_WIN32_WCE
LPCTSTR m_lpszOrigName;
WNDPROC pWndProc;
LPCTSTR m_lpszCursorID;
BOOL m_bSystemCursor;
ATOM m_atom;
TCHAR m_szAutoName[cchAutoName];
UINT m_uCommonResourceID;
#ifndef _WIN32_WCE
ATOM Register(WNDPROC* pProc)
{
if (m_atom == 0)
{
CWindowCreateCriticalSectionLock lock;
if(FAILED(lock.Lock()))
{
ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CFrameWndClassInfo::Register.\n"));
ATLASSERT(FALSE);
return 0;
}
if(m_atom == 0)
{
HINSTANCE hInst = ModuleHelper::GetModuleInstance();
if (m_lpszOrigName != NULL)
{
ATLASSERT(pProc != NULL);
LPCTSTR lpsz = m_wc.lpszClassName;
WNDPROC proc = m_wc.lpfnWndProc;
WNDCLASSEX wc = { 0 };
wc.cbSize = sizeof(WNDCLASSEX);
// try process local class first
if(!::GetClassInfoEx(ModuleHelper::GetModuleInstance(), m_lpszOrigName, &wc))
{
// try global class
if(!::GetClassInfoEx(NULL, m_lpszOrigName, &wc))
{
lock.Unlock();
return 0;
}
}
m_wc = wc;
pWndProc = m_wc.lpfnWndProc;
m_wc.lpszClassName = lpsz;
m_wc.lpfnWndProc = proc;
}
else
{
m_wc.hCursor = ::LoadCursor(m_bSystemCursor ? NULL : hInst, m_lpszCursorID);
}
m_wc.hInstance = hInst;
m_wc.style &= ~CS_GLOBALCLASS; // we don't register global classes
if (m_wc.lpszClassName == NULL)
{
#if (_WIN32_WINNT >= 0x0500) || defined(_WIN64)
SecureHelper::wsprintf_x(m_szAutoName, cchAutoName, _T("ATL:%p"), &m_wc);
#else // !((_WIN32_WINNT >= 0x0500) || defined(_WIN64))
SecureHelper::wsprintf_x(m_szAutoName, cchAutoName, _T("ATL:%8.8X"), (DWORD_PTR)&m_wc);
#endif // !((_WIN32_WINNT >= 0x0500) || defined(_WIN64))
m_wc.lpszClassName = m_szAutoName;
}
WNDCLASSEX wcTemp = m_wc;
m_atom = (ATOM)::GetClassInfoEx(m_wc.hInstance, m_wc.lpszClassName, &wcTemp);
if (m_atom == 0)
{
if(m_uCommonResourceID != 0) // use it if not zero
{
m_wc.hIcon = (HICON)::LoadImage(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(m_uCommonResourceID), IMAGE_ICON, 32, 32, LR_DEFAULTCOLOR);
m_wc.hIconSm = (HICON)::LoadImage(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(m_uCommonResourceID), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
}
m_atom = ::RegisterClassEx(&m_wc);
}
}
lock.Unlock();
}
if (m_lpszOrigName != NULL)
{
ATLASSERT(pProc != NULL);
ATLASSERT(pWndProc != NULL);
*pProc = pWndProc;
}
return m_atom;
}
#else // CE specific
ATOM Register(WNDPROC* pProc)
{
if (m_atom == 0)
{
CWindowCreateCriticalSectionLock lock;
if(FAILED(lock.Lock()))
{
ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CFrameWndClassInfo::Register.\n"));
ATLASSERT(FALSE);
return 0;
}
if(m_atom == 0)
{
HINSTANCE hInst = ModuleHelper::GetModuleInstance();
if (m_lpszOrigName != NULL)
{
ATLASSERT(pProc != NULL);
LPCTSTR lpsz = m_wc.lpszClassName;
WNDPROC proc = m_wc.lpfnWndProc;
WNDCLASS wc = { 0 };
// try process local class first
if(!::GetClassInfo(ModuleHelper::GetModuleInstance(), m_lpszOrigName, &wc))
{
// try global class
if(!::GetClassInfo(NULL, m_lpszOrigName, &wc))
{
lock.Unlock();
return 0;
}
}
m_wc = wc;
pWndProc = m_wc.lpfnWndProc;
m_wc.lpszClassName = lpsz;
m_wc.lpfnWndProc = proc;
}
else
{
#if defined(GWES_CURSOR) || defined(GWES_MCURSOR)
m_wc.hCursor = ::LoadCursor(m_bSystemCursor ? NULL : hInst, m_lpszCursorID);
#else // !(defined(GWES_CURSOR) || defined(GWES_MCURSOR))
m_wc.hCursor = NULL;
#endif // !(defined(GWES_CURSOR) || defined(GWES_MCURSOR))
}
m_wc.hInstance = hInst;
m_wc.style &= ~CS_GLOBALCLASS; // we don't register global classes
if (m_wc.lpszClassName == NULL)
{
wsprintf(m_szAutoName, _T("ATL:%8.8X"), (DWORD_PTR)&m_wc);
m_wc.lpszClassName = m_szAutoName;
}
WNDCLASS wcTemp = m_wc;
m_atom = (ATOM)::GetClassInfo(m_wc.hInstance, m_wc.lpszClassName, &wcTemp);
if (m_atom == 0)
{
if(m_uCommonResourceID != 0) // use it if not zero
m_wc.hIcon = (HICON)::LoadImage(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(m_uCommonResourceID), IMAGE_ICON, 32, 32, LR_DEFAULTCOLOR);
m_atom = ::RegisterClass(&m_wc);
}
}
lock.Unlock();
}
if (m_lpszOrigName != NULL)
{
ATLASSERT(pProc != NULL);
ATLASSERT(pWndProc != NULL);
*pProc = pWndProc;
}
return m_atom;
}
#endif // _WIN32_WCE
};
///////////////////////////////////////////////////////////////////////////////
// Macros for declaring frame window WNDCLASS
#ifndef _WIN32_WCE
#define DECLARE_FRAME_WND_CLASS(WndClassName, uCommonResourceID) \
static WTL::CFrameWndClassInfo& GetWndClassInfo() \
{ \
static WTL::CFrameWndClassInfo wc = \
{ \
{ sizeof(WNDCLASSEX), 0, StartWindowProc, \
0, 0, NULL, NULL, NULL, (HBRUSH)(COLOR_WINDOW + 1), NULL, WndClassName, NULL }, \
NULL, NULL, IDC_ARROW, TRUE, 0, _T(""), uCommonResourceID \
}; \
return wc; \
}
#define DECLARE_FRAME_WND_CLASS_EX(WndClassName, uCommonResourceID, style, bkgnd) \
static WTL::CFrameWndClassInfo& GetWndClassInfo() \
{ \
static WTL::CFrameWndClassInfo wc = \
{ \
{ sizeof(WNDCLASSEX), style, StartWindowProc, \
0, 0, NULL, NULL, NULL, (HBRUSH)(bkgnd + 1), NULL, WndClassName, NULL }, \
NULL, NULL, IDC_ARROW, TRUE, 0, _T(""), uCommonResourceID \
}; \
return wc; \
}
#define DECLARE_FRAME_WND_SUPERCLASS(WndClassName, OrigWndClassName, uCommonResourceID) \
static WTL::CFrameWndClassInfo& GetWndClassInfo() \
{ \
static WTL::CFrameWndClassInfo wc = \
{ \
{ sizeof(WNDCLASSEX), 0, StartWindowProc, \
0, 0, NULL, NULL, NULL, NULL, NULL, WndClassName, NULL }, \
OrigWndClassName, NULL, NULL, TRUE, 0, _T(""), uCommonResourceID \
}; \
return wc; \
}
#else // CE specific
#define DECLARE_FRAME_WND_CLASS(WndClassName, uCommonResourceID) \
static WTL::CFrameWndClassInfo& GetWndClassInfo() \
{ \
static WTL::CFrameWndClassInfo wc = \
{ \
{ 0, StartWindowProc, \
0, 0, NULL, NULL, NULL, (HBRUSH)(COLOR_WINDOW + 1), NULL, WndClassName }, \
NULL, NULL, IDC_ARROW, TRUE, 0, _T(""), uCommonResourceID \
}; \
return wc; \
}
#define DECLARE_FRAME_WND_CLASS_EX(WndClassName, uCommonResourceID, style, bkgnd) \
static WTL::CFrameWndClassInfo& GetWndClassInfo() \
{ \
static WTL::CFrameWndClassInfo wc = \
{ \
{ style, StartWindowProc, \
0, 0, NULL, NULL, NULL, (HBRUSH)(bkgnd + 1), NULL, WndClassName }, \
NULL, NULL, IDC_ARROW, TRUE, 0, _T(""), uCommonResourceID \
}; \
return wc; \
}
#define DECLARE_FRAME_WND_SUPERCLASS(WndClassName, OrigWndClassName, uCommonResourceID) \
static WTL::CFrameWndClassInfo& GetWndClassInfo() \
{ \
static WTL::CFrameWndClassInfo wc = \
{ \
{ NULL, StartWindowProc, \
0, 0, NULL, NULL, NULL, NULL, NULL, WndClassName }, \
OrigWndClassName, NULL, IDC_ARROW, TRUE, 0, _T(""), uCommonResourceID \
}; \
return wc; \
}
#endif // !_WIN32_WCE
///////////////////////////////////////////////////////////////////////////////
// CFrameWindowImpl
// Client window command chaining macro (only for frame windows)
#define CHAIN_CLIENT_COMMANDS() \
if(uMsg == WM_COMMAND && m_hWndClient != NULL) \
::SendMessage(m_hWndClient, uMsg, wParam, lParam);
// standard toolbar styles
#define ATL_SIMPLE_TOOLBAR_STYLE \
(WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | TBSTYLE_TOOLTIPS)
// toolbar in a rebar pane
#define ATL_SIMPLE_TOOLBAR_PANE_STYLE \
(WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | CCS_NODIVIDER | CCS_NORESIZE | CCS_NOPARENTALIGN | TBSTYLE_TOOLTIPS | TBSTYLE_FLAT)
// standard rebar styles
#if (_WIN32_IE >= 0x0400)
#define ATL_SIMPLE_REBAR_STYLE \
(WS_CHILD | WS_VISIBLE | WS_BORDER | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | RBS_VARHEIGHT | RBS_BANDBORDERS | RBS_AUTOSIZE)
#else
#define ATL_SIMPLE_REBAR_STYLE \
(WS_CHILD | WS_VISIBLE | WS_BORDER | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | RBS_VARHEIGHT | RBS_BANDBORDERS)
#endif // !(_WIN32_IE >= 0x0400)
// rebar without borders
#if (_WIN32_IE >= 0x0400)
#define ATL_SIMPLE_REBAR_NOBORDER_STYLE \
(WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | RBS_VARHEIGHT | RBS_BANDBORDERS | RBS_AUTOSIZE | CCS_NODIVIDER)
#else
#define ATL_SIMPLE_REBAR_NOBORDER_STYLE \
(WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | RBS_VARHEIGHT | RBS_BANDBORDERS | CCS_NODIVIDER)
#endif // !(_WIN32_IE >= 0x0400)
// command bar support
#if !defined(__ATLCTRLW_H__) && !defined(_WIN32_WCE)
#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
struct _AtlFrameWnd_CmdBarPopupMenu
{
int cbSize;
HMENU hMenu;
UINT uFlags;
int x;
int y;
LPTPMPARAMS lptpm;
};
#define CBRPOPUPMENU _AtlFrameWnd_CmdBarPopupMenu
#endif // !defined(__ATLCTRLW_H__) && !defined(_WIN32_WCE)
template <class TBase = ATL::CWindow, class TWinTraits = ATL::CFrameWinTraits>
class ATL_NO_VTABLE CFrameWindowImplBase : public ATL::CWindowImplBaseT< TBase, TWinTraits >
{
public:
DECLARE_FRAME_WND_CLASS(NULL, 0)
// Data members
HWND m_hWndToolBar;
HWND m_hWndStatusBar;
HWND m_hWndClient;
HACCEL m_hAccel;
#ifdef _WIN32_WCE
HWND m_hWndCECommandBar;
#endif // _WIN32_WCE
struct _AtlToolBarData
{
WORD wVersion;
WORD wWidth;
WORD wHeight;
WORD wItemCount;
//WORD aItems[wItemCount]
WORD* items()
{ return (WORD*)(this+1); }
};
#if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
struct _ChevronMenuInfo
{
HMENU hMenu;
LPNMREBARCHEVRON lpnm;
bool bCmdBar;
};
#endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
// Constructor
CFrameWindowImplBase() :
#ifdef _WIN32_WCE
m_hWndCECommandBar(NULL),
#endif // _WIN32_WCE
m_hWndToolBar(NULL),
m_hWndStatusBar(NULL),
m_hWndClient(NULL),
m_hAccel(NULL)
{ }
// Methods
HWND Create(HWND hWndParent, ATL::_U_RECT rect, LPCTSTR szWindowName, DWORD dwStyle, DWORD dwExStyle, ATL::_U_MENUorID MenuOrID, ATOM atom, LPVOID lpCreateParam)
{
ATLASSERT(m_hWnd == NULL);
if(atom == 0)
return NULL;
ModuleHelper::AddCreateWndData(&m_thunk.cd, this);
if(MenuOrID.m_hMenu == NULL && (dwStyle & WS_CHILD))
MenuOrID.m_hMenu = (HMENU)(UINT_PTR)this;
if(rect.m_lpRect == NULL)
rect.m_lpRect = &TBase::rcDefault;
HWND hWnd = ::CreateWindowEx(dwExStyle, MAKEINTATOM(atom), szWindowName,
dwStyle, rect.m_lpRect->left, rect.m_lpRect->top, rect.m_lpRect->right - rect.m_lpRect->left,
rect.m_lpRect->bottom - rect.m_lpRect->top, hWndParent, MenuOrID.m_hMenu,
ModuleHelper::GetModuleInstance(), lpCreateParam);
ATLASSERT(hWnd == NULL || m_hWnd == hWnd);
return hWnd;
}
static HWND CreateSimpleToolBarCtrl(HWND hWndParent, UINT nResourceID, BOOL bInitialSeparator = FALSE,
DWORD dwStyle = ATL_SIMPLE_TOOLBAR_STYLE, UINT nID = ATL_IDW_TOOLBAR)
{
HINSTANCE hInst = ModuleHelper::GetResourceInstance();
HRSRC hRsrc = ::FindResource(hInst, MAKEINTRESOURCE(nResourceID), RT_TOOLBAR);
if (hRsrc == NULL)
return NULL;
HGLOBAL hGlobal = ::LoadResource(hInst, hRsrc);
if (hGlobal == NULL)
return NULL;
_AtlToolBarData* pData = (_AtlToolBarData*)::LockResource(hGlobal);
if (pData == NULL)
return NULL;
ATLASSERT(pData->wVersion == 1);
WORD* pItems = pData->items();
int nItems = pData->wItemCount + (bInitialSeparator ? 1 : 0);
CTempBuffer<TBBUTTON, _WTL_STACK_ALLOC_THRESHOLD> buff;
TBBUTTON* pTBBtn = buff.Allocate(nItems);
ATLASSERT(pTBBtn != NULL);
if(pTBBtn == NULL)
return NULL;
const int cxSeparator = 8;
// set initial separator (half width)
if(bInitialSeparator)
{
pTBBtn[0].iBitmap = cxSeparator / 2;
pTBBtn[0].idCommand = 0;
pTBBtn[0].fsState = 0;
pTBBtn[0].fsStyle = TBSTYLE_SEP;
pTBBtn[0].dwData = 0;
pTBBtn[0].iString = 0;
}
int nBmp = 0;
for(int i = 0, j = bInitialSeparator ? 1 : 0; i < pData->wItemCount; i++, j++)
{
if(pItems[i] != 0)
{
pTBBtn[j].iBitmap = nBmp++;
pTBBtn[j].idCommand = pItems[i];
pTBBtn[j].fsState = TBSTATE_ENABLED;
pTBBtn[j].fsStyle = TBSTYLE_BUTTON;
pTBBtn[j].dwData = 0;
pTBBtn[j].iString = 0;
}
else
{
pTBBtn[j].iBitmap = cxSeparator;
pTBBtn[j].idCommand = 0;
pTBBtn[j].fsState = 0;
pTBBtn[j].fsStyle = TBSTYLE_SEP;
pTBBtn[j].dwData = 0;
pTBBtn[j].iString = 0;
}
}
#ifndef _WIN32_WCE
HWND hWnd = ::CreateWindowEx(0, TOOLBARCLASSNAME, NULL, dwStyle, 0, 0, 100, 100, hWndParent, (HMENU)LongToHandle(nID), ModuleHelper::GetModuleInstance(), NULL);
if(hWnd == NULL)
{
ATLASSERT(FALSE);
return NULL;
}
#else // CE specific
dwStyle;
nID;
// The toolbar must go onto the existing CommandBar or MenuBar
HWND hWnd = hWndParent;
#endif // _WIN32_WCE
::SendMessage(hWnd, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0L);
// check if font is taller than our bitmaps
CFontHandle font = (HFONT)::SendMessage(hWnd, WM_GETFONT, 0, 0L);
if(font.IsNull())
font = AtlGetDefaultGuiFont();
LOGFONT lf = { 0 };
font.GetLogFont(lf);
WORD cyFontHeight = (WORD)abs(lf.lfHeight);
#ifndef _WIN32_WCE
WORD bitsPerPixel = AtlGetBitmapResourceBitsPerPixel(nResourceID);
if(bitsPerPixel > 4)
{
COLORREF crMask = CLR_DEFAULT;
if(bitsPerPixel == 32)
{
// 32-bit color bitmap with alpha channel (valid for Windows XP and later)
crMask = CLR_NONE;
}
HIMAGELIST hImageList = ImageList_LoadImage(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(nResourceID), pData->wWidth, 1, crMask, IMAGE_BITMAP, LR_CREATEDIBSECTION | LR_DEFAULTSIZE);
ATLASSERT(hImageList != NULL);
::SendMessage(hWnd, TB_SETIMAGELIST, 0, (LPARAM)hImageList);
}
else
#endif // !_WIN32_WCE
{
TBADDBITMAP tbab = { 0 };
tbab.hInst = hInst;
tbab.nID = nResourceID;
::SendMessage(hWnd, TB_ADDBITMAP, nBmp, (LPARAM)&tbab);
}
::SendMessage(hWnd, TB_ADDBUTTONS, nItems, (LPARAM)pTBBtn);
::SendMessage(hWnd, TB_SETBITMAPSIZE, 0, MAKELONG(pData->wWidth, max(pData->wHeight, cyFontHeight)));
const int cxyButtonMargin = 7;
::SendMessage(hWnd, TB_SETBUTTONSIZE, 0, MAKELONG(pData->wWidth + cxyButtonMargin, max(pData->wHeight, cyFontHeight) + cxyButtonMargin));
return hWnd;
}
#ifndef _WIN32_WCE
static HWND CreateSimpleReBarCtrl(HWND hWndParent, DWORD dwStyle = ATL_SIMPLE_REBAR_STYLE, UINT nID = ATL_IDW_TOOLBAR)
{
// Ensure style combinations for proper rebar painting
if(dwStyle & CCS_NODIVIDER && dwStyle & WS_BORDER)
dwStyle &= ~WS_BORDER;
else if(!(dwStyle & WS_BORDER) && !(dwStyle & CCS_NODIVIDER))
dwStyle |= CCS_NODIVIDER;
// Create rebar window
HWND hWndReBar = ::CreateWindowEx(0, REBARCLASSNAME, NULL, dwStyle, 0, 0, 100, 100, hWndParent, (HMENU)LongToHandle(nID), ModuleHelper::GetModuleInstance(), NULL);
if(hWndReBar == NULL)
{
ATLTRACE2(atlTraceUI, 0, _T("Failed to create rebar.\n"));
return NULL;
}
// Initialize and send the REBARINFO structure
REBARINFO rbi = { 0 };
rbi.cbSize = sizeof(REBARINFO);
rbi.fMask = 0;
if(!::SendMessage(hWndReBar, RB_SETBARINFO, 0, (LPARAM)&rbi))
{
ATLTRACE2(atlTraceUI, 0, _T("Failed to initialize rebar.\n"));
::DestroyWindow(hWndReBar);
return NULL;
}
return hWndReBar;
}
BOOL CreateSimpleReBar(DWORD dwStyle = ATL_SIMPLE_REBAR_STYLE, UINT nID = ATL_IDW_TOOLBAR)
{
ATLASSERT(!::IsWindow(m_hWndToolBar));
m_hWndToolBar = CreateSimpleReBarCtrl(m_hWnd, dwStyle, nID);
return (m_hWndToolBar != NULL);
}
static BOOL AddSimpleReBarBandCtrl(HWND hWndReBar, HWND hWndBand, int nID = 0, LPCTSTR lpstrTitle = NULL, BOOL bNewRow = FALSE, int cxWidth = 0, BOOL bFullWidthAlways = FALSE)
{
ATLASSERT(::IsWindow(hWndReBar)); // must be already created
#ifdef _DEBUG
// block - check if this is really a rebar
{
TCHAR lpszClassName[sizeof(REBARCLASSNAME)] = { 0 };
::GetClassName(hWndReBar, lpszClassName, sizeof(REBARCLASSNAME));
ATLASSERT(lstrcmp(lpszClassName, REBARCLASSNAME) == 0);
}
#endif // _DEBUG
ATLASSERT(::IsWindow(hWndBand)); // must be already created
// Get number of buttons on the toolbar
int nBtnCount = (int)::SendMessage(hWndBand, TB_BUTTONCOUNT, 0, 0L);
// Set band info structure
REBARBANDINFO rbBand = { RunTimeHelper::SizeOf_REBARBANDINFO() };
#if (_WIN32_IE >= 0x0400)
rbBand.fMask = RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_STYLE | RBBIM_ID | RBBIM_SIZE | RBBIM_IDEALSIZE;
#else
rbBand.fMask = RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_STYLE | RBBIM_ID | RBBIM_SIZE;
#endif // !(_WIN32_IE >= 0x0400)
if(lpstrTitle != NULL)
rbBand.fMask |= RBBIM_TEXT;
rbBand.fStyle = RBBS_CHILDEDGE;
#if (_WIN32_IE >= 0x0500)
if(nBtnCount > 0) // add chevron style for toolbar with buttons
rbBand.fStyle |= RBBS_USECHEVRON;
#endif // (_WIN32_IE >= 0x0500)
if(bNewRow)
rbBand.fStyle |= RBBS_BREAK;
rbBand.lpText = (LPTSTR)lpstrTitle;
rbBand.hwndChild = hWndBand;
if(nID == 0) // calc band ID
nID = ATL_IDW_BAND_FIRST + (int)::SendMessage(hWndReBar, RB_GETBANDCOUNT, 0, 0L);
rbBand.wID = nID;
// Calculate the size of the band
BOOL bRet = FALSE;
RECT rcTmp = { 0 };
if(nBtnCount > 0)
{
bRet = (BOOL)::SendMessage(hWndBand, TB_GETITEMRECT, nBtnCount - 1, (LPARAM)&rcTmp);
ATLASSERT(bRet);
rbBand.cx = (cxWidth != 0) ? cxWidth : rcTmp.right;
rbBand.cyMinChild = rcTmp.bottom - rcTmp.top;
if(bFullWidthAlways)
{
rbBand.cxMinChild = rbBand.cx;
}
else if(lpstrTitle == NULL)
{
bRet = (BOOL)::SendMessage(hWndBand, TB_GETITEMRECT, 0, (LPARAM)&rcTmp);
ATLASSERT(bRet);
rbBand.cxMinChild = rcTmp.right;
}
else
{
rbBand.cxMinChild = 0;
}
}
else // no buttons, either not a toolbar or really has no buttons
{
bRet = ::GetWindowRect(hWndBand, &rcTmp);
ATLASSERT(bRet);
rbBand.cx = (cxWidth != 0) ? cxWidth : (rcTmp.right - rcTmp.left);
rbBand.cxMinChild = bFullWidthAlways ? rbBand.cx : 0;
rbBand.cyMinChild = rcTmp.bottom - rcTmp.top;
}
#if (_WIN32_IE >= 0x0400)
rbBand.cxIdeal = rbBand.cx;
#endif // (_WIN32_IE >= 0x0400)
// Add the band
LRESULT lRes = ::SendMessage(hWndReBar, RB_INSERTBAND, (WPARAM)-1, (LPARAM)&rbBand);
if(lRes == 0)
{
ATLTRACE2(atlTraceUI, 0, _T("Failed to add a band to the rebar.\n"));
return FALSE;
}
#if (_WIN32_IE >= 0x0501)
DWORD dwExStyle = (DWORD)::SendMessage(hWndBand, TB_GETEXTENDEDSTYLE, 0, 0L);
::SendMessage(hWndBand, TB_SETEXTENDEDSTYLE, 0, dwExStyle | TBSTYLE_EX_HIDECLIPPEDBUTTONS);
#endif // (_WIN32_IE >= 0x0501)
return TRUE;
}
BOOL AddSimpleReBarBand(HWND hWndBand, LPCTSTR lpstrTitle = NULL, BOOL bNewRow = FALSE, int cxWidth = 0, BOOL bFullWidthAlways = FALSE)
{
ATLASSERT(::IsWindow(m_hWndToolBar)); // must be an existing rebar
ATLASSERT(::IsWindow(hWndBand)); // must be created
return AddSimpleReBarBandCtrl(m_hWndToolBar, hWndBand, 0, lpstrTitle, bNewRow, cxWidth, bFullWidthAlways);
}
#if (_WIN32_IE >= 0x0400)
void SizeSimpleReBarBands()
{
ATLASSERT(::IsWindow(m_hWndToolBar)); // must be an existing rebar
int nCount = (int)::SendMessage(m_hWndToolBar, RB_GETBANDCOUNT, 0, 0L);
for(int i = 0; i < nCount; i++)
{
REBARBANDINFO rbBand = { RunTimeHelper::SizeOf_REBARBANDINFO() };
rbBand.fMask = RBBIM_SIZE;
BOOL bRet = (BOOL)::SendMessage(m_hWndToolBar, RB_GETBANDINFO, i, (LPARAM)&rbBand);
ATLASSERT(bRet);
RECT rect = { 0, 0, 0, 0 };
::SendMessage(m_hWndToolBar, RB_GETBANDBORDERS, i, (LPARAM)&rect);
rbBand.cx += rect.left + rect.right;
bRet = (BOOL)::SendMessage(m_hWndToolBar, RB_SETBANDINFO, i, (LPARAM)&rbBand);
ATLASSERT(bRet);
}
}
#endif // (_WIN32_IE >= 0x0400)
#endif // _WIN32_WCE
#ifndef _WIN32_WCE
BOOL CreateSimpleStatusBar(LPCTSTR lpstrText, DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | SBARS_SIZEGRIP, UINT nID = ATL_IDW_STATUS_BAR)
#else // CE specific
BOOL CreateSimpleStatusBar(LPCTSTR lpstrText, DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, UINT nID = ATL_IDW_STATUS_BAR)
#endif // _WIN32_WCE
{
ATLASSERT(!::IsWindow(m_hWndStatusBar));
m_hWndStatusBar = ::CreateStatusWindow(dwStyle, lpstrText, m_hWnd, nID);
return (m_hWndStatusBar != NULL);
}
#ifndef _WIN32_WCE
BOOL CreateSimpleStatusBar(UINT nTextID = ATL_IDS_IDLEMESSAGE, DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | SBARS_SIZEGRIP, UINT nID = ATL_IDW_STATUS_BAR)
#else // CE specific
BOOL CreateSimpleStatusBar(UINT nTextID = ATL_IDS_IDLEMESSAGE, DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, UINT nID = ATL_IDW_STATUS_BAR)
#endif // _WIN32_WCE
{
const int cchMax = 128; // max text length is 127 for status bars (+1 for null)
TCHAR szText[cchMax];
szText[0] = 0;
::LoadString(ModuleHelper::GetResourceInstance(), nTextID, szText, cchMax);
return CreateSimpleStatusBar(szText, dwStyle, nID);
}
#ifdef _WIN32_WCE
BOOL CreateSimpleCECommandBar(LPTSTR pszMenu = NULL, WORD iButton = 0, DWORD dwFlags = 0, int nCmdBarID = 1)
{
ATLASSERT(m_hWndCECommandBar == NULL);
ATLASSERT(m_hWndToolBar == NULL);
m_hWndCECommandBar = ::CommandBar_Create(ModuleHelper::GetModuleInstance(), m_hWnd, nCmdBarID);
if(m_hWndCECommandBar == NULL)
return FALSE;
m_hWndToolBar = m_hWndCECommandBar;
BOOL bRet = TRUE;
if(pszMenu != NULL)
bRet &= ::CommandBar_InsertMenubarEx(m_hWndCECommandBar, IS_INTRESOURCE(pszMenu) ? ModuleHelper::GetResourceInstance() : NULL, pszMenu, iButton);
bRet &= ::CommandBar_AddAdornments(m_hWndCECommandBar, dwFlags, 0);
return bRet;
}
#if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__)
BOOL CreateSimpleCEMenuBar(UINT nToolBarId = ATL_IDW_MENU_BAR, DWORD dwFlags = 0, int nBmpId = 0, int cBmpImages = 0)
{
ATLASSERT(m_hWndCECommandBar == NULL);
SHMENUBARINFO mbi = { 0 };
mbi.cbSize = sizeof(mbi);
mbi.hwndParent = m_hWnd;
mbi.dwFlags = dwFlags;
mbi.nToolBarId = nToolBarId;
mbi.hInstRes = ModuleHelper::GetResourceInstance();
mbi.nBmpId = nBmpId;
mbi.cBmpImages = cBmpImages;
mbi.hwndMB = NULL; // This gets set by SHCreateMenuBar
BOOL bRet = ::SHCreateMenuBar(&mbi);
if(bRet != FALSE)
{
m_hWndCECommandBar = mbi.hwndMB;
SizeToMenuBar();
}
return bRet;
}
void SizeToMenuBar() // for menu bar only
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT(::IsWindow(m_hWndCECommandBar));
RECT rect = { 0 };
GetWindowRect(&rect);
RECT rectMB = { 0 };
::GetWindowRect(m_hWndCECommandBar, &rectMB);
int cy = ::IsWindowVisible(m_hWndCECommandBar) ? rectMB.top - rect.top : rectMB.bottom - rect.top;
SetWindowPos(NULL, 0, 0, rect.right - rect.left, cy, SWP_NOZORDER | SWP_NOMOVE);
}
#endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__)
#endif // _WIN32_WCE
void UpdateLayout(BOOL bResizeBars = TRUE)
{
RECT rect = { 0 };
GetClientRect(&rect);
// position bars and offset their dimensions
UpdateBarsPosition(rect, bResizeBars);
// resize client window
if(m_hWndClient != NULL)
::SetWindowPos(m_hWndClient, NULL, rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top,
SWP_NOZORDER | SWP_NOACTIVATE);
}
void UpdateBarsPosition(RECT& rect, BOOL bResizeBars = TRUE)
{
// resize toolbar
if(m_hWndToolBar != NULL && ((DWORD)::GetWindowLong(m_hWndToolBar, GWL_STYLE) & WS_VISIBLE))
{
if(bResizeBars)
{
::SendMessage(m_hWndToolBar, WM_SIZE, 0, 0);
::InvalidateRect(m_hWndToolBar, NULL, FALSE);
}
RECT rectTB = { 0 };
::GetWindowRect(m_hWndToolBar, &rectTB);
rect.top += rectTB.bottom - rectTB.top;
}
// resize status bar
if(m_hWndStatusBar != NULL && ((DWORD)::GetWindowLong(m_hWndStatusBar, GWL_STYLE) & WS_VISIBLE))
{
if(bResizeBars)
::SendMessage(m_hWndStatusBar, WM_SIZE, 0, 0);
RECT rectSB = { 0 };
::GetWindowRect(m_hWndStatusBar, &rectSB);
rect.bottom -= rectSB.bottom - rectSB.top;
}
}
BOOL PreTranslateMessage(MSG* pMsg)
{
if(m_hAccel != NULL && ::TranslateAccelerator(m_hWnd, m_hAccel, pMsg))
return TRUE;
return FALSE;
}
BEGIN_MSG_MAP(CFrameWindowImplBase)
MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)
#ifndef _WIN32_WCE
MESSAGE_HANDLER(WM_MENUSELECT, OnMenuSelect)
#endif // !_WIN32_WCE
MESSAGE_HANDLER(WM_SETFOCUS, OnSetFocus)
MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
#ifndef _WIN32_WCE
NOTIFY_CODE_HANDLER(TTN_GETDISPINFOA, OnToolTipTextA)
NOTIFY_CODE_HANDLER(TTN_GETDISPINFOW, OnToolTipTextW)
#endif // !_WIN32_WCE
END_MSG_MAP()
LRESULT OnEraseBackground(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
{
if(m_hWndClient != NULL) // view will paint itself instead
return 1;
bHandled = FALSE;
return 0;
}
#ifndef _WIN32_WCE
LRESULT OnMenuSelect(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
bHandled = FALSE;
if(m_hWndStatusBar == NULL)
return 1;
WORD wFlags = HIWORD(wParam);
if(wFlags == 0xFFFF && lParam == NULL) // menu closing
{
::SendMessage(m_hWndStatusBar, SB_SIMPLE, FALSE, 0L);
}
else
{
const int cchBuff = 256;
TCHAR szBuff[cchBuff];
szBuff[0] = 0;
if(!(wFlags & MF_POPUP))
{
WORD wID = LOWORD(wParam);
// check for special cases
if(wID >= 0xF000 && wID < 0xF1F0) // system menu IDs
wID = (WORD)(((wID - 0xF000) >> 4) + ATL_IDS_SCFIRST);
else if(wID >= ID_FILE_MRU_FIRST && wID <= ID_FILE_MRU_LAST) // MRU items
wID = ATL_IDS_MRU_FILE;
else if(wID >= ATL_IDM_FIRST_MDICHILD && wID <= ATL_IDM_LAST_MDICHILD) // MDI child windows
wID = ATL_IDS_MDICHILD;
int nRet = ::LoadString(ModuleHelper::GetResourceInstance(), wID, szBuff, cchBuff);
for(int i = 0; i < nRet; i++)
{
if(szBuff[i] == _T('\n'))
{
szBuff[i] = 0;
break;
}
}
}
::SendMessage(m_hWndStatusBar, SB_SIMPLE, TRUE, 0L);
::SendMessage(m_hWndStatusBar, SB_SETTEXT, (255 | SBT_NOBORDERS), (LPARAM)szBuff);
}
return 1;
}
#endif // !_WIN32_WCE
LRESULT OnSetFocus(UINT, WPARAM, LPARAM, BOOL& bHandled)
{
if(m_hWndClient != NULL)
::SetFocus(m_hWndClient);
bHandled = FALSE;
return 1;
}
LRESULT OnDestroy(UINT, WPARAM, LPARAM, BOOL& bHandled)
{
if((GetStyle() & (WS_CHILD | WS_POPUP)) == 0)
::PostQuitMessage(1);
bHandled = FALSE;
return 1;
}
#ifndef _WIN32_WCE
LRESULT OnToolTipTextA(int idCtrl, LPNMHDR pnmh, BOOL& /*bHandled*/)
{
LPNMTTDISPINFOA pDispInfo = (LPNMTTDISPINFOA)pnmh;
pDispInfo->szText[0] = 0;
if((idCtrl != 0) && !(pDispInfo->uFlags & TTF_IDISHWND))
{
const int cchBuff = 256;
char szBuff[cchBuff];
szBuff[0] = 0;
int nRet = ::LoadStringA(ModuleHelper::GetResourceInstance(), idCtrl, szBuff, cchBuff);
for(int i = 0; i < nRet; i++)
{
if(szBuff[i] == '\n')
{
SecureHelper::strncpyA_x(pDispInfo->szText, _countof(pDispInfo->szText), &szBuff[i + 1], _TRUNCATE);
break;
}
}
#if (_WIN32_IE >= 0x0300)
if(nRet > 0) // string was loaded, save it
pDispInfo->uFlags |= TTF_DI_SETITEM;
#endif // (_WIN32_IE >= 0x0300)
}
return 0;
}
LRESULT OnToolTipTextW(int idCtrl, LPNMHDR pnmh, BOOL& /*bHandled*/)
{
LPNMTTDISPINFOW pDispInfo = (LPNMTTDISPINFOW)pnmh;
pDispInfo->szText[0] = 0;
if((idCtrl != 0) && !(pDispInfo->uFlags & TTF_IDISHWND))
{
const int cchBuff = 256;
wchar_t szBuff[cchBuff];
szBuff[0] = 0;
int nRet = ::LoadStringW(ModuleHelper::GetResourceInstance(), idCtrl, szBuff, cchBuff);
for(int i = 0; i < nRet; i++)
{
if(szBuff[i] == L'\n')
{
SecureHelper::strncpyW_x(pDispInfo->szText, _countof(pDispInfo->szText), &szBuff[i + 1], _TRUNCATE);
break;
}
}
#if (_WIN32_IE >= 0x0300)
if(nRet > 0) // string was loaded, save it
pDispInfo->uFlags |= TTF_DI_SETITEM;
#endif // (_WIN32_IE >= 0x0300)
}
return 0;
}
#endif // !_WIN32_WCE
// Implementation - chevron menu support
#if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
bool PrepareChevronMenu(_ChevronMenuInfo& cmi)
{
// get rebar and toolbar
REBARBANDINFO rbbi = { RunTimeHelper::SizeOf_REBARBANDINFO() };
rbbi.fMask = RBBIM_CHILD;
BOOL bRet = (BOOL)::SendMessage(cmi.lpnm->hdr.hwndFrom, RB_GETBANDINFO, cmi.lpnm->uBand, (LPARAM)&rbbi);
ATLASSERT(bRet);
// assume the band is a toolbar
ATL::CWindow wnd = rbbi.hwndChild;
int nCount = (int)wnd.SendMessage(TB_BUTTONCOUNT);
if(nCount <= 0) // probably not a toolbar
return false;
// check if it's a command bar
CMenuHandle menuCmdBar = (HMENU)wnd.SendMessage(CBRM_GETMENU);
cmi.bCmdBar = (menuCmdBar.m_hMenu != NULL);
// build a menu from hidden items
CMenuHandle menu;
bRet = menu.CreatePopupMenu();
ATLASSERT(bRet);
RECT rcClient = { 0 };
bRet = wnd.GetClientRect(&rcClient);
ATLASSERT(bRet);
for(int i = 0; i < nCount; i++)
{
TBBUTTON tbb = { 0 };
bRet = (BOOL)wnd.SendMessage(TB_GETBUTTON, i, (LPARAM)&tbb);
ATLASSERT(bRet);
// skip hidden buttons
if((tbb.fsState & TBSTATE_HIDDEN) != 0)
continue;
RECT rcButton = { 0 };
bRet = (BOOL)wnd.SendMessage(TB_GETITEMRECT, i, (LPARAM)&rcButton);
ATLASSERT(bRet);
bool bEnabled = ((tbb.fsState & TBSTATE_ENABLED) != 0);
if(rcButton.right > rcClient.right)
{
if(tbb.fsStyle & BTNS_SEP)
{
if(menu.GetMenuItemCount() > 0)
menu.AppendMenu(MF_SEPARATOR);
}
else if(cmi.bCmdBar)
{
const int cchBuff = 200;
TCHAR szBuff[cchBuff] = { 0 };
CMenuItemInfo mii;
mii.fMask = MIIM_TYPE | MIIM_SUBMENU;
mii.dwTypeData = szBuff;
mii.cch = cchBuff;
bRet = menuCmdBar.GetMenuItemInfo(i, TRUE, &mii);
ATLASSERT(bRet);
// Note: CmdBar currently supports only drop-down items
ATLASSERT(::IsMenu(mii.hSubMenu));
bRet = menu.AppendMenu(MF_STRING | MF_POPUP | (bEnabled ? MF_ENABLED : MF_GRAYED), (UINT_PTR)mii.hSubMenu, mii.dwTypeData);
ATLASSERT(bRet);
}
else
{
// get button's text
const int cchBuff = 200;
TCHAR szBuff[cchBuff] = { 0 };
LPTSTR lpstrText = szBuff;
TBBUTTONINFO tbbi = { 0 };
tbbi.cbSize = sizeof(TBBUTTONINFO);
tbbi.dwMask = TBIF_TEXT;
tbbi.pszText = szBuff;
tbbi.cchText = cchBuff;
if(wnd.SendMessage(TB_GETBUTTONINFO, tbb.idCommand, (LPARAM)&tbbi) == -1 || lstrlen(szBuff) == 0)
{
// no text for this button, try a resource string
lpstrText = _T("");
int nRet = ::LoadString(ModuleHelper::GetResourceInstance(), tbb.idCommand, szBuff, cchBuff);
for(int n = 0; n < nRet; n++)
{
if(szBuff[n] == _T('\n'))
{
lpstrText = &szBuff[n + 1];
break;
}
}
}
bRet = menu.AppendMenu(MF_STRING | (bEnabled ? MF_ENABLED : MF_GRAYED), tbb.idCommand, lpstrText);
ATLASSERT(bRet);
}
}
}
if(menu.GetMenuItemCount() == 0) // no hidden buttons after all
{
menu.DestroyMenu();
::MessageBeep((UINT)-1);
return false;
}
cmi.hMenu = menu;
return true;
}
void DisplayChevronMenu(_ChevronMenuInfo& cmi)
{
#ifndef TPM_VERPOSANIMATION
const UINT TPM_VERPOSANIMATION = 0x1000L; // Menu animation flag
#endif
// convert chevron rect to screen coordinates
ATL::CWindow wndFrom = cmi.lpnm->hdr.hwndFrom;
POINT pt = { cmi.lpnm->rc.left, cmi.lpnm->rc.bottom };
wndFrom.MapWindowPoints(NULL, &pt, 1);
RECT rc = cmi.lpnm->rc;
wndFrom.MapWindowPoints(NULL, &rc);
// set up flags and rect
UINT uMenuFlags = TPM_LEFTBUTTON | TPM_VERTICAL | TPM_LEFTALIGN | TPM_TOPALIGN | (!AtlIsOldWindows() ? TPM_VERPOSANIMATION : 0);
TPMPARAMS TPMParams = { 0 };
TPMParams.cbSize = sizeof(TPMPARAMS);
TPMParams.rcExclude = rc;
// check if this window has a command bar
HWND hWndCmdBar = (HWND)::SendMessage(m_hWnd, CBRM_GETCMDBAR, 0, 0L);
if(::IsWindow(hWndCmdBar))
{
CBRPOPUPMENU CBRPopupMenu = { sizeof(CBRPOPUPMENU), cmi.hMenu, uMenuFlags, pt.x, pt.y, &TPMParams };
::SendMessage(hWndCmdBar, CBRM_TRACKPOPUPMENU, 0, (LPARAM)&CBRPopupMenu);
}
else
{
CMenuHandle menu = cmi.hMenu;
menu.TrackPopupMenuEx(uMenuFlags, pt.x, pt.y, m_hWnd, &TPMParams);
}
}
void CleanupChevronMenu(_ChevronMenuInfo& cmi)
{
CMenuHandle menu = cmi.hMenu;
// if menu is from a command bar, detach submenus so they are not destroyed
if(cmi.bCmdBar)
{
for(int i = menu.GetMenuItemCount() - 1; i >=0; i--)
menu.RemoveMenu(i, MF_BYPOSITION);
}
// destroy menu
menu.DestroyMenu();
// convert chevron rect to screen coordinates
ATL::CWindow wndFrom = cmi.lpnm->hdr.hwndFrom;
RECT rc = cmi.lpnm->rc;
wndFrom.MapWindowPoints(NULL, &rc);
// 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(&rc, msg.pt))
::PeekMessage(&msg, m_hWnd, WM_LBUTTONDOWN, WM_LBUTTONDOWN, PM_REMOVE);
}
#endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
};
template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CFrameWinTraits>
class ATL_NO_VTABLE CFrameWindowImpl : public CFrameWindowImplBase< TBase, TWinTraits >
{
public:
HWND Create(HWND hWndParent = NULL, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
DWORD dwStyle = 0, DWORD dwExStyle = 0,
HMENU hMenu = NULL, LPVOID lpCreateParam = NULL)
{
ATOM atom = T::GetWndClassInfo().Register(&m_pfnSuperWindowProc);
dwStyle = T::GetWndStyle(dwStyle);
dwExStyle = T::GetWndExStyle(dwExStyle);
if(rect.m_lpRect == NULL)
rect.m_lpRect = &TBase::rcDefault;
return CFrameWindowImplBase< TBase, TWinTraits >::Create(hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, hMenu, atom, lpCreateParam);
}
HWND CreateEx(HWND hWndParent = NULL, ATL::_U_RECT rect = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, LPVOID lpCreateParam = NULL)
{
const int cchName = 256;
TCHAR szWindowName[cchName];
szWindowName[0] = 0;
#ifndef _WIN32_WCE
::LoadString(ModuleHelper::GetResourceInstance(), T::GetWndClassInfo().m_uCommonResourceID, szWindowName, cchName);
HMENU hMenu = ::LoadMenu(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(T::GetWndClassInfo().m_uCommonResourceID));
#else // CE specific
::LoadString(ModuleHelper::GetResourceInstance(), T::GetWndClassInfo().m_uCommonResourceID, szWindowName, cchName);
// This always needs to be NULL for Windows CE.
// Frame Window menus have to go onto the CommandBar.
// Use CreateSimpleCECommandBar
HMENU hMenu = NULL;
#endif // _WIN32_WCE
T* pT = static_cast<T*>(this);
HWND hWnd = pT->Create(hWndParent, rect, szWindowName, dwStyle, dwExStyle, hMenu, lpCreateParam);
if(hWnd != NULL)
m_hAccel = ::LoadAccelerators(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(T::GetWndClassInfo().m_uCommonResourceID));
return hWnd;
}
BOOL CreateSimpleToolBar(UINT nResourceID = 0, DWORD dwStyle = ATL_SIMPLE_TOOLBAR_STYLE, UINT nID = ATL_IDW_TOOLBAR)
{
if(nResourceID == 0)
nResourceID = T::GetWndClassInfo().m_uCommonResourceID;
#ifndef _WIN32_WCE
ATLASSERT(!::IsWindow(m_hWndToolBar));
m_hWndToolBar = T::CreateSimpleToolBarCtrl(m_hWnd, nResourceID, TRUE, dwStyle, nID);
return (m_hWndToolBar != NULL);
#else // CE specific
HWND hWnd= T::CreateSimpleToolBarCtrl(m_hWndCECommandBar, nResourceID, TRUE, dwStyle, nID);
return (hWnd != NULL);
#endif // _WIN32_WCE
}
#ifdef _WIN32_WCE
// CE specific variant that returns the handle of the toolbar
HWND CreateSimpleCEToolBar(UINT nResourceID = 0, DWORD dwStyle = ATL_SIMPLE_TOOLBAR_STYLE, UINT nID = ATL_IDW_TOOLBAR)
{
if(nResourceID == 0)
nResourceID = T::GetWndClassInfo().m_uCommonResourceID;
return T::CreateSimpleToolBarCtrl(m_hWndCECommandBar, nResourceID, TRUE, dwStyle, nID);
}
#endif // _WIN32_WCE
// message map and handlers
typedef CFrameWindowImplBase< TBase, TWinTraits > _baseClass;
BEGIN_MSG_MAP(CFrameWindowImpl)
MESSAGE_HANDLER(WM_SIZE, OnSize)
#ifndef _ATL_NO_REBAR_SUPPORT
#if (_WIN32_IE >= 0x0400)
NOTIFY_CODE_HANDLER(RBN_AUTOSIZE, OnReBarAutoSize)
#endif // (_WIN32_IE >= 0x0400)
#if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
NOTIFY_CODE_HANDLER(RBN_CHEVRONPUSHED, OnChevronPushed)
#endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
#endif // !_ATL_NO_REBAR_SUPPORT
CHAIN_MSG_MAP(_baseClass)
END_MSG_MAP()
LRESULT OnSize(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
{
if(wParam != SIZE_MINIMIZED)
{
T* pT = static_cast<T*>(this);
pT->UpdateLayout();
}
bHandled = FALSE;
return 1;
}
#ifndef _ATL_NO_REBAR_SUPPORT
#if (_WIN32_IE >= 0x0400)
LRESULT OnReBarAutoSize(int /*idCtrl*/, LPNMHDR /*pnmh*/, BOOL& /*bHandled*/)
{
T* pT = static_cast<T*>(this);
pT->UpdateLayout(FALSE);
return 0;
}
#endif // (_WIN32_IE >= 0x0400)
#if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
LRESULT OnChevronPushed(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled)
{
T* pT = static_cast<T*>(this);
_ChevronMenuInfo cmi = { NULL, (LPNMREBARCHEVRON)pnmh, false };
if(!pT->PrepareChevronMenu(cmi))
{
bHandled = FALSE;
return 1;
}
// display a popup menu with hidden items
pT->DisplayChevronMenu(cmi);
// cleanup
pT->CleanupChevronMenu(cmi);
return 0;
}
#endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
#endif // !_ATL_NO_REBAR_SUPPORT
};
///////////////////////////////////////////////////////////////////////////////
// AtlCreateSimpleToolBar - helper for creating simple toolbars
#ifndef _WIN32_WCE
inline HWND AtlCreateSimpleToolBar(HWND hWndParent, UINT nResourceID, BOOL bInitialSeparator = FALSE,
DWORD dwStyle = ATL_SIMPLE_TOOLBAR_STYLE, UINT nID = ATL_IDW_TOOLBAR)
{
return CFrameWindowImplBase<>::CreateSimpleToolBarCtrl(hWndParent, nResourceID, bInitialSeparator, dwStyle, nID);
}
#endif // !_WIN32_WCE
///////////////////////////////////////////////////////////////////////////////
// CMDIWindow
#ifndef _WIN32_WCE
#ifndef _WTL_MDIWINDOWMENU_TEXT
#define _WTL_MDIWINDOWMENU_TEXT _T("&Window")
#endif
class CMDIWindow : public ATL::CWindow
{
public:
// Data members
HWND m_hWndMDIClient;
HMENU m_hMenu;
// Constructors
CMDIWindow(HWND hWnd = NULL) : ATL::CWindow(hWnd), m_hWndMDIClient(NULL), m_hMenu(NULL)
{ }
CMDIWindow& operator =(HWND hWnd)
{
m_hWnd = hWnd;
return *this;
}
// Operations
HWND MDIGetActive(BOOL* lpbMaximized = NULL)
{
ATLASSERT(::IsWindow(m_hWndMDIClient));
return (HWND)::SendMessage(m_hWndMDIClient, WM_MDIGETACTIVE, 0, (LPARAM)lpbMaximized);
}
void MDIActivate(HWND hWndChildToActivate)
{
ATLASSERT(::IsWindow(m_hWndMDIClient));
ATLASSERT(::IsWindow(hWndChildToActivate));
::SendMessage(m_hWndMDIClient, WM_MDIACTIVATE, (WPARAM)hWndChildToActivate, 0);
}
void MDINext(HWND hWndChild, BOOL bPrevious = FALSE)
{
ATLASSERT(::IsWindow(m_hWndMDIClient));
ATLASSERT(hWndChild == NULL || ::IsWindow(hWndChild));
::SendMessage(m_hWndMDIClient, WM_MDINEXT, (WPARAM)hWndChild, (LPARAM)bPrevious);
}
void MDIMaximize(HWND hWndChildToMaximize)
{
ATLASSERT(::IsWindow(m_hWndMDIClient));
ATLASSERT(::IsWindow(hWndChildToMaximize));
::SendMessage(m_hWndMDIClient, WM_MDIMAXIMIZE, (WPARAM)hWndChildToMaximize, 0);
}
void MDIRestore(HWND hWndChildToRestore)
{
ATLASSERT(::IsWindow(m_hWndMDIClient));
ATLASSERT(::IsWindow(hWndChildToRestore));
::SendMessage(m_hWndMDIClient, WM_MDIRESTORE, (WPARAM)hWndChildToRestore, 0);
}
void MDIDestroy(HWND hWndChildToDestroy)
{
ATLASSERT(::IsWindow(m_hWndMDIClient));
ATLASSERT(::IsWindow(hWndChildToDestroy));
::SendMessage(m_hWndMDIClient, WM_MDIDESTROY, (WPARAM)hWndChildToDestroy, 0);
}
BOOL MDICascade(UINT uFlags = 0)
{
ATLASSERT(::IsWindow(m_hWndMDIClient));
return (BOOL)::SendMessage(m_hWndMDIClient, WM_MDICASCADE, (WPARAM)uFlags, 0);
}
BOOL MDITile(UINT uFlags = MDITILE_HORIZONTAL)
{
ATLASSERT(::IsWindow(m_hWndMDIClient));
return (BOOL)::SendMessage(m_hWndMDIClient, WM_MDITILE, (WPARAM)uFlags, 0);
}
void MDIIconArrange()
{
ATLASSERT(::IsWindow(m_hWndMDIClient));
::SendMessage(m_hWndMDIClient, WM_MDIICONARRANGE, 0, 0);
}
HMENU MDISetMenu(HMENU hMenuFrame, HMENU hMenuWindow)
{
ATLASSERT(::IsWindow(m_hWndMDIClient));
return (HMENU)::SendMessage(m_hWndMDIClient, WM_MDISETMENU, (WPARAM)hMenuFrame, (LPARAM)hMenuWindow);
}
HMENU MDIRefreshMenu()
{
ATLASSERT(::IsWindow(m_hWndMDIClient));
return (HMENU)::SendMessage(m_hWndMDIClient, WM_MDIREFRESHMENU, 0, 0);
}
// Additional operations
static HMENU GetStandardWindowMenu(HMENU hMenu)
{
int nCount = ::GetMenuItemCount(hMenu);
if(nCount == -1)
return NULL;
int nLen = ::GetMenuString(hMenu, nCount - 2, NULL, 0, MF_BYPOSITION);
if(nLen == 0)
return NULL;
CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
LPTSTR lpszText = buff.Allocate(nLen + 1);
if(lpszText == NULL)
return NULL;
if(::GetMenuString(hMenu, nCount - 2, lpszText, nLen + 1, MF_BYPOSITION) != nLen)
return NULL;
if(lstrcmp(lpszText, _WTL_MDIWINDOWMENU_TEXT) != 0)
return NULL;
return ::GetSubMenu(hMenu, nCount - 2);
}
void SetMDIFrameMenu()
{
HMENU hWindowMenu = GetStandardWindowMenu(m_hMenu);
MDISetMenu(m_hMenu, hWindowMenu);
MDIRefreshMenu();
::DrawMenuBar(GetMDIFrame());
}
HWND GetMDIFrame() const
{
return ::GetParent(m_hWndMDIClient);
}
};
#endif // !_WIN32_WCE
///////////////////////////////////////////////////////////////////////////////
// CMDIFrameWindowImpl
#ifndef _WIN32_WCE
// MDI child command chaining macro (only for MDI frame windows)
#define CHAIN_MDI_CHILD_COMMANDS() \
if(uMsg == WM_COMMAND) \
{ \
HWND hWndChild = MDIGetActive(); \
if(hWndChild != NULL) \
::SendMessage(hWndChild, uMsg, wParam, lParam); \
}
template <class T, class TBase = CMDIWindow, class TWinTraits = ATL::CFrameWinTraits>
class ATL_NO_VTABLE CMDIFrameWindowImpl : public CFrameWindowImplBase<TBase, TWinTraits >
{
public:
HWND Create(HWND hWndParent = NULL, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
DWORD dwStyle = 0, DWORD dwExStyle = 0,
HMENU hMenu = NULL, LPVOID lpCreateParam = NULL)
{
m_hMenu = hMenu;
ATOM atom = T::GetWndClassInfo().Register(&m_pfnSuperWindowProc);
dwStyle = T::GetWndStyle(dwStyle);
dwExStyle = T::GetWndExStyle(dwExStyle);
if(rect.m_lpRect == NULL)
rect.m_lpRect = &TBase::rcDefault;
return CFrameWindowImplBase<TBase, TWinTraits >::Create(hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, hMenu, atom, lpCreateParam);
}
HWND CreateEx(HWND hWndParent = NULL, ATL::_U_RECT rect = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, LPVOID lpCreateParam = NULL)
{
const int cchName = 256;
TCHAR szWindowName[cchName];
szWindowName[0] = 0;
::LoadString(ModuleHelper::GetResourceInstance(), T::GetWndClassInfo().m_uCommonResourceID, szWindowName, cchName);
HMENU hMenu = ::LoadMenu(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(T::GetWndClassInfo().m_uCommonResourceID));
T* pT = static_cast<T*>(this);
HWND hWnd = pT->Create(hWndParent, rect, szWindowName, dwStyle, dwExStyle, hMenu, lpCreateParam);
if(hWnd != NULL)
m_hAccel = ::LoadAccelerators(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(T::GetWndClassInfo().m_uCommonResourceID));
return hWnd;
}
BOOL CreateSimpleToolBar(UINT nResourceID = 0, DWORD dwStyle = ATL_SIMPLE_TOOLBAR_STYLE, UINT nID = ATL_IDW_TOOLBAR)
{
ATLASSERT(!::IsWindow(m_hWndToolBar));
if(nResourceID == 0)
nResourceID = T::GetWndClassInfo().m_uCommonResourceID;
m_hWndToolBar = T::CreateSimpleToolBarCtrl(m_hWnd, nResourceID, TRUE, dwStyle, nID);
return (m_hWndToolBar != NULL);
}
virtual WNDPROC GetWindowProc()
{
return MDIFrameWindowProc;
}
static LRESULT CALLBACK MDIFrameWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
CMDIFrameWindowImpl< T, TBase, TWinTraits >* pThis = (CMDIFrameWindowImpl< T, TBase, TWinTraits >*)hWnd;
// set a ptr to this message and save the old value
#if (_ATL_VER >= 0x0700)
ATL::_ATL_MSG msg(pThis->m_hWnd, uMsg, wParam, lParam);
const ATL::_ATL_MSG* pOldMsg = pThis->m_pCurrentMsg;
#else // !(_ATL_VER >= 0x0700)
MSG msg = { pThis->m_hWnd, uMsg, wParam, lParam, 0, { 0, 0 } };
const MSG* pOldMsg = pThis->m_pCurrentMsg;
#endif // !(_ATL_VER >= 0x0700)
pThis->m_pCurrentMsg = &msg;
// pass to the message map to process
LRESULT lRes = 0;
BOOL bRet = pThis->ProcessWindowMessage(pThis->m_hWnd, uMsg, wParam, lParam, lRes, 0);
// restore saved value for the current message
ATLASSERT(pThis->m_pCurrentMsg == &msg);
pThis->m_pCurrentMsg = pOldMsg;
// do the default processing if message was not handled
if(!bRet)
{
if(uMsg != WM_NCDESTROY)
lRes = pThis->DefWindowProc(uMsg, wParam, lParam);
else
{
// unsubclass, if needed
LONG_PTR pfnWndProc = ::GetWindowLongPtr(pThis->m_hWnd, GWLP_WNDPROC);
lRes = pThis->DefWindowProc(uMsg, wParam, lParam);
if(pThis->m_pfnSuperWindowProc != ::DefWindowProc && ::GetWindowLongPtr(pThis->m_hWnd, GWLP_WNDPROC) == pfnWndProc)
::SetWindowLongPtr(pThis->m_hWnd, GWLP_WNDPROC, (LONG_PTR)pThis->m_pfnSuperWindowProc);
#if (_ATL_VER >= 0x0700)
// mark window as destryed
pThis->m_dwState |= WINSTATE_DESTROYED;
#else // !(_ATL_VER >= 0x0700)
// clear out window handle
HWND hWnd = pThis->m_hWnd;
pThis->m_hWnd = NULL;
// clean up after window is destroyed
pThis->OnFinalMessage(hWnd);
#endif // !(_ATL_VER >= 0x0700)
}
}
#if (_ATL_VER >= 0x0700)
if(pThis->m_dwState & WINSTATE_DESTROYED && pThis->m_pCurrentMsg == NULL)
{
// clear out window handle
HWND hWnd = pThis->m_hWnd;
pThis->m_hWnd = NULL;
pThis->m_dwState &= ~WINSTATE_DESTROYED;
// clean up after window is destroyed
pThis->OnFinalMessage(hWnd);
}
#endif // (_ATL_VER >= 0x0700)
return lRes;
}
// Overriden to call DefWindowProc which uses DefFrameProc
LRESULT DefWindowProc()
{
const MSG* pMsg = m_pCurrentMsg;
LRESULT lRes = 0;
if (pMsg != NULL)
lRes = DefWindowProc(pMsg->message, pMsg->wParam, pMsg->lParam);
return lRes;
}
LRESULT DefWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
return ::DefFrameProc(m_hWnd, m_hWndMDIClient, uMsg, wParam, lParam);
}
BOOL PreTranslateMessage(MSG* pMsg)
{
if(CFrameWindowImplBase<TBase, TWinTraits>::PreTranslateMessage(pMsg))
return TRUE;
return ::TranslateMDISysAccel(m_hWndMDIClient, pMsg);
}
HWND CreateMDIClient(HMENU hWindowMenu = NULL, UINT nID = ATL_IDW_CLIENT, UINT nFirstChildID = ATL_IDM_FIRST_MDICHILD)
{
DWORD dwStyle = WS_VISIBLE | WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | MDIS_ALLCHILDSTYLES;
DWORD dwExStyle = WS_EX_CLIENTEDGE;
CLIENTCREATESTRUCT ccs = { 0 };
ccs.hWindowMenu = hWindowMenu;
ccs.idFirstChild = nFirstChildID;
if((GetStyle() & (WS_HSCROLL | WS_VSCROLL)) != 0)
{
// parent MDI frame's scroll styles move to the MDICLIENT
dwStyle |= (GetStyle() & (WS_HSCROLL | WS_VSCROLL));
// fast way to turn off the scrollbar bits (without a resize)
ModifyStyle(WS_HSCROLL | WS_VSCROLL, 0, SWP_NOREDRAW | SWP_FRAMECHANGED);
}
// Create MDICLIENT window
m_hWndClient = ::CreateWindowEx(dwExStyle, _T("MDIClient"), NULL,
dwStyle, 0, 0, 1, 1, m_hWnd, (HMENU)LongToHandle(nID),
ModuleHelper::GetModuleInstance(), (LPVOID)&ccs);
if (m_hWndClient == NULL)
{
ATLTRACE2(atlTraceUI, 0, _T("MDI Frame failed to create MDICLIENT.\n"));
return NULL;
}
// Move it to the top of z-order
::BringWindowToTop(m_hWndClient);
// set as MDI client window
m_hWndMDIClient = m_hWndClient;
// update to proper size
T* pT = static_cast<T*>(this);
pT->UpdateLayout();
return m_hWndClient;
}
typedef CFrameWindowImplBase<TBase, TWinTraits > _baseClass;
BEGIN_MSG_MAP(CMDIFrameWindowImpl)
MESSAGE_HANDLER(WM_SIZE, OnSize)
MESSAGE_HANDLER(WM_SETFOCUS, OnSetFocus)
MESSAGE_HANDLER(WM_MDISETMENU, OnMDISetMenu)
#ifndef _ATL_NO_REBAR_SUPPORT
#if (_WIN32_IE >= 0x0400)
NOTIFY_CODE_HANDLER(RBN_AUTOSIZE, OnReBarAutoSize)
#endif // (_WIN32_IE >= 0x0400)
#if (_WIN32_IE >= 0x0500)
NOTIFY_CODE_HANDLER(RBN_CHEVRONPUSHED, OnChevronPushed)
#endif // (_WIN32_IE >= 0x0500)
#endif // !_ATL_NO_REBAR_SUPPORT
CHAIN_MSG_MAP(_baseClass)
END_MSG_MAP()
LRESULT OnSize(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
{
if(wParam != SIZE_MINIMIZED)
{
T* pT = static_cast<T*>(this);
pT->UpdateLayout();
}
// message must be handled, otherwise DefFrameProc would resize the client again
return 0;
}
LRESULT OnSetFocus(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
{
// don't allow CFrameWindowImplBase to handle this one
return DefWindowProc(uMsg, wParam, lParam);
}
LRESULT OnMDISetMenu(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
{
SetMDIFrameMenu();
return 0;
}
#ifndef _ATL_NO_REBAR_SUPPORT
#if (_WIN32_IE >= 0x0400)
LRESULT OnReBarAutoSize(int /*idCtrl*/, LPNMHDR /*pnmh*/, BOOL& /*bHandled*/)
{
T* pT = static_cast<T*>(this);
pT->UpdateLayout(FALSE);
return 0;
}
#endif // (_WIN32_IE >= 0x0400)
#if (_WIN32_IE >= 0x0500)
LRESULT OnChevronPushed(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled)
{
T* pT = static_cast<T*>(this);
_ChevronMenuInfo cmi = { NULL, (LPNMREBARCHEVRON)pnmh, false };
if(!pT->PrepareChevronMenu(cmi))
{
bHandled = FALSE;
return 1;
}
// display a popup menu with hidden items
pT->DisplayChevronMenu(cmi);
// cleanup
pT->CleanupChevronMenu(cmi);
return 0;
}
#endif // (_WIN32_IE >= 0x0500)
#endif // !_ATL_NO_REBAR_SUPPORT
};
#endif // !_WIN32_WCE
///////////////////////////////////////////////////////////////////////////////
// CMDIChildWindowImpl
#ifndef _WIN32_WCE
template <class T, class TBase = CMDIWindow, class TWinTraits = ATL::CMDIChildWinTraits>
class ATL_NO_VTABLE CMDIChildWindowImpl : public CFrameWindowImplBase<TBase, TWinTraits >
{
public:
HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
DWORD dwStyle = 0, DWORD dwExStyle = 0,
UINT nMenuID = 0, LPVOID lpCreateParam = NULL)
{
ATOM atom = T::GetWndClassInfo().Register(&m_pfnSuperWindowProc);
if(nMenuID != 0)
m_hMenu = ::LoadMenu(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(nMenuID));
dwStyle = T::GetWndStyle(dwStyle);
dwExStyle = T::GetWndExStyle(dwExStyle);
dwExStyle |= WS_EX_MDICHILD; // force this one
m_pfnSuperWindowProc = ::DefMDIChildProc;
m_hWndMDIClient = hWndParent;
ATLASSERT(::IsWindow(m_hWndMDIClient));
if(rect.m_lpRect == NULL)
rect.m_lpRect = &TBase::rcDefault;
// If the currently active MDI child is maximized, we want to create this one maximized too
ATL::CWindow wndParent = hWndParent;
BOOL bMaximized = FALSE;
wndParent.SendMessage(WM_MDIGETACTIVE, 0, (LPARAM)&bMaximized);
if(bMaximized)
wndParent.SetRedraw(FALSE);
HWND hWnd = CFrameWindowImplBase<TBase, TWinTraits >::Create(hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, (UINT)0U, atom, lpCreateParam);
if(bMaximized)
{
// Maximize and redraw everything
if(hWnd != NULL)
MDIMaximize(hWnd);
wndParent.SetRedraw(TRUE);
wndParent.RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN);
::SetFocus(GetMDIFrame()); // focus will be set back to this window
}
else if(hWnd != NULL && ::IsWindowVisible(m_hWnd) && !::IsChild(hWnd, ::GetFocus()))
{
::SetFocus(hWnd);
}
return hWnd;
}
HWND CreateEx(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR lpcstrWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, LPVOID lpCreateParam = NULL)
{
const int cchName = 256;
TCHAR szWindowName[cchName];
szWindowName[0] = 0;
if(lpcstrWindowName == NULL)
{
::LoadString(ModuleHelper::GetResourceInstance(), T::GetWndClassInfo().m_uCommonResourceID, szWindowName, cchName);
lpcstrWindowName = szWindowName;
}
T* pT = static_cast<T*>(this);
HWND hWnd = pT->Create(hWndParent, rect, lpcstrWindowName, dwStyle, dwExStyle, T::GetWndClassInfo().m_uCommonResourceID, lpCreateParam);
if(hWnd != NULL)
m_hAccel = ::LoadAccelerators(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(T::GetWndClassInfo().m_uCommonResourceID));
return hWnd;
}
BOOL CreateSimpleToolBar(UINT nResourceID = 0, DWORD dwStyle = ATL_SIMPLE_TOOLBAR_STYLE, UINT nID = ATL_IDW_TOOLBAR)
{
ATLASSERT(!::IsWindow(m_hWndToolBar));
if(nResourceID == 0)
nResourceID = T::GetWndClassInfo().m_uCommonResourceID;
m_hWndToolBar = T::CreateSimpleToolBarCtrl(m_hWnd, nResourceID, TRUE, dwStyle, nID);
return (m_hWndToolBar != NULL);
}
BOOL UpdateClientEdge(LPRECT lpRect = NULL)
{
// only adjust for active MDI child window
HWND hWndChild = MDIGetActive();
if(hWndChild != NULL && hWndChild != m_hWnd)
return FALSE;
// need to adjust the client edge style as max/restore happens
DWORD dwStyle = ::GetWindowLong(m_hWndMDIClient, GWL_EXSTYLE);
DWORD dwNewStyle = dwStyle;
if(hWndChild != NULL && ((GetExStyle() & WS_EX_CLIENTEDGE) == 0) && ((GetStyle() & WS_MAXIMIZE) != 0))
dwNewStyle &= ~(WS_EX_CLIENTEDGE);
else
dwNewStyle |= WS_EX_CLIENTEDGE;
if(dwStyle != dwNewStyle)
{
// SetWindowPos will not move invalid bits
::RedrawWindow(m_hWndMDIClient, NULL, NULL,
RDW_INVALIDATE | RDW_ALLCHILDREN);
// remove/add WS_EX_CLIENTEDGE to MDI client area
::SetWindowLong(m_hWndMDIClient, GWL_EXSTYLE, dwNewStyle);
::SetWindowPos(m_hWndMDIClient, NULL, 0, 0, 0, 0,
SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE |
SWP_NOZORDER | SWP_NOCOPYBITS);
// return new client area
if (lpRect != NULL)
::GetClientRect(m_hWndMDIClient, lpRect);
return TRUE;
}
return FALSE;
}
typedef CFrameWindowImplBase<TBase, TWinTraits > _baseClass;
BEGIN_MSG_MAP(CMDIChildWindowImpl)
MESSAGE_HANDLER(WM_SIZE, OnSize)
MESSAGE_HANDLER(WM_WINDOWPOSCHANGED, OnWindowPosChanged)
MESSAGE_HANDLER(WM_MOUSEACTIVATE, OnMouseActivate)
MESSAGE_HANDLER(WM_MENUSELECT, OnMenuSelect)
MESSAGE_HANDLER(WM_MDIACTIVATE, OnMDIActivate)
MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
#ifndef _ATL_NO_REBAR_SUPPORT
#if (_WIN32_IE >= 0x0400)
NOTIFY_CODE_HANDLER(RBN_AUTOSIZE, OnReBarAutoSize)
#endif // (_WIN32_IE >= 0x0400)
#if (_WIN32_IE >= 0x0500)
NOTIFY_CODE_HANDLER(RBN_CHEVRONPUSHED, OnChevronPushed)
#endif // (_WIN32_IE >= 0x0500)
#endif // !_ATL_NO_REBAR_SUPPORT
CHAIN_MSG_MAP(_baseClass)
END_MSG_MAP()
LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
{
DefWindowProc(uMsg, wParam, lParam); // needed for MDI children
if(wParam != SIZE_MINIMIZED)
{
T* pT = static_cast<T*>(this);
pT->UpdateLayout();
}
return 0;
}
LRESULT OnWindowPosChanged(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
{
// update MDI client edge and adjust MDI child rect
LPWINDOWPOS lpWndPos = (LPWINDOWPOS)lParam;
if(!(lpWndPos->flags & SWP_NOSIZE))
{
RECT rectClient;
if(UpdateClientEdge(&rectClient) && ((GetStyle() & WS_MAXIMIZE) != 0))
{
::AdjustWindowRectEx(&rectClient, GetStyle(), FALSE, GetExStyle());
lpWndPos->x = rectClient.left;
lpWndPos->y = rectClient.top;
lpWndPos->cx = rectClient.right - rectClient.left;
lpWndPos->cy = rectClient.bottom - rectClient.top;
}
}
bHandled = FALSE;
return 1;
}
LRESULT OnMouseActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
{
LRESULT lRes = DefWindowProc(uMsg, wParam, lParam);
// Activate this MDI window if needed
if(lRes == MA_ACTIVATE || lRes == MA_ACTIVATEANDEAT)
{
if(MDIGetActive() != m_hWnd)
MDIActivate(m_hWnd);
}
return lRes;
}
LRESULT OnMenuSelect(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
{
return ::SendMessage(GetMDIFrame(), uMsg, wParam, lParam);
}
LRESULT OnMDIActivate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
{
if((HWND)lParam == m_hWnd && m_hMenu != NULL)
SetMDIFrameMenu();
else if((HWND)lParam == NULL)
::SendMessage(GetMDIFrame(), WM_MDISETMENU, 0, 0);
bHandled = FALSE;
return 1;
}
LRESULT OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
{
if(m_hMenu != NULL)
{
::DestroyMenu(m_hMenu);
m_hMenu = NULL;
}
UpdateClientEdge();
bHandled = FALSE;
return 1;
}
#ifndef _ATL_NO_REBAR_SUPPORT
#if (_WIN32_IE >= 0x0400)
LRESULT OnReBarAutoSize(int /*idCtrl*/, LPNMHDR /*pnmh*/, BOOL& /*bHandled*/)
{
T* pT = static_cast<T*>(this);
pT->UpdateLayout(FALSE);
return 0;
}
#endif // (_WIN32_IE >= 0x0400)
#if (_WIN32_IE >= 0x0500)
LRESULT OnChevronPushed(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled)
{
T* pT = static_cast<T*>(this);
_ChevronMenuInfo cmi = { NULL, (LPNMREBARCHEVRON)pnmh, false };
if(!pT->PrepareChevronMenu(cmi))
{
bHandled = FALSE;
return 1;
}
// display a popup menu with hidden items
pT->DisplayChevronMenu(cmi);
// cleanup
pT->CleanupChevronMenu(cmi);
return 0;
}
#endif // (_WIN32_IE >= 0x0500)
#endif // !_ATL_NO_REBAR_SUPPORT
};
#endif // !_WIN32_WCE
///////////////////////////////////////////////////////////////////////////////
// COwnerDraw - MI class for owner-draw support
template <class T>
class COwnerDraw
{
public:
#if (_ATL_VER < 0x0700)
BOOL m_bHandledOD;
BOOL IsMsgHandled() const
{
return m_bHandledOD;
}
void SetMsgHandled(BOOL bHandled)
{
m_bHandledOD = bHandled;
}
#endif // (_ATL_VER < 0x0700)
// Message map and handlers
BEGIN_MSG_MAP(COwnerDraw< T >)
MESSAGE_HANDLER(WM_DRAWITEM, OnDrawItem)
MESSAGE_HANDLER(WM_MEASUREITEM, OnMeasureItem)
MESSAGE_HANDLER(WM_COMPAREITEM, OnCompareItem)
MESSAGE_HANDLER(WM_DELETEITEM, OnDeleteItem)
ALT_MSG_MAP(1)
MESSAGE_HANDLER(OCM_DRAWITEM, OnDrawItem)
MESSAGE_HANDLER(OCM_MEASUREITEM, OnMeasureItem)
MESSAGE_HANDLER(OCM_COMPAREITEM, OnCompareItem)
MESSAGE_HANDLER(OCM_DELETEITEM, OnDeleteItem)
END_MSG_MAP()
LRESULT OnDrawItem(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
{
T* pT = static_cast<T*>(this);
pT->SetMsgHandled(TRUE);
pT->DrawItem((LPDRAWITEMSTRUCT)lParam);
bHandled = pT->IsMsgHandled();
return (LRESULT)TRUE;
}
LRESULT OnMeasureItem(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
{
T* pT = static_cast<T*>(this);
pT->SetMsgHandled(TRUE);
pT->MeasureItem((LPMEASUREITEMSTRUCT)lParam);
bHandled = pT->IsMsgHandled();
return (LRESULT)TRUE;
}
LRESULT OnCompareItem(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
{
T* pT = static_cast<T*>(this);
pT->SetMsgHandled(TRUE);
bHandled = pT->IsMsgHandled();
return (LRESULT)pT->CompareItem((LPCOMPAREITEMSTRUCT)lParam);
}
LRESULT OnDeleteItem(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
{
T* pT = static_cast<T*>(this);
pT->SetMsgHandled(TRUE);
pT->DeleteItem((LPDELETEITEMSTRUCT)lParam);
bHandled = pT->IsMsgHandled();
return (LRESULT)TRUE;
}
// Overrideables
void DrawItem(LPDRAWITEMSTRUCT /*lpDrawItemStruct*/)
{
// must be implemented
ATLASSERT(FALSE);
}
void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct)
{
if(lpMeasureItemStruct->CtlType != ODT_MENU)
{
// return default height for a system font
T* pT = static_cast<T*>(this);
HWND hWnd = pT->GetDlgItem(lpMeasureItemStruct->CtlID);
CClientDC dc(hWnd);
TEXTMETRIC tm = { 0 };
dc.GetTextMetrics(&tm);
lpMeasureItemStruct->itemHeight = tm.tmHeight;
}
else
lpMeasureItemStruct->itemHeight = ::GetSystemMetrics(SM_CYMENU);
}
int CompareItem(LPCOMPAREITEMSTRUCT /*lpCompareItemStruct*/)
{
// all items are equal
return 0;
}
void DeleteItem(LPDELETEITEMSTRUCT /*lpDeleteItemStruct*/)
{
// default - nothing
}
};
///////////////////////////////////////////////////////////////////////////////
// Update UI macros
// these build the Update UI map inside a class definition
#define BEGIN_UPDATE_UI_MAP(thisClass) \
static const CUpdateUIBase::_AtlUpdateUIMap* GetUpdateUIMap() \
{ \
static const _AtlUpdateUIMap theMap[] = \
{
#define UPDATE_ELEMENT(nID, wType) \
{ nID, wType },
#define END_UPDATE_UI_MAP() \
{ (WORD)-1, 0 } \
}; \
return theMap; \
}
///////////////////////////////////////////////////////////////////////////////
// CUpdateUI - manages UI elements updating
class CUpdateUIBase
{
public:
// constants
enum
{
// UI element type
UPDUI_MENUPOPUP = 0x0001,
UPDUI_MENUBAR = 0x0002,
UPDUI_CHILDWINDOW = 0x0004,
UPDUI_TOOLBAR = 0x0008,
UPDUI_STATUSBAR = 0x0010,
// state
UPDUI_ENABLED = 0x0000,
UPDUI_DISABLED = 0x0100,
UPDUI_CHECKED = 0x0200,
UPDUI_CHECKED2 = 0x0400,
UPDUI_RADIO = 0x0800,
UPDUI_DEFAULT = 0x1000,
UPDUI_TEXT = 0x2000,
// internal state
UPDUI_CLEARDEFAULT = 0x4000,
};
// element data
struct _AtlUpdateUIElement
{
HWND m_hWnd;
WORD m_wType;
bool operator ==(const _AtlUpdateUIElement& e) const
{ return (m_hWnd == e.m_hWnd && m_wType == e.m_wType); }
};
// map data
struct _AtlUpdateUIMap
{
WORD m_nID;
WORD m_wType;
bool operator ==(const _AtlUpdateUIMap& e) const
{ return (m_nID == e.m_nID && m_wType == e.m_wType); }
};
// instance data
struct _AtlUpdateUIData
{
WORD m_wState;
union
{
void* m_lpData;
LPTSTR m_lpstrText;
};
bool operator ==(const _AtlUpdateUIData& e) const
{ return (m_wState == e.m_wState && m_lpData == e.m_lpData); }
};
ATL::CSimpleArray<_AtlUpdateUIElement> m_UIElements; // elements data
const _AtlUpdateUIMap* m_pUIMap; // static UI data
_AtlUpdateUIData* m_pUIData; // instance UI data
WORD m_wDirtyType; // global dirty flag
bool m_bBlockAccelerators;
// Constructor, destructor
CUpdateUIBase() : m_pUIMap(NULL), m_pUIData(NULL), m_wDirtyType(0), m_bBlockAccelerators(false)
{ }
~CUpdateUIBase()
{
if(m_pUIMap != NULL && m_pUIData != NULL)
{
const _AtlUpdateUIMap* pUIMap = m_pUIMap;
_AtlUpdateUIData* pUIData = m_pUIData;
while(pUIMap->m_nID != (WORD)-1)
{
if(pUIData->m_wState & UPDUI_TEXT)
delete [] pUIData->m_lpstrText;
pUIMap++;
pUIData++;
}
delete [] m_pUIData;
}
}
// Check for disabled commands
bool UIGetBlockAccelerators() const
{
return m_bBlockAccelerators;
}
bool UISetBlockAccelerators(bool bBlock)
{
bool bOld = m_bBlockAccelerators;
m_bBlockAccelerators = bBlock;
return bOld;
}
// Add elements
BOOL UIAddMenuBar(HWND hWnd) // menu bar (main menu)
{
if(hWnd == NULL)
return FALSE;
_AtlUpdateUIElement e;
e.m_hWnd = hWnd;
e.m_wType = UPDUI_MENUBAR;
return m_UIElements.Add(e);
}
BOOL UIAddToolBar(HWND hWnd) // toolbar
{
if(hWnd == NULL)
return FALSE;
_AtlUpdateUIElement e;
e.m_hWnd = hWnd;
e.m_wType = UPDUI_TOOLBAR;
return m_UIElements.Add(e);
}
BOOL UIAddStatusBar(HWND hWnd) // status bar
{
if(hWnd == NULL)
return FALSE;
_AtlUpdateUIElement e;
e.m_hWnd = hWnd;
e.m_wType = UPDUI_STATUSBAR;
return m_UIElements.Add(e);
}
BOOL UIAddChildWindowContainer(HWND hWnd) // child window
{
if(hWnd == NULL)
return FALSE;
_AtlUpdateUIElement e;
e.m_hWnd = hWnd;
e.m_wType = UPDUI_CHILDWINDOW;
return m_UIElements.Add(e);
}
// Message map for popup menu updates and accelerator blocking
BEGIN_MSG_MAP(CUpdateUIBase)
MESSAGE_HANDLER(WM_INITMENUPOPUP, OnInitMenuPopup)
MESSAGE_HANDLER(WM_COMMAND, OnCommand)
END_MSG_MAP()
LRESULT OnInitMenuPopup(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
{
bHandled = FALSE;
HMENU hMenu = (HMENU)wParam;
if(hMenu == NULL)
return 1;
_AtlUpdateUIData* pUIData = m_pUIData;
if(pUIData == NULL)
return 1;
const _AtlUpdateUIMap* pMap = m_pUIMap;
while(pMap->m_nID != (WORD)-1)
{
if(pMap->m_wType & UPDUI_MENUPOPUP)
UIUpdateMenuBarElement(pMap->m_nID, pUIData, hMenu);
pMap++;
pUIData++;
}
return 0;
}
LRESULT OnCommand(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
{
bHandled = FALSE;
if(m_bBlockAccelerators && HIWORD(wParam) == 1) // accelerators only
{
int nID = LOWORD(wParam);
if((UIGetState(nID) & UPDUI_DISABLED) == UPDUI_DISABLED)
{
ATLTRACE2(atlTraceUI, 0, _T("CUpdateUIBase::OnCommand - blocked disabled command 0x%4.4X\n"), nID);
bHandled = TRUE; // eat the command, UI item is disabled
}
}
return 0;
}
// methods for setting UI element state
BOOL UIEnable(int nID, BOOL bEnable, BOOL bForceUpdate = FALSE)
{
const _AtlUpdateUIMap* pMap = m_pUIMap;
_AtlUpdateUIData* pUIData = m_pUIData;
if(pUIData == NULL)
return FALSE;
for( ; pMap->m_nID != (WORD)-1; pMap++, pUIData++)
{
if(nID == (int)pMap->m_nID)
{
if(bEnable)
{
if(pUIData->m_wState & UPDUI_DISABLED)
{
pUIData->m_wState |= pMap->m_wType;
pUIData->m_wState &= ~UPDUI_DISABLED;
}
}
else
{
if(!(pUIData->m_wState & UPDUI_DISABLED))
{
pUIData->m_wState |= pMap->m_wType;
pUIData->m_wState |= UPDUI_DISABLED;
}
}
if(bForceUpdate)
pUIData->m_wState |= pMap->m_wType;
if(pUIData->m_wState & pMap->m_wType)
m_wDirtyType |= pMap->m_wType;
break; // found
}
}
return TRUE;
}
BOOL UISetCheck(int nID, int nCheck, BOOL bForceUpdate = FALSE)
{
const _AtlUpdateUIMap* pMap = m_pUIMap;
_AtlUpdateUIData* pUIData = m_pUIData;
if(pUIData == NULL)
return FALSE;
for( ; pMap->m_nID != (WORD)-1; pMap++, pUIData++)
{
if(nID == (int)pMap->m_nID)
{
switch(nCheck)
{
case 0:
if((pUIData->m_wState & UPDUI_CHECKED) || (pUIData->m_wState & UPDUI_CHECKED2))
{
pUIData->m_wState |= pMap->m_wType;
pUIData->m_wState &= ~(UPDUI_CHECKED | UPDUI_CHECKED2);
}
break;
case 1:
if(!(pUIData->m_wState & UPDUI_CHECKED))
{
pUIData->m_wState |= pMap->m_wType;
pUIData->m_wState &= ~UPDUI_CHECKED2;
pUIData->m_wState |= UPDUI_CHECKED;
}
break;
case 2:
if(!(pUIData->m_wState & UPDUI_CHECKED2))
{
pUIData->m_wState |= pMap->m_wType;
pUIData->m_wState &= ~UPDUI_CHECKED;
pUIData->m_wState |= UPDUI_CHECKED2;
}
break;
}
if(bForceUpdate)
pUIData->m_wState |= pMap->m_wType;
if(pUIData->m_wState & pMap->m_wType)
m_wDirtyType |= pMap->m_wType;
break; // found
}
}
return TRUE;
}
// variant that supports bool (checked/not-checked, no intermediate state)
BOOL UISetCheck(int nID, bool bCheck, BOOL bForceUpdate = FALSE)
{
return UISetCheck(nID, bCheck ? 1 : 0, bForceUpdate);
}
BOOL UISetRadio(int nID, BOOL bRadio, BOOL bForceUpdate = FALSE)
{
const _AtlUpdateUIMap* pMap = m_pUIMap;
_AtlUpdateUIData* pUIData = m_pUIData;
if(pUIData == NULL)
return FALSE;
for( ; pMap->m_nID != (WORD)-1; pMap++, pUIData++)
{
if(nID == (int)pMap->m_nID)
{
if(bRadio)
{
if(!(pUIData->m_wState & UPDUI_RADIO))
{
pUIData->m_wState |= pMap->m_wType;
pUIData->m_wState |= UPDUI_RADIO;
}
}
else
{
if(pUIData->m_wState & UPDUI_RADIO)
{
pUIData->m_wState |= pMap->m_wType;
pUIData->m_wState &= ~UPDUI_RADIO;
}
}
if(bForceUpdate)
pUIData->m_wState |= pMap->m_wType;
if(pUIData->m_wState & pMap->m_wType)
m_wDirtyType |= pMap->m_wType;
break; // found
}
}
return TRUE;
}
BOOL UISetText(int nID, LPCTSTR lpstrText, BOOL bForceUpdate = FALSE)
{
const _AtlUpdateUIMap* pMap = m_pUIMap;
_AtlUpdateUIData* pUIData = m_pUIData;
if(pUIData == NULL)
return FALSE;
if(lpstrText == NULL)
lpstrText = _T("");
for( ; pMap->m_nID != (WORD)-1; pMap++, pUIData++)
{
if(nID == (int)pMap->m_nID)
{
if(pUIData->m_lpstrText == NULL || lstrcmp(pUIData->m_lpstrText, lpstrText))
{
delete [] pUIData->m_lpstrText;
pUIData->m_lpstrText = NULL;
int nStrLen = lstrlen(lpstrText);
ATLTRY(pUIData->m_lpstrText = new TCHAR[nStrLen + 1]);
if(pUIData->m_lpstrText == NULL)
{
ATLTRACE2(atlTraceUI, 0, _T("UISetText - memory allocation failed\n"));
break;
}
SecureHelper::strcpy_x(pUIData->m_lpstrText, nStrLen + 1, lpstrText);
pUIData->m_wState |= (UPDUI_TEXT | pMap->m_wType);
}
if(bForceUpdate)
pUIData->m_wState |= (UPDUI_TEXT | pMap->m_wType);
if(pUIData->m_wState & pMap->m_wType)
m_wDirtyType |= pMap->m_wType;
break; // found
}
}
return TRUE;
}
BOOL UISetDefault(int nID, BOOL bDefault, BOOL bForceUpdate = FALSE)
{
const _AtlUpdateUIMap* pMap = m_pUIMap;
_AtlUpdateUIData* pUIData = m_pUIData;
if(pUIData == NULL)
return FALSE;
for( ; pMap->m_nID != (WORD)-1; pMap++, pUIData++)
{
if(nID == (int)pMap->m_nID)
{
if(bDefault)
{
if((pUIData->m_wState & UPDUI_DEFAULT) == 0)
{
pUIData->m_wState |= pMap->m_wType;
pUIData->m_wState |= UPDUI_DEFAULT;
}
}
else
{
if((pUIData->m_wState & UPDUI_DEFAULT) != 0)
{
pUIData->m_wState |= pMap->m_wType;
pUIData->m_wState &= ~UPDUI_DEFAULT;
pUIData->m_wState |= UPDUI_CLEARDEFAULT;
}
}
if(bForceUpdate)
pUIData->m_wState |= pMap->m_wType;
if(pUIData->m_wState & pMap->m_wType)
m_wDirtyType |= pMap->m_wType;
break; // found
}
}
return TRUE;
}
// methods for complete state set/get
BOOL UISetState(int nID, DWORD dwState)
{
const _AtlUpdateUIMap* pMap = m_pUIMap;
_AtlUpdateUIData* pUIData = m_pUIData;
if(pUIData == NULL)
return FALSE;
for( ; pMap->m_nID != (WORD)-1; pMap++, pUIData++)
{
if(nID == (int)pMap->m_nID)
{
pUIData->m_wState = (WORD)(dwState | pMap->m_wType);
m_wDirtyType |= pMap->m_wType;
break; // found
}
}
return TRUE;
}
DWORD UIGetState(int nID)
{
const _AtlUpdateUIMap* pMap = m_pUIMap;
_AtlUpdateUIData* pUIData = m_pUIData;
if(pUIData == NULL)
return 0;
for( ; pMap->m_nID != (WORD)-1; pMap++, pUIData++)
{
if(nID == (int)pMap->m_nID)
return pUIData->m_wState;
}
return 0;
}
// methods for updating UI
#ifndef _WIN32_WCE
BOOL UIUpdateMenuBar(BOOL bForceUpdate = FALSE, BOOL bMainMenu = FALSE)
{
if(!(m_wDirtyType & UPDUI_MENUBAR) && !bForceUpdate)
return TRUE;
const _AtlUpdateUIMap* pMap = m_pUIMap;
_AtlUpdateUIData* pUIData = m_pUIData;
if(pUIData == NULL)
return FALSE;
while(pMap->m_nID != (WORD)-1)
{
for(int i = 0; i < m_UIElements.GetSize(); i++)
{
if(m_UIElements[i].m_wType == UPDUI_MENUBAR)
{
HMENU hMenu = ::GetMenu(m_UIElements[i].m_hWnd);
if(hMenu != NULL && (pUIData->m_wState & UPDUI_MENUBAR) && (pMap->m_wType & UPDUI_MENUBAR))
UIUpdateMenuBarElement(pMap->m_nID, pUIData, hMenu);
}
if(bMainMenu)
::DrawMenuBar(m_UIElements[i].m_hWnd);
}
pMap++;
pUIData->m_wState &= ~UPDUI_MENUBAR;
if(pUIData->m_wState & UPDUI_TEXT)
{
delete [] pUIData->m_lpstrText;
pUIData->m_lpstrText = NULL;
pUIData->m_wState &= ~UPDUI_TEXT;
}
pUIData++;
}
m_wDirtyType &= ~UPDUI_MENUBAR;
return TRUE;
}
#endif // !_WIN32_WCE
BOOL UIUpdateToolBar(BOOL bForceUpdate = FALSE)
{
if(!(m_wDirtyType & UPDUI_TOOLBAR) && !bForceUpdate)
return TRUE;
const _AtlUpdateUIMap* pMap = m_pUIMap;
_AtlUpdateUIData* pUIData = m_pUIData;
if(pUIData == NULL)
return FALSE;
while(pMap->m_nID != (WORD)-1)
{
for(int i = 0; i < m_UIElements.GetSize(); i++)
{
if(m_UIElements[i].m_wType == UPDUI_TOOLBAR)
{
if((pUIData->m_wState & UPDUI_TOOLBAR) && (pMap->m_wType & UPDUI_TOOLBAR))
UIUpdateToolBarElement(pMap->m_nID, pUIData, m_UIElements[i].m_hWnd);
}
}
pMap++;
pUIData->m_wState &= ~UPDUI_TOOLBAR;
pUIData++;
}
m_wDirtyType &= ~UPDUI_TOOLBAR;
return TRUE;
}
BOOL UIUpdateStatusBar(BOOL bForceUpdate = FALSE)
{
if(!(m_wDirtyType & UPDUI_STATUSBAR) && !bForceUpdate)
return TRUE;
const _AtlUpdateUIMap* pMap = m_pUIMap;
_AtlUpdateUIData* pUIData = m_pUIData;
if(pUIData == NULL)
return FALSE;
while(pMap->m_nID != (WORD)-1)
{
for(int i = 0; i < m_UIElements.GetSize(); i++)
{
if(m_UIElements[i].m_wType == UPDUI_STATUSBAR)
{
if((pUIData->m_wState & UPDUI_STATUSBAR) && (pMap->m_wType & UPDUI_STATUSBAR))
UIUpdateStatusBarElement(pMap->m_nID, pUIData, m_UIElements[i].m_hWnd);
}
}
pMap++;
pUIData->m_wState &= ~UPDUI_STATUSBAR;
if(pUIData->m_wState & UPDUI_TEXT)
{
delete [] pUIData->m_lpstrText;
pUIData->m_lpstrText = NULL;
pUIData->m_wState &= ~UPDUI_TEXT;
}
pUIData++;
}
m_wDirtyType &= ~UPDUI_STATUSBAR;
return TRUE;
}
BOOL UIUpdateChildWindows(BOOL bForceUpdate = FALSE)
{
if(!(m_wDirtyType & UPDUI_CHILDWINDOW) && !bForceUpdate)
return TRUE;
const _AtlUpdateUIMap* pMap = m_pUIMap;
_AtlUpdateUIData* pUIData = m_pUIData;
if(pUIData == NULL)
return FALSE;
while(pMap->m_nID != (WORD)-1)
{
for(int i = 0; i < m_UIElements.GetSize(); i++)
{
if(m_UIElements[i].m_wType == UPDUI_CHILDWINDOW)
{
if((pUIData->m_wState & UPDUI_CHILDWINDOW) && (pMap->m_wType & UPDUI_CHILDWINDOW))
UIUpdateChildWindow(pMap->m_nID, pUIData, m_UIElements[i].m_hWnd);
}
}
pMap++;
pUIData->m_wState &= ~UPDUI_CHILDWINDOW;
if(pUIData->m_wState & UPDUI_TEXT)
{
delete [] pUIData->m_lpstrText;
pUIData->m_lpstrText = NULL;
pUIData->m_wState &= ~UPDUI_TEXT;
}
pUIData++;
}
m_wDirtyType &= ~UPDUI_CHILDWINDOW;
return TRUE;
}
// internal element specific methods
static void UIUpdateMenuBarElement(int nID, _AtlUpdateUIData* pUIData, HMENU hMenu)
{
#ifndef _WIN32_WCE
if((pUIData->m_wState & UPDUI_CLEARDEFAULT) != 0)
{
::SetMenuDefaultItem(hMenu, (UINT)-1, 0);
pUIData->m_wState &= ~UPDUI_CLEARDEFAULT;
}
#endif // !_WIN32_WCE
CMenuItemInfo mii;
mii.fMask = MIIM_STATE;
mii.wID = nID;
#ifndef _WIN32_WCE
if((pUIData->m_wState & UPDUI_DISABLED) != 0)
mii.fState |= MFS_DISABLED | MFS_GRAYED;
else
mii.fState |= MFS_ENABLED;
if((pUIData->m_wState & UPDUI_CHECKED) != 0)
mii.fState |= MFS_CHECKED;
else
mii.fState |= MFS_UNCHECKED;
if((pUIData->m_wState & UPDUI_DEFAULT) != 0)
mii.fState |= MFS_DEFAULT;
#else // CE specific
// ::SetMenuItemInfo() can't disable or check menu items
// on Windows CE, so we have to do that directly
UINT uEnable = MF_BYCOMMAND;
if((pUIData->m_wState & UPDUI_DISABLED) != 0)
uEnable |= MF_GRAYED;
else
uEnable |= MF_ENABLED;
::EnableMenuItem(hMenu, nID, uEnable);
UINT uCheck = MF_BYCOMMAND;
if((pUIData->m_wState & UPDUI_CHECKED) != 0)
uCheck |= MF_CHECKED;
else
uCheck |= MF_UNCHECKED;
::CheckMenuItem(hMenu, nID, uCheck);
#endif // _WIN32_WCE
if((pUIData->m_wState & UPDUI_TEXT) != 0)
{
CMenuItemInfo miiNow;
miiNow.fMask = MIIM_TYPE;
miiNow.wID = nID;
if(::GetMenuItemInfo(hMenu, nID, FALSE, &miiNow))
{
mii.fMask |= MIIM_TYPE;
// MFT_BITMAP and MFT_SEPARATOR don't go together with MFT_STRING
#ifndef _WIN32_WCE
mii.fType |= (miiNow.fType & ~(MFT_BITMAP | MFT_SEPARATOR)) | MFT_STRING;
#else // CE specific
mii.fType |= (miiNow.fType & ~(MFT_SEPARATOR)) | MFT_STRING;
#endif // _WIN32_WCE
mii.dwTypeData = pUIData->m_lpstrText;
}
}
::SetMenuItemInfo(hMenu, nID, FALSE, &mii);
}
static void UIUpdateToolBarElement(int nID, _AtlUpdateUIData* pUIData, HWND hWndToolBar)
{
// Note: only handles enabled/disabled, checked state, and radio (press)
::SendMessage(hWndToolBar, TB_ENABLEBUTTON, nID, (LPARAM)(pUIData->m_wState & UPDUI_DISABLED) ? FALSE : TRUE);
::SendMessage(hWndToolBar, TB_CHECKBUTTON, nID, (LPARAM)(pUIData->m_wState & UPDUI_CHECKED) ? TRUE : FALSE);
::SendMessage(hWndToolBar, TB_INDETERMINATE, nID, (LPARAM)(pUIData->m_wState & UPDUI_CHECKED2) ? TRUE : FALSE);
::SendMessage(hWndToolBar, TB_PRESSBUTTON, nID, (LPARAM)(pUIData->m_wState & UPDUI_RADIO) ? TRUE : FALSE);
}
static void UIUpdateStatusBarElement(int nID, _AtlUpdateUIData* pUIData, HWND hWndStatusBar)
{
// Note: only handles text
if(pUIData->m_wState & UPDUI_TEXT)
::SendMessage(hWndStatusBar, SB_SETTEXT, nID, (LPARAM)pUIData->m_lpstrText);
}
static void UIUpdateChildWindow(int nID, _AtlUpdateUIData* pUIData, HWND hWnd)
{
HWND hChild = ::GetDlgItem(hWnd, nID);
::EnableWindow(hChild, (pUIData->m_wState & UPDUI_DISABLED) ? FALSE : TRUE);
// for check and radio, assume that window is a button
int nCheck = BST_UNCHECKED;
if(pUIData->m_wState & UPDUI_CHECKED || pUIData->m_wState & UPDUI_RADIO)
nCheck = BST_CHECKED;
else if(pUIData->m_wState & UPDUI_CHECKED2)
nCheck = BST_INDETERMINATE;
::SendMessage(hChild, BM_SETCHECK, nCheck, 0L);
if(pUIData->m_wState & UPDUI_DEFAULT)
{
DWORD dwRet = (DWORD)::SendMessage(hWnd, DM_GETDEFID, 0, 0L);
if(HIWORD(dwRet) == DC_HASDEFID)
{
HWND hOldDef = ::GetDlgItem(hWnd, (int)(short)LOWORD(dwRet));
// remove BS_DEFPUSHBUTTON
::SendMessage(hOldDef, BM_SETSTYLE, BS_PUSHBUTTON, MAKELPARAM(TRUE, 0));
}
::SendMessage(hWnd, DM_SETDEFID, nID, 0L);
}
if(pUIData->m_wState & UPDUI_TEXT)
::SetWindowText(hChild, pUIData->m_lpstrText);
}
};
template <class T>
class CUpdateUI : public CUpdateUIBase
{
public:
CUpdateUI()
{
T* pT = static_cast<T*>(this);
pT;
const _AtlUpdateUIMap* pMap = pT->GetUpdateUIMap();
m_pUIMap = pMap;
ATLASSERT(m_pUIMap != NULL);
int nCount;
for(nCount = 1; pMap->m_nID != (WORD)-1; nCount++)
pMap++;
// check for duplicates (debug only)
#ifdef _DEBUG
for(int i = 0; i < nCount; i++)
{
for(int j = 0; j < nCount; j++)
{
// shouldn't have duplicates in the update UI map
if(i != j)
ATLASSERT(m_pUIMap[j].m_nID != m_pUIMap[i].m_nID);
}
}
#endif // _DEBUG
ATLTRY(m_pUIData = new _AtlUpdateUIData[nCount]);
ATLASSERT(m_pUIData != NULL);
if(m_pUIData != NULL)
memset(m_pUIData, 0, sizeof(_AtlUpdateUIData) * nCount);
}
};
///////////////////////////////////////////////////////////////////////////////
// CDynamicUpdateUI - allows update elements to dynamically added and removed
// in addition to a static update UI map
template <class T>
class CDynamicUpdateUI : public CUpdateUIBase
{
public:
// Data members
ATL::CSimpleArray<_AtlUpdateUIMap> m_arrUIMap; // copy of the static UI data
ATL::CSimpleArray<_AtlUpdateUIData> m_arrUIData; // instance UI data
// Constructor/destructor
CDynamicUpdateUI()
{
T* pT = static_cast<T*>(this);
pT;
const _AtlUpdateUIMap* pMap = pT->GetUpdateUIMap();
ATLASSERT(pMap != NULL);
for(;;)
{
BOOL bRet = m_arrUIMap.Add(*(_AtlUpdateUIMap*)pMap);
ATLASSERT(bRet);
if(bRet != FALSE)
{
_AtlUpdateUIData data = { 0, NULL };
bRet = m_arrUIData.Add(data);
ATLASSERT(bRet);
}
if(pMap->m_nID == (WORD)-1)
break;
pMap++;
}
ATLASSERT(m_arrUIMap.GetSize() == m_arrUIData.GetSize());
#ifdef _DEBUG
// check for duplicates (debug only)
for(int i = 0; i < m_arrUIMap.GetSize(); i++)
{
for(int j = 0; j < m_arrUIMap.GetSize(); j++)
{
// shouldn't have duplicates in the update UI map
if(i != j)
ATLASSERT(m_arrUIMap[j].m_nID != m_arrUIMap[i].m_nID);
}
}
#endif // _DEBUG
// Set internal data pointers to point to the new data arrays
m_pUIMap = m_arrUIMap.m_aT;
m_pUIData = m_arrUIData.m_aT;
}
~CDynamicUpdateUI()
{
for(int i = 0; i < m_arrUIData.GetSize(); i++)
{
if((m_arrUIData[i].m_wState & UPDUI_TEXT) != 0)
delete [] m_arrUIData[i].m_lpstrText;
}
// Reset internal data pointers (memory will be released by CSimpleArray d-tor)
m_pUIMap = NULL;
m_pUIData = NULL;
}
// Methods for dynamically adding and removing update elements
bool UIAddUpdateElement(WORD nID, WORD wType)
{
// check for duplicates
for(int i = 0; i < m_arrUIMap.GetSize(); i++)
{
// shouldn't have duplicates in the update UI map
ATLASSERT(m_arrUIMap[i].m_nID != nID);
if(m_arrUIMap[i].m_nID == nID)
return false;
}
bool bRetVal = false;
// Add new end element
_AtlUpdateUIMap uumEnd = { (WORD)-1, 0 };
BOOL bRet = m_arrUIMap.Add(uumEnd);
ATLASSERT(bRet);
if(bRet != FALSE)
{
_AtlUpdateUIData uud = { 0, NULL };
bRet = m_arrUIData.Add(uud);
ATLASSERT(bRet);
// Set new data to the previous end element
if(bRet != FALSE)
{
int nSize = m_arrUIMap.GetSize();
_AtlUpdateUIMap uum = { nID, wType };
m_arrUIMap.SetAtIndex(nSize - 2, uum);
m_arrUIData.SetAtIndex(nSize - 2, uud);
// Set internal data pointers again, just in case that memory moved
m_pUIMap = m_arrUIMap.m_aT;
m_pUIData = m_arrUIData.m_aT;
bRetVal = true;
}
}
return bRetVal;
}
bool UIRemoveUpdateElement(WORD nID)
{
bool bRetVal = false;
for(int i = 0; i < m_arrUIMap.GetSize(); i++)
{
if(m_arrUIMap[i].m_nID == nID)
{
BOOL bRet = m_arrUIMap.RemoveAt(i);
ATLASSERT(bRet);
bRet = m_arrUIData.RemoveAt(i);
ATLASSERT(bRet);
bRetVal = true;
break;
}
}
return bRetVal;
}
};
///////////////////////////////////////////////////////////////////////////////
// CDialogResize - provides support for resizing dialog controls
// (works for any window that has child controls)
// Put CDialogResize in the list of base classes for a dialog (or even plain window),
// then implement DLGRESIZE map by specifying controls and groups of control
// and using DLSZ_* values to specify how are they supposed to be resized.
//
// Notes:
// - Resizeable border (WS_THICKFRAME style) should be set in the dialog template
// for top level dialogs (popup or overlapped), so that users can resize the dialog.
// - Some flags cannot be combined; for instance DLSZ_CENTER_X overrides DLSZ_SIZE_X,
// DLSZ_SIZE_X overrides DLSZ_MOVE_X. X and Y flags can be combined.
// - Order of controls is important - group controls are resized and moved based
// on the position of the previous control in a group.
// dialog resize map macros
#define BEGIN_DLGRESIZE_MAP(thisClass) \
static const _AtlDlgResizeMap* GetDlgResizeMap() \
{ \
static const _AtlDlgResizeMap theMap[] = \
{
#define END_DLGRESIZE_MAP() \
{ -1, 0 }, \
}; \
return theMap; \
}
#define DLGRESIZE_CONTROL(id, flags) \
{ id, flags },
#define BEGIN_DLGRESIZE_GROUP() \
{ -1, _DLSZ_BEGIN_GROUP },
#define END_DLGRESIZE_GROUP() \
{ -1, _DLSZ_END_GROUP },
template <class T>
class CDialogResize
{
public:
// Data declarations and members
enum
{
DLSZ_SIZE_X = 0x00000001,
DLSZ_SIZE_Y = 0x00000002,
DLSZ_MOVE_X = 0x00000004,
DLSZ_MOVE_Y = 0x00000008,
DLSZ_REPAINT = 0x00000010,
DLSZ_CENTER_X = 0x00000020,
DLSZ_CENTER_Y = 0x00000040,
// internal use only
_DLSZ_BEGIN_GROUP = 0x00001000,
_DLSZ_END_GROUP = 0x00002000,
_DLSZ_GRIPPER = 0x00004000
};
struct _AtlDlgResizeMap
{
int m_nCtlID;
DWORD m_dwResizeFlags;
};
struct _AtlDlgResizeData
{
int m_nCtlID;
DWORD m_dwResizeFlags;
RECT m_rect;
int GetGroupCount() const
{
return (int)LOBYTE(HIWORD(m_dwResizeFlags));
}
void SetGroupCount(int nCount)
{
ATLASSERT(nCount > 0 && nCount < 256);
DWORD dwCount = (DWORD)MAKELONG(0, MAKEWORD(nCount, 0));
m_dwResizeFlags &= 0xFF00FFFF;
m_dwResizeFlags |= dwCount;
}
bool operator ==(const _AtlDlgResizeData& r) const
{ return (m_nCtlID == r.m_nCtlID && m_dwResizeFlags == r.m_dwResizeFlags); }
};
ATL::CSimpleArray<_AtlDlgResizeData> m_arrData;
SIZE m_sizeDialog;
POINT m_ptMinTrackSize;
bool m_bGripper;
// Constructor
CDialogResize() : m_bGripper(false)
{
m_sizeDialog.cx = 0;
m_sizeDialog.cy = 0;
m_ptMinTrackSize.x = -1;
m_ptMinTrackSize.y = -1;
}
// Operations
void DlgResize_Init(bool bAddGripper = true, bool bUseMinTrackSize = true, DWORD dwForceStyle = WS_CLIPCHILDREN)
{
T* pT = static_cast<T*>(this);
ATLASSERT(::IsWindow(pT->m_hWnd));
DWORD dwStyle = pT->GetStyle();
#ifdef _DEBUG
// Debug only: Check if top level dialogs have a resizeable border.
if(((dwStyle & WS_CHILD) == 0) && ((dwStyle & WS_THICKFRAME) == 0))
ATLTRACE2(atlTraceUI, 0, _T("DlgResize_Init - warning: top level dialog without the WS_THICKFRAME style - user cannot resize it\n"));
#endif // _DEBUG
// Force specified styles (default WS_CLIPCHILDREN reduces flicker)
if((dwStyle & dwForceStyle) != dwForceStyle)
pT->ModifyStyle(0, dwForceStyle);
// Adding this style removes an empty icon that dialogs with WS_THICKFRAME have.
// Setting icon to NULL is required when XP themes are active.
// Note: This will not prevent adding an icon for the dialog using SetIcon()
if((dwStyle & WS_CHILD) == 0)
{
pT->ModifyStyleEx(0, WS_EX_DLGMODALFRAME);
if(pT->GetIcon(FALSE) == NULL)
pT->SetIcon(NULL, FALSE);
}
// Cleanup in case of multiple initialization
// block: first check for the gripper control, destroy it if needed
{
ATL::CWindow wndGripper = pT->GetDlgItem(ATL_IDW_STATUS_BAR);
if(wndGripper.IsWindow() && m_arrData.GetSize() > 0 && (m_arrData[0].m_dwResizeFlags & _DLSZ_GRIPPER) != 0)
wndGripper.DestroyWindow();
}
// clear out everything else
m_arrData.RemoveAll();
m_sizeDialog.cx = 0;
m_sizeDialog.cy = 0;
m_ptMinTrackSize.x = -1;
m_ptMinTrackSize.y = -1;
// Get initial dialog client size
RECT rectDlg = { 0 };
pT->GetClientRect(&rectDlg);
m_sizeDialog.cx = rectDlg.right;
m_sizeDialog.cy = rectDlg.bottom;
#ifndef _WIN32_WCE
// Create gripper if requested
m_bGripper = false;
if(bAddGripper)
{
// shouldn't exist already
ATLASSERT(!::IsWindow(pT->GetDlgItem(ATL_IDW_STATUS_BAR)));
if(!::IsWindow(pT->GetDlgItem(ATL_IDW_STATUS_BAR)))
{
ATL::CWindow wndGripper;
wndGripper.Create(_T("SCROLLBAR"), pT->m_hWnd, rectDlg, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | SBS_SIZEBOX | SBS_SIZEGRIP | SBS_SIZEBOXBOTTOMRIGHTALIGN, 0, ATL_IDW_STATUS_BAR);
ATLASSERT(wndGripper.IsWindow());
if(wndGripper.IsWindow())
{
m_bGripper = true;
RECT rectCtl = { 0 };
wndGripper.GetWindowRect(&rectCtl);
::MapWindowPoints(NULL, pT->m_hWnd, (LPPOINT)&rectCtl, 2);
_AtlDlgResizeData data = { ATL_IDW_STATUS_BAR, DLSZ_MOVE_X | DLSZ_MOVE_Y | DLSZ_REPAINT | _DLSZ_GRIPPER, { rectCtl.left, rectCtl.top, rectCtl.right, rectCtl.bottom } };
m_arrData.Add(data);
}
}
}
#else // CE specific
bAddGripper; // avoid level 4 warning
#endif // _WIN32_WCE
// Get min track position if requested
if(bUseMinTrackSize)
{
if((dwStyle & WS_CHILD) != 0)
{
RECT rect = { 0 };
pT->GetClientRect(&rect);
m_ptMinTrackSize.x = rect.right - rect.left;
m_ptMinTrackSize.y = rect.bottom - rect.top;
}
else
{
RECT rect = { 0 };
pT->GetWindowRect(&rect);
m_ptMinTrackSize.x = rect.right - rect.left;
m_ptMinTrackSize.y = rect.bottom - rect.top;
}
}
// Walk the map and initialize data
const _AtlDlgResizeMap* pMap = pT->GetDlgResizeMap();
ATLASSERT(pMap != NULL);
int nGroupStart = -1;
for(int nCount = 1; !(pMap->m_nCtlID == -1 && pMap->m_dwResizeFlags == 0); nCount++, pMap++)
{
if(pMap->m_nCtlID == -1)
{
switch(pMap->m_dwResizeFlags)
{
case _DLSZ_BEGIN_GROUP:
ATLASSERT(nGroupStart == -1);
nGroupStart = m_arrData.GetSize();
break;
case _DLSZ_END_GROUP:
{
ATLASSERT(nGroupStart != -1);
int nGroupCount = m_arrData.GetSize() - nGroupStart;
m_arrData[nGroupStart].SetGroupCount(nGroupCount);
nGroupStart = -1;
}
break;
default:
ATLASSERT(FALSE && _T("Invalid DLGRESIZE Map Entry"));
break;
}
}
else
{
// this ID conflicts with the default gripper one
ATLASSERT(m_bGripper ? (pMap->m_nCtlID != ATL_IDW_STATUS_BAR) : TRUE);
ATL::CWindow ctl = pT->GetDlgItem(pMap->m_nCtlID);
ATLASSERT(ctl.IsWindow());
RECT rectCtl = { 0 };
ctl.GetWindowRect(&rectCtl);
::MapWindowPoints(NULL, pT->m_hWnd, (LPPOINT)&rectCtl, 2);
DWORD dwGroupFlag = (nGroupStart != -1 && m_arrData.GetSize() == nGroupStart) ? _DLSZ_BEGIN_GROUP : 0;
_AtlDlgResizeData data = { pMap->m_nCtlID, pMap->m_dwResizeFlags | dwGroupFlag, { rectCtl.left, rectCtl.top, rectCtl.right, rectCtl.bottom } };
m_arrData.Add(data);
}
}
ATLASSERT((nGroupStart == -1) && _T("No End Group Entry in the DLGRESIZE Map"));
}
void DlgResize_UpdateLayout(int cxWidth, int cyHeight)
{
T* pT = static_cast<T*>(this);
ATLASSERT(::IsWindow(pT->m_hWnd));
// Restrict minimum size if requested
if(((pT->GetStyle() & WS_CHILD) != 0) && m_ptMinTrackSize.x != -1 && m_ptMinTrackSize.y != -1)
{
if(cxWidth < m_ptMinTrackSize.x)
cxWidth = m_ptMinTrackSize.x;
if(cyHeight < m_ptMinTrackSize.y)
cyHeight = m_ptMinTrackSize.y;
}
BOOL bVisible = pT->IsWindowVisible();
if(bVisible)
pT->SetRedraw(FALSE);
for(int i = 0; i < m_arrData.GetSize(); i++)
{
if((m_arrData[i].m_dwResizeFlags & _DLSZ_BEGIN_GROUP) != 0) // start of a group
{
int nGroupCount = m_arrData[i].GetGroupCount();
ATLASSERT(nGroupCount > 0 && i + nGroupCount - 1 < m_arrData.GetSize());
RECT rectGroup = m_arrData[i].m_rect;
int j = 1;
for(j = 1; j < nGroupCount; j++)
{
rectGroup.left = min(rectGroup.left, m_arrData[i + j].m_rect.left);
rectGroup.top = min(rectGroup.top, m_arrData[i + j].m_rect.top);
rectGroup.right = max(rectGroup.right, m_arrData[i + j].m_rect.right);
rectGroup.bottom = max(rectGroup.bottom, m_arrData[i + j].m_rect.bottom);
}
for(j = 0; j < nGroupCount; j++)
{
_AtlDlgResizeData* pDataPrev = NULL;
if(j > 0)
pDataPrev = &(m_arrData[i + j - 1]);
pT->DlgResize_PositionControl(cxWidth, cyHeight, rectGroup, m_arrData[i + j], true, pDataPrev);
}
i += nGroupCount - 1; // increment to skip all group controls
}
else // one control entry
{
RECT rectGroup = { 0, 0, 0, 0 };
pT->DlgResize_PositionControl(cxWidth, cyHeight, rectGroup, m_arrData[i], false);
}
}
if(bVisible)
pT->SetRedraw(TRUE);
pT->RedrawWindow(NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_UPDATENOW | RDW_ALLCHILDREN);
}
// Message map and handlers
BEGIN_MSG_MAP(CDialogResize)
MESSAGE_HANDLER(WM_SIZE, OnSize)
#ifndef _WIN32_WCE
MESSAGE_HANDLER(WM_GETMINMAXINFO, OnGetMinMaxInfo)
#endif // _WIN32_WCE
END_MSG_MAP()
LRESULT OnSize(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
{
T* pT = static_cast<T*>(this);
#ifndef _WIN32_WCE
if(m_bGripper)
{
ATL::CWindow wndGripper = pT->GetDlgItem(ATL_IDW_STATUS_BAR);
if(wParam == SIZE_MAXIMIZED)
wndGripper.ShowWindow(SW_HIDE);
else if(wParam == SIZE_RESTORED)
wndGripper.ShowWindow(SW_SHOW);
}
#endif // _WIN32_WCE
if(wParam != SIZE_MINIMIZED)
{
ATLASSERT(::IsWindow(pT->m_hWnd));
pT->DlgResize_UpdateLayout(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
}
return 0;
}
#ifndef _WIN32_WCE
LRESULT OnGetMinMaxInfo(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/)
{
if(m_ptMinTrackSize.x != -1 && m_ptMinTrackSize.y != -1)
{
LPMINMAXINFO lpMMI = (LPMINMAXINFO)lParam;
lpMMI->ptMinTrackSize = m_ptMinTrackSize;
}
return 0;
}
#endif // _WIN32_WCE
// Implementation
bool DlgResize_PositionControl(int cxWidth, int cyHeight, RECT& rectGroup, _AtlDlgResizeData& data, bool bGroup,
_AtlDlgResizeData* pDataPrev = NULL)
{
T* pT = static_cast<T*>(this);
ATLASSERT(::IsWindow(pT->m_hWnd));
ATL::CWindow ctl;
RECT rectCtl = { 0 };
ctl = pT->GetDlgItem(data.m_nCtlID);
if(!ctl.GetWindowRect(&rectCtl))
return false;
::MapWindowPoints(NULL, pT->m_hWnd, (LPPOINT)&rectCtl, 2);
if(bGroup)
{
if((data.m_dwResizeFlags & DLSZ_CENTER_X) != 0)
{
int cxRight = rectGroup.right + cxWidth - m_sizeDialog.cx;
int cxCtl = data.m_rect.right - data.m_rect.left;
rectCtl.left = rectGroup.left + (cxRight - rectGroup.left - cxCtl) / 2;
rectCtl.right = rectCtl.left + cxCtl;
}
else if((data.m_dwResizeFlags & (DLSZ_SIZE_X | DLSZ_MOVE_X)) != 0)
{
rectCtl.left = rectGroup.left + ::MulDiv(data.m_rect.left - rectGroup.left, rectGroup.right - rectGroup.left + (cxWidth - m_sizeDialog.cx), rectGroup.right - rectGroup.left);
if((data.m_dwResizeFlags & DLSZ_SIZE_X) != 0)
{
rectCtl.right = rectGroup.left + ::MulDiv(data.m_rect.right - rectGroup.left, rectGroup.right - rectGroup.left + (cxWidth - m_sizeDialog.cx), rectGroup.right - rectGroup.left);
if(pDataPrev != NULL)
{
ATL::CWindow ctlPrev = pT->GetDlgItem(pDataPrev->m_nCtlID);
RECT rcPrev = { 0 };
ctlPrev.GetWindowRect(&rcPrev);
::MapWindowPoints(NULL, pT->m_hWnd, (LPPOINT)&rcPrev, 2);
int dxAdjust = (rectCtl.left - rcPrev.right) - (data.m_rect.left - pDataPrev->m_rect.right);
rcPrev.right += dxAdjust;
ctlPrev.SetWindowPos(NULL, &rcPrev, SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE);
}
}
else
{
rectCtl.right = rectCtl.left + (data.m_rect.right - data.m_rect.left);
}
}
if((data.m_dwResizeFlags & DLSZ_CENTER_Y) != 0)
{
int cyBottom = rectGroup.bottom + cyHeight - m_sizeDialog.cy;
int cyCtl = data.m_rect.bottom - data.m_rect.top;
rectCtl.top = rectGroup.top + (cyBottom - rectGroup.top - cyCtl) / 2;
rectCtl.bottom = rectCtl.top + cyCtl;
}
else if((data.m_dwResizeFlags & (DLSZ_SIZE_Y | DLSZ_MOVE_Y)) != 0)
{
rectCtl.top = rectGroup.top + ::MulDiv(data.m_rect.top - rectGroup.top, rectGroup.bottom - rectGroup.top + (cyHeight - m_sizeDialog.cy), rectGroup.bottom - rectGroup.top);
if((data.m_dwResizeFlags & DLSZ_SIZE_Y) != 0)
{
rectCtl.bottom = rectGroup.top + ::MulDiv(data.m_rect.bottom - rectGroup.top, rectGroup.bottom - rectGroup.top + (cyHeight - m_sizeDialog.cy), rectGroup.bottom - rectGroup.top);
if(pDataPrev != NULL)
{
ATL::CWindow ctlPrev = pT->GetDlgItem(pDataPrev->m_nCtlID);
RECT rcPrev = { 0 };
ctlPrev.GetWindowRect(&rcPrev);
::MapWindowPoints(NULL, pT->m_hWnd, (LPPOINT)&rcPrev, 2);
int dxAdjust = (rectCtl.top - rcPrev.bottom) - (data.m_rect.top - pDataPrev->m_rect.bottom);
rcPrev.bottom += dxAdjust;
ctlPrev.SetWindowPos(NULL, &rcPrev, SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE);
}
}
else
{
rectCtl.bottom = rectCtl.top + (data.m_rect.bottom - data.m_rect.top);
}
}
}
else // no group
{
if((data.m_dwResizeFlags & DLSZ_CENTER_X) != 0)
{
int cxCtl = data.m_rect.right - data.m_rect.left;
rectCtl.left = (cxWidth - cxCtl) / 2;
rectCtl.right = rectCtl.left + cxCtl;
}
else if((data.m_dwResizeFlags & (DLSZ_SIZE_X | DLSZ_MOVE_X)) != 0)
{
rectCtl.right = data.m_rect.right + (cxWidth - m_sizeDialog.cx);
if((data.m_dwResizeFlags & DLSZ_MOVE_X) != 0)
rectCtl.left = rectCtl.right - (data.m_rect.right - data.m_rect.left);
}
if((data.m_dwResizeFlags & DLSZ_CENTER_Y) != 0)
{
int cyCtl = data.m_rect.bottom - data.m_rect.top;
rectCtl.top = (cyHeight - cyCtl) / 2;
rectCtl.bottom = rectCtl.top + cyCtl;
}
else if((data.m_dwResizeFlags & (DLSZ_SIZE_Y | DLSZ_MOVE_Y)) != 0)
{
rectCtl.bottom = data.m_rect.bottom + (cyHeight - m_sizeDialog.cy);
if((data.m_dwResizeFlags & DLSZ_MOVE_Y) != 0)
rectCtl.top = rectCtl.bottom - (data.m_rect.bottom - data.m_rect.top);
}
}
if((data.m_dwResizeFlags & DLSZ_REPAINT) != 0)
ctl.Invalidate();
if((data.m_dwResizeFlags & (DLSZ_SIZE_X | DLSZ_SIZE_Y | DLSZ_MOVE_X | DLSZ_MOVE_Y | DLSZ_REPAINT | DLSZ_CENTER_X | DLSZ_CENTER_Y)) != 0)
ctl.SetWindowPos(NULL, &rectCtl, SWP_NOZORDER | SWP_NOACTIVATE);
return true;
}
};
///////////////////////////////////////////////////////////////////////////////
// CDoubleBufferImpl - Provides double-buffer painting support to any window
template <class T>
class CDoubleBufferImpl
{
public:
// Overrideables
void DoPaint(CDCHandle /*dc*/)
{
// must be implemented in a derived class
ATLASSERT(FALSE);
}
// Message map and handlers
BEGIN_MSG_MAP(CDoubleBufferImpl)
MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)
MESSAGE_HANDLER(WM_PAINT, OnPaint)
#ifndef _WIN32_WCE
MESSAGE_HANDLER(WM_PRINTCLIENT, OnPaint)
#endif // !_WIN32_WCE
END_MSG_MAP()
LRESULT OnEraseBackground(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
{
return 1; // no background painting needed
}
LRESULT OnPaint(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
{
T* pT = static_cast<T*>(this);
ATLASSERT(::IsWindow(pT->m_hWnd));
if(wParam != NULL)
{
RECT rect = { 0 };
pT->GetClientRect(&rect);
CMemoryDC dcMem((HDC)wParam, rect);
pT->DoPaint(dcMem.m_hDC);
}
else
{
CPaintDC dc(pT->m_hWnd);
CMemoryDC dcMem(dc.m_hDC, dc.m_ps.rcPaint);
pT->DoPaint(dcMem.m_hDC);
}
return 0;
}
};
///////////////////////////////////////////////////////////////////////////////
// CDoubleBufferWindowImpl - Implements a double-buffer painting window
template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits>
class ATL_NO_VTABLE CDoubleBufferWindowImpl : public ATL::CWindowImpl< T, TBase, TWinTraits >, public CDoubleBufferImpl< T >
{
public:
BEGIN_MSG_MAP(CDoubleBufferWindowImpl)
CHAIN_MSG_MAP(CDoubleBufferImpl< T >)
END_MSG_MAP()
};
// command bar support
#if !defined(__ATLCTRLW_H__) && !defined(_WIN32_WCE)
#undef CBRM_GETMENU
#undef CBRM_TRACKPOPUPMENU
#undef CBRM_GETCMDBAR
#undef CBRPOPUPMENU
#endif // !defined(__ATLCTRLW_H__) && !defined(_WIN32_WCE)
}; // namespace WTL
#endif // __ATLFRAME_H__