// Windows Template Library - WTL version 9.10 // Copyright (C) Microsoft Corporation, WTL Team. All rights reserved. // // This file is a part of the Windows Template Library. // The use and distribution terms for this software are covered by the // Microsoft Public License (http://opensource.org/licenses/MS-PL) // which can be found in the file MS-PL.txt at the root folder. #ifndef __ATLDLGS_H__ #define __ATLDLGS_H__ #pragma once #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 #include #if (_WIN32_WINNT >= 0x0600) && !defined(_WIN32_WCE) #include #endif // (_WIN32_WINNT >= 0x0600) && !defined(_WIN32_WCE) /////////////////////////////////////////////////////////////////////////////// // Classes in this file: // // CFileDialogImpl // CFileDialog // CFileDialogEx // CMultiFileDialogImpl // CMultiFileDialog // CShellFileDialogImpl // CShellFileOpenDialogImpl // CShellFileOpenDialog // CShellFileSaveDialogImpl // CShellFileSaveDialog // CFolderDialogImpl // CFolderDialog // CFontDialogImpl // CFontDialog // CRichEditFontDialogImpl // CRichEditFontDialog // CColorDialogImpl // CColorDialog // CPrintDialogImpl // CPrintDialog // CPrintDialogExImpl // CPrintDialogEx // CPageSetupDialogImpl // CPageSetupDialog // CFindReplaceDialogImpl // CFindReplaceDialog // // CDialogBaseUnits // CMemDlgTemplate // CIndirectDialogImpl // // CPropertySheetWindow // CPropertySheetImpl // CPropertySheet // CPropertyPageWindow // CPropertyPageImpl // CPropertyPage // CAxPropertyPageImpl // CAxPropertyPage // // CWizard97SheetWindow // CWizard97SheetImpl // CWizard97Sheet // CWizard97PageWindow // CWizard97PageImpl // CWizard97ExteriorPageImpl // CWizard97InteriorPageImpl // // CAeroWizardFrameWindow // CAeroWizardFrameImpl // CAeroWizardFrame // CAeroWizardPageWindow // CAeroWizardPageImpl // CAeroWizardPage // CAeroWizardAxPageImpl // CAeroWizardAxPage // // CTaskDialogConfig // CTaskDialogImpl // CTaskDialog // // Global functions: // AtlTaskDialog() namespace WTL { /////////////////////////////////////////////////////////////////////////////// // 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) #if !defined(_WIN32_WCE) && !defined(CDN_INCLUDEITEM) #define CDN_INCLUDEITEM (CDN_FIRST - 0x0007) #endif template class ATL_NO_VTABLE CFileDialogImpl : public ATL::CDialogImplBase { public: #if defined(__AYGSHELL_H__) && (_WIN32_WCE >= 0x0501) OPENFILENAMEEX m_ofn; #else OPENFILENAME m_ofn; #endif 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] = _T('\0'); m_szFileTitle[0] = _T('\0'); m_bOpenFileDialog = bOpenFileDialog; #if defined(__AYGSHELL_H__) && (_WIN32_WCE >= 0x0501) m_ofn.lStructSize = bOpenFileDialog ? sizeof(m_ofn) : sizeof(OPENFILENAME); #else m_ofn.lStructSize = sizeof(m_ofn); #endif #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; #ifndef _WIN32_WCE m_ofn.Flags = dwFlags | OFN_EXPLORER | OFN_ENABLEHOOK | OFN_ENABLESIZING; #else // CE specific m_ofn.Flags = dwFlags | OFN_EXPLORER | OFN_ENABLEHOOK; #endif // !_WIN32_WCE m_ofn.lpstrFilter = lpszFilter; m_ofn.hInstance = ModuleHelper::GetResourceInstance(); m_ofn.lpfnHook = (LPOFNHOOKPROC)T::StartDialogProc; m_ofn.hwndOwner = hWndParent; // setup initial file name if(lpszFileName != NULL) SecureHelper::strncpy_x(m_szFileName, _countof(m_szFileName), lpszFileName, _TRUNCATE); } INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow()) { ATLASSERT((m_ofn.Flags & OFN_ENABLEHOOK) != 0); ATLASSERT(m_ofn.lpfnHook != NULL); // can still be a user hook ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0); if(m_ofn.hwndOwner == NULL) // set only if not specified before m_ofn.hwndOwner = hWndParent; ATLASSERT(m_hWnd == NULL); #if (_ATL_VER >= 0x0800) // Allocate the thunk structure here, where we can fail gracefully. BOOL bRetTh = m_thunk.Init(NULL, NULL); if(bRetTh == FALSE) { ::SetLastError(ERROR_OUTOFMEMORY); return -1; } #endif // (_ATL_VER >= 0x0800) ModuleHelper::AddCreateWndData(&m_thunk.cd, (ATL::CDialogImplBase*)this); BOOL bRet; if(m_bOpenFileDialog) #if defined(__AYGSHELL_H__) && (_WIN32_WCE >= 0x0501) bRet = ::GetOpenFileNameEx(&m_ofn); else bRet = ::GetSaveFileName((LPOPENFILENAME)&m_ofn); #else bRet = ::GetOpenFileName(&m_ofn); else bRet = ::GetSaveFileName(&m_ofn); #endif m_hWnd = NULL; return bRet ? IDOK : IDCANCEL; } // Attributes ATL::CWindow GetFileDialogWindow() const { ATLASSERT(::IsWindow(m_hWnd)); return ATL::CWindow(GetParent()); } int GetFilePath(LPTSTR lpstrFilePath, int nLength) const { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0); 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) != 0); 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) != 0); 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) != 0); 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) != 0); GetFileDialogWindow().SendMessage(CDM_SETCONTROLTEXT, nCtrlID, (LPARAM)lpstrText); } void SetDefExt(LPCTSTR lpstrExt) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0); GetFileDialogWindow().SendMessage(CDM_SETDEFEXT, 0, (LPARAM)lpstrExt); } BOOL GetReadOnlyPref() const // return TRUE if readonly checked { return ((m_ofn.Flags & OFN_READONLY) != 0) ? TRUE : FALSE; } // Operations void HideControl(int nCtrlID) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0); 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) 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) #ifndef _WIN32_WCE NOTIFY_CODE_HANDLER(CDN_INCLUDEITEM, _OnIncludeItem) #endif // !_WIN32_WCE END_MSG_MAP() LRESULT _OnFileOK(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/) { ATLASSERT(::IsWindow(m_hWnd)); T* pT = static_cast(this); return !pT->OnFileOK((LPOFNOTIFY)pnmh); } LRESULT _OnFolderChange(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/) { ATLASSERT(::IsWindow(m_hWnd)); T* pT = static_cast(this); pT->OnFolderChange((LPOFNOTIFY)pnmh); return 0; } LRESULT _OnHelp(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/) { ATLASSERT(::IsWindow(m_hWnd)); T* pT = static_cast(this); pT->OnHelp((LPOFNOTIFY)pnmh); return 0; } LRESULT _OnInitDone(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/) { ATLASSERT(::IsWindow(m_hWnd)); T* pT = static_cast(this); pT->OnInitDone((LPOFNOTIFY)pnmh); return 0; } LRESULT _OnSelChange(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/) { ATLASSERT(::IsWindow(m_hWnd)); T* pT = static_cast(this); pT->OnSelChange((LPOFNOTIFY)pnmh); return 0; } LRESULT _OnShareViolation(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/) { ATLASSERT(::IsWindow(m_hWnd)); T* pT = static_cast(this); return pT->OnShareViolation((LPOFNOTIFY)pnmh); } LRESULT _OnTypeChange(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/) { ATLASSERT(::IsWindow(m_hWnd)); T* pT = static_cast(this); pT->OnTypeChange((LPOFNOTIFY)pnmh); return 0; } #ifndef _WIN32_WCE LRESULT _OnIncludeItem(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/) { ATLASSERT(::IsWindow(m_hWnd)); T* pT = static_cast(this); return pT->OnIncludeItem((LPOFNOTIFYEX)pnmh); } #endif // !_WIN32_WCE // 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*/) { } #ifndef _WIN32_WCE BOOL OnIncludeItem(LPOFNOTIFYEX /*lponex*/) { return TRUE; // include item } #endif // !_WIN32_WCE }; class CFileDialog : public CFileDialogImpl { 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(bOpenFileDialog, lpszDefExt, lpszFileName, dwFlags, lpszFilter, hWndParent) { } // override base class map and references to handlers DECLARE_EMPTY_MSG_MAP() }; #if defined(__AYGSHELL_H__) && (_WIN32_WCE >= 0x0501) class CFileDialogEx : public CFileDialogImpl { public: CFileDialogEx( // Supports only FileOpen LPCTSTR lpszDefExt = NULL, LPCTSTR lpszFileName = NULL, DWORD dwFlags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, OFN_EXFLAG ExFlags = OFN_EXFLAG_THUMBNAILVIEW, OFN_SORTORDER dwSortOrder = OFN_SORTORDER_AUTO, LPCTSTR lpszFilter = NULL, HWND hWndParent = NULL) : CFileDialogImpl(TRUE, lpszDefExt, lpszFileName, dwFlags, lpszFilter, hWndParent) { m_ofn.ExFlags = ExFlags; m_ofn.dwSortOrder = dwSortOrder; } // override base class map and references to handlers DECLARE_EMPTY_MSG_MAP() }; #endif // defined(__AYGSHELL_H__) && (_WIN32_WCE >= 0x0501) /////////////////////////////////////////////////////////////////////////////// // Multi File Dialog - Multi-select File Open dialog #ifndef _WIN32_WCE // The class dynamically resizes the buffer as the file selection changes // (as described in Knowledge Base article 131462). It also expands selected // shortcut files to take into account the full path of the target file. // Note that this doesn't work on Win9x for the old style dialogs, as well as // on NT for non-Unicode builds. #ifndef _WTL_FIXED_OFN_BUFFER_LENGTH #define _WTL_FIXED_OFN_BUFFER_LENGTH 0x10000 #endif template class ATL_NO_VTABLE CMultiFileDialogImpl : public CFileDialogImpl< T > { public: mutable LPCTSTR m_pNextFile; #ifndef _UNICODE bool m_bIsNT; #endif CMultiFileDialogImpl( LPCTSTR lpszDefExt = NULL, LPCTSTR lpszFileName = NULL, DWORD dwFlags = OFN_HIDEREADONLY, LPCTSTR lpszFilter = NULL, HWND hWndParent = NULL) : CFileDialogImpl(TRUE, lpszDefExt, lpszFileName, dwFlags, lpszFilter, hWndParent), m_pNextFile(NULL) { m_ofn.Flags |= OFN_ALLOWMULTISELECT; // Force multiple selection mode #ifndef _UNICODE #ifdef _versionhelpers_H_INCLUDED_ OSVERSIONINFOEX ovi = { sizeof(OSVERSIONINFOEX) }; ovi.dwPlatformId = VER_PLATFORM_WIN32_NT; DWORDLONG const dwlConditionMask = ::VerSetConditionMask(0, VER_PLATFORMID, VER_EQUAL); m_bIsNT = (::VerifyVersionInfo(&ovi, VER_PLATFORMID, dwlConditionMask) != FALSE); #else // !_versionhelpers_H_INCLUDED_ OSVERSIONINFO ovi = { sizeof(OSVERSIONINFO) }; ::GetVersionEx(&ovi); m_bIsNT = (ovi.dwPlatformId == VER_PLATFORM_WIN32_NT); #endif // _versionhelpers_H_INCLUDED_ if (m_bIsNT) { // On NT platforms, GetOpenFileNameA thunks to GetOpenFileNameW and there // is absolutely nothing we can do except to start off with a large buffer. ATLVERIFY(ResizeFilenameBuffer(_WTL_FIXED_OFN_BUFFER_LENGTH)); } #endif } ~CMultiFileDialogImpl() { if (m_ofn.lpstrFile != m_szFileName) // Free the buffer if we allocated it delete[] m_ofn.lpstrFile; } // Operations // Get the directory that the files were chosen from. // The function returns the number of characters copied, not including the terminating zero. // If the buffer is NULL, the function returns the required size, in characters, including the terminating zero. // If the function fails, the return value is zero. int GetDirectory(LPTSTR pBuffer, int nBufLen) const { if (m_ofn.lpstrFile == NULL) return 0; LPCTSTR pStr = m_ofn.lpstrFile; int nLength = lstrlen(pStr); if (pStr[nLength + 1] == 0) { // The OFN buffer contains a single item so extract its path. LPCTSTR pSep = MinCrtHelper::_strrchr(pStr, _T('\\')); if (pSep != NULL) nLength = (int)(DWORD_PTR)(pSep - pStr); } int nRet = 0; if (pBuffer == NULL) // If the buffer is NULL, return the required length { nRet = nLength + 1; } else if (nBufLen > nLength) { SecureHelper::strncpy_x(pBuffer, nBufLen, pStr, nLength); nRet = nLength; } return nRet; } #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__) bool GetDirectory(_CSTRING_NS::CString& strDir) const { bool bRet = false; int nLength = GetDirectory(NULL, 0); if (nLength > 0) { bRet = (GetDirectory(strDir.GetBuffer(nLength), nLength) > 0); strDir.ReleaseBuffer(nLength - 1); } return bRet; } #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__) // Get the first filename as a pointer into the buffer. LPCTSTR GetFirstFileName() const { if (m_ofn.lpstrFile == NULL) return NULL; m_pNextFile = NULL; // Reset internal buffer pointer LPCTSTR pStr = m_ofn.lpstrFile; int nLength = lstrlen(pStr); if (pStr[nLength + 1] != 0) { // Multiple items were selected. The first string is the directory, // so skip forwards to the second string. pStr += nLength + 1; // Set up m_pNext so it points to the second item (or null). m_pNextFile = pStr; GetNextFileName(); } else { // A single item was selected. Skip forward past the path. LPCTSTR pSep = MinCrtHelper::_strrchr(pStr, _T('\\')); if (pSep != NULL) pStr = pSep + 1; } return pStr; } // Get the next filename as a pointer into the buffer. LPCTSTR GetNextFileName() const { if (m_pNextFile == NULL) return NULL; LPCTSTR pStr = m_pNextFile; // Set "m_pNextFile" to point to the next file name, or null if we // have reached the last file in the list. int nLength = lstrlen(pStr); m_pNextFile = (pStr[nLength + 1] != 0) ? &pStr[nLength + 1] : NULL; return pStr; } // Get the first filename as a full path. // The function returns the number of characters copied, not including the terminating zero. // If the buffer is NULL, the function returns the required size, in characters, including the terminating zero. // If the function fails, the return value is zero. int GetFirstPathName(LPTSTR pBuffer, int nBufLen) const { LPCTSTR pStr = GetFirstFileName(); int nLengthDir = GetDirectory(NULL, 0); if((pStr == NULL) || (nLengthDir == 0)) return 0; // Figure out the required length. int nLengthTotal = nLengthDir + lstrlen(pStr); int nRet = 0; if(pBuffer == NULL) // If the buffer is NULL, return the required length { nRet = nLengthTotal + 1; } else if (nBufLen > nLengthTotal) // If the buffer is big enough, go ahead and construct the path { GetDirectory(pBuffer, nBufLen); SecureHelper::strcat_x(pBuffer, nBufLen, _T("\\")); SecureHelper::strcat_x(pBuffer, nBufLen, pStr); nRet = nLengthTotal; } return nRet; } #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__) bool GetFirstPathName(_CSTRING_NS::CString& strPath) const { bool bRet = false; int nLength = GetFirstPathName(NULL, 0); if (nLength > 0) { bRet = (GetFirstPathName(strPath.GetBuffer(nLength), nLength) > 0); strPath.ReleaseBuffer(nLength - 1); } return bRet; } #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__) // Get the next filename as a full path. // The function returns the number of characters copied, not including the terminating zero. // If the buffer is NULL, the function returns the required size, in characters, including the terminating zero. // If the function fails, the return value is zero. // The internal position marker is moved forward only if the function succeeds and the buffer was large enough. int GetNextPathName(LPTSTR pBuffer, int nBufLen) const { if (m_pNextFile == NULL) return 0; int nRet = 0; LPCTSTR pStr = m_pNextFile; // Does the filename contain a backslash? if (MinCrtHelper::_strrchr(pStr, _T('\\')) != NULL) { // Yes, so we'll assume it's a full path. int nLength = lstrlen(pStr); if (pBuffer == NULL) // If the buffer is NULL, return the required length { nRet = nLength + 1; } else if (nBufLen > nLength) // The buffer is big enough, so go ahead and copy the filename { SecureHelper::strcpy_x(pBuffer, nBufLen, GetNextFileName()); nRet = nBufLen; } } else { // The filename is relative, so construct the full path. int nLengthDir = GetDirectory(NULL, 0); if (nLengthDir > 0) { // Calculate the required space. int nLengthTotal = nLengthDir + lstrlen(pStr); if(pBuffer == NULL) // If the buffer is NULL, return the required length { nRet = nLengthTotal + 1; } else if (nBufLen > nLengthTotal) // If the buffer is big enough, go ahead and construct the path { GetDirectory(pBuffer, nBufLen); SecureHelper::strcat_x(pBuffer, nBufLen, _T("\\")); SecureHelper::strcat_x(pBuffer, nBufLen, GetNextFileName()); nRet = nLengthTotal; } } } return nRet; } #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__) bool GetNextPathName(_CSTRING_NS::CString& strPath) const { bool bRet = false; int nLength = GetNextPathName(NULL, 0); if (nLength > 0) { bRet = (GetNextPathName(strPath.GetBuffer(nLength), nLength) > 0); strPath.ReleaseBuffer(nLength - 1); } return bRet; } #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__) // Implementation bool ResizeFilenameBuffer(DWORD dwLength) { if (dwLength > m_ofn.nMaxFile) { // Free the old buffer. if (m_ofn.lpstrFile != m_szFileName) { delete[] m_ofn.lpstrFile; m_ofn.lpstrFile = NULL; m_ofn.nMaxFile = 0; } // Allocate the new buffer. LPTSTR lpstrBuff = NULL; ATLTRY(lpstrBuff = new TCHAR[dwLength]); if (lpstrBuff != NULL) { m_ofn.lpstrFile = lpstrBuff; m_ofn.lpstrFile[0] = 0; m_ofn.nMaxFile = dwLength; } } return (m_ofn.lpstrFile != NULL); } void OnSelChange(LPOFNOTIFY /*lpon*/) { #ifndef _UNICODE // There is no point resizing the buffer in ANSI builds running on NT. if (m_bIsNT) return; #endif // Get the buffer length required to hold the spec. int nLength = GetSpec(NULL, 0); if (nLength <= 1) return; // no files are selected, presumably // Add room for the directory, and an extra terminating zero. nLength += GetFolderPath(NULL, 0) + 1; if (!ResizeFilenameBuffer(nLength)) { ATLASSERT(FALSE); return; } // If we are not following links then our work is done. if ((m_ofn.Flags & OFN_NODEREFERENCELINKS) != 0) return; // Get the file spec, which is the text in the edit control. if (GetSpec(m_ofn.lpstrFile, m_ofn.nMaxFile) <= 0) return; // Get the ID-list of the current folder. int nBytes = GetFolderIDList(NULL, 0); #ifdef STRICT_TYPED_ITEMIDS CTempBuffer idlist; #else CTempBuffer idlist; #endif idlist.AllocateBytes(nBytes); if ((nBytes <= 0) || (GetFolderIDList(idlist, nBytes) <= 0)) return; // First bind to the desktop folder, then to the current folder. ATL::CComPtr pDesktop, pFolder; if (FAILED(::SHGetDesktopFolder(&pDesktop))) return; if (FAILED(pDesktop->BindToObject(idlist, NULL, IID_IShellFolder, (void**)&pFolder))) return; // Work through the file spec, looking for quoted filenames. If we find a shortcut file, then // we need to add enough extra buffer space to hold its target path. DWORD nExtraChars = 0; bool bInsideQuotes = false; LPCTSTR pAnchor = m_ofn.lpstrFile; LPCTSTR pChar = m_ofn.lpstrFile; for ( ; *pChar; ++pChar) { // Look for quotation marks. if (*pChar == _T('\"')) { // We are either entering or leaving a passage of quoted text. bInsideQuotes = !bInsideQuotes; // Is it an opening or closing quote? if (bInsideQuotes) { // We found an opening quote, so set "pAnchor" to the following character. pAnchor = pChar + 1; } else // closing quote { // Each quoted entity should be shorter than MAX_PATH. if (pChar - pAnchor >= MAX_PATH) return; // Get the ID-list and attributes of the file. USES_CONVERSION; int nFileNameLength = (int)(DWORD_PTR)(pChar - pAnchor); TCHAR szFileName[MAX_PATH] = { 0 }; SecureHelper::strncpy_x(szFileName, MAX_PATH, pAnchor, nFileNameLength); #ifdef STRICT_TYPED_ITEMIDS PIDLIST_RELATIVE pidl = NULL; #else LPITEMIDLIST pidl = NULL; #endif DWORD dwAttrib = SFGAO_LINK; if (SUCCEEDED(pFolder->ParseDisplayName(NULL, NULL, T2W(szFileName), NULL, &pidl, &dwAttrib))) { // Is it a shortcut file? if (dwAttrib & SFGAO_LINK) { // Bind to its IShellLink interface. ATL::CComPtr pLink; if (SUCCEEDED(pFolder->BindToObject(pidl, NULL, IID_IShellLink, (void**)&pLink))) { // Get the shortcut's target path. TCHAR szPath[MAX_PATH] = { 0 }; if (SUCCEEDED(pLink->GetPath(szPath, MAX_PATH, NULL, 0))) { // If the target path is longer than the shortcut name, then add on the number // of extra characters that are required. int nNewLength = lstrlen(szPath); if (nNewLength > nFileNameLength) nExtraChars += nNewLength - nFileNameLength; } } } // Free the ID-list returned by ParseDisplayName. ::CoTaskMemFree(pidl); } } } } // If we need more space for shortcut targets, then reallocate. if (nExtraChars > 0) ATLVERIFY(ResizeFilenameBuffer(m_ofn.nMaxFile + nExtraChars)); } }; class CMultiFileDialog : public CMultiFileDialogImpl { public: CMultiFileDialog( LPCTSTR lpszDefExt = NULL, LPCTSTR lpszFileName = NULL, DWORD dwFlags = OFN_HIDEREADONLY, LPCTSTR lpszFilter = NULL, HWND hWndParent = NULL) : CMultiFileDialogImpl(lpszDefExt, lpszFileName, dwFlags, lpszFilter, hWndParent) { } BEGIN_MSG_MAP(CMultiFileDialog) CHAIN_MSG_MAP(CMultiFileDialogImpl) END_MSG_MAP() }; #endif // !_WIN32_WCE /////////////////////////////////////////////////////////////////////////////// // Shell File Dialog - new Shell File Open and Save dialogs in Vista // Note: Use GetPtr() to access dialog interface methods. // Example: // CShellFileOpenDialog dlg; // dlg.GetPtr()->SetTitle(L"MyFileOpenDialog"); #if (_WIN32_WINNT >= 0x0600) && !defined(_WIN32_WCE) /////////////////////////////////////////////////////////////////////////////// // CShellFileDialogImpl - base class for CShellFileOpenDialogImpl and CShellFileSaveDialogImpl template class ATL_NO_VTABLE CShellFileDialogImpl : public IFileDialogEvents { public: // Operations INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow()) { INT_PTR nRet = -1; T* pT = static_cast(this); if(pT->m_spFileDlg == NULL) { ATLASSERT(FALSE); return nRet; } DWORD dwCookie = 0; pT->_Advise(dwCookie); HRESULT hRet = pT->m_spFileDlg->Show(hWndParent); if(SUCCEEDED(hRet)) nRet = IDOK; else if(hRet == HRESULT_FROM_WIN32(ERROR_CANCELLED)) nRet = IDCANCEL; else ATLASSERT(FALSE); // error pT->_Unadvise(dwCookie); return nRet; } bool IsNull() const { const T* pT = static_cast(this); return (pT->m_spFileDlg == NULL); } // Operations - get file path after dialog returns HRESULT GetFilePath(LPWSTR lpstrFilePath, int cchLength) { T* pT = static_cast(this); ATLASSERT(pT->m_spFileDlg != NULL); ATL::CComPtr spItem; HRESULT hRet = pT->m_spFileDlg->GetResult(&spItem); if(SUCCEEDED(hRet)) hRet = GetFileNameFromShellItem(spItem, SIGDN_FILESYSPATH, lpstrFilePath, cchLength); return hRet; } HRESULT GetFileTitle(LPWSTR lpstrFileTitle, int cchLength) { T* pT = static_cast(this); ATLASSERT(pT->m_spFileDlg != NULL); ATL::CComPtr spItem; HRESULT hRet = pT->m_spFileDlg->GetResult(&spItem); if(SUCCEEDED(hRet)) hRet = GetFileNameFromShellItem(spItem, SIGDN_NORMALDISPLAY, lpstrFileTitle, cchLength); return hRet; } #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__) HRESULT GetFilePath(_CSTRING_NS::CString& strFilePath) { T* pT = static_cast(this); ATLASSERT(pT->m_spFileDlg != NULL); ATL::CComPtr spItem; HRESULT hRet = pT->m_spFileDlg->GetResult(&spItem); if(SUCCEEDED(hRet)) hRet = GetFileNameFromShellItem(spItem, SIGDN_FILESYSPATH, strFilePath); return hRet; } HRESULT GetFileTitle(_CSTRING_NS::CString& strFileTitle) { T* pT = static_cast(this); ATLASSERT(pT->m_spFileDlg != NULL); ATL::CComPtr spItem; HRESULT hRet = pT->m_spFileDlg->GetResult(&spItem); if(SUCCEEDED(hRet)) hRet = GetFileNameFromShellItem(spItem, SIGDN_NORMALDISPLAY, strFileTitle); return hRet; } #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__) // Helpers for IShellItem static HRESULT GetFileNameFromShellItem(IShellItem* pShellItem, SIGDN type, LPWSTR lpstr, int cchLength) { ATLASSERT(pShellItem != NULL); LPWSTR lpstrName = NULL; HRESULT hRet = pShellItem->GetDisplayName(type, &lpstrName); if(SUCCEEDED(hRet)) { if(lstrlenW(lpstrName) < cchLength) { SecureHelper::strcpyW_x(lpstr, cchLength, lpstrName); } else { ATLASSERT(FALSE); hRet = DISP_E_BUFFERTOOSMALL; } ::CoTaskMemFree(lpstrName); } return hRet; } #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__) static HRESULT GetFileNameFromShellItem(IShellItem* pShellItem, SIGDN type, _CSTRING_NS::CString& str) { ATLASSERT(pShellItem != NULL); LPWSTR lpstrName = NULL; HRESULT hRet = pShellItem->GetDisplayName(type, &lpstrName); if(SUCCEEDED(hRet)) { str = lpstrName; ::CoTaskMemFree(lpstrName); } return hRet; } #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__) // Implementation void _Advise(DWORD& dwCookie) { T* pT = static_cast(this); ATLASSERT(pT->m_spFileDlg != NULL); HRESULT hRet = pT->m_spFileDlg->Advise((IFileDialogEvents*)this, &dwCookie); ATLVERIFY(SUCCEEDED(hRet)); } void _Unadvise(DWORD dwCookie) { T* pT = static_cast(this); ATLASSERT(pT->m_spFileDlg != NULL); HRESULT hRet = pT->m_spFileDlg->Unadvise(dwCookie); ATLVERIFY(SUCCEEDED(hRet)); } void _Init(LPCWSTR lpszFileName, DWORD dwOptions, LPCWSTR lpszDefExt, const COMDLG_FILTERSPEC* arrFilterSpec, UINT uFilterSpecCount) { T* pT = static_cast(this); ATLASSERT(pT->m_spFileDlg != NULL); HRESULT hRet = E_FAIL; if(lpszFileName != NULL) { hRet = pT->m_spFileDlg->SetFileName(lpszFileName); ATLASSERT(SUCCEEDED(hRet)); } hRet = pT->m_spFileDlg->SetOptions(dwOptions); ATLASSERT(SUCCEEDED(hRet)); if(lpszDefExt != NULL) { hRet = pT->m_spFileDlg->SetDefaultExtension(lpszDefExt); ATLASSERT(SUCCEEDED(hRet)); } if(arrFilterSpec != NULL && uFilterSpecCount != 0U) { hRet = pT->m_spFileDlg->SetFileTypes(uFilterSpecCount, arrFilterSpec); ATLASSERT(SUCCEEDED(hRet)); } } // Implementation - IUnknown interface STDMETHOD(QueryInterface)(REFIID riid, void** ppvObject) { if(ppvObject == NULL) return E_POINTER; T* pT = static_cast(this); if(IsEqualGUID(riid, IID_IUnknown) || IsEqualGUID(riid, IID_IFileDialogEvents)) { *ppvObject = (IFileDialogEvents*)pT; // AddRef() not needed return S_OK; } return E_NOINTERFACE; } virtual ULONG STDMETHODCALLTYPE AddRef() { return 1; } virtual ULONG STDMETHODCALLTYPE Release() { return 1; } // Implementation - IFileDialogEvents interface virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnFileOk(IFileDialog* pfd) { T* pT = static_cast(this); ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd)); pfd; // avoid level 4 warning return pT->OnFileOk(); } virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnFolderChanging(IFileDialog* pfd, IShellItem* psiFolder) { T* pT = static_cast(this); ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd)); pfd; // avoid level 4 warning return pT->OnFolderChanging(psiFolder); } virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnFolderChange(IFileDialog* pfd) { T* pT = static_cast(this); ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd)); pfd; // avoid level 4 warning return pT->OnFolderChange(); } virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnSelectionChange(IFileDialog* pfd) { T* pT = static_cast(this); ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd)); pfd; // avoid level 4 warning return pT->OnSelectionChange(); } virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnShareViolation(IFileDialog* pfd, IShellItem* psi, FDE_SHAREVIOLATION_RESPONSE* pResponse) { T* pT = static_cast(this); ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd)); pfd; // avoid level 4 warning return pT->OnShareViolation(psi, pResponse); } virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnTypeChange(IFileDialog* pfd) { T* pT = static_cast(this); ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd)); pfd; // avoid level 4 warning return pT->OnTypeChange(); } virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnOverwrite(IFileDialog* pfd, IShellItem* psi, FDE_OVERWRITE_RESPONSE* pResponse) { T* pT = static_cast(this); ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd)); pfd; // avoid level 4 warning return pT->OnOverwrite(psi, pResponse); } // Overrideables - Event handlers HRESULT OnFileOk() { return E_NOTIMPL; } HRESULT OnFolderChanging(IShellItem* /*psiFolder*/) { return E_NOTIMPL; } HRESULT OnFolderChange() { return E_NOTIMPL; } HRESULT OnSelectionChange() { return E_NOTIMPL; } HRESULT OnShareViolation(IShellItem* /*psi*/, FDE_SHAREVIOLATION_RESPONSE* /*pResponse*/) { return E_NOTIMPL; } HRESULT OnTypeChange() { return E_NOTIMPL; } HRESULT OnOverwrite(IShellItem* /*psi*/, FDE_OVERWRITE_RESPONSE* /*pResponse*/) { return E_NOTIMPL; } }; /////////////////////////////////////////////////////////////////////////////// // CShellFileOpenDialogImpl - implements new Shell File Open dialog template class ATL_NO_VTABLE CShellFileOpenDialogImpl : public CShellFileDialogImpl< T > { public: ATL::CComPtr m_spFileDlg; CShellFileOpenDialogImpl(LPCWSTR lpszFileName = NULL, DWORD dwOptions = FOS_FORCEFILESYSTEM | FOS_PATHMUSTEXIST | FOS_FILEMUSTEXIST, LPCWSTR lpszDefExt = NULL, const COMDLG_FILTERSPEC* arrFilterSpec = NULL, UINT uFilterSpecCount = 0U) { HRESULT hRet = m_spFileDlg.CoCreateInstance(CLSID_FileOpenDialog); if(SUCCEEDED(hRet)) _Init(lpszFileName, dwOptions, lpszDefExt, arrFilterSpec, uFilterSpecCount); } IFileOpenDialog* GetPtr() { return m_spFileDlg; } }; /////////////////////////////////////////////////////////////////////////////// // CShellFileOpenDialog - new Shell File Open dialog without events class CShellFileOpenDialog : public CShellFileOpenDialogImpl { public: CShellFileOpenDialog(LPCWSTR lpszFileName = NULL, DWORD dwOptions = FOS_FORCEFILESYSTEM | FOS_PATHMUSTEXIST | FOS_FILEMUSTEXIST, LPCWSTR lpszDefExt = NULL, const COMDLG_FILTERSPEC* arrFilterSpec = NULL, UINT uFilterSpecCount = 0U) : CShellFileOpenDialogImpl(lpszFileName, dwOptions, lpszDefExt, arrFilterSpec, uFilterSpecCount) { } // Implementation (remove _Advise/_Unadvise code using template magic) void _Advise(DWORD& /*dwCookie*/) { } void _Unadvise(DWORD /*dwCookie*/) { } }; /////////////////////////////////////////////////////////////////////////////// // CShellFileSaveDialogImpl - implements new Shell File Save dialog template class ATL_NO_VTABLE CShellFileSaveDialogImpl : public CShellFileDialogImpl< T > { public: ATL::CComPtr m_spFileDlg; CShellFileSaveDialogImpl(LPCWSTR lpszFileName = NULL, DWORD dwOptions = FOS_FORCEFILESYSTEM | FOS_PATHMUSTEXIST | FOS_OVERWRITEPROMPT, LPCWSTR lpszDefExt = NULL, const COMDLG_FILTERSPEC* arrFilterSpec = NULL, UINT uFilterSpecCount = 0U) { HRESULT hRet = m_spFileDlg.CoCreateInstance(CLSID_FileSaveDialog); if(SUCCEEDED(hRet)) _Init(lpszFileName, dwOptions, lpszDefExt, arrFilterSpec, uFilterSpecCount); } IFileSaveDialog* GetPtr() { return m_spFileDlg; } }; /////////////////////////////////////////////////////////////////////////////// // CShellFileSaveDialog - new Shell File Save dialog without events class CShellFileSaveDialog : public CShellFileSaveDialogImpl { public: CShellFileSaveDialog(LPCWSTR lpszFileName = NULL, DWORD dwOptions = FOS_FORCEFILESYSTEM | FOS_PATHMUSTEXIST | FOS_OVERWRITEPROMPT, LPCWSTR lpszDefExt = NULL, const COMDLG_FILTERSPEC* arrFilterSpec = NULL, UINT uFilterSpecCount = 0U) : CShellFileSaveDialogImpl(lpszFileName, dwOptions, lpszDefExt, arrFilterSpec, uFilterSpecCount) { } // Implementation (remove _Advise/_Unadvise code using template magic) void _Advise(DWORD& /*dwCookie*/) { } void _Unadvise(DWORD /*dwCookie*/) { } }; #endif // (_WIN32_WINNT >= 0x0600) && !defined(_WIN32_WCE) /////////////////////////////////////////////////////////////////////////////// // CFolderDialogImpl - used for browsing for a folder #ifndef _WIN32_WCE template class ATL_NO_VTABLE CFolderDialogImpl { public: BROWSEINFO m_bi; LPCTSTR m_lpstrInitialFolder; LPCITEMIDLIST m_pidlInitialSelection; bool m_bExpandInitialSelection; TCHAR m_szFolderDisplayName[MAX_PATH]; TCHAR m_szFolderPath[MAX_PATH]; #ifdef STRICT_TYPED_ITEMIDS PIDLIST_ABSOLUTE m_pidlSelected; #else LPITEMIDLIST m_pidlSelected; #endif HWND m_hWnd; // used only in the callback function // Constructor CFolderDialogImpl(HWND hWndParent = NULL, LPCTSTR lpstrTitle = NULL, UINT uFlags = BIF_RETURNONLYFSDIRS) : m_lpstrInitialFolder(NULL), m_pidlInitialSelection(NULL), m_bExpandInitialSelection(false), m_pidlSelected(NULL), m_hWnd(NULL) { 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)static_cast(this); m_szFolderPath[0] = 0; m_szFolderDisplayName[0] = 0; } ~CFolderDialogImpl() { ::CoTaskMemFree(m_pidlSelected); } // Operations INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow()) { if(m_bi.hwndOwner == NULL) // set only if not specified before m_bi.hwndOwner = hWndParent; // Clear out any previous results m_szFolderPath[0] = 0; m_szFolderDisplayName[0] = 0; ::CoTaskMemFree(m_pidlSelected); INT_PTR nRet = IDCANCEL; m_pidlSelected = ::SHBrowseForFolder(&m_bi); if(m_pidlSelected != NULL) { nRet = IDOK; // If BIF_RETURNONLYFSDIRS is set, we try to get the filesystem path. // Otherwise, the caller must handle the ID-list directly. if((m_bi.ulFlags & BIF_RETURNONLYFSDIRS) != 0) { if(::SHGetPathFromIDList(m_pidlSelected, m_szFolderPath) == FALSE) nRet = IDCANCEL; } } return nRet; } // Methods to call before DoModal void SetInitialFolder(LPCTSTR lpstrInitialFolder, bool bExpand = true) { // lpstrInitialFolder may be a file if BIF_BROWSEINCLUDEFILES is specified m_lpstrInitialFolder = lpstrInitialFolder; m_bExpandInitialSelection = bExpand; } void SetInitialSelection(LPCITEMIDLIST pidl, bool bExpand = true) { m_pidlInitialSelection = pidl; m_bExpandInitialSelection = bExpand; } #ifdef STRICT_TYPED_ITEMIDS void SetRootFolder(PCIDLIST_ABSOLUTE pidl) #else void SetRootFolder(LPCITEMIDLIST pidl) #endif { m_bi.pidlRoot = pidl; } // Methods to call after DoModal LPITEMIDLIST GetSelectedItem(bool bDetach = false) { LPITEMIDLIST pidl = m_pidlSelected; if(bDetach) m_pidlSelected = NULL; return pidl; } 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 #ifndef BFFM_IUNKNOWN const int BFFM_IUNKNOWN = 5; #endif // !BFFM_IUNKNOWN #ifndef BIF_NEWDIALOGSTYLE const UINT BIF_NEWDIALOGSTYLE = 0x0040; #endif // !BIF_NEWDIALOGSTYLE int nRet = 0; T* pT = (T*)lpData; bool bClear = false; if(pT->m_hWnd == NULL) { pT->m_hWnd = hWnd; bClear = true; } else { ATLASSERT(pT->m_hWnd == hWnd); } switch(uMsg) { case BFFM_INITIALIZED: // Set initial selection // Note that m_pidlInitialSelection, if set, takes precedence over m_lpstrInitialFolder if(pT->m_pidlInitialSelection != NULL) pT->SetSelection(pT->m_pidlInitialSelection); else if(pT->m_lpstrInitialFolder != NULL) pT->SetSelection(pT->m_lpstrInitialFolder); // Expand initial selection if appropriate if(pT->m_bExpandInitialSelection && ((pT->m_bi.ulFlags & BIF_NEWDIALOGSTYLE) != 0)) { if(pT->m_pidlInitialSelection != NULL) pT->SetExpanded(pT->m_pidlInitialSelection); else if(pT->m_lpstrInitialFolder != NULL) pT->SetExpanded(pT->m_lpstrInitialFolder); } pT->OnInitialized(); break; case BFFM_SELCHANGED: pT->OnSelChanged((LPITEMIDLIST)lParam); break; case BFFM_VALIDATEFAILED: nRet = pT->OnValidateFailed((LPCTSTR)lParam); break; case BFFM_IUNKNOWN: pT->OnIUnknown((IUnknown*)lParam); break; default: ATLTRACE2(atlTraceUI, 0, _T("Unknown message received in CFolderDialogImpl::BrowseCallbackProc\n")); break; } if(bClear) pT->m_hWnd = NULL; return nRet; } void OnInitialized() { } void OnSelChanged(LPITEMIDLIST /*pItemIDList*/) { } int OnValidateFailed(LPCTSTR /*lpstrFolderPath*/) { return 1; // 1=continue, 0=EndDialog } void OnIUnknown(IUnknown* /*pUnknown*/) { } // Commands - valid to call only from handlers void EnableOK(BOOL bEnable) { ATLASSERT(m_hWnd != NULL); ::SendMessage(m_hWnd, BFFM_ENABLEOK, 0, bEnable); } void SetSelection(LPCITEMIDLIST 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); } void SetOKText(LPCTSTR lpstrOKText) { #ifndef BFFM_SETOKTEXT const UINT BFFM_SETOKTEXT = WM_USER + 105; #endif ATLASSERT(m_hWnd != NULL); USES_CONVERSION; LPCWSTR lpstr = T2CW(lpstrOKText); ::SendMessage(m_hWnd, BFFM_SETOKTEXT, 0, (LPARAM)lpstr); } void SetExpanded(LPCITEMIDLIST pItemIDList) { #ifndef BFFM_SETEXPANDED const UINT BFFM_SETEXPANDED = WM_USER + 106; #endif ATLASSERT(m_hWnd != NULL); ::SendMessage(m_hWnd, BFFM_SETEXPANDED, FALSE, (LPARAM)pItemIDList); } void SetExpanded(LPCTSTR lpstrFolderPath) { #ifndef BFFM_SETEXPANDED const UINT BFFM_SETEXPANDED = WM_USER + 106; #endif ATLASSERT(m_hWnd != NULL); USES_CONVERSION; LPCWSTR lpstr = T2CW(lpstrFolderPath); ::SendMessage(m_hWnd, BFFM_SETEXPANDED, TRUE, (LPARAM)lpstr); } }; class CFolderDialog : public CFolderDialogImpl { public: CFolderDialog(HWND hWndParent = NULL, LPCTSTR lpstrTitle = NULL, UINT uFlags = BIF_RETURNONLYFSDIRS) : CFolderDialogImpl(hWndParent, lpstrTitle, uFlags) { } }; #endif // !_WIN32_WCE /////////////////////////////////////////////////////////////////////////////// // CCommonDialogImplBase - base class for common dialog classes class ATL_NO_VTABLE CCommonDialogImplBase : public ATL::CWindowImplBase { public: static UINT_PTR APIENTRY HookProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { if(uMsg != WM_INITDIALOG) return 0; CCommonDialogImplBase* pT = (CCommonDialogImplBase*)ModuleHelper::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 = 0; 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, ATL::_U_RECT, LPCTSTR, DWORD, DWORD, ATL::_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 #ifndef _WIN32_WCE template class ATL_NO_VTABLE CFontDialogImpl : public CCommonDialogImplBase { public: enum { _cchStyleName = 64 }; CHOOSEFONT m_cf; TCHAR m_szStyleName[_cchStyleName]; // 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; m_lf = *lplfInitial; } 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) != 0); 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); #if (_ATL_VER >= 0x0800) // Allocate the thunk structure here, where we can fail gracefully. BOOL bRetTh = m_thunk.Init(NULL, NULL); if(bRetTh == FALSE) { ::SetLastError(ERROR_OUTOFMEMORY); return -1; } #endif // (_ATL_VER >= 0x0800) ModuleHelper::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) SecureHelper::memcpy_x(&m_lf, sizeof(m_lf), m_cf.lpLogFont, sizeof(m_lf)); return bRet ? IDOK : IDCANCEL; } // works only when the dialog is dislayed 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; } // works only when the dialog is dislayed or before #ifndef _WIN32_WCE void SetLogFont(LPLOGFONT lplf) { ATLASSERT(lplf != NULL); #ifndef WM_CHOOSEFONT_SETLOGFONT const UINT WM_CHOOSEFONT_SETLOGFONT = (WM_USER + 101); #endif if(m_hWnd != NULL) { ::SendMessage(m_hWnd, WM_CHOOSEFONT_SETLOGFONT, 0, (LPARAM)lplf); } else { m_lf = *lplf; m_cf.Flags |= CF_INITTOLOGFONTSTRUCT; } } void SetFlags(DWORD dwFlags) { #ifndef WM_CHOOSEFONT_SETFLAGS const UINT WM_CHOOSEFONT_SETFLAGS = (WM_USER + 102); #endif if(m_hWnd != NULL) { CHOOSEFONT cf = { sizeof(CHOOSEFONT) }; cf.Flags = dwFlags; ::SendMessage(m_hWnd, WM_CHOOSEFONT_SETFLAGS, 0, (LPARAM)&cf); } else { m_cf.Flags = dwFlags; } } #endif // !_WIN32_WCE // 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 { public: CFontDialog(LPLOGFONT lplfInitial = NULL, DWORD dwFlags = CF_EFFECTS | CF_SCREENFONTS, HDC hDCPrinter = NULL, HWND hWndParent = NULL) : CFontDialogImpl(lplfInitial, dwFlags, hDCPrinter, hWndParent) { } DECLARE_EMPTY_MSG_MAP() }; #endif // _WIN32_WCE /////////////////////////////////////////////////////////////////////////////// // CRichEditFontDialogImpl - font selection for the Rich Edit ctrl #if defined(_RICHEDIT_) && !defined(_WIN32_WCE) template 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) != 0) 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) SecureHelper::strcpy_x(cf.szFaceName, _countof(cf.szFaceName), GetFaceName()); #else // !(_RICHEDIT_VER >= 0x0200) SecureHelper::strcpyA_x(cf.szFaceName, _countof(cf.szFaceName), T2A((LPTSTR)(LPCTSTR)GetFaceName())); #endif // !(_RICHEDIT_VER >= 0x0200) } if((m_cf.Flags & CF_EFFECTS) != 0) { 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) != 0) { 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) != 0) ? FW_BOLD : FW_NORMAL; m_lf.lfItalic = (BYTE)(((cf.dwEffects & CFE_ITALIC) != 0) ? 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) != 0) ? TRUE : FALSE); m_lf.lfStrikeOut = (BYTE)(((cf.dwEffects & CFE_STRIKEOUT) != 0) ? TRUE : FALSE); } else { m_lf.lfUnderline = (BYTE)FALSE; m_lf.lfStrikeOut = (BYTE)FALSE; } if((cf.dwMask & CFM_CHARSET) != 0) 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) != 0) { m_lf.lfPitchAndFamily = cf.bPitchAndFamily; #if (_RICHEDIT_VER >= 0x0200) SecureHelper::strcpy_x(m_lf.lfFaceName, _countof(m_lf.lfFaceName), cf.szFaceName); #else // !(_RICHEDIT_VER >= 0x0200) SecureHelper::strcpy_x(m_lf.lfFaceName, _countof(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 { public: CRichEditFontDialog(const CHARFORMAT& charformat, DWORD dwFlags = CF_SCREENFONTS, HDC hDCPrinter = NULL, HWND hWndParent = NULL) : CRichEditFontDialogImpl(charformat, dwFlags, hDCPrinter, hWndParent) { } DECLARE_EMPTY_MSG_MAP() }; #endif // defined(_RICHEDIT_) && !defined(_WIN32_WCE) /////////////////////////////////////////////////////////////////////////////// // CColorDialogImpl - color selection #if !defined(_WIN32_WCE) || ((_WIN32_WCE > 420) && !(defined(WIN32_PLATFORM_WFSP) && (_WIN32_WCE > 0x0500))) #ifdef _WIN32_WCE #pragma comment(lib, "commdlg.lib") #ifndef SETRGBSTRING #define SETRGBSTRING _T("commdlg_SetRGBColor") #endif #ifndef COLOROKSTRING #define COLOROKSTRING _T("commdlg_ColorOK") #endif #endif template class ATL_NO_VTABLE CColorDialogImpl : public CCommonDialogImplBase { public: CHOOSECOLOR m_cc; // Constructor 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) != 0); 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); #if (_ATL_VER >= 0x0800) // Allocate the thunk structure here, where we can fail gracefully. BOOL bRetTh = m_thunk.Init(NULL, NULL); if(bRetTh == FALSE) { ::SetLastError(ERROR_OUTOFMEMORY); return -1; } #endif // (_ATL_VER >= 0x0800) ModuleHelper::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(_GetSetRGBMessage(), 0, (LPARAM)clr); } // Get the selected color after DoModal returns, or in OnColorOK COLORREF GetColor() const { return m_cc.rgbResult; } // Special override for the color dialog static UINT_PTR APIENTRY HookProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { if(uMsg != WM_INITDIALOG && uMsg != _GetColorOKMessage()) return 0; LPCHOOSECOLOR lpCC = (LPCHOOSECOLOR)lParam; CCommonDialogImplBase* pT = NULL; if(uMsg == WM_INITDIALOG) { pT = (CCommonDialogImplBase*)ModuleHelper::ExtractCreateWndData(); lpCC->lCustData = (LPARAM)pT; 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 Color common dialog failed\n")); return 0; } } else if(uMsg == _GetColorOKMessage()) { pT = (CCommonDialogImplBase*)lpCC->lCustData; ATLASSERT(pT != NULL); ATLASSERT(::IsWindow(pT->m_hWnd)); } else { ATLASSERT(FALSE); return 0; } // pass to the message map LRESULT lRes = 0; if(pT->ProcessWindowMessage(pT->m_hWnd, uMsg, wParam, lParam, lRes, 0) == FALSE) return 0; return lRes; } // Helpers 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; } static UINT _GetSetRGBMessage() { static UINT uSetRGBMessage = 0; if(uSetRGBMessage == 0) { CStaticDataInitCriticalSectionLock lock; if(FAILED(lock.Lock())) { ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CColorDialogImpl::_GetSetRGBMessage.\n")); ATLASSERT(FALSE); return 0; } if(uSetRGBMessage == 0) uSetRGBMessage = ::RegisterWindowMessage(SETRGBSTRING); lock.Unlock(); } ATLASSERT(uSetRGBMessage != 0); return uSetRGBMessage; } static UINT _GetColorOKMessage() { static UINT uColorOKMessage = 0; if(uColorOKMessage == 0) { CStaticDataInitCriticalSectionLock lock; if(FAILED(lock.Lock())) { ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CColorDialogImpl::_GetColorOKMessage.\n")); ATLASSERT(FALSE); return 0; } if(uColorOKMessage == 0) uColorOKMessage = ::RegisterWindowMessage(COLOROKSTRING); lock.Unlock(); } ATLASSERT(uColorOKMessage != 0); return uColorOKMessage; } // Message map and handlers BEGIN_MSG_MAP(CColorDialogImpl) MESSAGE_HANDLER(_GetColorOKMessage(), _OnColorOK) END_MSG_MAP() LRESULT _OnColorOK(UINT, WPARAM, LPARAM, BOOL&) { T* pT = static_cast(this); return pT->OnColorOK(); } // Overrideable BOOL OnColorOK() // validate color { return FALSE; } }; class CColorDialog : public CColorDialogImpl { public: CColorDialog(COLORREF clrInit = 0, DWORD dwFlags = 0, HWND hWndParent = NULL) : CColorDialogImpl(clrInit, dwFlags, hWndParent) { } // override base class map and references to handlers DECLARE_EMPTY_MSG_MAP() }; #endif // !defined(_WIN32_WCE) || ((_WIN32_WCE > 420) && !(defined(WIN32_PLATFORM_WFSP) && (_WIN32_WCE > 0x0500))) /////////////////////////////////////////////////////////////////////////////// // CPrintDialogImpl - used for Print... and PrintSetup... #ifndef _WIN32_WCE // global helper static inline 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; } #pragma warning(push) #pragma warning(disable: 4512) // assignment operator could not be generated template 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) != 0); ATLASSERT((m_pd.Flags & PD_ENABLESETUPHOOK) != 0); 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); #if (_ATL_VER >= 0x0800) // Allocate the thunk structure here, where we can fail gracefully. BOOL bRetTh = m_thunk.Init(NULL, NULL); if(bRetTh == FALSE) { ::SetLastError(ERROR_OUTOFMEMORY); return -1; } #endif // (_ATL_VER >= 0x0800) ModuleHelper::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) != 0) { 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) != 0) ? TRUE : FALSE; } BOOL PrintSelection() const // TRUE if printing selection { return ((m_pd.Flags & PD_SELECTION) != 0) ? 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) != 0) ? TRUE : FALSE; } BOOL PrintToFile() const // TRUE if printing to a file { return ((m_pd.Flags & PD_PRINTTOFILE) != 0) ? TRUE : FALSE; } int GetFromPage() const // starting page if valid { return PrintRange() ? m_pd.nFromPage : -1; } int GetToPage() const // ending 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) != 0); 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) #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*/) { T dlgSetup(m_pd); ModuleHelper::AddCreateWndData(&dlgSetup.m_thunk.cd, (CCommonDialogImplBase*)&dlgSetup); return DefWindowProc(WM_COMMAND, MAKEWPARAM(wID, wNotifyCode), (LPARAM)hWndCtl); } }; class CPrintDialog : public CPrintDialogImpl { public: CPrintDialog(BOOL bPrintSetupOnly = FALSE, DWORD dwFlags = PD_ALLPAGES | PD_USEDEVMODECOPIES | PD_NOPAGENUMS | PD_NOSELECTION, HWND hWndParent = NULL) : CPrintDialogImpl(bPrintSetupOnly, dwFlags, hWndParent) { } CPrintDialog(PRINTDLG& pdInit) : CPrintDialogImpl(pdInit) { } }; #pragma warning(pop) #endif // _WIN32_WCE /////////////////////////////////////////////////////////////////////////////// // CPrintDialogExImpl - new print dialog for Windows 2000 #if (WINVER >= 0x0500) && !defined(_WIN32_WCE) }; // namespace WTL #include 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 ATL_NO_VTABLE CPrintDialogExImpl : public ATL::CWindow, public ATL::CMessageMap, public IPrintDialogCallback, public ATL::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(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() { ATLASSERT(m_pdex.hDevMode == NULL); // must be NULL ATLASSERT(m_pdex.hDevNames == NULL); // must be NULL if(m_pdex.hwndOwner == NULL) // set only if not specified before m_pdex.hwndOwner = ::GetActiveWindow(); m_pdex.Flags |= PD_RETURNDEFAULT; HRESULT hRet = ::PrintDlgEx(&m_pdex); m_pdex.Flags &= ~PD_RETURNDEFAULT; return hRet; } // Helpers for parsing information after successful return num. copies requested int GetCopies() const { if((m_pdex.Flags & PD_USEDEVMODECOPIES) != 0) { 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) != 0) ? TRUE : FALSE; } BOOL PrintSelection() const // TRUE if printing selection { return ((m_pdex.Flags & PD_SELECTION) != 0) ? 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) != 0) ? TRUE : FALSE; } BOOL PrintToFile() const // TRUE if printing to a file { return ((m_pdex.Flags & PD_PRINTTOFILE) != 0) ? 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) != 0); 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(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 { public: CPrintDialogEx( DWORD dwFlags = PD_ALLPAGES | PD_USEDEVMODECOPIES | PD_NOPAGENUMS | PD_NOSELECTION | PD_NOCURRENTPAGE, HWND hWndParent = NULL) : CPrintDialogExImpl(dwFlags, hWndParent) { } DECLARE_EMPTY_MSG_MAP() }; #endif // (WINVER >= 0x0500) && !defined(_WIN32_WCE) /////////////////////////////////////////////////////////////////////////////// // CPageSetupDialogImpl - Page Setup dialog #ifndef _WIN32_WCE template class ATL_NO_VTABLE CPageSetupDialogImpl : public CCommonDialogImplBase { public: PAGESETUPDLG m_psd; ATL::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); #if (_ATL_VER >= 0x0700) m_psd.lpfnPagePaintHook = (LPPAGEPAINTHOOK)m_thunkPaint.GetWNDPROC(); #else m_psd.lpfnPagePaintHook = (LPPAGEPAINTHOOK)&(m_thunkPaint.thunk); #endif } 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 = { m_psd.ptPaperSize.x, m_psd.ptPaperSize.y }; return size; } void GetMargins(LPRECT lpRectMargins, LPRECT lpRectMinMargins) const { if(lpRectMargins != NULL) *lpRectMargins = m_psd.rtMargin; if(lpRectMinMargins != NULL) *lpRectMinMargins = m_psd.rtMinMargin; } // Operations INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow()) { ATLASSERT((m_psd.Flags & PSD_ENABLEPAGESETUPHOOK) != 0); ATLASSERT((m_psd.Flags & PSD_ENABLEPAGEPAINTHOOK) != 0); 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); #if (_ATL_VER >= 0x0800) // Allocate the thunk structure here, where we can fail gracefully. BOOL bRetTh = m_thunk.Init(NULL, NULL); if(bRetTh == FALSE) { ::SetLastError(ERROR_OUTOFMEMORY); return -1; } #endif // (_ATL_VER >= 0x0800) ModuleHelper::AddCreateWndData(&m_thunk.cd, (CCommonDialogImplBase*)this); BOOL bRet = ::PageSetupDlg(&m_psd); m_hWnd = NULL; return bRet ? IDOK : IDCANCEL; } // Implementation static UINT_PTR CALLBACK PaintHookProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { T* pT = (T*)hWnd; UINT_PTR uRet = 0; switch(uMsg) { case WM_PSD_PAGESETUPDLG: uRet = pT->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 = pT->OnDrawPage(uMsg, (HDC)wParam, (LPRECT)lParam); break; default: ATLTRACE2(atlTraceUI, 0, _T("CPageSetupDialogImpl::PaintHookProc - unknown message received\n")); break; } return uRet; } // Overridables UINT_PTR PreDrawPage(WORD /*wPaper*/, WORD /*wFlags*/, LPPAGESETUPDLG /*pPSD*/) { // return 1 to prevent any more drawing return 0; } UINT_PTR OnDrawPage(UINT /*uMsg*/, HDC /*hDC*/, LPRECT /*lpRect*/) { return 0; // do the default } }; class CPageSetupDialog : public CPageSetupDialogImpl { public: CPageSetupDialog(DWORD dwFlags = PSD_MARGINS | PSD_INWININIINTLMEASURE, HWND hWndParent = NULL) : CPageSetupDialogImpl(dwFlags, hWndParent) { } // override PaintHookProc and references to handlers static UINT_PTR CALLBACK PaintHookProc(HWND, UINT, WPARAM, LPARAM) { return 0; } }; #endif // _WIN32_WCE /////////////////////////////////////////////////////////////////////////////// // CFindReplaceDialogImpl - Find/FindReplace modeless dialogs #ifndef _WIN32_WCE template class ATL_NO_VTABLE CFindReplaceDialogImpl : public CCommonDialogImplBase { public: enum { _cchFindReplaceBuffer = 128 }; FINDREPLACE m_fr; TCHAR m_szFindWhat[_cchFindReplaceBuffer]; TCHAR m_szReplaceWith[_cchFindReplaceBuffer]; // Constructors CFindReplaceDialogImpl() { memset(&m_fr, 0, sizeof(m_fr)); m_szFindWhat[0] = _T('\0'); m_szReplaceWith[0] = _T('\0'); m_fr.lStructSize = sizeof(m_fr); m_fr.Flags = FR_ENABLEHOOK; m_fr.lpfnHook = (LPFRHOOKPROC)T::HookProc; m_fr.lpstrFindWhat = (LPTSTR)m_szFindWhat; m_fr.wFindWhatLen = _cchFindReplaceBuffer; m_fr.lpstrReplaceWith = (LPTSTR)m_szReplaceWith; m_fr.wReplaceWithLen = _cchFindReplaceBuffer; } // 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) != 0); ATLASSERT(m_fr.lpfnHook != NULL); 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) SecureHelper::strncpy_x(m_szFindWhat, _countof(m_szFindWhat), lpszFindWhat, _TRUNCATE); if(lpszReplaceWith != NULL) SecureHelper::strncpy_x(m_szReplaceWith, _countof(m_szReplaceWith), lpszReplaceWith, _TRUNCATE); ATLASSERT(m_hWnd == NULL); #if (_ATL_VER >= 0x0800) // Allocate the thunk structure here, where we can fail gracefully. BOOL bRet = m_thunk.Init(NULL, NULL); if(bRet == FALSE) { ::SetLastError(ERROR_OUTOFMEMORY); return NULL; } #endif // (_ATL_VER >= 0x0800) ModuleHelper::AddCreateWndData(&m_thunk.cd, (CCommonDialogImplBase*)this); HWND hWnd = NULL; 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) != 0) ? TRUE : FALSE; } BOOL FindNext() const // TRUE if command is find next { return ((m_fr.Flags & FR_FINDNEXT) != 0) ? TRUE : FALSE; } BOOL MatchCase() const // TRUE if matching case { return ((m_fr.Flags & FR_MATCHCASE) != 0) ? TRUE : FALSE; } BOOL MatchWholeWord() const // TRUE if matching whole words only { return ((m_fr.Flags & FR_WHOLEWORD) != 0) ? TRUE : FALSE; } BOOL ReplaceCurrent() const // TRUE if replacing current string { return ((m_fr. Flags & FR_REPLACE) != 0) ? TRUE : FALSE; } BOOL ReplaceAll() const // TRUE if replacing all occurrences { return ((m_fr.Flags & FR_REPLACEALL) != 0) ? TRUE : FALSE; } BOOL IsTerminating() const // TRUE if terminating dialog { return ((m_fr.Flags & FR_DIALOGTERM) != 0) ? TRUE : FALSE ; } }; class CFindReplaceDialog : public CFindReplaceDialogImpl { public: DECLARE_EMPTY_MSG_MAP() }; #endif // !_WIN32_WCE ///////////////////////////////////////////////////////////////////////// // CDialogBaseUnits - Dialog Units helper // class CDialogBaseUnits { public: SIZE m_sizeUnits; // Constructors CDialogBaseUnits() { // The base units of the out-dated System Font LONG nDlgBaseUnits = ::GetDialogBaseUnits(); m_sizeUnits.cx = LOWORD(nDlgBaseUnits); m_sizeUnits.cy = HIWORD(nDlgBaseUnits); } CDialogBaseUnits(HWND hWnd) { if(!InitDialogBaseUnits(hWnd)) { LONG nDlgBaseUnits = ::GetDialogBaseUnits(); m_sizeUnits.cx = LOWORD(nDlgBaseUnits); m_sizeUnits.cy = HIWORD(nDlgBaseUnits); } } CDialogBaseUnits(HFONT hFont, HWND hWnd = NULL) { if(!InitDialogBaseUnits(hFont, hWnd)) { LONG nDlgBaseUnits = ::GetDialogBaseUnits(); m_sizeUnits.cx = LOWORD(nDlgBaseUnits); m_sizeUnits.cy = HIWORD(nDlgBaseUnits); } } CDialogBaseUnits(LOGFONT lf, HWND hWnd = NULL) { if(!InitDialogBaseUnits(lf, hWnd)) { LONG nDlgBaseUnits = ::GetDialogBaseUnits(); m_sizeUnits.cx = LOWORD(nDlgBaseUnits); m_sizeUnits.cy = HIWORD(nDlgBaseUnits); } } // Operations BOOL InitDialogBaseUnits(HWND hWnd) { ATLASSERT(::IsWindow(hWnd)); RECT rc = { 0, 0, 4, 8 }; if(!::MapDialogRect(hWnd, &rc)) return FALSE; m_sizeUnits.cx = rc.right; m_sizeUnits.cy = rc.bottom; return TRUE; } BOOL InitDialogBaseUnits(LOGFONT lf, HWND hWnd = NULL) { CFont font; font.CreateFontIndirect(&lf); if(font.IsNull()) return FALSE; return InitDialogBaseUnits(font, hWnd); } BOOL InitDialogBaseUnits(HFONT hFont, HWND hWnd = NULL) { ATLASSERT(hFont != NULL); CWindowDC dc = hWnd; TEXTMETRIC tmText = { 0 }; SIZE sizeText = { 0 }; HFONT hFontOld = dc.SelectFont(hFont); dc.GetTextMetrics(&tmText); m_sizeUnits.cy = tmText.tmHeight + tmText.tmExternalLeading; dc.GetTextExtent(_T("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"), 52, &sizeText); m_sizeUnits.cx = (sizeText.cx + 26) / 52; dc.SelectFont(hFontOld); return TRUE; } SIZE GetDialogBaseUnits() const { return m_sizeUnits; } INT MapDialogPixelsX(INT x) const { return ::MulDiv(x, 4, m_sizeUnits.cx); // Pixels X to DLU } INT MapDialogPixelsY(INT y) const { return ::MulDiv(y, 8, m_sizeUnits.cy); // Pixels Y to DLU } POINT MapDialogPixels(POINT pt) const { POINT out = { MapDialogPixelsX(pt.x), MapDialogPixelsY(pt.y) }; return out; } SIZE MapDialogPixels(SIZE input) const { SIZE out = { MapDialogPixelsX(input.cx), MapDialogPixelsY(input.cy) }; return out; } RECT MapDialogPixels(const RECT& input) const { RECT out = { MapDialogPixelsX(input.left), MapDialogPixelsY(input.top), MapDialogPixelsX(input.right), MapDialogPixelsY(input.bottom) }; return out; } INT MapDialogUnitsX(INT x) const { return ::MulDiv(x, m_sizeUnits.cx, 4); // DLU to Pixels X } INT MapDialogUnitsY(INT y) const { return ::MulDiv(y, m_sizeUnits.cy, 8); // DLU to Pixels Y } POINT MapDialogUnits(POINT pt) const { POINT out = { MapDialogUnitsX(pt.x), MapDialogUnitsY(pt.y) }; return out; } SIZE MapDialogUnits(SIZE input) const { SIZE out = { MapDialogUnitsX(input.cx), MapDialogUnitsY(input.cy) }; return out; } RECT MapDialogUnits(const RECT& input) const { RECT out = { MapDialogUnitsX(input.left), MapDialogUnitsY(input.top), MapDialogUnitsX(input.right), MapDialogUnitsY(input.bottom) }; return out; } }; /////////////////////////////////////////////////////////////////////////////// // CMemDlgTemplate - in-memory dialog template - DLGTEMPLATE or DLGTEMPLATEEX #if (_ATL_VER >= 0x800) typedef ATL::_DialogSplitHelper::DLGTEMPLATEEX DLGTEMPLATEEX; typedef ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX DLGITEMTEMPLATEEX; #else // (_ATL_VER >= 0x800) typedef ATL::_DialogSizeHelper::_ATL_DLGTEMPLATEEX DLGTEMPLATEEX; #pragma pack(push, 4) struct DLGITEMTEMPLATEEX { DWORD helpID; DWORD exStyle; DWORD style; short x; short y; short cx; short cy; DWORD id; }; #pragma pack(pop) #endif // (_ATL_VER >= 0x800) template class CMemDlgTemplateT { public: enum StdCtrlType { CTRL_BUTTON = 0x0080, CTRL_EDIT = 0x0081, CTRL_STATIC = 0x0082, CTRL_LISTBOX = 0x0083, CTRL_SCROLLBAR = 0x0084, CTRL_COMBOBOX = 0x0085 }; HANDLE m_hData; LPBYTE m_pData; LPBYTE m_pPtr; SIZE_T m_cAllocated; CMemDlgTemplateT() : m_hData(NULL), m_pData(NULL), m_pPtr(NULL), m_cAllocated(0) { } ~CMemDlgTemplateT() { Reset(); } bool IsValid() const { return (m_pData != NULL); } bool IsTemplateEx() const { return (IsValid() && ((DLGTEMPLATEEX*)m_pData)->signature == 0xFFFF); } LPDLGTEMPLATE GetTemplatePtr() { return reinterpret_cast(m_pData); } DLGTEMPLATEEX* GetTemplateExPtr() { return reinterpret_cast(m_pData); } void Reset() { if (IsValid()) { #ifndef UNDER_CE ::GlobalUnlock(m_pData); #endif ATLVERIFY(::GlobalFree(m_hData) == NULL); } m_hData = NULL; m_pData = NULL; m_pPtr = NULL; m_cAllocated = 0; } void Create(bool bDlgEx, LPCTSTR lpszCaption, const RECT& rc, DWORD dwStyle = 0, DWORD dwExStyle = 0, LPCTSTR lpstrFontName = NULL, WORD wFontSize = 0, WORD wWeight = 0, BYTE bItalic = 0, BYTE bCharset = 0, DWORD dwHelpID = 0, ATL::_U_STRINGorID ClassName = 0U, ATL::_U_STRINGorID Menu = 0U) { Create(bDlgEx, lpszCaption, (short) rc.left, (short) rc.top, (short) (rc.right - rc.left), (short) (rc.bottom - rc.top), dwStyle, dwExStyle, lpstrFontName, wFontSize, wWeight, bItalic, bCharset, dwHelpID, ClassName.m_lpstr, Menu.m_lpstr); } void Create(bool bDlgEx, LPCTSTR lpszCaption, short nX, short nY, short nWidth, short nHeight, DWORD dwStyle = 0, DWORD dwExStyle = 0, LPCTSTR lpstrFontName = NULL, WORD wFontSize = 0, WORD wWeight = 0, BYTE bItalic = 0, BYTE bCharset = 0, DWORD dwHelpID = 0, ATL::_U_STRINGorID ClassName = 0U, ATL::_U_STRINGorID Menu = 0U) { // Should have DS_SETFONT style to set the dialog font name and size if (lpstrFontName != NULL) { dwStyle |= DS_SETFONT; } else { dwStyle &= ~DS_SETFONT; } if (bDlgEx) { DLGTEMPLATEEX dlg = {1, 0xFFFF, dwHelpID, dwExStyle, dwStyle, 0, nX, nY, nWidth, nHeight}; AddData(&dlg, sizeof(dlg)); } else { DLGTEMPLATE dlg = {dwStyle, dwExStyle, 0, nX, nY, nWidth, nHeight}; AddData(&dlg, sizeof(dlg)); } #ifndef _WIN32_WCE if (Menu.m_lpstr == NULL) { WORD menuData = 0; AddData(&menuData, sizeof(WORD)); } else if (IS_INTRESOURCE(Menu.m_lpstr)) { WORD menuData[] = { 0xFFFF, LOWORD(Menu.m_lpstr) }; AddData(menuData, sizeof(menuData)); } else { AddString(Menu.m_lpstr); } #else // _WIN32_WCE // Windows CE doesn't support the addition of menus to a dialog box ATLASSERT(Menu.m_lpstr == NULL); Menu.m_lpstr; // avoid level 4 warning WORD menuData = 0; AddData(&menuData, sizeof(WORD)); #endif // _WIN32_WCE if (ClassName.m_lpstr == NULL) { WORD classData = 0; AddData(&classData, sizeof(WORD)); } else if (IS_INTRESOURCE(ClassName.m_lpstr)) { WORD classData[] = { 0xFFFF, LOWORD(ClassName.m_lpstr) }; AddData(classData, sizeof(classData)); } else { AddString(ClassName.m_lpstr); } // Set dialog caption AddString(lpszCaption); if (lpstrFontName != NULL) { AddData(&wFontSize, sizeof(wFontSize)); if (bDlgEx) { AddData(&wWeight, sizeof(wWeight)); AddData(&bItalic, sizeof(bItalic)); AddData(&bCharset, sizeof(bCharset)); } AddString(lpstrFontName); } } void AddControl(ATL::_U_STRINGorID ClassName, WORD wId, const RECT& rc, DWORD dwStyle, DWORD dwExStyle, ATL::_U_STRINGorID Text, const WORD* pCreationData = NULL, WORD nCreationData = 0, DWORD dwHelpID = 0) { AddControl(ClassName.m_lpstr, wId, (short) rc.left, (short) rc.top, (short) (rc.right - rc.left), (short) (rc.bottom - rc.top), dwStyle, dwExStyle, Text.m_lpstr, pCreationData, nCreationData, dwHelpID); } void AddControl(ATL::_U_STRINGorID ClassName, WORD wId, short nX, short nY, short nWidth, short nHeight, DWORD dwStyle, DWORD dwExStyle, ATL::_U_STRINGorID Text, const WORD* pCreationData = NULL, WORD nCreationData = 0, DWORD dwHelpID = 0) { ATLASSERT(IsValid()); // DWORD align data const DWORD_PTR dwDwordAlignBits = sizeof(DWORD) - 1; m_pPtr = (LPBYTE)(((DWORD_PTR)m_pPtr + dwDwordAlignBits) & (~dwDwordAlignBits)); if (IsTemplateEx()) { DLGTEMPLATEEX* dlg = (DLGTEMPLATEEX*)m_pData; dlg->cDlgItems++; DLGITEMTEMPLATEEX item = {dwHelpID, TWinTraits::GetWndExStyle(0) | dwExStyle, TWinTraits::GetWndStyle(0) | dwStyle, nX, nY, nWidth, nHeight, wId}; AddData(&item, sizeof(item)); } else { LPDLGTEMPLATE dlg = (LPDLGTEMPLATE)m_pData; dlg->cdit++; DLGITEMTEMPLATE item = {TWinTraits::GetWndStyle(0) | dwStyle, TWinTraits::GetWndExStyle(0) | dwExStyle, nX, nY, nWidth, nHeight, wId}; AddData(&item, sizeof(item)); } ATLASSERT(ClassName.m_lpstr != NULL); if (IS_INTRESOURCE(ClassName.m_lpstr)) { WORD wData[] = { 0xFFFF, LOWORD(ClassName.m_lpstr) }; AddData(wData, sizeof(wData)); } else { AddString(ClassName.m_lpstr); } if (Text.m_lpstr == NULL) { WORD classData = 0; AddData(&classData, sizeof(WORD)); } else if (IS_INTRESOURCE(Text.m_lpstr)) { WORD wData[] = { 0xFFFF, LOWORD(Text.m_lpstr) }; AddData(wData, sizeof(wData)); } else { AddString(Text.m_lpstr); } AddData(&nCreationData, sizeof(nCreationData)); if ((nCreationData != 0)) { ATLASSERT(pCreationData != NULL); AddData(pCreationData, nCreationData * sizeof(WORD)); } } void AddStdControl(StdCtrlType CtrlType, WORD wId, short nX, short nY, short nWidth, short nHeight, DWORD dwStyle, DWORD dwExStyle, ATL::_U_STRINGorID Text, const WORD* pCreationData = NULL, WORD nCreationData = 0, DWORD dwHelpID = 0) { AddControl(CtrlType, wId, nX, nY, nWidth, nHeight, dwStyle, dwExStyle, Text, pCreationData, nCreationData, dwHelpID); } void AddData(LPCVOID pData, size_t nData) { ATLASSERT(pData != NULL); const SIZE_T ALLOCATION_INCREMENT = 1024; if (m_pData == NULL) { m_cAllocated = ((nData / ALLOCATION_INCREMENT) + 1) * ALLOCATION_INCREMENT; m_hData = ::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, m_cAllocated); ATLASSERT(m_hData != NULL); #ifndef UNDER_CE m_pPtr = m_pData = static_cast(::GlobalLock(m_hData)); #else m_pPtr = m_pData = static_cast(m_hData); #endif ATLASSERT(m_pData != NULL); } else if (((m_pPtr - m_pData) + nData) > m_cAllocated) { SIZE_T ptrPos = (m_pPtr - m_pData); m_cAllocated += ((nData / ALLOCATION_INCREMENT) + 1) * ALLOCATION_INCREMENT; #ifndef UNDER_CE ::GlobalUnlock(m_pData); #endif m_hData = ::GlobalReAlloc(m_hData, m_cAllocated, GMEM_MOVEABLE | GMEM_ZEROINIT); ATLASSERT(m_hData != NULL); #ifndef UNDER_CE m_pData = static_cast(::GlobalLock(m_hData)); #else m_pData = static_cast(m_hData); #endif ATLASSERT(m_pData != NULL); m_pPtr = m_pData + ptrPos; } SecureHelper::memcpy_x(m_pPtr, m_cAllocated - (m_pPtr - m_pData), pData, nData); m_pPtr += nData; } void AddString(LPCTSTR lpszStr) { if (lpszStr == NULL) { WCHAR szEmpty = 0; AddData(&szEmpty, sizeof(szEmpty)); } else { USES_CONVERSION; LPCWSTR lpstr = T2CW(lpszStr); int nSize = lstrlenW(lpstr) + 1; AddData(lpstr, nSize * sizeof(WCHAR)); } } }; typedef CMemDlgTemplateT CMemDlgTemplate; /////////////////////////////////////////////////////////////////////////////// // Dialog and control macros for indirect dialogs // for DLGTEMPLATE #define BEGIN_DIALOG(x, y, width, height) \ void DoInitTemplate() \ { \ bool bExTemplate = false; \ short nX = x, nY = y, nWidth = width, nHeight = height; \ LPCTSTR szCaption = NULL; \ DWORD dwStyle = WS_POPUP | WS_BORDER | WS_SYSMENU; \ DWORD dwExStyle = 0; \ LPCTSTR szFontName = NULL; \ WORD wFontSize = 0; \ WORD wWeight = 0; \ BYTE bItalic = 0; \ BYTE bCharset = 0; \ DWORD dwHelpID = 0; \ ATL::_U_STRINGorID Menu = 0U; \ ATL::_U_STRINGorID ClassName = 0U; // for DLGTEMPLATEEX #define BEGIN_DIALOG_EX(x, y, width, height, helpID) \ void DoInitTemplate() \ { \ bool bExTemplate = true; \ short nX = x, nY = y, nWidth = width, nHeight = height; \ LPCTSTR szCaption = NULL; \ DWORD dwStyle = WS_POPUP | WS_BORDER | WS_SYSMENU; \ DWORD dwExStyle = 0; \ LPCTSTR szFontName = NULL; \ WORD wFontSize = 0; \ WORD wWeight = 0; \ BYTE bItalic = 0; \ BYTE bCharset = 0; \ DWORD dwHelpID = helpID; \ ATL::_U_STRINGorID Menu = 0U; \ ATL::_U_STRINGorID ClassName = 0U; #define END_DIALOG() \ m_Template.Create(bExTemplate, szCaption, nX, nY, nWidth, nHeight, dwStyle, dwExStyle, szFontName, wFontSize, wWeight, bItalic, bCharset, dwHelpID, ClassName, Menu); \ }; #define DIALOG_CAPTION(caption) \ szCaption = caption; #define DIALOG_STYLE(style) \ dwStyle = style; #define DIALOG_EXSTYLE(exStyle) \ dwExStyle = exStyle; #define DIALOG_FONT(pointSize, typeFace) \ wFontSize = pointSize; \ szFontName = typeFace; #define DIALOG_FONT_EX(pointsize, typeface, weight, italic, charset) \ ATLASSERT(bExTemplate); \ wFontSize = pointsize; \ szFontName = typeface; \ wWeight = weight; \ bItalic = italic; \ bCharset = charset; #define DIALOG_MENU(menuName) \ Menu = menuName; #define DIALOG_CLASS(className) \ ClassName = className; #define BEGIN_CONTROLS_MAP() \ void DoInitControls() \ { #define END_CONTROLS_MAP() \ }; #define CONTROL_LTEXT(text, id, x, y, width, height, style, exStyle) \ m_Template.AddStdControl(m_Template.CTRL_STATIC, (WORD)id, x, y, width, height, style | SS_LEFT | WS_GROUP, exStyle, text, NULL, 0); #define CONTROL_CTEXT(text, id, x, y, width, height, style, exStyle) \ m_Template.AddStdControl(m_Template.CTRL_STATIC, (WORD)id, x, y, width, height, style | SS_CENTER | WS_GROUP, exStyle, text, NULL, 0); #define CONTROL_RTEXT(text, id, x, y, width, height, style, exStyle) \ m_Template.AddStdControl(m_Template.CTRL_STATIC, (WORD)id, x, y, width, height, style | SS_RIGHT | WS_GROUP, exStyle, text, NULL, 0); #define CONTROL_PUSHBUTTON(text, id, x, y, width, height, style, exStyle) \ m_Template.AddStdControl(m_Template.CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_PUSHBUTTON | WS_TABSTOP, exStyle, text, NULL, 0); #define CONTROL_DEFPUSHBUTTON(text, id, x, y, width, height, style, exStyle) \ m_Template.AddStdControl(m_Template.CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_DEFPUSHBUTTON | WS_TABSTOP, exStyle, text, NULL, 0); #ifndef _WIN32_WCE #define CONTROL_PUSHBOX(text, id, x, y, width, height, style, exStyle) \ m_Template.AddStdControl(m_Template.CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_PUSHBOX | WS_TABSTOP, exStyle, text, NULL, 0); #endif // !_WIN32_WCE #define CONTROL_STATE3(text, id, x, y, width, height, style, exStyle) \ m_Template.AddStdControl(m_Template.CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_3STATE | WS_TABSTOP, exStyle, text, NULL, 0); #define CONTROL_AUTO3STATE(text, id, x, y, width, height, style, exStyle) \ m_Template.AddStdControl(m_Template.CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_AUTO3STATE | WS_TABSTOP, exStyle, text, NULL, 0); #define CONTROL_CHECKBOX(text, id, x, y, width, height, style, exStyle) \ m_Template.AddStdControl(m_Template.CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_CHECKBOX | WS_TABSTOP, exStyle, text, NULL, 0); #define CONTROL_AUTOCHECKBOX(text, id, x, y, width, height, style, exStyle) \ m_Template.AddStdControl(m_Template.CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_AUTOCHECKBOX | WS_TABSTOP, exStyle, text, NULL, 0); #define CONTROL_RADIOBUTTON(text, id, x, y, width, height, style, exStyle) \ m_Template.AddStdControl(m_Template.CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_RADIOBUTTON | WS_TABSTOP, exStyle, text, NULL, 0); #define CONTROL_AUTORADIOBUTTON(text, id, x, y, width, height, style, exStyle) \ m_Template.AddStdControl(m_Template.CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_AUTORADIOBUTTON | WS_TABSTOP, exStyle, text, NULL, 0); #define CONTROL_COMBOBOX(id, x, y, width, height, style, exStyle) \ m_Template.AddStdControl(m_Template.CTRL_COMBOBOX, (WORD)id, x, y, width, height, style | CBS_DROPDOWN | WS_TABSTOP, exStyle, (LPCTSTR)NULL, NULL, 0); #define CONTROL_EDITTEXT(id, x, y, width, height, style, exStyle) \ m_Template.AddStdControl(m_Template.CTRL_EDIT, (WORD)id, x, y, width, height, style | ES_LEFT | WS_BORDER | WS_TABSTOP, exStyle, (LPCTSTR)NULL, NULL, 0); #define CONTROL_GROUPBOX(text, id, x, y, width, height, style, exStyle) \ m_Template.AddStdControl(m_Template.CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_GROUPBOX, exStyle, text, NULL, 0); #define CONTROL_LISTBOX(id, x, y, width, height, style, exStyle) \ m_Template.AddStdControl(m_Template.CTRL_LISTBOX, (WORD)id, x, y, width, height, style | LBS_NOTIFY | WS_BORDER, exStyle, (LPCTSTR)NULL, NULL, 0); #define CONTROL_SCROLLBAR(id, x, y, width, height, style, exStyle) \ m_Template.AddStdControl(m_Template.CTRL_SCROLLBAR, (WORD)id, x, y, width, height, style | SBS_HORZ, exStyle, (LPCTSTR)NULL, NULL, 0); #define CONTROL_ICON(text, id, x, y, width, height, style, exStyle) \ m_Template.AddStdControl(m_Template.CTRL_STATIC, (WORD)id, x, y, width, height, style | SS_ICON, exStyle, text, NULL, 0); #define CONTROL_CONTROL(text, id, className, style, x, y, width, height, exStyle) \ m_Template.AddControl(className, (WORD)id, x, y, width, height, style, exStyle, text, NULL, 0); /////////////////////////////////////////////////////////////////////////////// // CIndirectDialogImpl - dialogs with template in memory template class ATL_NO_VTABLE CIndirectDialogImpl : public ATL::CDialogImpl< T, TBase > { public: enum { IDD = 0 }; // no dialog template resource TDlgTemplate m_Template; void CreateTemplate() { T* pT = static_cast(this); pT->DoInitTemplate(); pT->DoInitControls(); } INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow(), LPARAM dwInitParam = NULL) { T* pT = static_cast(this); ATLASSERT(pT->m_hWnd == NULL); if(!m_Template.IsValid()) CreateTemplate(); #if (_ATL_VER >= 0x0800) // Allocate the thunk structure here, where we can fail gracefully. BOOL bRet = m_thunk.Init(NULL, NULL); if(bRet == FALSE) { ::SetLastError(ERROR_OUTOFMEMORY); return -1; } #endif // (_ATL_VER >= 0x0800) ModuleHelper::AddCreateWndData(&m_thunk.cd, (ATL::CDialogImplBaseT< TBase >*)pT); #ifdef _DEBUG m_bModal = true; #endif // _DEBUG return ::DialogBoxIndirectParam(ModuleHelper::GetResourceInstance(), m_Template.GetTemplatePtr(), hWndParent, (DLGPROC)T::StartDialogProc, dwInitParam); } HWND Create(HWND hWndParent, LPARAM dwInitParam = NULL) { T* pT = static_cast(this); ATLASSERT(pT->m_hWnd == NULL); if(!m_Template.IsValid()) CreateTemplate(); #if (_ATL_VER >= 0x0800) // Allocate the thunk structure here, where we can fail gracefully. BOOL bRet = m_thunk.Init(NULL, NULL); if(bRet == FALSE) { ::SetLastError(ERROR_OUTOFMEMORY); return NULL; } #endif // (_ATL_VER >= 0x0800) ModuleHelper::AddCreateWndData(&m_thunk.cd, (ATL::CDialogImplBaseT< TBase >*)pT); #ifdef _DEBUG m_bModal = false; #endif // _DEBUG HWND hWnd = ::CreateDialogIndirectParam(ModuleHelper::GetResourceInstance(), (LPCDLGTEMPLATE)m_Template.GetTemplatePtr(), hWndParent, (DLGPROC)T::StartDialogProc, dwInitParam); ATLASSERT(m_hWnd == hWnd); return hWnd; } // for CComControl HWND Create(HWND hWndParent, RECT&, LPARAM dwInitParam = NULL) { return Create(hWndParent, dwInitParam); } void DoInitTemplate() { ATLASSERT(FALSE); // MUST be defined in derived class } void DoInitControls() { ATLASSERT(FALSE); // MUST be defined in derived class } }; /////////////////////////////////////////////////////////////////////////////// // CPropertySheetWindow - client side for a property sheet class CPropertySheetWindow : public ATL::CWindow { public: // Constructors CPropertySheetWindow(HWND hWnd = NULL) : ATL::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 BOOL AddPage(HPROPSHEETPAGE hPage) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(hPage != NULL); return (BOOL)::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; return (BOOL)::SendMessage(m_hWnd, PSM_ADDPAGE, 0, (LPARAM)hPage); } #ifndef _WIN32_WCE BOOL InsertPage(int nNewPageIndex, HPROPSHEETPAGE hPage) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(hPage != NULL); return (BOOL)::SendMessage(m_hWnd, PSM_INSERTPAGE, nNewPageIndex, (LPARAM)hPage); } BOOL InsertPage(int nNewPageIndex, LPCPROPSHEETPAGE pPage) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(pPage != NULL); HPROPSHEETPAGE hPage = ::CreatePropertySheetPage(pPage); if(hPage == NULL) return FALSE; return (BOOL)::SendMessage(m_hWnd, PSM_INSERTPAGE, nNewPageIndex, (LPARAM)hPage); } BOOL InsertPage(HPROPSHEETPAGE hPageInsertAfter, HPROPSHEETPAGE hPage) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(hPage != NULL); return (BOOL)::SendMessage(m_hWnd, PSM_INSERTPAGE, (WPARAM)hPageInsertAfter, (LPARAM)hPage); } BOOL InsertPage(HPROPSHEETPAGE hPageInsertAfter, LPCPROPSHEETPAGE pPage) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(pPage != NULL); HPROPSHEETPAGE hPage = ::CreatePropertySheetPage(pPage); if(hPage == NULL) return FALSE; return (BOOL)::SendMessage(m_hWnd, PSM_INSERTPAGE, (WPARAM)hPageInsertAfter, (LPARAM)hPage); } #endif // !_WIN32_WCE 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) && !defined(_WIN32_WCE) 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); } void SetHeaderTitle(int nIndex, LPCTSTR lpstrHeaderTitle) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, PSM_SETHEADERTITLE, nIndex, (LPARAM)lpstrHeaderTitle); } void SetHeaderSubTitle(int nIndex, LPCTSTR lpstrHeaderSubTitle) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, PSM_SETHEADERSUBTITLE, nIndex, (LPARAM)lpstrHeaderSubTitle); } #endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE) // Implementation - override to prevent usage HWND Create(LPCTSTR, HWND, ATL::_U_RECT = NULL, LPCTSTR = NULL, DWORD = 0, DWORD = 0, ATL::_U_MENUorID = 0U, LPVOID = NULL) { ATLASSERT(FALSE); return NULL; } }; /////////////////////////////////////////////////////////////////////////////// // CPropertySheetImpl - implements a property sheet template class ATL_NO_VTABLE CPropertySheetImpl : public ATL::CWindowImplBaseT< TBase > { public: PROPSHEETHEADER m_psh; ATL::CSimpleArray m_arrPages; #if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC specific #ifndef PROPSHEET_LINK_SIZE #define PROPSHEET_LINK_SIZE 128 #endif // PROPSHEET_LINK_SIZE TCHAR m_szLink[PROPSHEET_LINK_SIZE]; static LPCTSTR m_pszTitle; static LPCTSTR m_pszLink; #endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // Construction/Destruction CPropertySheetImpl(ATL::_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 = ModuleHelper::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; #if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC specific m_psh.dwFlags |= PSH_MAXIMIZE; m_szLink[0] = 0; #endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) } ~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]); } } // Callback function and overrideables static int CALLBACK PropSheetCallback(HWND hWnd, UINT uMsg, LPARAM lParam) { lParam; // avoid level 4 warning int nRet = 0; if(uMsg == PSCB_INITIALIZED) { ATLASSERT(hWnd != NULL); T* pT = (T*)ModuleHelper::ExtractCreateWndData(); // subclass the sheet window pT->SubclassWindow(hWnd); // remove page handles array pT->_CleanUpPages(); #if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC specific m_pszTitle = pT->m_psh.pszCaption; if(*pT->m_szLink != 0) m_pszLink = pT->m_szLink; #endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC specific pT->OnSheetInitialized(); } #if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC specific uMsg else { switch(uMsg) { case PSCB_GETVERSION : nRet = COMCTL32_VERSION; break; case PSCB_GETTITLE : if(m_pszTitle != NULL) { lstrcpy((LPTSTR)lParam, m_pszTitle); m_pszTitle = NULL; } break; case PSCB_GETLINKTEXT: if(m_pszLink != NULL) { lstrcpy((LPTSTR)lParam, m_pszLink); m_pszLink = NULL; } break; default: break; } } #endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) return nRet; } void OnSheetInitialized() { } // Create method 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(this); #if (_ATL_VER >= 0x0800) // Allocate the thunk structure here, where we can fail gracefully. BOOL bRet = pT->m_thunk.Init(NULL, NULL); if(bRet == FALSE) { ::SetLastError(ERROR_OUTOFMEMORY); return NULL; } #endif // (_ATL_VER >= 0x0800) ModuleHelper::AddCreateWndData(&pT->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(this); #if (_ATL_VER >= 0x0800) // Allocate the thunk structure here, where we can fail gracefully. BOOL bRet = pT->m_thunk.Init(NULL, NULL); if(bRet == FALSE) { ::SetLastError(ERROR_OUTOFMEMORY); return -1; } #endif // (_ATL_VER >= 0x0800) ModuleHelper::AddCreateWndData(&pT->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&)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); } } #if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC specific Link field void SetLinkText(LPCTSTR lpszText) { ATLASSERT(lpszText != NULL); ATLASSERT(lstrlen(lpszText) < PROPSHEET_LINK_SIZE); lstrcpy(m_szLink, lpszText); } #endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) void SetWizardMode() { m_psh.dwFlags |= PSH_WIZARD; } void EnableHelp() { m_psh.dwFlags |= PSH_HASHELP; } // Operations BOOL AddPage(HPROPSHEETPAGE hPage) { ATLASSERT(hPage != NULL); BOOL bRet = FALSE; if(m_hWnd != NULL) bRet = TBase::AddPage(hPage); else // sheet not created yet, use internal data bRet = m_arrPages.Add((HPROPSHEETPAGE&)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) && !defined(_WIN32_WCE) 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 // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE) // Message map and handlers BEGIN_MSG_MAP(CPropertySheetImpl) MESSAGE_HANDLER(WM_COMMAND, OnCommand) MESSAGE_HANDLER(WM_SYSCOMMAND, OnSysCommand) 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; } LRESULT OnSysCommand(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) { if(((m_psh.dwFlags & PSH_MODELESS) == PSH_MODELESS) && ((wParam & 0xFFF0) == SC_CLOSE)) SendMessage(WM_CLOSE); else bHandled = FALSE; return 0; } }; #if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC static pointers template < class T, class TBase > LPCWSTR CPropertySheetImpl::m_pszTitle = NULL; template < class T, class TBase> LPCWSTR CPropertySheetImpl::m_pszLink = NULL; #endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // for non-customized sheets class CPropertySheet : public CPropertySheetImpl { public: CPropertySheet(ATL::_U_STRINGorID title = (LPCTSTR)NULL, UINT uStartPage = 0, HWND hWndParent = NULL) : CPropertySheetImpl(title, uStartPage, hWndParent) { } }; /////////////////////////////////////////////////////////////////////////////// // CPropertyPageWindow - client side for a property page class CPropertyPageWindow : public ATL::CWindow { public: // Constructors CPropertyPageWindow(HWND hWnd = NULL) : ATL::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, ATL::_U_RECT = NULL, LPCTSTR = NULL, DWORD = 0, DWORD = 0, ATL::_U_MENUorID = 0U, LPVOID = NULL) { ATLASSERT(FALSE); return NULL; } }; /////////////////////////////////////////////////////////////////////////////// // CPropertyPageImpl - implements a property page template class ATL_NO_VTABLE CPropertyPageImpl : public ATL::CDialogImplBaseT< TBase > { public: PROPSHEETPAGE m_psp; operator PROPSHEETPAGE*() { return &m_psp; } // Construction CPropertyPageImpl(ATL::_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 = ModuleHelper::GetResourceInstance(); T* pT = static_cast(this); m_psp.pszTemplate = MAKEINTRESOURCE(pT->IDD); m_psp.pfnDlgProc = (DLGPROC)T::StartDialogProc; m_psp.pfnCallback = T::PropPageCallback; m_psp.lParam = (LPARAM)pT; if(title.m_lpstr != NULL) SetTitle(title); } // Callback function and overrideables static UINT CALLBACK PropPageCallback(HWND hWnd, UINT uMsg, LPPROPSHEETPAGE ppsp) { hWnd; // avoid level 4 warning ATLASSERT(hWnd == NULL); T* pT = (T*)ppsp->lParam; UINT uRet = 0; switch(uMsg) { case PSPCB_CREATE: { ATL::CDialogImplBaseT< TBase >* pPage = (ATL::CDialogImplBaseT< TBase >*)pT; ModuleHelper::AddCreateWndData(&pPage->m_thunk.cd, pPage); uRet = pT->OnPageCreate() ? 1 : 0; } break; #if (_WIN32_IE >= 0x0500) case PSPCB_ADDREF: pT->OnPageAddRef(); break; #endif // (_WIN32_IE >= 0x0500) case PSPCB_RELEASE: pT->OnPageRelease(); break; default: break; } return uRet; } bool OnPageCreate() { return true; // true - allow page to be created, false - prevent creation } #if (_WIN32_IE >= 0x0500) void OnPageAddRef() { } #endif // (_WIN32_IE >= 0x0500) void OnPageRelease() { } // Create method HPROPSHEETPAGE Create() { return ::CreatePropertySheetPage(&m_psp); } // Attributes void SetTitle(ATL::_U_STRINGorID title) { m_psp.pszTitle = title.m_lpstr; m_psp.dwFlags |= PSP_USETITLE; } #if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE) 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) && !defined(_WIN32_WCE) // Operations void EnableHelp() { m_psp.dwFlags |= PSP_HASHELP; } // Message map and handlers BEGIN_MSG_MAP(CPropertyPageImpl) MESSAGE_HANDLER(WM_NOTIFY, OnNotify) END_MSG_MAP() // NOTE: Define _WTL_NEW_PAGE_NOTIFY_HANDLERS to use new notification // handlers that return direct values without any restrictions LRESULT OnNotify(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled) { #ifndef _WIN32_WCE // This notification is sometimes received on Windows CE after the window is already destroyed ATLASSERT(::IsWindow(m_hWnd)); #endif 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; } #ifdef _WIN32_WCE ATLASSERT(::IsWindow(m_hWnd)); #endif T* pT = static_cast(this); LRESULT lResult = 0; switch(pNMHDR->code) { #ifdef _WTL_NEW_PAGE_NOTIFY_HANDLERS case PSN_SETACTIVE: lResult = pT->OnSetActive(); break; case PSN_KILLACTIVE: lResult = pT->OnKillActive(); break; case PSN_APPLY: lResult = pT->OnApply(); 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; #ifndef _WIN32_WCE #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); } break; case PSN_QUERYINITIALFOCUS: { LPPSHNOTIFY lpPSHNotify = (LPPSHNOTIFY)lParam; lResult = (LRESULT)pT->OnQueryInitialFocus((HWND)lpPSHNotify->lParam); } break; #endif // (_WIN32_IE >= 0x0500) #endif // !_WIN32_WCE #else // !_WTL_NEW_PAGE_NOTIFY_HANDLERS 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; #ifndef _WIN32_WCE #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) #endif // !_WIN32_WCE #endif // !_WTL_NEW_PAGE_NOTIFY_HANDLERS default: bHandled = FALSE; // not handled } return lResult; } // Overridables // NOTE: Define _WTL_NEW_PAGE_NOTIFY_HANDLERS to use new notification // handlers that return direct values without any restrictions #ifdef _WTL_NEW_PAGE_NOTIFY_HANDLERS int OnSetActive() { // 0 = allow activate // -1 = go back that was active // page ID = jump to page return 0; } BOOL OnKillActive() { // FALSE = allow deactivate // TRUE = prevent deactivation return FALSE; } int OnApply() { // PSNRET_NOERROR = apply OK // PSNRET_INVALID = apply not OK, return to this page // PSNRET_INVALID_NOCHANGEPAGE = apply not OK, don't change focus return PSNRET_NOERROR; } void OnReset() { } BOOL OnQueryCancel() { // FALSE = allow cancel // TRUE = prevent cancel return FALSE; } int OnWizardBack() { // 0 = goto previous 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; } INT_PTR OnWizardFinish() { // FALSE = allow finish // TRUE = prevent finish // HWND = prevent finish and set focus to HWND (CommCtrl 5.80 only) return FALSE; } void OnHelp() { } #ifndef _WIN32_WCE #if (_WIN32_IE >= 0x0400) BOOL OnGetObject(LPNMOBJECTNOTIFY /*lpObjectNotify*/) { return FALSE; // not processed } #endif // (_WIN32_IE >= 0x0400) #if (_WIN32_IE >= 0x0500) int OnTranslateAccelerator(LPMSG /*lpMsg*/) { // PSNRET_NOERROR - message not handled // PSNRET_MESSAGEHANDLED - message handled return PSNRET_NOERROR; } HWND OnQueryInitialFocus(HWND /*hWndFocus*/) { // NULL = set focus to default control // HWND = set focus to HWND return NULL; } #endif // (_WIN32_IE >= 0x0500) #endif // !_WIN32_WCE #else // !_WTL_NEW_PAGE_NOTIFY_HANDLERS 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 previous 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() { } #ifndef _WIN32_WCE #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) #endif // !_WIN32_WCE #endif // !_WTL_NEW_PAGE_NOTIFY_HANDLERS }; // for non-customized pages template class CPropertyPage : public CPropertyPageImpl > { public: enum { IDD = t_wDlgTemplateID }; CPropertyPage(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : CPropertyPageImpl(title) { } DECLARE_EMPTY_MSG_MAP() }; /////////////////////////////////////////////////////////////////////////////// // CAxPropertyPageImpl - property page that hosts ActiveX controls #ifndef _ATL_NO_HOSTING // Note: You must #include to use these classes template class ATL_NO_VTABLE CAxPropertyPageImpl : public CPropertyPageImpl< T, TBase > { public: // Data members HGLOBAL m_hInitData; HGLOBAL m_hDlgRes; HGLOBAL m_hDlgResSplit; // Constructor/destructor CAxPropertyPageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : CPropertyPageImpl< T, TBase >(title), m_hInitData(NULL), m_hDlgRes(NULL), m_hDlgResSplit(NULL) { T* pT = static_cast(this); pT; // avoid level 4 warning // initialize ActiveX hosting and modify dialog template ATL::AtlAxWinInit(); HINSTANCE hInstance = ModuleHelper::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 = ATL::_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 #ifdef _WTL_NEW_PAGE_NOTIFY_HANDLERS int OnTranslateAccelerator(LPMSG lpMsg) { T* pT = static_cast(this); return (pT->PreTranslateMessage(lpMsg) != FALSE) ? PSNRET_MESSAGEHANDLED : PSNRET_NOERROR; } #else // !_WTL_NEW_PAGE_NOTIFY_HANDLERS BOOL OnTranslateAccelerator(LPMSG lpMsg) { T* pT = static_cast(this); return pT->PreTranslateMessage(lpMsg); } #endif // !_WTL_NEW_PAGE_NOTIFY_HANDLERS #endif // (_WIN32_IE >= 0x0500) // Support for new stuff in ATL7 #if (_ATL_VER >= 0x0700) int GetIDD() { return( static_cast(this)->IDD ); } virtual DLGPROC GetDialogProc() { return DialogProc; } static INT_PTR CALLBACK DialogProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { CAxPropertyPageImpl< T, TBase >* pThis = (CAxPropertyPageImpl< T, TBase >*)hWnd; if (uMsg == WM_INITDIALOG) { HRESULT hr; if (FAILED(hr = pThis->CreateActiveXControls(pThis->GetIDD()))) { ATLASSERT(FALSE); return FALSE; } } return CPropertyPageImpl< T, TBase >::DialogProc(hWnd, uMsg, wParam, lParam); } // ActiveX controls creation virtual HRESULT CreateActiveXControls(UINT nID) { // Load dialog template and InitData HRSRC hDlgInit = ::FindResource(ATL::_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCE(nID), (LPTSTR)_ATL_RT_DLGINIT); BYTE* pInitData = NULL; HGLOBAL hData = NULL; HRESULT hr = S_OK; if (hDlgInit != NULL) { hData = ::LoadResource(ATL::_AtlBaseModule.GetResourceInstance(), hDlgInit); if (hData != NULL) pInitData = (BYTE*) ::LockResource(hData); } HRSRC hDlg = ::FindResource(ATL::_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCE(nID), (LPTSTR)RT_DIALOG); if (hDlg != NULL) { HGLOBAL hResource = ::LoadResource(ATL::_AtlBaseModule.GetResourceInstance(), hDlg); DLGTEMPLATE* pDlg = NULL; if (hResource != NULL) { pDlg = (DLGTEMPLATE*) ::LockResource(hResource); if (pDlg != NULL) { // Get first control on the template BOOL bDialogEx = ATL::_DialogSplitHelper::IsDialogEx(pDlg); WORD nItems = ATL::_DialogSplitHelper::DlgTemplateItemCount(pDlg); // Get first control on the dialog DLGITEMTEMPLATE* pItem = ATL::_DialogSplitHelper::FindFirstDlgItem(pDlg); HWND hWndPrev = GetWindow(GW_CHILD); // Create all ActiveX cotnrols in the dialog template and place them in the correct tab order (z-order) for (WORD nItem = 0; nItem < nItems; nItem++) { DWORD wID = bDialogEx ? ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->id : pItem->id; if (ATL::_DialogSplitHelper::IsActiveXControl(pItem, bDialogEx)) { BYTE* pData = NULL; DWORD dwLen = ATL::_DialogSplitHelper::FindCreateData(wID, pInitData, &pData); ATL::CComPtr spStream; if (dwLen != 0) { HGLOBAL h = GlobalAlloc(GHND, dwLen); if (h != NULL) { BYTE* pBytes = (BYTE*) GlobalLock(h); BYTE* pSource = pData; SecureHelper::memcpy_x(pBytes, dwLen, pSource, dwLen); GlobalUnlock(h); CreateStreamOnHGlobal(h, TRUE, &spStream); } else { hr = E_OUTOFMEMORY; break; } } ATL::CComBSTR bstrLicKey; hr = ATL::_DialogSplitHelper::ParseInitData(spStream, &bstrLicKey.m_str); if (SUCCEEDED(hr)) { ATL::CAxWindow2 wnd; // Get control caption. LPWSTR pszClassName = bDialogEx ? (LPWSTR)(((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem) + 1) : (LPWSTR)(pItem + 1); // Get control rect. RECT rect = { 0 }; rect.left = bDialogEx ? ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->x : pItem->x; rect.top = bDialogEx ? ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->y : pItem->y; rect.right = rect.left + (bDialogEx ? ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->cx : pItem->cx); rect.bottom = rect.top + (bDialogEx ? ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->cy : pItem->cy); // Convert from dialog units to screen units MapDialogRect(&rect); // Create AxWindow with a NULL caption. wnd.Create(m_hWnd, &rect, NULL, (bDialogEx ? ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->style : pItem->style) | WS_TABSTOP, bDialogEx ? ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->exStyle : 0, bDialogEx ? ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->id : pItem->id, NULL); if (wnd != NULL) { #ifndef _WIN32_WCE // Set the Help ID if (bDialogEx && ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->helpID != 0) wnd.SetWindowContextHelpId(((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->helpID); #endif // !_WIN32_WCE // Try to create the ActiveX control. hr = wnd.CreateControlLic(pszClassName, spStream, NULL, bstrLicKey); if (FAILED(hr)) break; // Set the correct tab position. if (nItem == 0) hWndPrev = HWND_TOP; wnd.SetWindowPos(hWndPrev, 0,0,0,0,SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE); hWndPrev = wnd; } else { hr = ATL::AtlHresultFromLastError(); } } } else { if (nItem != 0) hWndPrev = ::GetWindow(hWndPrev, GW_HWNDNEXT); } pItem = ATL::_DialogSplitHelper::FindNextDlgItem(pItem, bDialogEx); } } else hr = ATL::AtlHresultFromLastError(); } else hr = ATL::AtlHresultFromLastError(); } return hr; } // Event handling support HRESULT AdviseSinkMap(bool bAdvise) { if(!bAdvise && m_hWnd == NULL) { // window is gone, controls are already unadvised ATLTRACE2(atlTraceUI, 0, _T("CAxPropertyPageImpl::AdviseSinkMap called after the window was destroyed\n")); return S_OK; } HRESULT hRet = E_NOTIMPL; __if_exists(T::_GetSinkMapFinder) { T* pT = static_cast(this); hRet = AtlAdviseSinkMap(pT, bAdvise); } return hRet; } // Message map and handlers typedef CPropertyPageImpl< T, TBase> _baseClass; BEGIN_MSG_MAP(CAxPropertyPageImpl) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) MESSAGE_HANDLER(WM_DESTROY, OnDestroy) CHAIN_MSG_MAP(_baseClass) END_MSG_MAP() LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) { // initialize controls in dialog with DLGINIT resource section ExecuteDlgInit(static_cast(this)->IDD); AdviseSinkMap(true); bHandled = FALSE; return 1; } LRESULT OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) { AdviseSinkMap(false); bHandled = FALSE; return 1; } #endif // (_ATL_VER >= 0x0700) }; // for non-customized pages template class CAxPropertyPage : public CAxPropertyPageImpl > { public: enum { IDD = t_wDlgTemplateID }; CAxPropertyPage(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : CAxPropertyPageImpl(title) { } #if (_WIN32_IE >= 0x0500) || (_ATL_VER >= 0x0700) // not empty so we handle accelerators/create controls BEGIN_MSG_MAP(CAxPropertyPage) CHAIN_MSG_MAP(CAxPropertyPageImpl >) END_MSG_MAP() #else // !((_WIN32_IE >= 0x0500) || (_ATL_VER >= 0x0700)) DECLARE_EMPTY_MSG_MAP() #endif // !((_WIN32_IE >= 0x0500) || (_ATL_VER >= 0x0700)) }; #endif // _ATL_NO_HOSTING /////////////////////////////////////////////////////////////////////////////// // Wizard97 Support #if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE) // Sample wizard dialog resources: // // IDD_WIZ97_INTERIOR_BLANK DIALOG 0, 0, 317, 143 // STYLE DS_SETFONT | WS_CHILD | WS_DISABLED | WS_CAPTION // CAPTION "Wizard97 Property Page - Interior" // FONT 8, "MS Shell Dlg" // BEGIN // END // // IDD_WIZ97_EXTERIOR_BLANK DIALOGEX 0, 0, 317, 193 // STYLE DS_SETFONT | DS_FIXEDSYS | WS_CHILD | WS_DISABLED | WS_CAPTION // CAPTION "Wizard97 Property Page - Welcome/Complete" // FONT 8, "MS Shell Dlg", 0, 0, 0x0 // BEGIN // LTEXT "Welcome to the X Wizard",IDC_WIZ97_EXTERIOR_TITLE,115,8, // 195,24 // LTEXT "Wizard Explanation\r\n(The height of the static text should be in multiples of 8 dlus)", // IDC_STATIC,115,40,195,16 // LTEXT "h",IDC_WIZ97_BULLET1,118,64,8,8 // LTEXT "List Item 1 (the h is turned into a bullet)",IDC_STATIC, // 127,63,122,8 // LTEXT "h",IDC_WIZ97_BULLET2,118,79,8,8 // LTEXT "List Item 2. Keep 7 dlus between paragraphs",IDC_STATIC, // 127,78,33,8 // CONTROL "&Do not show this Welcome page again", // IDC_WIZ97_WELCOME_NOTAGAIN,"Button",BS_AUTOCHECKBOX | // WS_TABSTOP,115,169,138,10 // END // // GUIDELINES DESIGNINFO // BEGIN // IDD_WIZ97_INTERIOR_BLANK, DIALOG // BEGIN // LEFTMARGIN, 7 // RIGHTMARGIN, 310 // VERTGUIDE, 21 // VERTGUIDE, 31 // VERTGUIDE, 286 // VERTGUIDE, 296 // TOPMARGIN, 7 // BOTTOMMARGIN, 136 // HORZGUIDE, 8 // END // // IDD_WIZ97_EXTERIOR_BLANK, DIALOG // BEGIN // RIGHTMARGIN, 310 // VERTGUIDE, 115 // VERTGUIDE, 118 // VERTGUIDE, 127 // TOPMARGIN, 7 // BOTTOMMARGIN, 186 // HORZGUIDE, 8 // HORZGUIDE, 32 // HORZGUIDE, 40 // HORZGUIDE, 169 // END // END /////////////////////////////////////////////////////////////////////////////// // CWizard97SheetWindow - client side for a Wizard 97 style wizard sheet class CWizard97SheetWindow : public CPropertySheetWindow { public: // Constructors CWizard97SheetWindow(HWND hWnd = NULL) : CPropertySheetWindow(hWnd) { } CWizard97SheetWindow& operator =(HWND hWnd) { m_hWnd = hWnd; return *this; } // Operations HFONT GetExteriorPageTitleFont(void) { ATLASSERT(::IsWindow(m_hWnd)); return (HFONT)::SendMessage(m_hWnd, GetMessage_GetExteriorPageTitleFont(), 0, 0L); } HFONT GetBulletFont(void) { ATLASSERT(::IsWindow(m_hWnd)); return (HFONT)::SendMessage(m_hWnd, GetMessage_GetBulletFont(), 0, 0L); } // Helpers static UINT GetMessage_GetExteriorPageTitleFont() { static UINT uGetExteriorPageTitleFont = 0; if(uGetExteriorPageTitleFont == 0) { CStaticDataInitCriticalSectionLock lock; if(FAILED(lock.Lock())) { ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CWizard97SheetWindow::GetMessage_GetExteriorPageTitleFont().\n")); ATLASSERT(FALSE); return 0; } if(uGetExteriorPageTitleFont == 0) uGetExteriorPageTitleFont = ::RegisterWindowMessage(_T("GetExteriorPageTitleFont_531AF056-B8BE-4c4c-B786-AC608DF0DF12")); lock.Unlock(); } ATLASSERT(uGetExteriorPageTitleFont != 0); return uGetExteriorPageTitleFont; } static UINT GetMessage_GetBulletFont() { static UINT uGetBulletFont = 0; if(uGetBulletFont == 0) { CStaticDataInitCriticalSectionLock lock; if(FAILED(lock.Lock())) { ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CWizard97SheetWindow::GetMessage_GetBulletFont().\n")); ATLASSERT(FALSE); return 0; } if(uGetBulletFont == 0) uGetBulletFont = ::RegisterWindowMessage(_T("GetBulletFont_AD347D08-8F65-45ef-982E-6352E8218AD5")); lock.Unlock(); } ATLASSERT(uGetBulletFont != 0); return uGetBulletFont; } // Implementation - override to prevent usage HWND Create(LPCTSTR, HWND, ATL::_U_RECT = NULL, LPCTSTR = NULL, DWORD = 0, DWORD = 0, ATL::_U_MENUorID = 0U, LPVOID = NULL) { ATLASSERT(FALSE); return NULL; } }; /////////////////////////////////////////////////////////////////////////////// // CWizard97SheetImpl - implements a Wizard 97 style wizard sheet template class ATL_NO_VTABLE CWizard97SheetImpl : public CPropertySheetImpl< T, TBase > { protected: // Typedefs typedef CWizard97SheetImpl< T, TBase > thisClass; typedef CPropertySheetImpl< T, TBase > baseClass; // Member variables CFont m_fontExteriorPageTitle; // Welcome and Completion page title font CFont m_fontBullet; // Bullet font (used on static text 'h' to produce a small bullet) bool m_bReceivedFirstSizeMessage; public: CWizard97SheetImpl(ATL::_U_STRINGorID title, ATL::_U_STRINGorID headerBitmap, ATL::_U_STRINGorID watermarkBitmap, UINT uStartPage = 0, HWND hWndParent = NULL) : baseClass(title, uStartPage, hWndParent), m_bReceivedFirstSizeMessage(false) { m_psh.dwFlags &= ~(PSH_NOCONTEXTHELP); m_psh.dwFlags &= ~(PSH_WIZARD | PSH_WIZARD_LITE); m_psh.dwFlags |= (PSH_HASHELP | PSH_WIZARDCONTEXTHELP); m_psh.dwFlags |= PSH_WIZARD97; baseClass::SetHeader(headerBitmap.m_lpstr); baseClass::SetWatermark(watermarkBitmap.m_lpstr); } // Overrides from base class void OnSheetInitialized() { T* pT = static_cast(this); pT->_InitializeFonts(); // We'd like to center the wizard here, but its too early. // Instead, we'll do CenterWindow upon our first WM_SIZE message } // Initialization void _InitializeFonts() { // Setup the Title and Bullet Font // (Property pages can send the "get external page title font" and "get bullet font" messages) // The derived class needs to do the actual SetFont for the dialog items) CFontHandle fontThisDialog = this->GetFont(); CClientDC dcScreen(NULL); LOGFONT titleLogFont = {0}; LOGFONT bulletLogFont = {0}; fontThisDialog.GetLogFont(&titleLogFont); fontThisDialog.GetLogFont(&bulletLogFont); // The Wizard 97 Spec recommends to do the Title Font // as Verdana Bold, 12pt. titleLogFont.lfCharSet = DEFAULT_CHARSET; titleLogFont.lfWeight = FW_BOLD; SecureHelper::strcpy_x(titleLogFont.lfFaceName, _countof(titleLogFont.lfFaceName), _T("Verdana Bold")); INT titleFontPointSize = 12; titleLogFont.lfHeight = -::MulDiv(titleFontPointSize, dcScreen.GetDeviceCaps(LOGPIXELSY), 72); m_fontExteriorPageTitle.CreateFontIndirect(&titleLogFont); // The Wizard 97 Spec recommends to do Bullets by having // static text of "h" in the Marlett font. bulletLogFont.lfCharSet = DEFAULT_CHARSET; bulletLogFont.lfWeight = FW_NORMAL; SecureHelper::strcpy_x(bulletLogFont.lfFaceName, _countof(bulletLogFont.lfFaceName), _T("Marlett")); INT bulletFontSize = 8; bulletLogFont.lfHeight = -::MulDiv(bulletFontSize, dcScreen.GetDeviceCaps(LOGPIXELSY), 72); m_fontBullet.CreateFontIndirect(&bulletLogFont); } // Message Handling BEGIN_MSG_MAP(thisClass) MESSAGE_HANDLER(CWizard97SheetWindow::GetMessage_GetExteriorPageTitleFont(), OnGetExteriorPageTitleFont) MESSAGE_HANDLER(CWizard97SheetWindow::GetMessage_GetBulletFont(), OnGetBulletFont) MESSAGE_HANDLER(WM_SIZE, OnSize) CHAIN_MSG_MAP(baseClass) END_MSG_MAP() LRESULT OnGetExteriorPageTitleFont(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) { return (LRESULT)(HFONT)m_fontExteriorPageTitle; } LRESULT OnGetBulletFont(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) { return (LRESULT)(HFONT)m_fontBullet; } LRESULT OnSize(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) { if(!m_bReceivedFirstSizeMessage) { m_bReceivedFirstSizeMessage = true; this->CenterWindow(); } bHandled = FALSE; return 0; } }; // for non-customized sheets class CWizard97Sheet : public CWizard97SheetImpl { protected: // Typedefs typedef CWizard97Sheet thisClass; typedef CWizard97SheetImpl baseClass; public: CWizard97Sheet(ATL::_U_STRINGorID title, ATL::_U_STRINGorID headerBitmap, ATL::_U_STRINGorID watermarkBitmap, UINT uStartPage = 0, HWND hWndParent = NULL) : baseClass(title, headerBitmap, watermarkBitmap, uStartPage, hWndParent) { } BEGIN_MSG_MAP(thisClass) CHAIN_MSG_MAP(baseClass) END_MSG_MAP() }; /////////////////////////////////////////////////////////////////////////////// // CWizard97PageWindow - client side for a Wizard 97 style wizard page #define WIZARD97_EXTERIOR_CXDLG 317 #define WIZARD97_EXTERIOR_CYDLG 193 #define WIZARD97_INTERIOR_CXDLG 317 #define WIZARD97_INTERIOR_CYDLG 143 class CWizard97PageWindow : public CPropertyPageWindow { public: // Constructors CWizard97PageWindow(HWND hWnd = NULL) : CPropertyPageWindow(hWnd) { } CWizard97PageWindow& operator =(HWND hWnd) { m_hWnd = hWnd; return *this; } // Attributes CWizard97SheetWindow GetPropertySheet() const { ATLASSERT(::IsWindow(m_hWnd)); return CWizard97SheetWindow(GetParent()); } // Operations HFONT GetExteriorPageTitleFont(void) { ATLASSERT(::IsWindow(m_hWnd)); return GetPropertySheet().GetExteriorPageTitleFont(); } HFONT GetBulletFont(void) { ATLASSERT(::IsWindow(m_hWnd)); return GetPropertySheet().GetBulletFont(); } // Implementation - overrides to prevent usage HWND Create(LPCTSTR, HWND, ATL::_U_RECT = NULL, LPCTSTR = NULL, DWORD = 0, DWORD = 0, ATL::_U_MENUorID = 0U, LPVOID = NULL) { ATLASSERT(FALSE); return NULL; } }; /////////////////////////////////////////////////////////////////////////////// // CWizard97PageImpl - implements a Wizard 97 style wizard page template class ATL_NO_VTABLE CWizard97PageImpl : public CPropertyPageImpl< T, TBase > { protected: // Typedefs typedef CWizard97PageImpl< T, TBase > thisClass; typedef CPropertyPageImpl< T, TBase > baseClass; public: CWizard97PageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : baseClass(title) { } // Message Handling BEGIN_MSG_MAP(thisClass) CHAIN_MSG_MAP(baseClass) END_MSG_MAP() }; /////////////////////////////////////////////////////////////////////////////// // CWizard97ExteriorPageImpl - implements a Wizard 97 style exterior wizard page template class ATL_NO_VTABLE CWizard97ExteriorPageImpl : public CPropertyPageImpl< T, TBase > { protected: // Typedefs typedef CWizard97ExteriorPageImpl< T, TBase > thisClass; typedef CPropertyPageImpl< T, TBase > baseClass; public: // Constructors CWizard97ExteriorPageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : baseClass(title) { m_psp.dwFlags |= PSP_HASHELP; m_psp.dwFlags |= PSP_HIDEHEADER; } // Message Handling BEGIN_MSG_MAP(thisClass) CHAIN_MSG_MAP(baseClass) END_MSG_MAP() }; /////////////////////////////////////////////////////////////////////////////// // CWizard97InteriorPageImpl - implements a Wizard 97 style interior wizard page template class ATL_NO_VTABLE CWizard97InteriorPageImpl : public CPropertyPageImpl< T, TBase > { protected: // Typedefs typedef CWizard97InteriorPageImpl< T, TBase > thisClass; typedef CPropertyPageImpl< T, TBase > baseClass; public: // Constructors CWizard97InteriorPageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : baseClass(title) { m_psp.dwFlags |= PSP_HASHELP; m_psp.dwFlags &= ~PSP_HIDEHEADER; m_psp.dwFlags |= PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE; // Be sure to have the derived class define this in the constructor. // We'll default it to something obvious in case its forgotten. baseClass::SetHeaderTitle(_T("Call SetHeaderTitle in Derived Class")); baseClass::SetHeaderSubTitle(_T("Call SetHeaderSubTitle in the constructor of the Derived Class.")); } // Message Handling BEGIN_MSG_MAP(thisClass) CHAIN_MSG_MAP(baseClass) END_MSG_MAP() }; #endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE) /////////////////////////////////////////////////////////////////////////////// // Aero Wizard support #if (_WIN32_WINNT >= 0x0600) && !defined(_WIN32_WCE) /////////////////////////////////////////////////////////////////////////////// // CAeroWizardFrameWindow - client side for an Aero Wizard frame window class CAeroWizardFrameWindow : public CPropertySheetWindow { public: // Constructors CAeroWizardFrameWindow(HWND hWnd = NULL) : CPropertySheetWindow(hWnd) { } CAeroWizardFrameWindow& operator =(HWND hWnd) { m_hWnd = hWnd; return *this; } // Operations - new, Aero Wizard only void SetNextText(LPCWSTR lpszText) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, PSM_SETNEXTTEXT, 0, (LPARAM)lpszText); } void ShowWizardButtons(DWORD dwButtons, DWORD dwStates) { ATLASSERT(::IsWindow(m_hWnd)); ::PostMessage(m_hWnd, PSM_SHOWWIZBUTTONS, (WPARAM)dwStates, (LPARAM)dwButtons); } void EnableWizardButtons(DWORD dwButtons, DWORD dwStates) { ATLASSERT(::IsWindow(m_hWnd)); ::PostMessage(m_hWnd, PSM_ENABLEWIZBUTTONS, (WPARAM)dwStates, (LPARAM)dwButtons); } void SetButtonText(DWORD dwButton, LPCWSTR lpszText) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, PSM_SETBUTTONTEXT, (WPARAM)dwButton, (LPARAM)lpszText); } }; /////////////////////////////////////////////////////////////////////////////// // CAeroWizardFrameImpl - implements an Aero Wizard frame template class ATL_NO_VTABLE CAeroWizardFrameImpl : public CPropertySheetImpl { public: // Constructor CAeroWizardFrameImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL, UINT uStartPage = 0, HWND hWndParent = NULL) : CPropertySheetImpl(title, uStartPage, hWndParent) { m_psh.dwFlags |= PSH_WIZARD | PSH_AEROWIZARD; } // Operations void EnableResizing() { ATLASSERT(m_hWnd == NULL); // can't do this after it's created m_psh.dwFlags |= PSH_RESIZABLE; } void UseHeaderBitmap() { ATLASSERT(m_hWnd == NULL); // can't do this after it's created m_psh.dwFlags |= PSH_HEADERBITMAP; } void SetNoMargin() { ATLASSERT(m_hWnd == NULL); // can't do this after it's created m_psh.dwFlags |= PSH_NOMARGIN; } // Override to prevent use HWND Create(HWND /*hWndParent*/ = NULL) { ATLASSERT(FALSE); // not supported for Aero Wizard return NULL; } }; /////////////////////////////////////////////////////////////////////////////// // CAeroWizardFrame - for non-customized frames class CAeroWizardFrame : public CAeroWizardFrameImpl { public: CAeroWizardFrame(ATL::_U_STRINGorID title = (LPCTSTR)NULL, UINT uStartPage = 0, HWND hWndParent = NULL) : CAeroWizardFrameImpl(title, uStartPage, hWndParent) { } BEGIN_MSG_MAP(CAeroWizardFrame) MESSAGE_HANDLER(WM_COMMAND, CAeroWizardFrameImpl::OnCommand) END_MSG_MAP() }; /////////////////////////////////////////////////////////////////////////////// // CAeroWizardPageWindow - client side for an Aero Wizard page class CAeroWizardPageWindow : public CPropertyPageWindow { public: // Constructors CAeroWizardPageWindow(HWND hWnd = NULL) : CPropertyPageWindow(hWnd) { } CAeroWizardPageWindow& operator =(HWND hWnd) { m_hWnd = hWnd; return *this; } // Attributes CAeroWizardFrameWindow GetAeroWizardFrame() const { ATLASSERT(::IsWindow(m_hWnd)); // This is not really top-level frame window, but it processes all frame messages return CAeroWizardFrameWindow(GetParent()); } // Operations - new, Aero Wizard only void SetNextText(LPCWSTR lpszText) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(GetParent() != NULL); GetAeroWizardFrame().SetNextText(lpszText); } void ShowWizardButtons(DWORD dwButtons, DWORD dwStates) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(GetParent() != NULL); GetAeroWizardFrame().ShowWizardButtons(dwButtons, dwStates); } void EnableWizardButtons(DWORD dwButtons, DWORD dwStates) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(GetParent() != NULL); GetAeroWizardFrame().EnableWizardButtons(dwButtons, dwStates); } void SetButtonText(DWORD dwButton, LPCWSTR lpszText) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(GetParent() != NULL); GetAeroWizardFrame().SetButtonText(dwButton, lpszText); } }; /////////////////////////////////////////////////////////////////////////////// // CAeroWizardPageImpl - implements an Aero Wizard page template class ATL_NO_VTABLE CAeroWizardPageImpl : public CPropertyPageImpl { public: CAeroWizardPageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : CPropertyPageImpl(title) { } }; /////////////////////////////////////////////////////////////////////////////// // CAeroWizardPage - for non-customized pages template class CAeroWizardPage : public CAeroWizardPageImpl > { public: enum { IDD = t_wDlgTemplateID }; CAeroWizardPage(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : CAeroWizardPageImpl(title) { } DECLARE_EMPTY_MSG_MAP() }; #ifndef _ATL_NO_HOSTING // Note: You must #include to use these classes /////////////////////////////////////////////////////////////////////////////// // CAeroWizardAxPageImpl - Aero Wizard page that hosts ActiveX controls template class ATL_NO_VTABLE CAeroWizardAxPageImpl : public CAxPropertyPageImpl< T, TBase > { public: CAeroWizardAxPageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : CAxPropertyPageImpl< T, TBase >(title) { } }; /////////////////////////////////////////////////////////////////////////////// // CAeroWizardAxPage - for non-customized pages template class CAeroWizardAxPage : public CAeroWizardAxPageImpl > { public: enum { IDD = t_wDlgTemplateID }; CAeroWizardAxPage(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : CAeroWizardAxPageImpl(title) { } #if (_WIN32_IE >= 0x0500) || (_ATL_VER >= 0x0700) // not empty so we handle accelerators/create controls BEGIN_MSG_MAP(CAeroWizardAxPage) CHAIN_MSG_MAP(CAeroWizardAxPageImpl >) END_MSG_MAP() #else // !((_WIN32_IE >= 0x0500) || (_ATL_VER >= 0x0700)) DECLARE_EMPTY_MSG_MAP() #endif // !((_WIN32_IE >= 0x0500) || (_ATL_VER >= 0x0700)) }; #endif // _ATL_NO_HOSTING #endif // (_WIN32_WINNT >= 0x0600) && !defined(_WIN32_WCE) /////////////////////////////////////////////////////////////////////////////// // TaskDialog support #if ((_WIN32_WINNT >= 0x0600) || defined(_WTL_TASKDIALOG)) && !defined(_WIN32_WCE) /////////////////////////////////////////////////////////////////////////////// // AtlTaskDialog - support for TaskDialog() function inline int AtlTaskDialog(HWND hWndParent, ATL::_U_STRINGorID WindowTitle, ATL::_U_STRINGorID MainInstructionText, ATL::_U_STRINGorID ContentText, TASKDIALOG_COMMON_BUTTON_FLAGS dwCommonButtons = 0U, ATL::_U_STRINGorID Icon = (LPCTSTR)NULL) { int nRet = -1; #ifdef _WTL_TASKDIALOG_DIRECT USES_CONVERSION; HRESULT hRet = ::TaskDialog(hWndParent, ModuleHelper::GetResourceInstance(), IS_INTRESOURCE(WindowTitle.m_lpstr) ? (LPCWSTR) WindowTitle.m_lpstr : T2CW(WindowTitle.m_lpstr), IS_INTRESOURCE(MainInstructionText.m_lpstr) ? (LPCWSTR) MainInstructionText.m_lpstr : T2CW(MainInstructionText.m_lpstr), IS_INTRESOURCE(ContentText.m_lpstr) ? (LPCWSTR) ContentText.m_lpstr : T2CW(ContentText.m_lpstr), dwCommonButtons, IS_INTRESOURCE(Icon.m_lpstr) ? (LPCWSTR) Icon.m_lpstr : T2CW(Icon.m_lpstr), &nRet); ATLVERIFY(SUCCEEDED(hRet)); #else // This allows apps to run on older versions of Windows typedef HRESULT (STDAPICALLTYPE *PFN_TaskDialog)(HWND hwndParent, HINSTANCE hInstance, PCWSTR pszWindowTitle, PCWSTR pszMainInstruction, PCWSTR pszContent, TASKDIALOG_COMMON_BUTTON_FLAGS dwCommonButtons, PCWSTR pszIcon, int* pnButton); HMODULE m_hCommCtrlDLL = ::LoadLibrary(_T("comctl32.dll")); if(m_hCommCtrlDLL != NULL) { PFN_TaskDialog pfnTaskDialog = (PFN_TaskDialog)::GetProcAddress(m_hCommCtrlDLL, "TaskDialog"); if(pfnTaskDialog != NULL) { USES_CONVERSION; HRESULT hRet = pfnTaskDialog(hWndParent, ModuleHelper::GetResourceInstance(), IS_INTRESOURCE(WindowTitle.m_lpstr) ? (LPCWSTR) WindowTitle.m_lpstr : T2CW(WindowTitle.m_lpstr), IS_INTRESOURCE(MainInstructionText.m_lpstr) ? (LPCWSTR) MainInstructionText.m_lpstr : T2CW(MainInstructionText.m_lpstr), IS_INTRESOURCE(ContentText.m_lpstr) ? (LPCWSTR) ContentText.m_lpstr : T2CW(ContentText.m_lpstr), dwCommonButtons, IS_INTRESOURCE(Icon.m_lpstr) ? (LPCWSTR) Icon.m_lpstr : T2CW(Icon.m_lpstr), &nRet); ATLVERIFY(SUCCEEDED(hRet)); } ::FreeLibrary(m_hCommCtrlDLL); } #endif return nRet; } /////////////////////////////////////////////////////////////////////////////// // CTaskDialogConfig - TASKDIALOGCONFIG wrapper class CTaskDialogConfig : public TASKDIALOGCONFIG { public: // Constructor CTaskDialogConfig() { Init(); } void Init() { memset(this, 0, sizeof(TASKDIALOGCONFIG)); // initialize structure to 0/NULL this->cbSize = sizeof(TASKDIALOGCONFIG); this->hInstance = ModuleHelper::GetResourceInstance(); } // Operations - setting values // common buttons void SetCommonButtons(TASKDIALOG_COMMON_BUTTON_FLAGS dwCommonButtonsArg) { this->dwCommonButtons = dwCommonButtonsArg; } // window title text void SetWindowTitle(UINT nID) { this->pszWindowTitle = MAKEINTRESOURCEW(nID); } void SetWindowTitle(LPCWSTR lpstrWindowTitle) { this->pszWindowTitle = lpstrWindowTitle; } // main icon void SetMainIcon(HICON hIcon) { this->dwFlags |= TDF_USE_HICON_MAIN; this->hMainIcon = hIcon; } void SetMainIcon(UINT nID) { this->dwFlags &= ~TDF_USE_HICON_MAIN; this->pszMainIcon = MAKEINTRESOURCEW(nID); } void SetMainIcon(LPCWSTR lpstrMainIcon) { this->dwFlags &= ~TDF_USE_HICON_MAIN; this->pszMainIcon = lpstrMainIcon; } // main instruction text void SetMainInstructionText(UINT nID) { this->pszMainInstruction = MAKEINTRESOURCEW(nID); } void SetMainInstructionText(LPCWSTR lpstrMainInstruction) { this->pszMainInstruction = lpstrMainInstruction; } // content text void SetContentText(UINT nID) { this->pszContent = MAKEINTRESOURCEW(nID); } void SetContentText(LPCWSTR lpstrContent) { this->pszContent = lpstrContent; } // buttons void SetButtons(const TASKDIALOG_BUTTON* pButtonsArg, UINT cButtonsArg, int nDefaultButtonArg = 0) { this->pButtons = pButtonsArg; this->cButtons = cButtonsArg; if(nDefaultButtonArg != 0) this->nDefaultButton = nDefaultButtonArg; } void SetDefaultButton(int nDefaultButtonArg) { this->nDefaultButton = nDefaultButtonArg; } // radio buttons void SetRadioButtons(const TASKDIALOG_BUTTON* pRadioButtonsArg, UINT cRadioButtonsArg, int nDefaultRadioButtonArg = 0) { this->pRadioButtons = pRadioButtonsArg; this->cRadioButtons = cRadioButtonsArg; if(nDefaultRadioButtonArg != 0) this->nDefaultRadioButton = nDefaultRadioButtonArg; } void SetDefaultRadioButton(int nDefaultRadioButtonArg) { this->nDefaultRadioButton = nDefaultRadioButtonArg; } // verification text void SetVerificationText(UINT nID) { this->pszVerificationText = MAKEINTRESOURCEW(nID); } void SetVerificationText(LPCWSTR lpstrVerificationText) { this->pszVerificationText = lpstrVerificationText; } // expanded information text void SetExpandedInformationText(UINT nID) { this->pszExpandedInformation = MAKEINTRESOURCEW(nID); } void SetExpandedInformationText(LPCWSTR lpstrExpandedInformation) { this->pszExpandedInformation = lpstrExpandedInformation; } // expanded control text void SetExpandedControlText(UINT nID) { this->pszExpandedControlText = MAKEINTRESOURCEW(nID); } void SetExpandedControlText(LPCWSTR lpstrExpandedControlText) { this->pszExpandedControlText = lpstrExpandedControlText; } // collapsed control text void SetCollapsedControlText(UINT nID) { this->pszCollapsedControlText = MAKEINTRESOURCEW(nID); } void SetCollapsedControlText(LPCWSTR lpstrCollapsedControlText) { this->pszCollapsedControlText = lpstrCollapsedControlText; } // footer icon void SetFooterIcon(HICON hIcon) { this->dwFlags |= TDF_USE_HICON_FOOTER; this->hFooterIcon = hIcon; } void SetFooterIcon(UINT nID) { this->dwFlags &= ~TDF_USE_HICON_FOOTER; this->pszFooterIcon = MAKEINTRESOURCEW(nID); } void SetFooterIcon(LPCWSTR lpstrFooterIcon) { this->dwFlags &= ~TDF_USE_HICON_FOOTER; this->pszFooterIcon = lpstrFooterIcon; } // footer text void SetFooterText(UINT nID) { this->pszFooter = MAKEINTRESOURCEW(nID); } void SetFooterText(LPCWSTR lpstrFooterText) { this->pszFooter = lpstrFooterText; } // width (in DLUs) void SetWidth(UINT cxWidthArg) { this->cxWidth = cxWidthArg; } // modify flags void ModifyFlags(DWORD dwRemove, DWORD dwAdd) { this->dwFlags = (this->dwFlags & ~dwRemove) | dwAdd; } }; /////////////////////////////////////////////////////////////////////////////// // CTaskDialogImpl - implements a Task Dialog template class ATL_NO_VTABLE CTaskDialogImpl { public: CTaskDialogConfig m_tdc; HWND m_hWnd; // used only in callback functions // Constructor CTaskDialogImpl(HWND hWndParent = NULL) : m_hWnd(NULL) { m_tdc.hwndParent = hWndParent; m_tdc.pfCallback = T::TaskDialogCallback; m_tdc.lpCallbackData = (LONG_PTR)static_cast(this); } // Operations HRESULT DoModal(HWND hWndParent = ::GetActiveWindow(), int* pnButton = NULL, int* pnRadioButton = NULL, BOOL* pfVerificationFlagChecked = NULL) { if(m_tdc.hwndParent == NULL) m_tdc.hwndParent = hWndParent; #ifdef _WTL_TASKDIALOG_DIRECT return ::TaskDialogIndirect(&m_tdc, pnButton, pnRadioButton, pfVerificationFlagChecked); #else // This allows apps to run on older versions of Windows typedef HRESULT (STDAPICALLTYPE *PFN_TaskDialogIndirect)(const TASKDIALOGCONFIG* pTaskConfig, int* pnButton, int* pnRadioButton, BOOL* pfVerificationFlagChecked); HRESULT hRet = E_UNEXPECTED; HMODULE m_hCommCtrlDLL = ::LoadLibrary(_T("comctl32.dll")); if(m_hCommCtrlDLL != NULL) { PFN_TaskDialogIndirect pfnTaskDialogIndirect = (PFN_TaskDialogIndirect)::GetProcAddress(m_hCommCtrlDLL, "TaskDialogIndirect"); if(pfnTaskDialogIndirect != NULL) hRet = pfnTaskDialogIndirect(&m_tdc, pnButton, pnRadioButton, pfVerificationFlagChecked); ::FreeLibrary(m_hCommCtrlDLL); } return hRet; #endif } // Operations - setting values of TASKDIALOGCONFIG // common buttons void SetCommonButtons(TASKDIALOG_COMMON_BUTTON_FLAGS dwCommonButtons) { m_tdc.SetCommonButtons(dwCommonButtons); } // window title text void SetWindowTitle(UINT nID) { m_tdc.SetWindowTitle(nID); } void SetWindowTitle(LPCWSTR lpstrWindowTitle) { m_tdc.SetWindowTitle(lpstrWindowTitle); } // main icon void SetMainIcon(HICON hIcon) { m_tdc.SetMainIcon(hIcon); } void SetMainIcon(UINT nID) { m_tdc.SetMainIcon(nID); } void SetMainIcon(LPCWSTR lpstrMainIcon) { m_tdc.SetMainIcon(lpstrMainIcon); } // main instruction text void SetMainInstructionText(UINT nID) { m_tdc.SetMainInstructionText(nID); } void SetMainInstructionText(LPCWSTR lpstrMainInstruction) { m_tdc.SetMainInstructionText(lpstrMainInstruction); } // content text void SetContentText(UINT nID) { m_tdc.SetContentText(nID); } void SetContentText(LPCWSTR lpstrContent) { m_tdc.SetContentText(lpstrContent); } // buttons void SetButtons(const TASKDIALOG_BUTTON* pButtons, UINT cButtons, int nDefaultButton = 0) { m_tdc.SetButtons(pButtons, cButtons, nDefaultButton); } void SetDefaultButton(int nDefaultButton) { m_tdc.SetDefaultButton(nDefaultButton); } // radio buttons void SetRadioButtons(const TASKDIALOG_BUTTON* pRadioButtons, UINT cRadioButtons, int nDefaultRadioButton = 0) { m_tdc.SetRadioButtons(pRadioButtons, cRadioButtons, nDefaultRadioButton); } void SetDefaultRadioButton(int nDefaultRadioButton) { m_tdc.SetDefaultRadioButton(nDefaultRadioButton); } // verification text void SetVerificationText(UINT nID) { m_tdc.SetVerificationText(nID); } void SetVerificationText(LPCWSTR lpstrVerificationText) { m_tdc.SetVerificationText(lpstrVerificationText); } // expanded information text void SetExpandedInformationText(UINT nID) { m_tdc.SetExpandedInformationText(nID); } void SetExpandedInformationText(LPCWSTR lpstrExpandedInformation) { m_tdc.SetExpandedInformationText(lpstrExpandedInformation); } // expanded control text void SetExpandedControlText(UINT nID) { m_tdc.SetExpandedControlText(nID); } void SetExpandedControlText(LPCWSTR lpstrExpandedControlText) { m_tdc.SetExpandedControlText(lpstrExpandedControlText); } // collapsed control text void SetCollapsedControlText(UINT nID) { m_tdc.SetCollapsedControlText(nID); } void SetCollapsedControlText(LPCWSTR lpstrCollapsedControlText) { m_tdc.SetCollapsedControlText(lpstrCollapsedControlText); } // footer icon void SetFooterIcon(HICON hIcon) { m_tdc.SetFooterIcon(hIcon); } void SetFooterIcon(UINT nID) { m_tdc.SetFooterIcon(nID); } void SetFooterIcon(LPCWSTR lpstrFooterIcon) { m_tdc.SetFooterIcon(lpstrFooterIcon); } // footer text void SetFooterText(UINT nID) { m_tdc.SetFooterText(nID); } void SetFooterText(LPCWSTR lpstrFooterText) { m_tdc.SetFooterText(lpstrFooterText); } // width (in DLUs) void SetWidth(UINT cxWidth) { m_tdc.SetWidth(cxWidth); } // modify flags void ModifyFlags(DWORD dwRemove, DWORD dwAdd) { m_tdc.ModifyFlags(dwRemove, dwAdd); } // Implementation static HRESULT CALLBACK TaskDialogCallback(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LONG_PTR lpRefData) { T* pT = (T*)lpRefData; ATLASSERT(pT->m_hWnd == NULL || pT->m_hWnd == hWnd); BOOL bRet = FALSE; switch(uMsg) { case TDN_DIALOG_CONSTRUCTED: pT->m_hWnd = hWnd; pT->OnDialogConstructed(); break; case TDN_CREATED: pT->OnCreated(); break; case TDN_BUTTON_CLICKED: bRet = pT->OnButtonClicked((int)wParam); break; case TDN_RADIO_BUTTON_CLICKED: pT->OnRadioButtonClicked((int)wParam); break; case TDN_HYPERLINK_CLICKED: pT->OnHyperlinkClicked((LPCWSTR)lParam); break; case TDN_EXPANDO_BUTTON_CLICKED: pT->OnExpandoButtonClicked((wParam != 0)); break; case TDN_VERIFICATION_CLICKED: pT->OnVerificationClicked((wParam != 0)); break; case TDN_HELP: pT->OnHelp(); break; case TDN_TIMER: bRet = pT->OnTimer((DWORD)wParam); break; case TDN_NAVIGATED: pT->OnNavigated(); break; case TDN_DESTROYED: pT->OnDestroyed(); pT->m_hWnd = NULL; break; default: ATLTRACE2(atlTraceUI, 0, _T("Unknown notification received in CTaskDialogImpl::TaskDialogCallback\n")); break; } return (bRet != FALSE) ? S_OK : S_FALSE; } // Overrideables - notification handlers void OnDialogConstructed() { } void OnCreated() { } BOOL OnButtonClicked(int /*nButton*/) { return FALSE; // don't prevent dialog to close } void OnRadioButtonClicked(int /*nRadioButton*/) { } void OnHyperlinkClicked(LPCWSTR /*pszHREF*/) { } void OnExpandoButtonClicked(bool /*bExpanded*/) { } void OnVerificationClicked(bool /*bChecked*/) { } void OnHelp() { } BOOL OnTimer(DWORD /*dwTickCount*/) { return FALSE; // don't reset counter } void OnNavigated() { } void OnDestroyed() { } // Commands - valid to call only from handlers void NavigatePage(TASKDIALOGCONFIG& tdc) { ATLASSERT(m_hWnd != NULL); tdc.cbSize = sizeof(TASKDIALOGCONFIG); if(tdc.hwndParent == NULL) tdc.hwndParent = m_tdc.hwndParent; tdc.pfCallback = m_tdc.pfCallback; tdc.lpCallbackData = m_tdc.lpCallbackData; (TASKDIALOGCONFIG)m_tdc = tdc; ::SendMessage(m_hWnd, TDM_NAVIGATE_PAGE, 0, (LPARAM)&tdc); } // modify TASKDIALOGCONFIG values, then call this to update task dialog void NavigatePage() { ATLASSERT(m_hWnd != NULL); ::SendMessage(m_hWnd, TDM_NAVIGATE_PAGE, 0, (LPARAM)&m_tdc); } void ClickButton(int nButton) { ATLASSERT(m_hWnd != NULL); ::SendMessage(m_hWnd, TDM_CLICK_BUTTON, nButton, 0L); } void SetMarqueeProgressBar(BOOL bMarquee) { ATLASSERT(m_hWnd != NULL); ::SendMessage(m_hWnd, TDM_SET_MARQUEE_PROGRESS_BAR, bMarquee, 0L); } BOOL SetProgressBarState(int nNewState) { ATLASSERT(m_hWnd != NULL); return (BOOL)::SendMessage(m_hWnd, TDM_SET_PROGRESS_BAR_STATE, nNewState, 0L); } DWORD SetProgressBarRange(int nMinRange, int nMaxRange) { ATLASSERT(m_hWnd != NULL); return (DWORD)::SendMessage(m_hWnd, TDM_SET_PROGRESS_BAR_RANGE, 0, MAKELPARAM(nMinRange, nMaxRange)); } int SetProgressBarPos(int nNewPos) { ATLASSERT(m_hWnd != NULL); return (int)::SendMessage(m_hWnd, TDM_SET_PROGRESS_BAR_POS, nNewPos, 0L); } BOOL SetProgressBarMarquee(BOOL bMarquee, UINT uSpeed) { ATLASSERT(m_hWnd != NULL); return (BOOL)::SendMessage(m_hWnd, TDM_SET_PROGRESS_BAR_MARQUEE, bMarquee, uSpeed); } void SetElementText(TASKDIALOG_ELEMENTS element, LPCWSTR lpstrText) { ATLASSERT(m_hWnd != NULL); ::SendMessage(m_hWnd, TDM_SET_ELEMENT_TEXT, element, (LPARAM)lpstrText); } void ClickRadioButton(int nRadioButton) { ATLASSERT(m_hWnd != NULL); ::SendMessage(m_hWnd, TDM_CLICK_RADIO_BUTTON, nRadioButton, 0L); } void EnableButton(int nButton, BOOL bEnable) { ATLASSERT(m_hWnd != NULL); ::SendMessage(m_hWnd, TDM_ENABLE_BUTTON, nButton, bEnable); } void EnableRadioButton(int nButton, BOOL bEnable) { ATLASSERT(m_hWnd != NULL); ::SendMessage(m_hWnd, TDM_ENABLE_RADIO_BUTTON, nButton, bEnable); } void ClickVerification(BOOL bCheck, BOOL bFocus) { ATLASSERT(m_hWnd != NULL); ::SendMessage(m_hWnd, TDM_CLICK_VERIFICATION, bCheck, bFocus); } void UpdateElementText(TASKDIALOG_ELEMENTS element, LPCWSTR lpstrText) { ATLASSERT(m_hWnd != NULL); ::SendMessage(m_hWnd, TDM_UPDATE_ELEMENT_TEXT, element, (LPARAM)lpstrText); } void SetButtonElevationRequiredState(int nButton, BOOL bElevation) { ATLASSERT(m_hWnd != NULL); ::SendMessage(m_hWnd, TDM_SET_BUTTON_ELEVATION_REQUIRED_STATE, nButton, bElevation); } void UpdateIcon(TASKDIALOG_ICON_ELEMENTS element, HICON hIcon) { ATLASSERT(m_hWnd != NULL); #ifdef _DEBUG if(element == TDIE_ICON_MAIN) ATLASSERT((m_tdc.dwFlags & TDF_USE_HICON_MAIN) != 0); else if(element == TDIE_ICON_FOOTER) ATLASSERT((m_tdc.dwFlags & TDF_USE_HICON_FOOTER) != 0); #endif // _DEBUG ::SendMessage(m_hWnd, TDM_UPDATE_ICON, element, (LPARAM)hIcon); } void UpdateIcon(TASKDIALOG_ICON_ELEMENTS element, LPCWSTR lpstrIcon) { ATLASSERT(m_hWnd != NULL); #ifdef _DEBUG if(element == TDIE_ICON_MAIN) ATLASSERT((m_tdc.dwFlags & TDF_USE_HICON_MAIN) == 0); else if(element == TDIE_ICON_FOOTER) ATLASSERT((m_tdc.dwFlags & TDF_USE_HICON_FOOTER) == 0); #endif // _DEBUG ::SendMessage(m_hWnd, TDM_UPDATE_ICON, element, (LPARAM)lpstrIcon); } }; /////////////////////////////////////////////////////////////////////////////// // CTaskDialog - for non-customized task dialogs class CTaskDialog : public CTaskDialogImpl { public: CTaskDialog(HWND hWndParent = NULL) : CTaskDialogImpl(hWndParent) { m_tdc.pfCallback = NULL; } }; #endif // ((_WIN32_WINNT >= 0x0600) || defined(_WTL_TASKDIALOG)) && !defined(_WIN32_WCE) }; // namespace WTL #endif // __ATLDLGS_H__