|
|
// WTL Version 3.1
// Copyright (C) 1997-2000 Microsoft Corporation
// All rights reserved.
//
// This file is a part of Windows Template Library.
// The code and information is provided "as-is" without
// warranty of any kind, either expressed or implied.
#ifndef __ATLDLGS_H__
#define __ATLDLGS_H__
#pragma once
#ifndef __cplusplus
#error ATL requires C++ compilation (use a .cpp suffix)
#endif
#ifndef __ATLAPP_H__
#error atldlgs.h requires atlapp.h to be included first
#endif
#ifndef __ATLWIN_H__
#error atldlgs.h requires atlwin.h to be included first
#endif
#include <commdlg.h>
#include <shlobj.h>
namespace WTL {
/////////////////////////////////////////////////////////////////////////////
// Forward declarations
template <class T> class CFileDialogImpl; class CFileDialog; template <class T> class CFolderDialogImpl; class CFolderDialog; template <class T> class CFontDialogImpl; class CFontDialog; #ifdef _RICHEDIT_
template <class T> class CRichEditFontDialogImpl; class CRichEditFontDialog; #endif //_RICHEDIT_
template <class T> class CColorDialogImpl; class CColorDialog; template <class T> class CPrintDialogImpl; class CPrintDialog; template <class T> class CPageSetupDialogImpl; #if (WINVER >= 0x0500)
template <class T> class CPrintDialogExImpl; class CPrintDialogEx; #endif //(WINVER >= 0x0500)
class CPageSetupDialog; template <class T> class CFindReplaceDialogImpl; class CFindReplaceDialog;
class CPropertySheetWindow; template <class T, class TBase = CPropertySheetWindow> class CPropertySheetImpl; class CPropertySheet; class CPropertyPageWindow; template <class T, class TBase = CPropertyPageWindow> class CPropertyPageImpl; template <WORD t_wDlgTemplateID> class CPropertyPage;
/////////////////////////////////////////////////////////////////////////////
// CFileDialogImpl - used for File Open or File Save As
// compatibility with the old (vc6.0) headers
#if (_WIN32_WINNT >= 0x0500) && !defined(OPENFILENAME_SIZE_VERSION_400)
#ifndef CDSIZEOF_STRUCT
#define CDSIZEOF_STRUCT(structname, member) (((int)((LPBYTE)(&((structname*)0)->member) - ((LPBYTE)((structname*)0)))) + sizeof(((structname*)0)->member))
#endif
#define OPENFILENAME_SIZE_VERSION_400A CDSIZEOF_STRUCT(OPENFILENAMEA,lpTemplateName)
#define OPENFILENAME_SIZE_VERSION_400W CDSIZEOF_STRUCT(OPENFILENAMEW,lpTemplateName)
#ifdef UNICODE
#define OPENFILENAME_SIZE_VERSION_400 OPENFILENAME_SIZE_VERSION_400W
#else
#define OPENFILENAME_SIZE_VERSION_400 OPENFILENAME_SIZE_VERSION_400A
#endif // !UNICODE
#endif // (_WIN32_WINNT >= 0x0500) && !defined(OPENFILENAME_SIZE_VERSION_400)
template <class T> class ATL_NO_VTABLE CFileDialogImpl : public CDialogImplBase { public: OPENFILENAME m_ofn; BOOL m_bOpenFileDialog; // TRUE for file open, FALSE for file save
TCHAR m_szFileTitle[_MAX_FNAME]; // contains file title after return
TCHAR m_szFileName[_MAX_PATH]; // contains full path name after return
CFileDialogImpl(BOOL bOpenFileDialog, // TRUE for FileOpen, FALSE for FileSaveAs
LPCTSTR lpszDefExt = NULL, LPCTSTR lpszFileName = NULL, DWORD dwFlags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, LPCTSTR lpszFilter = NULL, HWND hWndParent = NULL) { memset(&m_ofn, 0, sizeof(m_ofn)); // initialize structure to 0/NULL
m_szFileName[0] = '\0'; m_szFileTitle[0] = '\0';
m_bOpenFileDialog = bOpenFileDialog;
m_ofn.lStructSize = sizeof(m_ofn); #if (_WIN32_WINNT >= 0x0500)
// adjust struct size if running on older version of Windows
if(AtlIsOldWindows()) { ATLASSERT(sizeof(m_ofn) > OPENFILENAME_SIZE_VERSION_400); // must be
m_ofn.lStructSize = OPENFILENAME_SIZE_VERSION_400; } #endif //(_WIN32_WINNT >= 0x0500)
m_ofn.lpstrFile = m_szFileName; m_ofn.nMaxFile = _MAX_PATH; m_ofn.lpstrDefExt = lpszDefExt; m_ofn.lpstrFileTitle = (LPTSTR)m_szFileTitle; m_ofn.nMaxFileTitle = _MAX_FNAME; m_ofn.Flags |= dwFlags | OFN_EXPLORER | OFN_ENABLEHOOK | OFN_ENABLESIZING; m_ofn.lpstrFilter = lpszFilter; m_ofn.hInstance = _Module.GetResourceInstance(); m_ofn.lpfnHook = (LPOFNHOOKPROC)T::StartDialogProc; m_ofn.hwndOwner = hWndParent;
// setup initial file name
if(lpszFileName != NULL) lstrcpyn(m_szFileName, lpszFileName, _MAX_PATH); }
INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow()) { ATLASSERT(m_ofn.Flags & OFN_ENABLEHOOK); ATLASSERT(m_ofn.lpfnHook != NULL); // can still be a user hook
ATLASSERT(m_ofn.Flags & OFN_EXPLORER);
if(m_ofn.hwndOwner == NULL) // set only if not specified before
m_ofn.hwndOwner = hWndParent;
ATLASSERT(m_hWnd == NULL); _Module.AddCreateWndData(&m_thunk.cd, (CDialogImplBase*)this);
BOOL bRet; if(m_bOpenFileDialog) bRet = ::GetOpenFileName(&m_ofn); else bRet = ::GetSaveFileName(&m_ofn);
m_hWnd = NULL;
return bRet ? IDOK : IDCANCEL; }
// Attributes
CWindow GetFileDialogWindow() const { ATLASSERT(::IsWindow(m_hWnd)); return CWindow(GetParent()); }
int GetFilePath(LPTSTR lpstrFilePath, int nLength) const { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(m_ofn.Flags & OFN_EXPLORER);
return (int)GetFileDialogWindow().SendMessage(CDM_GETFILEPATH, nLength, (LPARAM)lpstrFilePath); }
int GetFolderIDList(LPVOID lpBuff, int nLength) const { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(m_ofn.Flags & OFN_EXPLORER);
return (int)GetFileDialogWindow().SendMessage(CDM_GETFOLDERIDLIST, nLength, (LPARAM)lpBuff); }
int GetFolderPath(LPTSTR lpstrFolderPath, int nLength) const { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(m_ofn.Flags & OFN_EXPLORER);
return (int)GetFileDialogWindow().SendMessage(CDM_GETFOLDERPATH, nLength, (LPARAM)lpstrFolderPath); }
int GetSpec(LPTSTR lpstrSpec, int nLength) const { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(m_ofn.Flags & OFN_EXPLORER);
return (int)GetFileDialogWindow().SendMessage(CDM_GETSPEC, nLength, (LPARAM)lpstrSpec); }
void SetControlText(int nCtrlID, LPCTSTR lpstrText) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(m_ofn.Flags & OFN_EXPLORER);
GetFileDialogWindow().SendMessage(CDM_SETCONTROLTEXT, nCtrlID, (LPARAM)lpstrText); }
void SetDefExt(LPCTSTR lpstrExt) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(m_ofn.Flags & OFN_EXPLORER);
GetFileDialogWindow().SendMessage(CDM_SETDEFEXT, 0, (LPARAM)lpstrExt); }
BOOL GetReadOnlyPref() const // return TRUE if readonly checked
{ return m_ofn.Flags & OFN_READONLY ? TRUE : FALSE; }
// Operations
void HideControl(int nCtrlID) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(m_ofn.Flags & OFN_EXPLORER);
GetFileDialogWindow().SendMessage(CDM_HIDECONTROL, nCtrlID); }
// Special override for common dialogs
BOOL EndDialog(INT_PTR /*nRetCode*/ = 0) { ATLASSERT(::IsWindow(m_hWnd)); GetFileDialogWindow().SendMessage(WM_COMMAND, MAKEWPARAM(IDCANCEL, 0)); return TRUE; }
// Message map and handlers
BEGIN_MSG_MAP(CFileDialogImpl< T >) NOTIFY_CODE_HANDLER(CDN_FILEOK, _OnFileOK) NOTIFY_CODE_HANDLER(CDN_FOLDERCHANGE, _OnFolderChange) NOTIFY_CODE_HANDLER(CDN_HELP, _OnHelp) NOTIFY_CODE_HANDLER(CDN_INITDONE, _OnInitDone) NOTIFY_CODE_HANDLER(CDN_SELCHANGE, _OnSelChange) NOTIFY_CODE_HANDLER(CDN_SHAREVIOLATION, _OnShareViolation) NOTIFY_CODE_HANDLER(CDN_TYPECHANGE, _OnTypeChange) END_MSG_MAP()
LRESULT _OnFileOK(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/) { ATLASSERT(::IsWindow(m_hWnd)); T* pT = static_cast<T*>(this); return !pT->OnFileOK((LPOFNOTIFY)pnmh); } LRESULT _OnFolderChange(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/) { ATLASSERT(::IsWindow(m_hWnd)); T* pT = static_cast<T*>(this); pT->OnFolderChange((LPOFNOTIFY)pnmh); return 0; } LRESULT _OnHelp(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/) { ATLASSERT(::IsWindow(m_hWnd)); T* pT = static_cast<T*>(this); pT->OnHelp((LPOFNOTIFY)pnmh); return 0; } LRESULT _OnInitDone(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/) { ATLASSERT(::IsWindow(m_hWnd)); T* pT = static_cast<T*>(this); pT->OnInitDone((LPOFNOTIFY)pnmh); return 0; } LRESULT _OnSelChange(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/) { ATLASSERT(::IsWindow(m_hWnd)); T* pT = static_cast<T*>(this); pT->OnSelChange((LPOFNOTIFY)pnmh); return 0; } LRESULT _OnShareViolation(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/) { ATLASSERT(::IsWindow(m_hWnd)); T* pT = static_cast<T*>(this); return pT->OnShareViolation((LPOFNOTIFY)pnmh); } LRESULT _OnTypeChange(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/) { ATLASSERT(::IsWindow(m_hWnd)); T* pT = static_cast<T*>(this); pT->OnTypeChange((LPOFNOTIFY)pnmh); return 0; }
// Overrideables
BOOL OnFileOK(LPOFNOTIFY /*lpon*/) { return TRUE; } void OnFolderChange(LPOFNOTIFY /*lpon*/) { } void OnHelp(LPOFNOTIFY /*lpon*/) { } void OnInitDone(LPOFNOTIFY /*lpon*/) { } void OnSelChange(LPOFNOTIFY /*lpon*/) { } int OnShareViolation(LPOFNOTIFY /*lpon*/) { return 0; } void OnTypeChange(LPOFNOTIFY /*lpon*/) { } };
class CFileDialog : public CFileDialogImpl<CFileDialog> { public: CFileDialog(BOOL bOpenFileDialog, // TRUE for FileOpen, FALSE for FileSaveAs
LPCTSTR lpszDefExt = NULL, LPCTSTR lpszFileName = NULL, DWORD dwFlags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, LPCTSTR lpszFilter = NULL, HWND hWndParent = NULL) : CFileDialogImpl<CFileDialog>(bOpenFileDialog, lpszDefExt, lpszFileName, dwFlags, lpszFilter, hWndParent) { }
// override base class map and references to handlers
DECLARE_EMPTY_MSG_MAP() };
/////////////////////////////////////////////////////////////////////////////
// CFolderDialogImpl - used for browsing for a folder
template <class T> class ATL_NO_VTABLE CFolderDialogImpl { public: BROWSEINFO m_bi; TCHAR m_szFolderDisplayName[MAX_PATH]; TCHAR m_szFolderPath[MAX_PATH]; HWND m_hWnd; // used only in the callback function
// Constructor
CFolderDialogImpl(HWND hWndParent = NULL, LPCTSTR lpstrTitle = NULL, UINT uFlags = BIF_RETURNONLYFSDIRS) { memset(&m_bi, 0, sizeof(m_bi)); // initialize structure to 0/NULL
m_bi.hwndOwner = hWndParent; m_bi.pidlRoot = NULL; m_bi.pszDisplayName = m_szFolderDisplayName; m_bi.lpszTitle = lpstrTitle; m_bi.ulFlags = uFlags; m_bi.lpfn = BrowseCallbackProc; m_bi.lParam = (LPARAM)this;
m_szFolderPath[0] = 0; m_szFolderDisplayName[0] = 0;
m_hWnd = NULL; }
// Operations
INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow()) { if(m_bi.hwndOwner == NULL) // set only if not specified before
m_bi.hwndOwner = hWndParent;
INT_PTR nRet = -1; LPITEMIDLIST pItemIDList = ::SHBrowseForFolder(&m_bi); if(pItemIDList != NULL) { if(::SHGetPathFromIDList(pItemIDList, m_szFolderPath)) { IMalloc* pMalloc = NULL; if(SUCCEEDED(::SHGetMalloc(&pMalloc))) { pMalloc->Free(pItemIDList); pMalloc->Release(); } nRet = IDOK; } else { nRet = IDCANCEL; } } return nRet; }
// filled after a call to DoModal
LPCTSTR GetFolderPath() const { return m_szFolderPath; } LPCTSTR GetFolderDisplayName() const { return m_szFolderDisplayName; } int GetFolderImageIndex() const { return m_bi.iImage; }
// Callback function and overrideables
static int CALLBACK BrowseCallbackProc(HWND hWnd, UINT uMsg, LPARAM lParam, LPARAM lpData) { #ifndef BFFM_VALIDATEFAILED
#ifdef UNICODE
const int BFFM_VALIDATEFAILED = 4; #else
const int BFFM_VALIDATEFAILED = 3; #endif
#endif //!BFFM_VALIDATEFAILED
int nRet = 0; T* pT = (T*)lpData; pT->m_hWnd = hWnd; switch(uMsg) { case BFFM_INITIALIZED: pT->OnInitialized(); break; case BFFM_SELCHANGED: pT->OnSelChanged((LPITEMIDLIST)lParam); break; case BFFM_VALIDATEFAILED: nRet = pT->OnValidateFailed((LPCTSTR)lParam); break; default: ATLTRACE2(atlTraceUI, 0, _T("Unknown message received in CFolderDialogImpl::BrowseCallbackProc\n")); break; } pT->m_hWnd = NULL; return nRet; } void OnInitialized() { } void OnSelChanged(LPITEMIDLIST /*pItemIDList*/) { } int OnValidateFailed(LPCTSTR /*lpstrFolderPath*/) { return 1; // 1=continue, 0=EndDialog
}
// Commands - valid to call only from handlers
void EnableOK(BOOL bEnable) { ATLASSERT(m_hWnd != NULL); ::SendMessage(m_hWnd, BFFM_ENABLEOK, bEnable, 0L); } void SetSelection(LPITEMIDLIST pItemIDList) { ATLASSERT(m_hWnd != NULL); ::SendMessage(m_hWnd, BFFM_SETSELECTION, FALSE, (LPARAM)pItemIDList); } void SetSelection(LPCTSTR lpstrFolderPath) { ATLASSERT(m_hWnd != NULL); ::SendMessage(m_hWnd, BFFM_SETSELECTION, TRUE, (LPARAM)lpstrFolderPath); } void SetStatusText(LPCTSTR lpstrText) { ATLASSERT(m_hWnd != NULL); ::SendMessage(m_hWnd, BFFM_SETSTATUSTEXT, 0, (LPARAM)lpstrText); } };
class CFolderDialog : public CFolderDialogImpl<CFolderDialog> { public: CFolderDialog(HWND hWndParent = NULL, LPCTSTR lpstrTitle = NULL, UINT uFlags = BIF_RETURNONLYFSDIRS) : CFolderDialogImpl<CFolderDialog>(hWndParent, lpstrTitle, uFlags) { m_bi.lpfn = NULL; } };
/////////////////////////////////////////////////////////////////////////////
// CCommonDialogImplBase - base class for common dialog classes
class ATL_NO_VTABLE CCommonDialogImplBase : public CWindowImplBase { public: static UINT_PTR APIENTRY HookProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { if(uMsg != WM_INITDIALOG) return 0; CCommonDialogImplBase* pT = (CCommonDialogImplBase*)_Module.ExtractCreateWndData(); ATLASSERT(pT != NULL); ATLASSERT(pT->m_hWnd == NULL); ATLASSERT(::IsWindow(hWnd)); // subclass dialog's window
if(!pT->SubclassWindow(hWnd)) { ATLTRACE2(atlTraceUI, 0, _T("Subclassing a common dialog failed\n")); return 0; } // check message map for WM_INITDIALOG handler
LRESULT lRes; if(pT->ProcessWindowMessage(pT->m_hWnd, uMsg, wParam, lParam, lRes, 0) == FALSE) return 0; return lRes; }
// Special override for common dialogs
BOOL EndDialog(INT_PTR /*nRetCode*/ = 0) { ATLASSERT(::IsWindow(m_hWnd)); SendMessage(WM_COMMAND, MAKEWPARAM(IDABORT, 0)); return TRUE; }
// Implementation - try to override these, to prevent errors
HWND Create(HWND, _U_RECT, LPCTSTR, DWORD, DWORD, _U_MENUorID, ATOM, LPVOID) { ATLASSERT(FALSE); // should not be called
return NULL; } static LRESULT CALLBACK StartWindowProc(HWND /*hWnd*/, UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/) { ATLASSERT(FALSE); // should not be called
return 0; } };
/////////////////////////////////////////////////////////////////////////////
// CFontDialogImpl - font selection dialog
template <class T> class ATL_NO_VTABLE CFontDialogImpl : public CCommonDialogImplBase { public: CHOOSEFONT m_cf; TCHAR m_szStyleName[64]; // contains style name after return
LOGFONT m_lf; // default LOGFONT to store the info
// Constructors
CFontDialogImpl(LPLOGFONT lplfInitial = NULL, DWORD dwFlags = CF_EFFECTS | CF_SCREENFONTS, HDC hDCPrinter = NULL, HWND hWndParent = NULL) { memset(&m_cf, 0, sizeof(m_cf)); memset(&m_lf, 0, sizeof(m_lf)); memset(&m_szStyleName, 0, sizeof(m_szStyleName));
m_cf.lStructSize = sizeof(m_cf); m_cf.hwndOwner = hWndParent; m_cf.rgbColors = RGB(0, 0, 0); m_cf.lpszStyle = (LPTSTR)&m_szStyleName; m_cf.Flags = dwFlags | CF_ENABLEHOOK; m_cf.lpfnHook = (LPCFHOOKPROC)T::HookProc;
if(lplfInitial != NULL) { m_cf.lpLogFont = lplfInitial; m_cf.Flags |= CF_INITTOLOGFONTSTRUCT; memcpy(&m_lf, m_cf.lpLogFont, sizeof(m_lf)); } else { m_cf.lpLogFont = &m_lf; }
if(hDCPrinter != NULL) { m_cf.hDC = hDCPrinter; m_cf.Flags |= CF_PRINTERFONTS; } }
// Operations
INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow()) { ATLASSERT(m_cf.Flags & CF_ENABLEHOOK); ATLASSERT(m_cf.lpfnHook != NULL); // can still be a user hook
if(m_cf.hwndOwner == NULL) // set only if not specified before
m_cf.hwndOwner = hWndParent;
ATLASSERT(m_hWnd == NULL); _Module.AddCreateWndData(&m_thunk.cd, (CCommonDialogImplBase*)this);
BOOL bRet = ::ChooseFont(&m_cf);
m_hWnd = NULL;
if(bRet) // copy logical font from user's initialization buffer (if needed)
memcpy(&m_lf, m_cf.lpLogFont, sizeof(m_lf));
return bRet ? IDOK : IDCANCEL; }
// Get the selected font (works during DoModal displayed or after)
void GetCurrentFont(LPLOGFONT lplf) const { ATLASSERT(lplf != NULL);
if(m_hWnd != NULL) ::SendMessage(m_hWnd, WM_CHOOSEFONT_GETLOGFONT, 0, (LPARAM)lplf); else *lplf = m_lf; }
// Helpers for parsing information after successful return
LPCTSTR GetFaceName() const // return the face name of the font
{ return (LPCTSTR)m_cf.lpLogFont->lfFaceName; } LPCTSTR GetStyleName() const // return the style name of the font
{ return m_cf.lpszStyle; } int GetSize() const // return the pt size of the font
{ return m_cf.iPointSize; } COLORREF GetColor() const // return the color of the font
{ return m_cf.rgbColors; } int GetWeight() const // return the chosen font weight
{ return (int)m_cf.lpLogFont->lfWeight; } BOOL IsStrikeOut() const // return TRUE if strikeout
{ return m_cf.lpLogFont->lfStrikeOut ? TRUE : FALSE; } BOOL IsUnderline() const // return TRUE if underline
{ return m_cf.lpLogFont->lfUnderline ? TRUE : FALSE; } BOOL IsBold() const // return TRUE if bold font
{ return m_cf.lpLogFont->lfWeight == FW_BOLD ? TRUE : FALSE; } BOOL IsItalic() const // return TRUE if italic font
{ return m_cf.lpLogFont->lfItalic ? TRUE : FALSE; } };
class CFontDialog : public CFontDialogImpl<CFontDialog> { public: CFontDialog(LPLOGFONT lplfInitial = NULL, DWORD dwFlags = CF_EFFECTS | CF_SCREENFONTS, HDC hDCPrinter = NULL, HWND hWndParent = NULL) : CFontDialogImpl<CFontDialog>(lplfInitial, dwFlags, hDCPrinter, hWndParent) { }
DECLARE_EMPTY_MSG_MAP() };
/////////////////////////////////////////////////////////////////////////////
// CRichEditFontDialogImpl - font selection for the Rich Edit ctrl
#ifdef _RICHEDIT_
template <class T> class ATL_NO_VTABLE CRichEditFontDialogImpl : public CFontDialogImpl< T > { public: CRichEditFontDialogImpl(const CHARFORMAT& charformat, DWORD dwFlags = CF_SCREENFONTS, HDC hDCPrinter = NULL, HWND hWndParent = NULL) : CFontDialogImpl< T >(NULL, dwFlags, hDCPrinter, hWndParent) { m_cf.Flags |= CF_INITTOLOGFONTSTRUCT; m_cf.Flags |= FillInLogFont(charformat); m_cf.lpLogFont = &m_lf;
if(charformat.dwMask & CFM_COLOR) m_cf.rgbColors = charformat.crTextColor; }
void GetCharFormat(CHARFORMAT& cf) const { USES_CONVERSION; cf.dwEffects = 0; cf.dwMask = 0; if((m_cf.Flags & CF_NOSTYLESEL) == 0) { cf.dwMask |= CFM_BOLD | CFM_ITALIC; cf.dwEffects |= (IsBold()) ? CFE_BOLD : 0; cf.dwEffects |= (IsItalic()) ? CFE_ITALIC : 0; } if((m_cf.Flags & CF_NOSIZESEL) == 0) { cf.dwMask |= CFM_SIZE; //GetSize() returns in tenths of points so mulitply by 2 to get twips
cf.yHeight = GetSize() * 2; }
if((m_cf.Flags & CF_NOFACESEL) == 0) { cf.dwMask |= CFM_FACE; cf.bPitchAndFamily = m_cf.lpLogFont->lfPitchAndFamily; #if (_RICHEDIT_VER >= 0x0200)
lstrcpy(cf.szFaceName, GetFaceName()); #else
lstrcpyA(cf.szFaceName, T2A((LPTSTR)(LPCTSTR)GetFaceName())); #endif //(_RICHEDIT_VER >= 0x0200)
}
if(m_cf.Flags & CF_EFFECTS) { cf.dwMask |= CFM_UNDERLINE | CFM_STRIKEOUT | CFM_COLOR; cf.dwEffects |= (IsUnderline()) ? CFE_UNDERLINE : 0; cf.dwEffects |= (IsStrikeOut()) ? CFE_STRIKEOUT : 0; cf.crTextColor = GetColor(); } if((m_cf.Flags & CF_NOSCRIPTSEL) == 0) { cf.bCharSet = m_cf.lpLogFont->lfCharSet; cf.dwMask |= CFM_CHARSET; } cf.yOffset = 0; }
DWORD FillInLogFont(const CHARFORMAT& cf) { USES_CONVERSION; DWORD dwFlags = 0; if(cf.dwMask & CFM_SIZE) { HDC hDC = ::CreateDC(_T("DISPLAY"), NULL, NULL, NULL); LONG yPerInch = ::GetDeviceCaps(hDC, LOGPIXELSY); m_lf.lfHeight = -(int)((cf.yHeight * yPerInch) / 1440); } else m_lf.lfHeight = 0;
m_lf.lfWidth = 0; m_lf.lfEscapement = 0; m_lf.lfOrientation = 0;
if((cf.dwMask & (CFM_ITALIC|CFM_BOLD)) == (CFM_ITALIC|CFM_BOLD)) { m_lf.lfWeight = (cf.dwEffects & CFE_BOLD) ? FW_BOLD : FW_NORMAL; m_lf.lfItalic = (BYTE)((cf.dwEffects & CFE_ITALIC) ? TRUE : FALSE); } else { dwFlags |= CF_NOSTYLESEL; m_lf.lfWeight = FW_DONTCARE; m_lf.lfItalic = FALSE; }
if((cf.dwMask & (CFM_UNDERLINE|CFM_STRIKEOUT|CFM_COLOR)) == (CFM_UNDERLINE|CFM_STRIKEOUT|CFM_COLOR)) { dwFlags |= CF_EFFECTS; m_lf.lfUnderline = (BYTE)((cf.dwEffects & CFE_UNDERLINE) ? TRUE : FALSE); m_lf.lfStrikeOut = (BYTE)((cf.dwEffects & CFE_STRIKEOUT) ? TRUE : FALSE); } else { m_lf.lfUnderline = (BYTE)FALSE; m_lf.lfStrikeOut = (BYTE)FALSE; }
if(cf.dwMask & CFM_CHARSET) m_lf.lfCharSet = cf.bCharSet; else dwFlags |= CF_NOSCRIPTSEL; m_lf.lfOutPrecision = OUT_DEFAULT_PRECIS; m_lf.lfClipPrecision = CLIP_DEFAULT_PRECIS; m_lf.lfQuality = DEFAULT_QUALITY; if(cf.dwMask & CFM_FACE) { m_lf.lfPitchAndFamily = cf.bPitchAndFamily; #if (_RICHEDIT_VER >= 0x0200)
lstrcpy(m_lf.lfFaceName, cf.szFaceName); #else
lstrcpy(m_lf.lfFaceName, A2T((LPSTR)cf.szFaceName)); #endif //(_RICHEDIT_VER >= 0x0200)
} else { m_lf.lfPitchAndFamily = DEFAULT_PITCH|FF_DONTCARE; m_lf.lfFaceName[0] = (TCHAR)0; } return dwFlags; } };
class CRichEditFontDialog : public CRichEditFontDialogImpl<CRichEditFontDialog> { public: CRichEditFontDialog(const CHARFORMAT& charformat, DWORD dwFlags = CF_SCREENFONTS, HDC hDCPrinter = NULL, HWND hWndParent = NULL) : CRichEditFontDialogImpl<CRichEditFontDialog>(charformat, dwFlags, hDCPrinter, hWndParent) { }
DECLARE_EMPTY_MSG_MAP() };
#endif // _RICHEDIT_
/////////////////////////////////////////////////////////////////////////////
// CColorDialogImpl - color selection
static const UINT _nMsgCOLOROK = ::RegisterWindowMessage(COLOROKSTRING); const UINT _nMsgSETRGB = ::RegisterWindowMessage(SETRGBSTRING);
template <class T> class ATL_NO_VTABLE CColorDialogImpl : public CCommonDialogImplBase { public: CHOOSECOLOR m_cc;
// Constructors
CColorDialogImpl(COLORREF clrInit = 0, DWORD dwFlags = 0, HWND hWndParent = NULL) { memset(&m_cc, 0, sizeof(m_cc));
m_cc.lStructSize = sizeof(m_cc); m_cc.lpCustColors = GetCustomColors(); m_cc.hwndOwner = hWndParent; m_cc.Flags = dwFlags | CC_ENABLEHOOK; m_cc.lpfnHook = (LPCCHOOKPROC)T::HookProc;
if(clrInit != 0) { m_cc.rgbResult = clrInit; m_cc.Flags |= CC_RGBINIT; } }
// Operations
INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow()) { ATLASSERT(m_cc.Flags & CC_ENABLEHOOK); ATLASSERT(m_cc.lpfnHook != NULL); // can still be a user hook
if(m_cc.hwndOwner == NULL) // set only if not specified before
m_cc.hwndOwner = hWndParent;
ATLASSERT(m_hWnd == NULL); _Module.AddCreateWndData(&m_thunk.cd, (CCommonDialogImplBase*)this);
BOOL bRet = ::ChooseColor(&m_cc);
m_hWnd = NULL;
return bRet ? IDOK : IDCANCEL; }
// Set the current color while dialog is displayed
void SetCurrentColor(COLORREF clr) { ATLASSERT(::IsWindow(m_hWnd)); SendMessage(_nMsgSETRGB, 0, (LPARAM)clr); }
// Helpers for parsing information after successful return
COLORREF GetColor() const { return m_cc.rgbResult; }
static COLORREF* GetCustomColors() { static COLORREF rgbCustomColors[16] = { RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255), };
return rgbCustomColors; }
// Overridable callbacks
BEGIN_MSG_MAP(CColorDialogImpl< T >) MESSAGE_HANDLER(_nMsgCOLOROK, _OnColorOK) END_MSG_MAP()
LRESULT _OnColorOK(UINT, WPARAM, LPARAM, BOOL&) { T* pT = static_cast<T*>(this); return pT->OnColorOK(); }
BOOL OnColorOK() // validate color
{ return FALSE; } };
class CColorDialog : public CColorDialogImpl<CColorDialog> { public: CColorDialog(COLORREF clrInit = 0, DWORD dwFlags = 0, HWND hWndParent = NULL) : CColorDialogImpl<CColorDialog>(clrInit, dwFlags, hWndParent) { }
// override base class map and references to handlers
DECLARE_EMPTY_MSG_MAP() };
/////////////////////////////////////////////////////////////////////////////
// CPrintDialogImpl - used for Print... and PrintSetup...
// global helper
static HDC _AtlCreateDC(HGLOBAL hDevNames, HGLOBAL hDevMode) { if(hDevNames == NULL) return NULL;
LPDEVNAMES lpDevNames = (LPDEVNAMES)::GlobalLock(hDevNames); LPDEVMODE lpDevMode = (hDevMode != NULL) ? (LPDEVMODE)::GlobalLock(hDevMode) : NULL;
if(lpDevNames == NULL) return NULL;
HDC hDC = ::CreateDC((LPCTSTR)lpDevNames + lpDevNames->wDriverOffset, (LPCTSTR)lpDevNames + lpDevNames->wDeviceOffset, (LPCTSTR)lpDevNames + lpDevNames->wOutputOffset, lpDevMode);
::GlobalUnlock(hDevNames); if(hDevMode != NULL) ::GlobalUnlock(hDevMode); return hDC; }
template <class T> class ATL_NO_VTABLE CPrintDialogImpl : public CCommonDialogImplBase { public: // print dialog parameter block (note this is a reference)
PRINTDLG& m_pd;
// Constructors
CPrintDialogImpl(BOOL bPrintSetupOnly = FALSE, // TRUE for Print Setup, FALSE for Print Dialog
DWORD dwFlags = PD_ALLPAGES | PD_USEDEVMODECOPIES | PD_NOPAGENUMS | PD_NOSELECTION, HWND hWndParent = NULL) : m_pd(m_pdActual) { memset(&m_pdActual, 0, sizeof(m_pdActual));
m_pd.lStructSize = sizeof(m_pdActual); m_pd.hwndOwner = hWndParent; m_pd.Flags = (dwFlags | PD_ENABLEPRINTHOOK | PD_ENABLESETUPHOOK); m_pd.lpfnPrintHook = (LPPRINTHOOKPROC)T::HookProc; m_pd.lpfnSetupHook = (LPSETUPHOOKPROC)T::HookProc;
if(bPrintSetupOnly) m_pd.Flags |= PD_PRINTSETUP; else m_pd.Flags |= PD_RETURNDC;
m_pd.Flags &= ~PD_RETURNIC; // do not support information context
}
// Operations
INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow()) { ATLASSERT(m_pd.Flags & PD_ENABLEPRINTHOOK); ATLASSERT(m_pd.Flags & PD_ENABLESETUPHOOK); ATLASSERT(m_pd.lpfnPrintHook != NULL); // can still be a user hook
ATLASSERT(m_pd.lpfnSetupHook != NULL); // can still be a user hook
ATLASSERT((m_pd.Flags & PD_RETURNDEFAULT) == 0); // use GetDefaults for this
if(m_pd.hwndOwner == NULL) // set only if not specified before
m_pd.hwndOwner = hWndParent;
ATLASSERT(m_hWnd == NULL); _Module.AddCreateWndData(&m_thunk.cd, (CCommonDialogImplBase*)this);
BOOL bRet = ::PrintDlg(&m_pd);
m_hWnd = NULL;
return bRet ? IDOK : IDCANCEL; }
// GetDefaults will not display a dialog but will get device defaults
BOOL GetDefaults() { m_pd.Flags |= PD_RETURNDEFAULT; ATLASSERT(m_pd.hDevMode == NULL); // must be NULL
ATLASSERT(m_pd.hDevNames == NULL); // must be NULL
return ::PrintDlg(&m_pd); }
// Helpers for parsing information after successful return num. copies requested
int GetCopies() const { if(m_pd.Flags & PD_USEDEVMODECOPIES) { LPDEVMODE lpDevMode = GetDevMode(); return (lpDevMode != NULL) ? lpDevMode->dmCopies : -1; }
return m_pd.nCopies; } BOOL PrintCollate() const // TRUE if collate checked
{ return m_pd.Flags & PD_COLLATE ? TRUE : FALSE; } BOOL PrintSelection() const // TRUE if printing selection
{ return m_pd.Flags & PD_SELECTION ? TRUE : FALSE; } BOOL PrintAll() const // TRUE if printing all pages
{ return !PrintRange() && !PrintSelection() ? TRUE : FALSE; } BOOL PrintRange() const // TRUE if printing page range
{ return m_pd.Flags & PD_PAGENUMS ? TRUE : FALSE; } int GetFromPage() const // starting page if valid
{ return (PrintRange() ? m_pd.nFromPage :-1); } int GetToPage() const // starting page if valid
{ return (PrintRange() ? m_pd.nToPage :-1); } LPDEVMODE GetDevMode() const // return DEVMODE
{ if(m_pd.hDevMode == NULL) return NULL;
return (LPDEVMODE)::GlobalLock(m_pd.hDevMode); } LPCTSTR GetDriverName() const // return driver name
{ if(m_pd.hDevNames == NULL) return NULL;
LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_pd.hDevNames); if(lpDev == NULL) return NULL;
return (LPCTSTR)lpDev + lpDev->wDriverOffset; } LPCTSTR GetDeviceName() const // return device name
{ if(m_pd.hDevNames == NULL) return NULL;
LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_pd.hDevNames); if(lpDev == NULL) return NULL;
return (LPCTSTR)lpDev + lpDev->wDeviceOffset; } LPCTSTR GetPortName() const // return output port name
{ if(m_pd.hDevNames == NULL) return NULL;
LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_pd.hDevNames); if(lpDev == NULL) return NULL;
return (LPCTSTR)lpDev + lpDev->wOutputOffset; } HDC GetPrinterDC() const // return HDC (caller must delete)
{ ATLASSERT(m_pd.Flags & PD_RETURNDC); return m_pd.hDC; }
// This helper creates a DC based on the DEVNAMES and DEVMODE structures.
// This DC is returned, but also stored in m_pd.hDC as though it had been
// returned by CommDlg. It is assumed that any previously obtained DC
// has been/will be deleted by the user. This may be
// used without ever invoking the print/print setup dialogs.
HDC CreatePrinterDC() { m_pd.hDC = _AtlCreateDC(m_pd.hDevNames, m_pd.hDevMode); return m_pd.hDC; }
// Implementation
PRINTDLG m_pdActual; // the Print/Print Setup need to share this
// The following handle the case of print setup... from the print dialog
CPrintDialogImpl(PRINTDLG& pdInit) : m_pd(pdInit) { }
BEGIN_MSG_MAP(CPrintDialogImpl< T >) #ifdef psh1
COMMAND_ID_HANDLER(psh1, OnPrintSetup) // print setup button when print is displayed
#else //!psh1
COMMAND_ID_HANDLER(0x0400, OnPrintSetup) // value from dlgs.h
#endif //!psh1
END_MSG_MAP()
LRESULT OnPrintSetup(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& /*bHandled*/) { CPrintDialogImpl< T >* pDlgSetup = NULL; ATLTRY(pDlgSetup = new CPrintDialogImpl< T >(m_pd)); ATLASSERT(pDlgSetup != NULL);
_Module.AddCreateWndData(&m_thunk.cd, (CCommonDialogImplBase*)pDlgSetup); LRESULT lRet = DefWindowProc(WM_COMMAND, MAKEWPARAM(wID, wNotifyCode), (LPARAM)hWndCtl);
delete pDlgSetup; return lRet; } };
class CPrintDialog : public CPrintDialogImpl<CPrintDialog> { public: CPrintDialog(BOOL bPrintSetupOnly = FALSE, DWORD dwFlags = PD_ALLPAGES | PD_USEDEVMODECOPIES | PD_NOPAGENUMS | PD_NOSELECTION, HWND hWndParent = NULL) : CPrintDialogImpl<CPrintDialog>(bPrintSetupOnly, dwFlags, hWndParent) { } CPrintDialog(PRINTDLG& pdInit) : CPrintDialogImpl<CPrintDialog>(pdInit) { } };
/////////////////////////////////////////////////////////////////////////////
// CPrintDialogExImpl - new print dialog for Windows 2000
#if (WINVER >= 0x0500)
}; //namespace WTL
#include <atlcom.h>
extern "C" const __declspec(selectany) IID IID_IPrintDialogCallback = {0x5852a2c3, 0x6530, 0x11d1, {0xb6, 0xa3, 0x0, 0x0, 0xf8, 0x75, 0x7b, 0xf9}}; extern "C" const __declspec(selectany) IID IID_IPrintDialogServices = {0x509aaeda, 0x5639, 0x11d1, {0xb6, 0xa1, 0x0, 0x0, 0xf8, 0x75, 0x7b, 0xf9}};
namespace WTL {
template <class T> class ATL_NO_VTABLE CPrintDialogExImpl : public CWindow, public CMessageMap, public IPrintDialogCallback, public IObjectWithSiteImpl< T > { public: PRINTDLGEX m_pdex;
// Constructor
CPrintDialogExImpl(DWORD dwFlags = PD_ALLPAGES | PD_USEDEVMODECOPIES | PD_NOPAGENUMS | PD_NOSELECTION | PD_NOCURRENTPAGE, HWND hWndParent = NULL) { memset(&m_pdex, 0, sizeof(m_pdex));
m_pdex.lStructSize = sizeof(PRINTDLGEX); m_pdex.hwndOwner = hWndParent; m_pdex.Flags = dwFlags; m_pdex.nStartPage = START_PAGE_GENERAL; // callback object will be set in DoModal
m_pdex.Flags &= ~PD_RETURNIC; // do not support information context
}
// Operations
HRESULT DoModal(HWND hWndParent = ::GetActiveWindow()) { ATLASSERT(m_hWnd == NULL); ATLASSERT((m_pdex.Flags & PD_RETURNDEFAULT) == 0); // use GetDefaults for this
if(m_pdex.hwndOwner == NULL) // set only if not specified before
m_pdex.hwndOwner = hWndParent;
T* pT = static_cast<T*>(this); m_pdex.lpCallback = (IUnknown*)(IPrintDialogCallback*)pT;
HRESULT hResult = ::PrintDlgEx(&m_pdex);
m_hWnd = NULL;
return hResult; }
BOOL EndDialog(INT_PTR /*nRetCode*/ = 0) { ATLASSERT(::IsWindow(m_hWnd)); SendMessage(WM_COMMAND, MAKEWPARAM(IDABORT, 0)); return TRUE; }
// GetDefaults will not display a dialog but will get device defaults
HRESULT GetDefaults() { m_pdex.Flags |= PD_RETURNDEFAULT; ATLASSERT(m_pdex.hDevMode == NULL); // must be NULL
ATLASSERT(m_pdex.hDevNames == NULL); // must be NULL
return ::PrintDlgEx(&m_pdex); }
// Helpers for parsing information after successful return num. copies requested
int GetCopies() const { if(m_pdex.Flags & PD_USEDEVMODECOPIES) { LPDEVMODE lpDevMode = GetDevMode(); return (lpDevMode != NULL) ? lpDevMode->dmCopies : -1; }
return m_pdex.nCopies; } BOOL PrintCollate() const // TRUE if collate checked
{ return m_pdex.Flags & PD_COLLATE ? TRUE : FALSE; } BOOL PrintSelection() const // TRUE if printing selection
{ return m_pdex.Flags & PD_SELECTION ? TRUE : FALSE; } BOOL PrintAll() const // TRUE if printing all pages
{ return !PrintRange() && !PrintSelection() ? TRUE : FALSE; } BOOL PrintRange() const // TRUE if printing page range
{ return m_pdex.Flags & PD_PAGENUMS ? TRUE : FALSE; } LPDEVMODE GetDevMode() const // return DEVMODE
{ if(m_pdex.hDevMode == NULL) return NULL;
return (LPDEVMODE)::GlobalLock(m_pdex.hDevMode); } LPCTSTR GetDriverName() const // return driver name
{ if(m_pdex.hDevNames == NULL) return NULL;
LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_pdex.hDevNames); if(lpDev == NULL) return NULL;
return (LPCTSTR)lpDev + lpDev->wDriverOffset; } LPCTSTR GetDeviceName() const // return device name
{ if(m_pdex.hDevNames == NULL) return NULL;
LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_pdex.hDevNames); if(lpDev == NULL) return NULL;
return (LPCTSTR)lpDev + lpDev->wDeviceOffset; } LPCTSTR GetPortName() const // return output port name
{ if(m_pdex.hDevNames == NULL) return NULL;
LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_pdex.hDevNames); if(lpDev == NULL) return NULL;
return (LPCTSTR)lpDev + lpDev->wOutputOffset; } HDC GetPrinterDC() const // return HDC (caller must delete)
{ ATLASSERT(m_pdex.Flags & PD_RETURNDC); return m_pdex.hDC; }
// This helper creates a DC based on the DEVNAMES and DEVMODE structures.
// This DC is returned, but also stored in m_pdex.hDC as though it had been
// returned by CommDlg. It is assumed that any previously obtained DC
// has been/will be deleted by the user. This may be
// used without ever invoking the print/print setup dialogs.
HDC CreatePrinterDC() { m_pdex.hDC = _AtlCreateDC(m_pdex.hDevNames, m_pdex.hDevMode); return m_pdex.hDC; }
// Implementation - interfaces
// IUnknown
STDMETHOD(QueryInterface)(REFIID riid, void** ppvObject) { if(ppvObject == NULL) return E_POINTER;
T* pT = static_cast<T*>(this); if(IsEqualGUID(riid, IID_IUnknown) || IsEqualGUID(riid, IID_IPrintDialogCallback)) { *ppvObject = (IPrintDialogCallback*)pT; // AddRef() not needed
return S_OK; } else if(IsEqualGUID(riid, IID_IObjectWithSite)) { *ppvObject = (IObjectWithSite*)pT; // AddRef() not needed
return S_OK; }
return E_NOINTERFACE; } virtual ULONG STDMETHODCALLTYPE AddRef() { return 1; } virtual ULONG STDMETHODCALLTYPE Release() { return 1; }
// IPrintDialogCallback
STDMETHOD(InitDone)() { return S_FALSE; } STDMETHOD(SelectionChange)() { return S_FALSE; } STDMETHOD(HandleMessage)(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT* plResult) { // set up m_hWnd the first time
if(m_hWnd == NULL) Attach(hWnd);
// call message map
HRESULT hRet = ProcessWindowMessage(hWnd, uMsg, wParam, lParam, *plResult, 0) ? S_OK : S_FALSE; if(hRet == S_OK && uMsg == WM_NOTIFY) // return in DWLP_MSGRESULT
::SetWindowLongPtr(GetParent(), DWLP_MSGRESULT, (LONG_PTR)*plResult);
if(uMsg == WM_INITDIALOG && hRet == S_OK && (BOOL)*plResult != FALSE) hRet = S_FALSE;
return hRet; } };
class CPrintDialogEx : public CPrintDialogExImpl<CPrintDialogEx> { public: CPrintDialogEx( DWORD dwFlags = PD_ALLPAGES | PD_USEDEVMODECOPIES | PD_NOPAGENUMS | PD_NOSELECTION | PD_NOCURRENTPAGE, HWND hWndParent = NULL) : CPrintDialogExImpl<CPrintDialogEx>(dwFlags, hWndParent) { }
DECLARE_EMPTY_MSG_MAP() };
#endif //(WINVER >= 0x0500)
/////////////////////////////////////////////////////////////////////////////
// CPageSetupDialogImpl - Page Setup dialog
template <class T> class ATL_NO_VTABLE CPageSetupDialogImpl : public CCommonDialogImplBase { public: PAGESETUPDLG m_psd; CWndProcThunk m_thunkPaint;
// Constructors
CPageSetupDialogImpl(DWORD dwFlags = PSD_MARGINS | PSD_INWININIINTLMEASURE, HWND hWndParent = NULL) { memset(&m_psd, 0, sizeof(m_psd));
m_psd.lStructSize = sizeof(m_psd); m_psd.hwndOwner = hWndParent; m_psd.Flags = (dwFlags | PSD_ENABLEPAGESETUPHOOK | PSD_ENABLEPAGEPAINTHOOK); m_psd.lpfnPageSetupHook = (LPPAGESETUPHOOK)T::HookProc; m_thunkPaint.Init((WNDPROC)T::PaintHookProc, this); m_psd.lpfnPagePaintHook = (LPPAGEPAINTHOOK)&(m_thunkPaint.thunk); }
DECLARE_EMPTY_MSG_MAP()
// Attributes
LPDEVMODE GetDevMode() const // return DEVMODE
{ if(m_psd.hDevMode == NULL) return NULL;
return (LPDEVMODE)::GlobalLock(m_psd.hDevMode); } LPCTSTR GetDriverName() const // return driver name
{ if(m_psd.hDevNames == NULL) return NULL;
LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_psd.hDevNames); return (LPCTSTR)lpDev + lpDev->wDriverOffset; } LPCTSTR GetDeviceName() const // return device name
{ if(m_psd.hDevNames == NULL) return NULL;
LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_psd.hDevNames); return (LPCTSTR)lpDev + lpDev->wDeviceOffset; } LPCTSTR GetPortName() const // return output port name
{ if(m_psd.hDevNames == NULL) return NULL;
LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_psd.hDevNames); return (LPCTSTR)lpDev + lpDev->wOutputOffset; } HDC CreatePrinterDC() { return _AtlCreateDC(m_psd.hDevNames, m_psd.hDevMode); } SIZE GetPaperSize() const { SIZE size; size.cx = m_psd.ptPaperSize.x; size.cy = m_psd.ptPaperSize.y; return size; } void GetMargins(LPRECT lpRectMargins, LPRECT lpRectMinMargins) const { if(lpRectMargins != NULL) memcpy(lpRectMargins, &m_psd.rtMargin, sizeof(RECT)); if(lpRectMinMargins != NULL) memcpy(lpRectMinMargins, &m_psd.rtMinMargin, sizeof(RECT)); }
// Operations
INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow()) { ATLASSERT(m_psd.Flags & PSD_ENABLEPAGESETUPHOOK); ATLASSERT(m_psd.Flags & PSD_ENABLEPAGEPAINTHOOK); ATLASSERT(m_psd.lpfnPageSetupHook != NULL); // can still be a user hook
ATLASSERT(m_psd.lpfnPagePaintHook != NULL); // can still be a user hook
if(m_psd.hwndOwner == NULL) // set only if not specified before
m_psd.hwndOwner = hWndParent;
ATLASSERT(m_hWnd == NULL); _Module.AddCreateWndData(&m_thunk.cd, (CCommonDialogImplBase*)this);
BOOL bRet = ::PageSetupDlg(&m_psd);
m_hWnd = NULL;
return bRet ? IDOK : IDCANCEL; }
// Implementation
static UINT CALLBACK PaintHookProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { CPageSetupDialogImpl< T >* pDlg = (CPageSetupDialogImpl< T >*)hWnd; ATLASSERT(pDlg->m_hWnd == ::GetParent(hWnd)); UINT uRet = 0; switch(uMsg) { case WM_PSD_PAGESETUPDLG: uRet = pDlg->PreDrawPage(LOWORD(wParam), HIWORD(wParam), (LPPAGESETUPDLG)lParam); break; case WM_PSD_FULLPAGERECT: case WM_PSD_MINMARGINRECT: case WM_PSD_MARGINRECT: case WM_PSD_GREEKTEXTRECT: case WM_PSD_ENVSTAMPRECT: case WM_PSD_YAFULLPAGERECT: uRet = pDlg->OnDrawPage(uMsg, (HDC)wParam, (LPRECT)lParam); break; default: ATLTRACE2(atlTraceUI, 0, _T("CPageSetupDialogImpl::PaintHookProc - unknown message received\n")); break; } return uRet; }
// Overridables
UINT PreDrawPage(WORD /*wPaper*/, WORD /*wFlags*/, LPPAGESETUPDLG /*pPSD*/) { // return 1 to prevent any more drawing
return 0; } UINT OnDrawPage(UINT /*uMsg*/, HDC /*hDC*/, LPRECT /*lpRect*/) { return 0; // do the default
} };
class CPageSetupDialog : public CPageSetupDialogImpl<CPageSetupDialog> { public: CPageSetupDialog(DWORD dwFlags = PSD_MARGINS | PSD_INWININIINTLMEASURE, HWND hWndParent = NULL) : CPageSetupDialogImpl<CPageSetupDialog>(dwFlags, hWndParent) { }
// override PaintHookProc and references to handlers
static UINT CALLBACK PaintHookProc(HWND, UINT, WPARAM, LPARAM) { return 0; } };
/////////////////////////////////////////////////////////////////////////////
// CFindReplaceDialogImpl - Find/FindReplace modeless dialogs
template <class T> class ATL_NO_VTABLE CFindReplaceDialogImpl : public CCommonDialogImplBase { public: FINDREPLACE m_fr; TCHAR m_szFindWhat[128]; TCHAR m_szReplaceWith[128];
// Constructors
CFindReplaceDialogImpl() { memset(&m_fr, 0, sizeof(m_fr)); m_szFindWhat[0] = '\0'; m_szReplaceWith[0] = '\0';
m_fr.lStructSize = sizeof(m_fr); m_fr.Flags = FR_ENABLEHOOK; m_fr.lpfnHook = (LPFRHOOKPROC)T::HookProc; m_fr.lpstrFindWhat = (LPTSTR)m_szFindWhat; }
// Note: You must allocate the object on the heap.
// If you do not, you must override OnFinalMessage()
virtual void OnFinalMessage(HWND /*hWnd*/) { delete this; }
HWND Create(BOOL bFindDialogOnly, // TRUE for Find, FALSE for FindReplace
LPCTSTR lpszFindWhat, LPCTSTR lpszReplaceWith = NULL, DWORD dwFlags = FR_DOWN, HWND hWndParent = NULL) { ATLASSERT(m_fr.Flags & FR_ENABLEHOOK); ATLASSERT(m_fr.lpfnHook != NULL);
m_fr.wFindWhatLen = sizeof(m_szFindWhat)/sizeof(TCHAR); m_fr.lpstrReplaceWith = (LPTSTR)m_szReplaceWith; m_fr.wReplaceWithLen = sizeof(m_szReplaceWith)/sizeof(TCHAR); m_fr.Flags |= dwFlags;
if(hWndParent == NULL) m_fr.hwndOwner = ::GetActiveWindow(); else m_fr.hwndOwner = hWndParent; ATLASSERT(m_fr.hwndOwner != NULL); // must have an owner for modeless dialog
if(lpszFindWhat != NULL) lstrcpyn(m_szFindWhat, lpszFindWhat, sizeof(m_szFindWhat)/sizeof(TCHAR));
if(lpszReplaceWith != NULL) lstrcpyn(m_szReplaceWith, lpszReplaceWith, sizeof(m_szReplaceWith)/sizeof(TCHAR));
ATLASSERT(m_hWnd == NULL); _Module.AddCreateWndData(&m_thunk.cd, (CCommonDialogImplBase*)this); HWND hWnd;
if(bFindDialogOnly) hWnd = ::FindText(&m_fr); else hWnd = ::ReplaceText(&m_fr);
ATLASSERT(m_hWnd == hWnd); return hWnd; }
static const UINT GetFindReplaceMsg() { static const UINT nMsgFindReplace = ::RegisterWindowMessage(FINDMSGSTRING); return nMsgFindReplace; } // call while handling FINDMSGSTRING registered message
// to retreive the object
static T* PASCAL GetNotifier(LPARAM lParam) { ATLASSERT(lParam != NULL); T* pDlg = (T*)(lParam - offsetof(T, m_fr)); return pDlg; }
// Operations
// Helpers for parsing information after successful return
LPCTSTR GetFindString() const // get find string
{ return (LPCTSTR)m_fr.lpstrFindWhat; } LPCTSTR GetReplaceString() const // get replacement string
{ return (LPCTSTR)m_fr.lpstrReplaceWith; } BOOL SearchDown() const // TRUE if search down, FALSE is up
{ return m_fr.Flags & FR_DOWN ? TRUE : FALSE; } BOOL FindNext() const // TRUE if command is find next
{ return m_fr.Flags & FR_FINDNEXT ? TRUE : FALSE; } BOOL MatchCase() const // TRUE if matching case
{ return m_fr.Flags & FR_MATCHCASE ? TRUE : FALSE; } BOOL MatchWholeWord() const // TRUE if matching whole words only
{ return m_fr.Flags & FR_WHOLEWORD ? TRUE : FALSE; } BOOL ReplaceCurrent() const // TRUE if replacing current string
{ return m_fr. Flags & FR_REPLACE ? TRUE : FALSE; } BOOL ReplaceAll() const // TRUE if replacing all occurrences
{ return m_fr.Flags & FR_REPLACEALL ? TRUE : FALSE; } BOOL IsTerminating() const // TRUE if terminating dialog
{ return m_fr.Flags & FR_DIALOGTERM ? TRUE : FALSE ; } };
class CFindReplaceDialog : public CFindReplaceDialogImpl<CFindReplaceDialog> { public: DECLARE_EMPTY_MSG_MAP() };
/////////////////////////////////////////////////////////////////////////////
// CPropertySheetWindow - client side for a property sheet
class CPropertySheetWindow : public CWindow { public: // Constructors
CPropertySheetWindow(HWND hWnd = NULL) : CWindow(hWnd) { }
CPropertySheetWindow& operator=(HWND hWnd) { m_hWnd = hWnd; return *this; }
// Attributes
int GetPageCount() const { ATLASSERT(::IsWindow(m_hWnd)); HWND hWndTabCtrl = GetTabControl(); ATLASSERT(hWndTabCtrl != NULL); return (int)::SendMessage(hWndTabCtrl, TCM_GETITEMCOUNT, 0, 0L); } HWND GetActivePage() const { ATLASSERT(::IsWindow(m_hWnd)); return (HWND)::SendMessage(m_hWnd, PSM_GETCURRENTPAGEHWND, 0, 0L); } int GetActiveIndex() const { ATLASSERT(::IsWindow(m_hWnd)); HWND hWndTabCtrl = GetTabControl(); ATLASSERT(hWndTabCtrl != NULL); return (int)::SendMessage(hWndTabCtrl, TCM_GETCURSEL, 0, 0L); } BOOL SetActivePage(int nPageIndex) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, PSM_SETCURSEL, nPageIndex, 0L); } BOOL SetActivePage(HPROPSHEETPAGE hPage) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(hPage != NULL); return (BOOL)::SendMessage(m_hWnd, PSM_SETCURSEL, 0, (LPARAM)hPage); } BOOL SetActivePageByID(int nPageID) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, PSM_SETCURSELID, 0, nPageID); } void SetTitle(LPCTSTR lpszText, UINT nStyle = 0) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT((nStyle & ~PSH_PROPTITLE) == 0); // only PSH_PROPTITLE is valid
ATLASSERT(lpszText != NULL); ::SendMessage(m_hWnd, PSM_SETTITLE, nStyle, (LPARAM)lpszText); } HWND GetTabControl() const { ATLASSERT(::IsWindow(m_hWnd)); return (HWND)::SendMessage(m_hWnd, PSM_GETTABCONTROL, 0, 0L); } void SetFinishText(LPCTSTR lpszText) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, PSM_SETFINISHTEXT, 0, (LPARAM)lpszText); } void SetWizardButtons(DWORD dwFlags) { ATLASSERT(::IsWindow(m_hWnd)); ::PostMessage(m_hWnd, PSM_SETWIZBUTTONS, 0, dwFlags); }
// Operations
void AddPage(HPROPSHEETPAGE hPage) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(hPage != NULL); ::SendMessage(m_hWnd, PSM_ADDPAGE, 0, (LPARAM)hPage); } BOOL AddPage(LPCPROPSHEETPAGE pPage) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(pPage != NULL); HPROPSHEETPAGE hPage = ::CreatePropertySheetPage(pPage); if(hPage == NULL) return FALSE; ::SendMessage(m_hWnd, PSM_ADDPAGE, 0, (LPARAM)hPage); return TRUE; } void RemovePage(int nPageIndex) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, PSM_REMOVEPAGE, nPageIndex, 0L); } void RemovePage(HPROPSHEETPAGE hPage) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(hPage != NULL); ::SendMessage(m_hWnd, PSM_REMOVEPAGE, 0, (LPARAM)hPage); } BOOL PressButton(int nButton) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, PSM_PRESSBUTTON, nButton, 0L); } BOOL Apply() { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, PSM_APPLY, 0, 0L); } void CancelToClose() { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, PSM_CANCELTOCLOSE, 0, 0L); } void SetModified(HWND hWndPage, BOOL bChanged = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(::IsWindow(hWndPage)); UINT uMsg = bChanged ? PSM_CHANGED : PSM_UNCHANGED; ::SendMessage(m_hWnd, uMsg, (WPARAM)hWndPage, 0L); } LRESULT QuerySiblings(WPARAM wParam, LPARAM lParam) { ATLASSERT(::IsWindow(m_hWnd)); return ::SendMessage(m_hWnd, PSM_QUERYSIBLINGS, wParam, lParam); } void RebootSystem() { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, PSM_REBOOTSYSTEM, 0, 0L); } void RestartWindows() { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, PSM_RESTARTWINDOWS, 0, 0L); } BOOL IsDialogMessage(LPMSG lpMsg) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, PSM_ISDIALOGMESSAGE, 0, (LPARAM)lpMsg); }
#if (_WIN32_IE >= 0x0500)
int HwndToIndex(HWND hWnd) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, PSM_HWNDTOINDEX, (WPARAM)hWnd, 0L); } HWND IndexToHwnd(int nIndex) const { ATLASSERT(::IsWindow(m_hWnd)); return (HWND)::SendMessage(m_hWnd, PSM_INDEXTOHWND, nIndex, 0L); } int PageToIndex(HPROPSHEETPAGE hPage) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, PSM_PAGETOINDEX, 0, (LPARAM)hPage); } HPROPSHEETPAGE IndexToPage(int nIndex) const { ATLASSERT(::IsWindow(m_hWnd)); return (HPROPSHEETPAGE)::SendMessage(m_hWnd, PSM_INDEXTOPAGE, nIndex, 0L); } int IdToIndex(int nID) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, PSM_IDTOINDEX, 0, nID); } int IndexToId(int nIndex) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, PSM_INDEXTOID, nIndex, 0L); } int GetResult() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, PSM_GETRESULT, 0, 0L); } BOOL RecalcPageSizes() { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, PSM_RECALCPAGESIZES, 0, 0L); } #endif //(_WIN32_IE >= 0x0500)
// Implementation - override to prevent usage
HWND Create(LPCTSTR, HWND, _U_RECT = NULL, LPCTSTR = NULL, DWORD = 0, DWORD = 0, _U_MENUorID = 0U, LPVOID = NULL) { ATLASSERT(FALSE); return NULL; } };
/////////////////////////////////////////////////////////////////////////////
// CPropertySheetImpl - implements a property sheet
#if (_MSC_VER >= 1200)
typedef HPROPSHEETPAGE _HPROPSHEETPAGE_TYPE; #else
// we use void* here instead of HPROPSHEETPAGE becuase HPROPSHEETPAGE
// is a _PSP*, but _PSP is not defined properly
typedef void* _HPROPSHEETPAGE_TYPE; #endif
template <class T, class TBase /*= CPropertySheetWindow */ > class ATL_NO_VTABLE CPropertySheetImpl : public CWindowImplBaseT< TBase > { public: PROPSHEETHEADER m_psh; CSimpleArray<_HPROPSHEETPAGE_TYPE> m_arrPages;
// Construction/Destruction
CPropertySheetImpl(_U_STRINGorID title = (LPCTSTR)NULL, UINT uStartPage = 0, HWND hWndParent = NULL) { memset(&m_psh, 0, sizeof(PROPSHEETHEADER)); m_psh.dwSize = sizeof(PROPSHEETHEADER); m_psh.dwFlags = PSH_USECALLBACK; m_psh.hInstance = _Module.GetResourceInstance(); m_psh.phpage = NULL; // will be set later
m_psh.nPages = 0; // will be set later
m_psh.pszCaption = title.m_lpstr; m_psh.nStartPage = uStartPage; m_psh.hwndParent = hWndParent; // if NULL, will be set in DoModal/Create
m_psh.pfnCallback = T::PropSheetCallback; }
~CPropertySheetImpl() { if(m_arrPages.GetSize() > 0) // sheet never created, destroy all pages
{ for(int i = 0; i < m_arrPages.GetSize(); i++) ::DestroyPropertySheetPage((HPROPSHEETPAGE)m_arrPages[i]); } }
static int CALLBACK PropSheetCallback(HWND hWnd, UINT uMsg, LPARAM) { if(uMsg == PSCB_INITIALIZED) { ATLASSERT(hWnd != NULL); T* pT = (T*)_Module.ExtractCreateWndData(); // subclass the sheet window
pT->SubclassWindow(hWnd); // remove page handles array
pT->_CleanUpPages(); }
return 0; }
HWND Create(HWND hWndParent = NULL) { ATLASSERT(m_hWnd == NULL);
m_psh.dwFlags |= PSH_MODELESS; if(m_psh.hwndParent == NULL) m_psh.hwndParent = hWndParent; m_psh.phpage = (HPROPSHEETPAGE*)m_arrPages.GetData(); m_psh.nPages = m_arrPages.GetSize();
T* pT = static_cast<T*>(this); _Module.AddCreateWndData(&m_thunk.cd, pT);
HWND hWnd = (HWND)::PropertySheet(&m_psh); _CleanUpPages(); // ensure clean-up, required if call failed
ATLASSERT(m_hWnd == hWnd);
return hWnd; }
INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow()) { ATLASSERT(m_hWnd == NULL);
m_psh.dwFlags &= ~PSH_MODELESS; if(m_psh.hwndParent == NULL) m_psh.hwndParent = hWndParent; m_psh.phpage = (HPROPSHEETPAGE*)m_arrPages.GetData(); m_psh.nPages = m_arrPages.GetSize();
T* pT = static_cast<T*>(this); _Module.AddCreateWndData(&m_thunk.cd, pT);
INT_PTR nRet = ::PropertySheet(&m_psh); _CleanUpPages(); // ensure clean-up, required if call failed
return nRet; }
// implementation helper - clean up pages array
void _CleanUpPages() { m_psh.nPages = 0; m_psh.phpage = NULL; m_arrPages.RemoveAll(); }
// Attributes (extended overrides of client class methods)
// These now can be called before the sheet is created
// Note: Calling these after the sheet is created gives unpredictable results
int GetPageCount() const { if(m_hWnd == NULL) // not created yet
return m_arrPages.GetSize(); return TBase::GetPageCount(); } int GetActiveIndex() const { if(m_hWnd == NULL) // not created yet
return m_psh.nStartPage; return TBase::GetActiveIndex(); } HPROPSHEETPAGE GetPage(int nPageIndex) const { ATLASSERT(m_hWnd == NULL); // can't do this after it's created
return (HPROPSHEETPAGE)m_arrPages[nPageIndex]; } int GetPageIndex(HPROPSHEETPAGE hPage) const { ATLASSERT(m_hWnd == NULL); // can't do this after it's created
return m_arrPages.Find((_HPROPSHEETPAGE_TYPE&)hPage); } BOOL SetActivePage(int nPageIndex) { if(m_hWnd == NULL) // not created yet
{ ATLASSERT(nPageIndex >= 0 && nPageIndex < m_arrPages.GetSize()); m_psh.nStartPage = nPageIndex; return TRUE; } return TBase::SetActivePage(nPageIndex); } BOOL SetActivePage(HPROPSHEETPAGE hPage) { ATLASSERT(hPage != NULL); if (m_hWnd == NULL) // not created yet
{ int nPageIndex = GetPageIndex(hPage); if(nPageIndex == -1) return FALSE;
return SetActivePage(nPageIndex); } return TBase::SetActivePage(hPage);
} void SetTitle(LPCTSTR lpszText, UINT nStyle = 0) { ATLASSERT((nStyle & ~PSH_PROPTITLE) == 0); // only PSH_PROPTITLE is valid
ATLASSERT(lpszText != NULL);
if(m_hWnd == NULL) { // set internal state
m_psh.pszCaption = lpszText; // must exist until sheet is created
m_psh.dwFlags &= ~PSH_PROPTITLE; m_psh.dwFlags |= nStyle; } else { // set external state
TBase::SetTitle(lpszText, nStyle); } } void SetWizardMode() { m_psh.dwFlags |= PSH_WIZARD; } void EnableHelp() { m_psh.dwFlags |= PSH_HASHELP; }
// Operations
BOOL AddPage(HPROPSHEETPAGE hPage) { ATLASSERT(hPage != NULL); BOOL bRet = TRUE; if(m_hWnd != NULL) TBase::AddPage(hPage); else // sheet not created yet, use internal data
bRet = m_arrPages.Add((_HPROPSHEETPAGE_TYPE&)hPage); return bRet; } BOOL AddPage(LPCPROPSHEETPAGE pPage) { ATLASSERT(pPage != NULL); HPROPSHEETPAGE hPage = ::CreatePropertySheetPage(pPage); if(hPage == NULL) return FALSE; BOOL bRet = AddPage(hPage); if(!bRet) ::DestroyPropertySheetPage(hPage); return bRet; } BOOL RemovePage(HPROPSHEETPAGE hPage) { ATLASSERT(hPage != NULL); if (m_hWnd == NULL) // not created yet
{ int nPage = GetPageIndex(hPage); if(nPage == -1) return FALSE; return RemovePage(nPage); } TBase::RemovePage(hPage); return TRUE;
} BOOL RemovePage(int nPageIndex) { BOOL bRet = TRUE; if(m_hWnd != NULL) TBase::RemovePage(nPageIndex); else // sheet not created yet, use internal data
bRet = m_arrPages.RemoveAt(nPageIndex); return bRet; }
#if (_WIN32_IE >= 0x0400)
void SetHeader(LPCTSTR szbmHeader) { ATLASSERT(m_hWnd == NULL); // can't do this after it's created
m_psh.dwFlags &= ~PSH_WIZARD; m_psh.dwFlags |= (PSH_HEADER | PSH_WIZARD97); m_psh.pszbmHeader = szbmHeader; }
void SetHeader(HBITMAP hbmHeader) { ATLASSERT(m_hWnd == NULL); // can't do this after it's created
m_psh.dwFlags &= ~PSH_WIZARD; m_psh.dwFlags |= (PSH_HEADER | PSH_USEHBMHEADER | PSH_WIZARD97); m_psh.hbmHeader = hbmHeader; }
void SetWatermark(LPCTSTR szbmWatermark, HPALETTE hplWatermark = NULL) { ATLASSERT(m_hWnd == NULL); // can't do this after it's created
m_psh.dwFlags &= ~PSH_WIZARD; m_psh.dwFlags |= PSH_WATERMARK | PSH_WIZARD97; m_psh.pszbmWatermark = szbmWatermark;
if (hplWatermark != NULL) { m_psh.dwFlags |= PSH_USEHPLWATERMARK; m_psh.hplWatermark = hplWatermark; } }
void SetWatermark(HBITMAP hbmWatermark, HPALETTE hplWatermark = NULL) { ATLASSERT(m_hWnd == NULL); // can't do this after it's created
m_psh.dwFlags &= ~PSH_WIZARD; m_psh.dwFlags |= (PSH_WATERMARK | PSH_USEHBMWATERMARK | PSH_WIZARD97); m_psh.hbmWatermark = hbmWatermark;
if (hplWatermark != NULL) { m_psh.dwFlags |= PSH_USEHPLWATERMARK; m_psh.hplWatermark = hplWatermark; } }
void StretchWatermark(bool bStretchWatermark) { ATLASSERT(m_hWnd == NULL); // can't do this after it's created
if (bStretchWatermark) m_psh.dwFlags |= PSH_STRETCHWATERMARK; else m_psh.dwFlags &= ~PSH_STRETCHWATERMARK; } #endif
// Message map and handlers handlers
typedef CPropertySheetImpl< T, TBase > thisClass; BEGIN_MSG_MAP(thisClass) MESSAGE_HANDLER(WM_COMMAND, OnCommand) END_MSG_MAP()
LRESULT OnCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/) { LRESULT lRet = DefWindowProc(uMsg, wParam, lParam); if(HIWORD(wParam) == BN_CLICKED && (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) && ((m_psh.dwFlags & PSH_MODELESS) != 0) && (GetActivePage() == NULL)) DestroyWindow(); return lRet; } };
// for non-customized sheets
class CPropertySheet : public CPropertySheetImpl<CPropertySheet> { public: CPropertySheet(_U_STRINGorID title = (LPCTSTR)NULL, UINT uStartPage = 0, HWND hWndParent = NULL) : CPropertySheetImpl<CPropertySheet>(title, uStartPage, hWndParent) { }
BEGIN_MSG_MAP(thisClass) MESSAGE_HANDLER(WM_COMMAND, CPropertySheetImpl<CPropertySheet>::OnCommand) END_MSG_MAP() };
/////////////////////////////////////////////////////////////////////////////
// CPropertyPageWindow - client side for a property page
class CPropertyPageWindow : public CWindow { public: // Constructors
CPropertyPageWindow(HWND hWnd = NULL) : CWindow(hWnd) { }
CPropertyPageWindow& operator=(HWND hWnd) { m_hWnd = hWnd; return *this; }
// Attributes
CPropertySheetWindow GetPropertySheet() const { ATLASSERT(::IsWindow(m_hWnd)); return CPropertySheetWindow(GetParent()); }
// Operations
BOOL Apply() { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(GetParent() != NULL); return GetPropertySheet().Apply(); } void CancelToClose() { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(GetParent() != NULL); GetPropertySheet().CancelToClose(); } void SetModified(BOOL bChanged = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(GetParent() != NULL); GetPropertySheet().SetModified(m_hWnd, bChanged); } LRESULT QuerySiblings(WPARAM wParam, LPARAM lParam) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(GetParent() != NULL); return GetPropertySheet().QuerySiblings(wParam, lParam); } void RebootSystem() { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(GetParent() != NULL); GetPropertySheet().RebootSystem(); } void RestartWindows() { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(GetParent() != NULL); GetPropertySheet().RestartWindows(); } void SetWizardButtons(DWORD dwFlags) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(GetParent() != NULL); GetPropertySheet().SetWizardButtons(dwFlags); }
// Implementation - overrides to prevent usage
HWND Create(LPCTSTR, HWND, _U_RECT = NULL, LPCTSTR = NULL, DWORD = 0, DWORD = 0, _U_MENUorID = 0U, LPVOID = NULL) { ATLASSERT(FALSE); return NULL; } };
/////////////////////////////////////////////////////////////////////////////
// CPropertyPageImpl - implements a property page
template <class T, class TBase /*= CPropertyPageWindow */ > class ATL_NO_VTABLE CPropertyPageImpl : public CDialogImplBaseT< TBase > { public: PROPSHEETPAGE m_psp;
operator PROPSHEETPAGE*() { return &m_psp; }
// Construction
CPropertyPageImpl(_U_STRINGorID title = (LPCTSTR)NULL) { // initialize PROPSHEETPAGE struct
memset(&m_psp, 0, sizeof(PROPSHEETPAGE)); m_psp.dwSize = sizeof(PROPSHEETPAGE); m_psp.dwFlags = PSP_USECALLBACK; m_psp.hInstance = _Module.GetResourceInstance(); T* pT = static_cast<T*>(this); m_psp.pszTemplate = MAKEINTRESOURCE(pT->IDD); m_psp.pfnDlgProc = T::StartDialogProc; m_psp.pfnCallback = T::PropPageCallback; m_psp.lParam = (LPARAM)pT;
if(title.m_lpstr != NULL) SetTitle(title); }
static UINT CALLBACK PropPageCallback(HWND hWnd, UINT uMsg, LPPROPSHEETPAGE ppsp) { hWnd; // avoid level 4 warning
if(uMsg == PSPCB_CREATE) { ATLASSERT(hWnd == NULL); CDialogImplBaseT< TBase >* pPage = (CDialogImplBaseT< TBase >*)(T*)ppsp->lParam; _Module.AddCreateWndData(&pPage->m_thunk.cd, pPage); }
return 1; }
HPROPSHEETPAGE Create() { return ::CreatePropertySheetPage(&m_psp); }
// Attributes
void SetTitle(_U_STRINGorID title) { m_psp.pszTitle = title.m_lpstr; m_psp.dwFlags |= PSP_USETITLE; }
#if (_WIN32_IE >= 0x0500)
void SetHeaderTitle(LPCTSTR lpstrHeaderTitle) { ATLASSERT(m_hWnd == NULL); // can't do this after it's created
m_psp.dwFlags |= PSP_USEHEADERTITLE; m_psp.pszHeaderTitle = lpstrHeaderTitle; } void SetHeaderSubTitle(LPCTSTR lpstrHeaderSubTitle) { ATLASSERT(m_hWnd == NULL); // can't do this after it's created
m_psp.dwFlags |= PSP_USEHEADERSUBTITLE; m_psp.pszHeaderSubTitle = lpstrHeaderSubTitle; } #endif //(_WIN32_IE >= 0x0500)
// Operations
void EnableHelp() { m_psp.dwFlags |= PSP_HASHELP; }
// Message map and handlers
typedef CPropertyPageImpl< T, TBase > thisClass; BEGIN_MSG_MAP(thisClass) MESSAGE_HANDLER(WM_NOTIFY, OnNotify) END_MSG_MAP()
LRESULT OnNotify(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled) { ATLASSERT(::IsWindow(m_hWnd)); NMHDR* pNMHDR = (NMHDR*)lParam;
// don't handle messages not from the page/sheet itself
if(pNMHDR->hwndFrom != m_hWnd && pNMHDR->hwndFrom != ::GetParent(m_hWnd)) { bHandled = FALSE; return 1; }
T* pT = static_cast<T*>(this); LRESULT lResult = 0; switch(pNMHDR->code) { case PSN_SETACTIVE: lResult = pT->OnSetActive() ? 0 : -1; break; case PSN_KILLACTIVE: lResult = !pT->OnKillActive(); break; case PSN_APPLY: lResult = pT->OnApply() ? PSNRET_NOERROR : PSNRET_INVALID_NOCHANGEPAGE; break; case PSN_RESET: pT->OnReset(); break; case PSN_QUERYCANCEL: lResult = !pT->OnQueryCancel(); break; case PSN_WIZNEXT: lResult = pT->OnWizardNext(); break; case PSN_WIZBACK: lResult = pT->OnWizardBack(); break; case PSN_WIZFINISH: lResult = !pT->OnWizardFinish(); break; case PSN_HELP: pT->OnHelp(); break; #if (_WIN32_IE >= 0x0400)
case PSN_GETOBJECT: if(!pT->OnGetObject((LPNMOBJECTNOTIFY)lParam)) bHandled = FALSE; break; #endif //(_WIN32_IE >= 0x0400)
#if (_WIN32_IE >= 0x0500)
case PSN_TRANSLATEACCELERATOR: { LPPSHNOTIFY lpPSHNotify = (LPPSHNOTIFY)lParam; lResult = pT->OnTranslateAccelerator((LPMSG)lpPSHNotify->lParam) ? PSNRET_MESSAGEHANDLED : PSNRET_NOERROR; } break; case PSN_QUERYINITIALFOCUS: { LPPSHNOTIFY lpPSHNotify = (LPPSHNOTIFY)lParam; lResult = (LRESULT)pT->OnQueryInitialFocus((HWND)lpPSHNotify->lParam); } break; #endif //(_WIN32_IE >= 0x0500)
default: bHandled = FALSE; // not handled
}
return lResult; }
// Overridables
BOOL OnSetActive() { return TRUE; } BOOL OnKillActive() { return TRUE; } BOOL OnApply() { return TRUE; } void OnReset() { } BOOL OnQueryCancel() { return TRUE; // ok to cancel
} int OnWizardBack() { // 0 = goto next page
// -1 = prevent page change
// >0 = jump to page by dlg ID
return 0; } int OnWizardNext() { // 0 = goto next page
// -1 = prevent page change
// >0 = jump to page by dlg ID
return 0; } BOOL OnWizardFinish() { return TRUE; } void OnHelp() { } #if (_WIN32_IE >= 0x0400)
BOOL OnGetObject(LPNMOBJECTNOTIFY /*lpObjectNotify*/) { return FALSE; // not processed
} #endif //(_WIN32_IE >= 0x0400)
#if (_WIN32_IE >= 0x0500)
BOOL OnTranslateAccelerator(LPMSG /*lpMsg*/) { return FALSE; // not translated
} HWND OnQueryInitialFocus(HWND /*hWndFocus*/) { return NULL; // default
} #endif //(_WIN32_IE >= 0x0500)
};
// for non-customized pages
template <WORD t_wDlgTemplateID> class CPropertyPage : public CPropertyPageImpl<CPropertyPage<t_wDlgTemplateID> > { public: enum { IDD = t_wDlgTemplateID };
CPropertyPage(_U_STRINGorID title = (LPCTSTR)NULL) : CPropertyPageImpl<CPropertyPage>(title) { }
DECLARE_EMPTY_MSG_MAP() };
/////////////////////////////////////////////////////////////////////////////
// CAxPropertyPageImpl - property page that hosts ActiveX controls
#ifndef _ATL_NO_HOSTING
// Note: You must #include <atlhost.h> to use these classes
template <class T, class TBase = CPropertyPageWindow> class ATL_NO_VTABLE CAxPropertyPageImpl : public CPropertyPageImpl< T, TBase > { public: // Data members
HGLOBAL m_hInitData; HGLOBAL m_hDlgRes; HGLOBAL m_hDlgResSplit;
// Constructor/destructor
CAxPropertyPageImpl(_U_STRINGorID title = (LPCTSTR)NULL) : CPropertyPageImpl< T, TBase >(title), m_hInitData(NULL), m_hDlgRes(NULL), m_hDlgResSplit(NULL) { T* pT = static_cast<T*>(this); pT; // avoid level 4 warning
// initialize ActiveX hosting and modify dialog template
AtlAxWinInit();
HINSTANCE hInstance = _Module.GetResourceInstance(); LPCTSTR lpTemplateName = MAKEINTRESOURCE(pT->IDD); HRSRC hDlg = ::FindResource(hInstance, lpTemplateName, (LPTSTR)RT_DIALOG); if(hDlg != NULL) { HRSRC hDlgInit = ::FindResource(hInstance, lpTemplateName, (LPTSTR)_ATL_RT_DLGINIT);
BYTE* pInitData = NULL; if(hDlgInit != NULL) { m_hInitData = ::LoadResource(hInstance, hDlgInit); pInitData = (BYTE*)::LockResource(m_hInitData); }
m_hDlgRes = ::LoadResource(hInstance, hDlg); DLGTEMPLATE* pDlg = (DLGTEMPLATE*)::LockResource(m_hDlgRes); LPCDLGTEMPLATE lpDialogTemplate = _DialogSplitHelper::SplitDialogTemplate(pDlg, pInitData); if(lpDialogTemplate != pDlg) m_hDlgResSplit = ::GlobalHandle(lpDialogTemplate);
// set up property page to use in-memory dialog template
if(lpDialogTemplate != NULL) { m_psp.dwFlags |= PSP_DLGINDIRECT; m_psp.pResource = lpDialogTemplate; } else { ATLASSERT(FALSE && _T("CAxPropertyPageImpl - ActiveX initializtion failed!")); } } else { ATLASSERT(FALSE && _T("CAxPropertyPageImpl - Cannot find dialog template!")); } }
~CAxPropertyPageImpl() { if(m_hInitData != NULL) { UnlockResource(m_hInitData); ::FreeResource(m_hInitData); } if(m_hDlgRes != NULL) { UnlockResource(m_hDlgRes); ::FreeResource(m_hDlgRes); } if(m_hDlgResSplit != NULL) { ::GlobalFree(m_hDlgResSplit); } }
// Methods
// call this one to handle keyboard message for ActiveX controls
BOOL PreTranslateMessage(LPMSG pMsg) { if ((pMsg->message < WM_KEYFIRST || pMsg->message > WM_KEYLAST) && (pMsg->message < WM_MOUSEFIRST || pMsg->message > WM_MOUSELAST)) return FALSE; // find a direct child of the dialog from the window that has focus
HWND hWndCtl = ::GetFocus(); if (IsChild(hWndCtl) && ::GetParent(hWndCtl) != m_hWnd) { do { hWndCtl = ::GetParent(hWndCtl); } while (::GetParent(hWndCtl) != m_hWnd); } // give controls a chance to translate this message
return (BOOL)::SendMessage(hWndCtl, WM_FORWARDMSG, 0, (LPARAM)pMsg); }
// Overridables
#if (_WIN32_IE >= 0x0500)
// new default implementation for ActiveX hosting pages
BOOL OnTranslateAccelerator(LPMSG lpMsg) { T* pT = static_cast<T*>(this); return pT->PreTranslateMessage(lpMsg); } #endif //(_WIN32_IE >= 0x0500)
};
// for non-customized pages
template <WORD t_wDlgTemplateID> class CAxPropertyPage : public CAxPropertyPageImpl<CAxPropertyPage<t_wDlgTemplateID> > { public: enum { IDD = t_wDlgTemplateID };
CAxPropertyPage(_U_STRINGorID title = (LPCTSTR)NULL) : CAxPropertyPageImpl<CAxPropertyPage>(title) { }
#if (_WIN32_IE >= 0x0500)
// not empty so we handle accelerators
BEGIN_MSG_MAP(CAxPropertyPage) CHAIN_MSG_MAP(CAxPropertyPageImpl<CAxPropertyPage<t_wDlgTemplateID> >) END_MSG_MAP() #else //!(_WIN32_IE >= 0x0500)
DECLARE_EMPTY_MSG_MAP() #endif //!(_WIN32_IE >= 0x0500)
};
#endif //_ATL_NO_HOSTING
}; //namespace WTL
#endif // __ATLDLGS_H__
|