?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add policy_templates target for GN.
[chromium-blink-merge.git] / third_party / wtl / include / atldlgs.h
blob62db9178013cd6e61cf763e11c079f388e20f144
1 // Windows Template Library - WTL version 8.0
2 // Copyright (C) Microsoft Corporation. All rights reserved.
3 //
4 // This file is a part of the Windows Template Library.
5 // The use and distribution terms for this software are covered by the
6 // Microsoft Permissive License (Ms-PL) which can be found in the file
7 // Ms-PL.txt at the root of this distribution.
8
9 #ifndef __ATLDLGS_H__
10 #define __ATLDLGS_H__
11
12 #pragma once
13
14 #ifndef __cplusplus
15 #error ATL requires C++ compilation (use a .cpp suffix)
16 #endif
17
18 #ifndef __ATLAPP_H__
19 #error atldlgs.h requires atlapp.h to be included first
20 #endif
21
22 #ifndef __ATLWIN_H__
23 #error atldlgs.h requires atlwin.h to be included first
24 #endif
25
26 #include <commdlg.h>
27 #include <shlobj.h>
28
29 #if (_WIN32_WINNT >= 0x0600) && !defined(_WIN32_WCE)
30 #include <shobjidl.h>
31 #endif // (_WIN32_WINNT >= 0x0600) && !defined(_WIN32_WCE)
32
33
34 ///////////////////////////////////////////////////////////////////////////////
35 // Classes in this file:
36 //
37 // CFileDialogImpl<T>
38 // CFileDialog
39 // CFileDialogEx
40 // CMultiFileDialogImpl<T>
41 // CMultiFileDialog
42 // CShellFileDialogImpl<T>
43 // CShellFileOpenDialogImpl<T>
44 // CShellFileOpenDialog
45 // CShellFileSaveDialogImpl<T>
46 // CShellFileSaveDialog
47 // CFolderDialogImpl<T>
48 // CFolderDialog
49 // CFontDialogImpl<T>
50 // CFontDialog
51 // CRichEditFontDialogImpl<T>
52 // CRichEditFontDialog
53 // CColorDialogImpl<T>
54 // CColorDialog
55 // CPrintDialogImpl<T>
56 // CPrintDialog
57 // CPrintDialogExImpl<T>
58 // CPrintDialogEx
59 // CPageSetupDialogImpl<T>
60 // CPageSetupDialog
61 // CFindReplaceDialogImpl<T>
62 // CFindReplaceDialog
63 //
64 // CMemDlgTemplate
65 // CIndirectDialogImpl<T, TDlgTemplate, TBase>
66 //
67 // CPropertySheetWindow
68 // CPropertySheetImpl<T, TBase>
69 // CPropertySheet
70 // CPropertyPageWindow
71 // CPropertyPageImpl<T, TBase>
72 // CPropertyPage<t_wDlgTemplateID>
73 // CAxPropertyPageImpl<T, TBase>
74 // CAxPropertyPage<t_wDlgTemplateID>
75 //
76 // CWizard97SheetWindow
77 // CWizard97SheetImpl<T, TBase>
78 // CWizard97Sheet
79 // CWizard97PageWindow
80 // CWizard97PageImpl<T, TBase>
81 // CWizard97ExteriorPageImpl<T, TBase>
82 // CWizard97InteriorPageImpl<T, TBase>
83 //
84 // CAeroWizardFrameWindow
85 // CAeroWizardFrameImpl<T, TBase>
86 // CAeroWizardFrame
87 // CAeroWizardPageWindow
88 // CAeroWizardPageImpl<T, TBase>
89 // CAeroWizardPage<t_wDlgTemplateID>
90 // CAeroWizardAxPageImpl<T, TBase>
91 // CAeroWizardAxPage<t_wDlgTemplateID>
92 //
93 // CTaskDialogConfig
94 // CTaskDialogImpl<T>
95 // CTaskDialog
96 //
97 // Global functions:
98 // AtlTaskDialog()
99
100
101 namespace WTL
102 {
103
104 ///////////////////////////////////////////////////////////////////////////////
105 // CFileDialogImpl - used for File Open or File Save As
106
107 // compatibility with the old (vc6.0) headers
108 #if (_WIN32_WINNT >= 0x0500) && !defined(OPENFILENAME_SIZE_VERSION_400)
109 #ifndef CDSIZEOF_STRUCT
110 #define CDSIZEOF_STRUCT(structname, member) (((int)((LPBYTE)(&((structname*)0)->member) - ((LPBYTE)((structname*)0)))) + sizeof(((structname*)0)->member))
111 #endif
112 #define OPENFILENAME_SIZE_VERSION_400A CDSIZEOF_STRUCT(OPENFILENAMEA,lpTemplateName)
113 #define OPENFILENAME_SIZE_VERSION_400W CDSIZEOF_STRUCT(OPENFILENAMEW,lpTemplateName)
114 #ifdef UNICODE
115 #define OPENFILENAME_SIZE_VERSION_400 OPENFILENAME_SIZE_VERSION_400W
116 #else
117 #define OPENFILENAME_SIZE_VERSION_400 OPENFILENAME_SIZE_VERSION_400A
118 #endif // !UNICODE
119 #endif // (_WIN32_WINNT >= 0x0500) && !defined(OPENFILENAME_SIZE_VERSION_400)
120
121 #if !defined(_WIN32_WCE) && !defined(CDN_INCLUDEITEM)
122 #define CDN_INCLUDEITEM (CDN_FIRST - 0x0007)
123 #endif
124
125 template <class T>
126 class ATL_NO_VTABLE CFileDialogImpl : public ATL::CDialogImplBase
127 {
128 public:
129 #if defined(__AYGSHELL_H__) && (_WIN32_WCE >= 0x0501)
130 OPENFILENAMEEX m_ofn;
131 #else
132 OPENFILENAME m_ofn;
133 #endif
134 BOOL m_bOpenFileDialog; // TRUE for file open, FALSE for file save
135 TCHAR m_szFileTitle[_MAX_FNAME]; // contains file title after return
136 TCHAR m_szFileName[_MAX_PATH]; // contains full path name after return
137
138 CFileDialogImpl(BOOL bOpenFileDialog, // TRUE for FileOpen, FALSE for FileSaveAs
139 LPCTSTR lpszDefExt = NULL,
140 LPCTSTR lpszFileName = NULL,
141 DWORD dwFlags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
142 LPCTSTR lpszFilter = NULL,
143 HWND hWndParent = NULL)
144 {
145 memset(&m_ofn, 0, sizeof(m_ofn)); // initialize structure to 0/NULL
146 m_szFileName[0] = _T('\0');
147 m_szFileTitle[0] = _T('\0');
148
149 m_bOpenFileDialog = bOpenFileDialog;
150
151 m_ofn.lStructSize = sizeof(m_ofn);
152 #if (_WIN32_WINNT >= 0x0500)
153 // adjust struct size if running on older version of Windows
154 if(AtlIsOldWindows())
155 {
156 ATLASSERT(sizeof(m_ofn) > OPENFILENAME_SIZE_VERSION_400); // must be
157 m_ofn.lStructSize = OPENFILENAME_SIZE_VERSION_400;
158 }
159 #endif // (_WIN32_WINNT >= 0x0500)
160 m_ofn.lpstrFile = m_szFileName;
161 m_ofn.nMaxFile = _MAX_PATH;
162 m_ofn.lpstrDefExt = lpszDefExt;
163 m_ofn.lpstrFileTitle = (LPTSTR)m_szFileTitle;
164 m_ofn.nMaxFileTitle = _MAX_FNAME;
165 #ifndef _WIN32_WCE
166 m_ofn.Flags = dwFlags | OFN_EXPLORER | OFN_ENABLEHOOK | OFN_ENABLESIZING;
167 #else // CE specific
168 m_ofn.Flags = dwFlags | OFN_EXPLORER | OFN_ENABLEHOOK;
169 #endif // !_WIN32_WCE
170 m_ofn.lpstrFilter = lpszFilter;
171 m_ofn.hInstance = ModuleHelper::GetResourceInstance();
172 m_ofn.lpfnHook = (LPOFNHOOKPROC)T::StartDialogProc;
173 m_ofn.hwndOwner = hWndParent;
174
175 // setup initial file name
176 if(lpszFileName != NULL)
177 SecureHelper::strncpy_x(m_szFileName, _countof(m_szFileName), lpszFileName, _TRUNCATE);
178 }
179
180 INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow())
181 {
182 ATLASSERT((m_ofn.Flags & OFN_ENABLEHOOK) != 0);
183 ATLASSERT(m_ofn.lpfnHook != NULL); // can still be a user hook
184
185 ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0);
186
187 if(m_ofn.hwndOwner == NULL) // set only if not specified before
188 m_ofn.hwndOwner = hWndParent;
189
190 ATLASSERT(m_hWnd == NULL);
191 ModuleHelper::AddCreateWndData(&m_thunk.cd, (ATL::CDialogImplBase*)this);
192
193 BOOL bRet;
194 if(m_bOpenFileDialog)
195 #if defined(__AYGSHELL_H__) && (_WIN32_WCE >= 0x0501)
196 bRet = ::GetOpenFileNameEx(&m_ofn);
197 else
198 bRet = ::GetSaveFileName((LPOPENFILENAME)&m_ofn);
199 #else
200 bRet = ::GetOpenFileName(&m_ofn);
201 else
202 bRet = ::GetSaveFileName(&m_ofn);
203 #endif
204
205 m_hWnd = NULL;
206
207 return bRet ? IDOK : IDCANCEL;
208 }
209
210 // Attributes
211 ATL::CWindow GetFileDialogWindow() const
212 {
213 ATLASSERT(::IsWindow(m_hWnd));
214 return ATL::CWindow(GetParent());
215 }
216
217 int GetFilePath(LPTSTR lpstrFilePath, int nLength) const
218 {
219 ATLASSERT(::IsWindow(m_hWnd));
220 ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0);
221
222 return (int)GetFileDialogWindow().SendMessage(CDM_GETFILEPATH, nLength, (LPARAM)lpstrFilePath);
223 }
224
225 int GetFolderIDList(LPVOID lpBuff, int nLength) const
226 {
227 ATLASSERT(::IsWindow(m_hWnd));
228 ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0);
229
230 return (int)GetFileDialogWindow().SendMessage(CDM_GETFOLDERIDLIST, nLength, (LPARAM)lpBuff);
231 }
232
233 int GetFolderPath(LPTSTR lpstrFolderPath, int nLength) const
234 {
235 ATLASSERT(::IsWindow(m_hWnd));
236 ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0);
237
238 return (int)GetFileDialogWindow().SendMessage(CDM_GETFOLDERPATH, nLength, (LPARAM)lpstrFolderPath);
239 }
240
241 int GetSpec(LPTSTR lpstrSpec, int nLength) const
242 {
243 ATLASSERT(::IsWindow(m_hWnd));
244 ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0);
245
246 return (int)GetFileDialogWindow().SendMessage(CDM_GETSPEC, nLength, (LPARAM)lpstrSpec);
247 }
248
249 void SetControlText(int nCtrlID, LPCTSTR lpstrText)
250 {
251 ATLASSERT(::IsWindow(m_hWnd));
252 ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0);
253
254 GetFileDialogWindow().SendMessage(CDM_SETCONTROLTEXT, nCtrlID, (LPARAM)lpstrText);
255 }
256
257 void SetDefExt(LPCTSTR lpstrExt)
258 {
259 ATLASSERT(::IsWindow(m_hWnd));
260 ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0);
261
262 GetFileDialogWindow().SendMessage(CDM_SETDEFEXT, 0, (LPARAM)lpstrExt);
263 }
264
265 BOOL GetReadOnlyPref() const // return TRUE if readonly checked
266 {
267 return ((m_ofn.Flags & OFN_READONLY) != 0) ? TRUE : FALSE;
268 }
269
270 // Operations
271 void HideControl(int nCtrlID)
272 {
273 ATLASSERT(::IsWindow(m_hWnd));
274 ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0);
275
276 GetFileDialogWindow().SendMessage(CDM_HIDECONTROL, nCtrlID);
277 }
278
279 // Special override for common dialogs
280 BOOL EndDialog(INT_PTR /*nRetCode*/ = 0)
281 {
282 ATLASSERT(::IsWindow(m_hWnd));
283 GetFileDialogWindow().SendMessage(WM_COMMAND, MAKEWPARAM(IDCANCEL, 0));
284 return TRUE;
285 }
286
287 // Message map and handlers
288 BEGIN_MSG_MAP(CFileDialogImpl)
289 NOTIFY_CODE_HANDLER(CDN_FILEOK, _OnFileOK)
290 NOTIFY_CODE_HANDLER(CDN_FOLDERCHANGE, _OnFolderChange)
291 NOTIFY_CODE_HANDLER(CDN_HELP, _OnHelp)
292 NOTIFY_CODE_HANDLER(CDN_INITDONE, _OnInitDone)
293 NOTIFY_CODE_HANDLER(CDN_SELCHANGE, _OnSelChange)
294 NOTIFY_CODE_HANDLER(CDN_SHAREVIOLATION, _OnShareViolation)
295 NOTIFY_CODE_HANDLER(CDN_TYPECHANGE, _OnTypeChange)
296 #ifndef _WIN32_WCE
297 NOTIFY_CODE_HANDLER(CDN_INCLUDEITEM, _OnIncludeItem)
298 #endif // !_WIN32_WCE
299 END_MSG_MAP()
300
301 LRESULT _OnFileOK(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/)
302 {
303 ATLASSERT(::IsWindow(m_hWnd));
304 T* pT = static_cast<T*>(this);
305 return !pT->OnFileOK((LPOFNOTIFY)pnmh);
306 }
307
308 LRESULT _OnFolderChange(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/)
309 {
310 ATLASSERT(::IsWindow(m_hWnd));
311 T* pT = static_cast<T*>(this);
312 pT->OnFolderChange((LPOFNOTIFY)pnmh);
313 return 0;
314 }
315
316 LRESULT _OnHelp(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/)
317 {
318 ATLASSERT(::IsWindow(m_hWnd));
319 T* pT = static_cast<T*>(this);
320 pT->OnHelp((LPOFNOTIFY)pnmh);
321 return 0;
322 }
323
324 LRESULT _OnInitDone(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/)
325 {
326 ATLASSERT(::IsWindow(m_hWnd));
327 T* pT = static_cast<T*>(this);
328 pT->OnInitDone((LPOFNOTIFY)pnmh);
329 return 0;
330 }
331
332 LRESULT _OnSelChange(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/)
333 {
334 ATLASSERT(::IsWindow(m_hWnd));
335 T* pT = static_cast<T*>(this);
336 pT->OnSelChange((LPOFNOTIFY)pnmh);
337 return 0;
338 }
339
340 LRESULT _OnShareViolation(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/)
341 {
342 ATLASSERT(::IsWindow(m_hWnd));
343 T* pT = static_cast<T*>(this);
344 return pT->OnShareViolation((LPOFNOTIFY)pnmh);
345 }
346
347 LRESULT _OnTypeChange(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/)
348 {
349 ATLASSERT(::IsWindow(m_hWnd));
350 T* pT = static_cast<T*>(this);
351 pT->OnTypeChange((LPOFNOTIFY)pnmh);
352 return 0;
353 }
354
355 #ifndef _WIN32_WCE
356 LRESULT _OnIncludeItem(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/)
357 {
358 ATLASSERT(::IsWindow(m_hWnd));
359 T* pT = static_cast<T*>(this);
360 return pT->OnIncludeItem((LPOFNOTIFYEX)pnmh);
361 }
362 #endif // !_WIN32_WCE
363
364 // Overrideables
365 BOOL OnFileOK(LPOFNOTIFY /*lpon*/)
366 {
367 return TRUE;
368 }
369
370 void OnFolderChange(LPOFNOTIFY /*lpon*/)
371 {
372 }
373
374 void OnHelp(LPOFNOTIFY /*lpon*/)
375 {
376 }
377
378 void OnInitDone(LPOFNOTIFY /*lpon*/)
379 {
380 }
381
382 void OnSelChange(LPOFNOTIFY /*lpon*/)
383 {
384 }
385
386 int OnShareViolation(LPOFNOTIFY /*lpon*/)
387 {
388 return 0;
389 }
390
391 void OnTypeChange(LPOFNOTIFY /*lpon*/)
392 {
393 }
394
395 #ifndef _WIN32_WCE
396 BOOL OnIncludeItem(LPOFNOTIFYEX /*lponex*/)
397 {
398 return TRUE; // include item
399 }
400 #endif // !_WIN32_WCE
401 };
402
403 class CFileDialog : public CFileDialogImpl<CFileDialog>
404 {
405 public:
406 CFileDialog(BOOL bOpenFileDialog, // TRUE for FileOpen, FALSE for FileSaveAs
407 LPCTSTR lpszDefExt = NULL,
408 LPCTSTR lpszFileName = NULL,
409 DWORD dwFlags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
410 LPCTSTR lpszFilter = NULL,
411 HWND hWndParent = NULL)
412 : CFileDialogImpl<CFileDialog>(bOpenFileDialog, lpszDefExt, lpszFileName, dwFlags, lpszFilter, hWndParent)
413 { }
414
415 // override base class map and references to handlers
416 DECLARE_EMPTY_MSG_MAP()
417 };
418
419 #if defined(__AYGSHELL_H__) && (_WIN32_WCE >= 0x0501)
420 class CFileDialogEx : public CFileDialogImpl<CFileDialogEx>
421 {
422 public:
423 CFileDialogEx( // Supports only FileOpen
424 LPCTSTR lpszDefExt = NULL,
425 LPCTSTR lpszFileName = NULL,
426 DWORD dwFlags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
427 OFN_EXFLAG ExFlags = OFN_EXFLAG_THUMBNAILVIEW,
428 OFN_SORTORDER dwSortOrder = OFN_SORTORDER_AUTO,
429 LPCTSTR lpszFilter = NULL,
430 HWND hWndParent = NULL)
431 : CFileDialogImpl<CFileDialogEx>(TRUE, lpszDefExt, lpszFileName, dwFlags, lpszFilter, hWndParent)
432 {
433 m_ofn.ExFlags = ExFlags;
434 m_ofn.dwSortOrder = dwSortOrder;
435 }
436
437 // override base class map and references to handlers
438 DECLARE_EMPTY_MSG_MAP()
439 };
440 #endif // defined(__AYGSHELL_H__) && (_WIN32_WCE >= 0x0501)
441
442
443 ///////////////////////////////////////////////////////////////////////////////
444 // Multi File Dialog - Multi-select File Open dialog
445
446 #ifndef _WIN32_WCE
447
448 // The class dynamically resizes the buffer as the file selection changes
449 // (as described in Knowledge Base article 131462). It also expands selected
450 // shortcut files to take into account the full path of the target file.
451 // Note that this doesn't work on Win9x for the old style dialogs, as well as
452 // on NT for non-Unicode builds.
453
454 #ifndef _WTL_FIXED_OFN_BUFFER_LENGTH
455 #define _WTL_FIXED_OFN_BUFFER_LENGTH 0x10000
456 #endif
457
458 template <class T>
459 class ATL_NO_VTABLE CMultiFileDialogImpl : public CFileDialogImpl< T >
460 {
461 public:
462 mutable LPCTSTR m_pNextFile;
463 #ifndef _UNICODE
464 bool m_bIsNT;
465 #endif
466
467 CMultiFileDialogImpl(
468 LPCTSTR lpszDefExt = NULL,
469 LPCTSTR lpszFileName = NULL,
470 DWORD dwFlags = OFN_HIDEREADONLY,
471 LPCTSTR lpszFilter = NULL,
472 HWND hWndParent = NULL)
473 : CFileDialogImpl<T>(TRUE, lpszDefExt, lpszFileName, dwFlags, lpszFilter, hWndParent),
474 m_pNextFile(NULL)
475 {
476 m_ofn.Flags |= OFN_ALLOWMULTISELECT; // Force multiple selection mode
477
478 #ifndef _UNICODE
479 OSVERSIONINFO ovi = { sizeof(ovi) };
480 ::GetVersionEx(&ovi);
481 m_bIsNT = (ovi.dwPlatformId == VER_PLATFORM_WIN32_NT);
482 if (m_bIsNT)
483 {
484 // On NT platforms, GetOpenFileNameA thunks to GetOpenFileNameW and there
485 // is absolutely nothing we can do except to start off with a large buffer.
486 ATLVERIFY(ResizeFilenameBuffer(_WTL_FIXED_OFN_BUFFER_LENGTH));
487 }
488 #endif
489 }
490
491 ~CMultiFileDialogImpl()
492 {
493 if (m_ofn.lpstrFile != m_szFileName) // Free the buffer if we allocated it
494 delete[] m_ofn.lpstrFile;
495 }
496
497 // Operations
498 // Get the directory that the files were chosen from.
499 // The function returns the number of characters copied, not including the terminating zero.
500 // If the buffer is NULL, the function returns the required size, in characters, including the terminating zero.
501 // If the function fails, the return value is zero.
502 int GetDirectory(LPTSTR pBuffer, int nBufLen) const
503 {
504 if (m_ofn.lpstrFile == NULL)
505 return 0;
506
507 LPCTSTR pStr = m_ofn.lpstrFile;
508 int nLength = lstrlen(pStr);
509 if (pStr[nLength + 1] == 0)
510 {
511 // The OFN buffer contains a single item so extract its path.
512 LPCTSTR pSep = _strrchr(pStr, _T('\\'));
513 if (pSep != NULL)
514 nLength = (int)(DWORD_PTR)(pSep - pStr);
515 }
516
517 int nRet = 0;
518 if (pBuffer == NULL) // If the buffer is NULL, return the required length
519 {
520 nRet = nLength + 1;
521 }
522 else if (nBufLen > nLength)
523 {
524 SecureHelper::strncpy_x(pBuffer, nBufLen, pStr, nLength);
525 nRet = nLength;
526 }
527
528 return nRet;
529 }
530
531 #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
532 bool GetDirectory(_CSTRING_NS::CString& strDir) const
533 {
534 bool bRet = false;
535
536 int nLength = GetDirectory(NULL, 0);
537 if (nLength > 0)
538 {
539 bRet = (GetDirectory(strDir.GetBuffer(nLength), nLength) > 0);
540 strDir.ReleaseBuffer(nLength - 1);
541 }
542
543 return bRet;
544 }
545 #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
546
547 // Get the first filename as a pointer into the buffer.
548 LPCTSTR GetFirstFileName() const
549 {
550 if (m_ofn.lpstrFile == NULL)
551 return NULL;
552
553 m_pNextFile = NULL; // Reset internal buffer pointer
554
555 LPCTSTR pStr = m_ofn.lpstrFile;
556 int nLength = lstrlen(pStr);
557 if (pStr[nLength + 1] != 0)
558 {
559 // Multiple items were selected. The first string is the directory,
560 // so skip forwards to the second string.
561 pStr += nLength + 1;
562
563 // Set up m_pNext so it points to the second item (or null).
564 m_pNextFile = pStr;
565 GetNextFileName();
566 }
567 else
568 {
569 // A single item was selected. Skip forward past the path.
570 LPCTSTR pSep = _strrchr(pStr, _T('\\'));
571 if (pSep != NULL)
572 pStr = pSep + 1;
573 }
574
575 return pStr;
576 }
577
578 // Get the next filename as a pointer into the buffer.
579 LPCTSTR GetNextFileName() const
580 {
581 if (m_pNextFile == NULL)
582 return NULL;
583
584 LPCTSTR pStr = m_pNextFile;
585 // Set "m_pNextFile" to point to the next file name, or null if we
586 // have reached the last file in the list.
587 int nLength = lstrlen(pStr);
588 m_pNextFile = (pStr[nLength + 1] != 0) ? &pStr[nLength + 1] : NULL;
589
590 return pStr;
591 }
592
593 // Get the first filename as a full path.
594 // The function returns the number of characters copied, not including the terminating zero.
595 // If the buffer is NULL, the function returns the required size, in characters, including the terminating zero.
596 // If the function fails, the return value is zero.
597 int GetFirstPathName(LPTSTR pBuffer, int nBufLen) const
598 {
599 LPCTSTR pStr = GetFirstFileName();
600 int nLengthDir = GetDirectory(NULL, 0);
601 if((pStr == NULL) || (nLengthDir == 0))
602 return 0;
603
604 // Figure out the required length.
605 int nLengthTotal = nLengthDir + lstrlen(pStr);
606
607 int nRet = 0;
608 if(pBuffer == NULL) // If the buffer is NULL, return the required length
609 {
610 nRet = nLengthTotal + 1;
611 }
612 else if (nBufLen > nLengthTotal) // If the buffer is big enough, go ahead and construct the path
613 {
614 GetDirectory(pBuffer, nBufLen);
615 SecureHelper::strcat_x(pBuffer, nBufLen, _T("\\"));
616 SecureHelper::strcat_x(pBuffer, nBufLen, pStr);
617 nRet = nLengthTotal;
618 }
619
620 return nRet;
621 }
622
623 #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
624 bool GetFirstPathName(_CSTRING_NS::CString& strPath) const
625 {
626 bool bRet = false;
627
628 int nLength = GetFirstPathName(NULL, 0);
629 if (nLength > 0)
630 {
631 bRet = (GetFirstPathName(strPath.GetBuffer(nLength), nLength) > 0);
632 strPath.ReleaseBuffer(nLength - 1);
633 }
634
635 return bRet;
636 }
637 #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
638
639 // Get the next filename as a full path.
640 // The function returns the number of characters copied, not including the terminating zero.
641 // If the buffer is NULL, the function returns the required size, in characters, including the terminating zero.
642 // If the function fails, the return value is zero.
643 // The internal position marker is moved forward only if the function succeeds and the buffer was large enough.
644 int GetNextPathName(LPTSTR pBuffer, int nBufLen) const
645 {
646 if (m_pNextFile == NULL)
647 return 0;
648
649 int nRet = 0;
650 LPCTSTR pStr = m_pNextFile;
651 // Does the filename contain a backslash?
652 if (_strrchr(pStr, _T('\\')) != NULL)
653 {
654 // Yes, so we'll assume it's a full path.
655 int nLength = lstrlen(pStr);
656
657 if (pBuffer == NULL) // If the buffer is NULL, return the required length
658 {
659 nRet = nLength + 1;
660 }
661 else if (nBufLen > nLength) // The buffer is big enough, so go ahead and copy the filename
662 {
663 SecureHelper::strcpy_x(pBuffer, nBufLen, GetNextFileName());
664 nRet = nBufLen;
665 }
666 }
667 else
668 {
669 // The filename is relative, so construct the full path.
670 int nLengthDir = GetDirectory(NULL, 0);
671 if (nLengthDir > 0)
672 {
673 // Calculate the required space.
674 int nLengthTotal = nLengthDir + lstrlen(pStr);
675
676 if(pBuffer == NULL) // If the buffer is NULL, return the required length
677 {
678 nRet = nLengthTotal + 1;
679 }
680 else if (nBufLen > nLengthTotal) // If the buffer is big enough, go ahead and construct the path
681 {
682 GetDirectory(pBuffer, nBufLen);
683 SecureHelper::strcat_x(pBuffer, nBufLen, _T("\\"));
684 SecureHelper::strcat_x(pBuffer, nBufLen, GetNextFileName());
685 nRet = nLengthTotal;
686 }
687 }
688 }
689
690 return nRet;
691 }
692
693 #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
694 bool GetNextPathName(_CSTRING_NS::CString& strPath) const
695 {
696 bool bRet = false;
697
698 int nLength = GetNextPathName(NULL, 0);
699 if (nLength > 0)
700 {
701 bRet = (GetNextPathName(strPath.GetBuffer(nLength), nLength) > 0);
702 strPath.ReleaseBuffer(nLength - 1);
703 }
704
705 return bRet;
706 }
707 #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
708
709 // Implementation
710 bool ResizeFilenameBuffer(DWORD dwLength)
711 {
712 if (dwLength > m_ofn.nMaxFile)
713 {
714 // Free the old buffer.
715 if (m_ofn.lpstrFile != m_szFileName)
716 {
717 delete[] m_ofn.lpstrFile;
718 m_ofn.lpstrFile = NULL;
719 m_ofn.nMaxFile = 0;
720 }
721
722 // Allocate the new buffer.
723 LPTSTR lpstrBuff = NULL;
724 ATLTRY(lpstrBuff = new TCHAR[dwLength]);
725 if (lpstrBuff != NULL)
726 {
727 m_ofn.lpstrFile = lpstrBuff;
728 m_ofn.lpstrFile[0] = 0;
729 m_ofn.nMaxFile = dwLength;
730 }
731 }
732
733 return (m_ofn.lpstrFile != NULL);
734 }
735
736 void OnSelChange(LPOFNOTIFY /*lpon*/)
737 {
738 #ifndef _UNICODE
739 // There is no point resizing the buffer in ANSI builds running on NT.
740 if (m_bIsNT)
741 return;
742 #endif
743
744 // Get the buffer length required to hold the spec.
745 int nLength = GetSpec(NULL, 0);
746 if (nLength <= 1)
747 return; // no files are selected, presumably
748
749 // Add room for the directory, and an extra terminating zero.
750 nLength += GetFolderPath(NULL, 0) + 1;
751
752 if (!ResizeFilenameBuffer(nLength))
753 {
754 ATLASSERT(FALSE);
755 return;
756 }
757
758 // If we are not following links then our work is done.
759 if ((m_ofn.Flags & OFN_NODEREFERENCELINKS) != 0)
760 return;
761
762 // Get the file spec, which is the text in the edit control.
763 if (GetSpec(m_ofn.lpstrFile, m_ofn.nMaxFile) <= 0)
764 return;
765
766 // Get the ID-list of the current folder.
767 int nBytes = GetFolderIDList(NULL, 0);
768 CTempBuffer<ITEMIDLIST> idlist;
769 idlist.AllocateBytes(nBytes);
770 if ((nBytes <= 0) || (GetFolderIDList(idlist, nBytes) <= 0))
771 return;
772
773 // First bind to the desktop folder, then to the current folder.
774 ATL::CComPtr<IShellFolder> pDesktop, pFolder;
775 if (FAILED(::SHGetDesktopFolder(&pDesktop)))
776 return;
777 if (FAILED(pDesktop->BindToObject(idlist, NULL, IID_IShellFolder, (void**)&pFolder)))
778 return;
779
780 // Work through the file spec, looking for quoted filenames. If we find a shortcut file, then
781 // we need to add enough extra buffer space to hold its target path.
782 DWORD nExtraChars = 0;
783 bool bInsideQuotes = false;
784 LPCTSTR pAnchor = m_ofn.lpstrFile;
785 LPCTSTR pChar = m_ofn.lpstrFile;
786 for ( ; *pChar; ++pChar)
787 {
788 // Look for quotation marks.
789 if (*pChar == _T('\"'))
790 {
791 // We are either entering or leaving a passage of quoted text.
792 bInsideQuotes = !bInsideQuotes;
793
794 // Is it an opening or closing quote?
795 if (bInsideQuotes)
796 {
797 // We found an opening quote, so set "pAnchor" to the following character.
798 pAnchor = pChar + 1;
799 }
800 else // closing quote
801 {
802 // Each quoted entity should be shorter than MAX_PATH.
803 if (pChar - pAnchor >= MAX_PATH)
804 return;
805
806 // Get the ID-list and attributes of the file.
807 USES_CONVERSION;
808 int nFileNameLength = (int)(DWORD_PTR)(pChar - pAnchor);
809 TCHAR szFileName[MAX_PATH];
810 SecureHelper::strncpy_x(szFileName, MAX_PATH, pAnchor, nFileNameLength);
811 LPITEMIDLIST pidl = NULL;
812 DWORD dwAttrib = SFGAO_LINK;
813 if (SUCCEEDED(pFolder->ParseDisplayName(NULL, NULL, T2W(szFileName), NULL, &pidl, &dwAttrib)))
814 {
815 // Is it a shortcut file?
816 if (dwAttrib & SFGAO_LINK)
817 {
818 // Bind to its IShellLink interface.
819 ATL::CComPtr<IShellLink> pLink;
820 if (SUCCEEDED(pFolder->BindToObject(pidl, NULL, IID_IShellLink, (void**)&pLink)))
821 {
822 // Get the shortcut's target path.
823 TCHAR szPath[MAX_PATH];
824 if (SUCCEEDED(pLink->GetPath(szPath, MAX_PATH, NULL, 0)))
825 {
826 // If the target path is longer than the shortcut name, then add on the number
827 // of extra characters that are required.
828 int nNewLength = lstrlen(szPath);
829 if (nNewLength > nFileNameLength)
830 nExtraChars += nNewLength - nFileNameLength;
831 }
832 }
833 }
834
835 // Free the ID-list returned by ParseDisplayName.
836 ::CoTaskMemFree(pidl);
837 }
838 }
839 }
840 }
841
842 // If we need more space for shortcut targets, then reallocate.
843 if (nExtraChars > 0)
844 ATLVERIFY(ResizeFilenameBuffer(m_ofn.nMaxFile + nExtraChars));
845 }
846
847 // Helper for _ATM_MIN_CRT
848 static const TCHAR* _strrchr(const TCHAR* p, TCHAR ch)
849 {
850 #ifndef _ATL_MIN_CRT
851 return _tcsrchr(p, ch);
852 #else // _ATL_MIN_CRT
853 const TCHAR* lpsz = NULL;
854 while (*p != 0)
855 {
856 if (*p == ch)
857 lpsz = p;
858 p = ::CharNext(p);
859 }
860 return lpsz;
861 #endif // _ATL_MIN_CRT
862 }
863 };
864
865 class CMultiFileDialog : public CMultiFileDialogImpl<CMultiFileDialog>
866 {
867 public:
868 CMultiFileDialog(
869 LPCTSTR lpszDefExt = NULL,
870 LPCTSTR lpszFileName = NULL,
871 DWORD dwFlags = OFN_HIDEREADONLY,
872 LPCTSTR lpszFilter = NULL,
873 HWND hWndParent = NULL)
874 : CMultiFileDialogImpl<CMultiFileDialog>(lpszDefExt, lpszFileName, dwFlags, lpszFilter, hWndParent)
875 { }
876
877 BEGIN_MSG_MAP(CMultiFileDialog)
878 CHAIN_MSG_MAP(CMultiFileDialogImpl<CMultiFileDialog>)
879 END_MSG_MAP()
880 };
881
882 #endif // !_WIN32_WCE
883
884
885 ///////////////////////////////////////////////////////////////////////////////
886 // Shell File Dialog - new Shell File Open and Save dialogs in Vista
887
888 // Note: Use GetPtr() to access dialog interface methods.
889 // Example:
890 // CShellFileOpenDialog dlg;
891 // dlg.GetPtr()->SetTitle(L"MyFileOpenDialog");
892
893 #if (_WIN32_WINNT >= 0x0600) && !defined(_WIN32_WCE)
894
895 ///////////////////////////////////////////////////////////////////////////////
896 // CShellFileDialogImpl - base class for CShellFileOpenDialogImpl and CShellFileSaveDialogImpl
897
898 template <class T>
899 class ATL_NO_VTABLE CShellFileDialogImpl : public IFileDialogEvents
900 {
901 public:
902 // Operations
903 INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow())
904 {
905 INT_PTR nRet = -1;
906
907 T* pT = static_cast<T*>(this);
908 if(pT->m_spFileDlg == NULL)
909 {
910 ATLASSERT(FALSE);
911 return nRet;
912 }
913
914 DWORD dwCookie = 0;
915 pT->_Advise(dwCookie);
916
917 HRESULT hRet = pT->m_spFileDlg->Show(hWndParent);
918 if(SUCCEEDED(hRet))
919 nRet = IDOK;
920 else if(hRet == HRESULT_FROM_WIN32(ERROR_CANCELLED))
921 nRet = IDCANCEL;
922 else
923 ATLASSERT(FALSE); // error
924
925 pT->_Unadvise(dwCookie);
926
927 return nRet;
928 }
929
930 bool IsNull() const
931 {
932 const T* pT = static_cast<const T*>(this);
933 return (pT->m_spFileDlg == NULL);
934 }
935
936 // Operations - get file path after dialog returns
937 HRESULT GetFilePath(LPWSTR lpstrFilePath, int cchLength)
938 {
939 T* pT = static_cast<T*>(this);
940 ATLASSERT(pT->m_spFileDlg != NULL);
941
942 ATL::CComPtr<IShellItem> spItem;
943 HRESULT hRet = pT->m_spFileDlg->GetResult(&spItem);
944
945 if(SUCCEEDED(hRet))
946 hRet = GetFileNameFromShellItem(spItem, SIGDN_FILESYSPATH, lpstrFilePath, cchLength);
947
948 return hRet;
949 }
950
951 HRESULT GetFileTitle(LPWSTR lpstrFileTitle, int cchLength)
952 {
953 T* pT = static_cast<T*>(this);
954 ATLASSERT(pT->m_spFileDlg != NULL);
955
956 ATL::CComPtr<IShellItem> spItem;
957 HRESULT hRet = pT->m_spFileDlg->GetResult(&spItem);
958
959 if(SUCCEEDED(hRet))
960 hRet = GetFileNameFromShellItem(spItem, SIGDN_NORMALDISPLAY, lpstrFileTitle, cchLength);
961
962 return hRet;
963 }
964
965 #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
966 HRESULT GetFilePath(_CSTRING_NS::CString& strFilePath)
967 {
968 T* pT = static_cast<T*>(this);
969 ATLASSERT(pT->m_spFileDlg != NULL);
970
971 ATL::CComPtr<IShellItem> spItem;
972 HRESULT hRet = pT->m_spFileDlg->GetResult(&spItem);
973
974 if(SUCCEEDED(hRet))
975 hRet = GetFileNameFromShellItem(spItem, SIGDN_FILESYSPATH, strFilePath);
976
977 return hRet;
978 }
979
980 HRESULT GetFileTitle(_CSTRING_NS::CString& strFileTitle)
981 {
982 T* pT = static_cast<T*>(this);
983 ATLASSERT(pT->m_spFileDlg != NULL);
984
985 ATL::CComPtr<IShellItem> spItem;
986 HRESULT hRet = pT->m_spFileDlg->GetResult(&spItem);
987
988 if(SUCCEEDED(hRet))
989 hRet = GetFileNameFromShellItem(spItem, SIGDN_NORMALDISPLAY, strFileTitle);
990
991 return hRet;
992 }
993 #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
994
995 // Helpers for IShellItem
996 static HRESULT GetFileNameFromShellItem(IShellItem* pShellItem, SIGDN type, LPWSTR lpstr, int cchLength)
997 {
998 ATLASSERT(pShellItem != NULL);
999
1000 LPWSTR lpstrName = NULL;
1001 HRESULT hRet = pShellItem->GetDisplayName(type, &lpstrName);
1002
1003 if(SUCCEEDED(hRet))
1004 {
1005 if(lstrlenW(lpstrName) < cchLength)
1006 {
1007 SecureHelper::strcpyW_x(lpstr, cchLength, lpstrName);
1008 }
1009 else
1010 {
1011 ATLASSERT(FALSE);
1012 hRet = DISP_E_BUFFERTOOSMALL;
1013 }
1014
1015 ::CoTaskMemFree(lpstrName);
1016 }
1017
1018 return hRet;
1019 }
1020
1021 #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
1022 static HRESULT GetFileNameFromShellItem(IShellItem* pShellItem, SIGDN type, _CSTRING_NS::CString& str)
1023 {
1024 ATLASSERT(pShellItem != NULL);
1025
1026 LPWSTR lpstrName = NULL;
1027 HRESULT hRet = pShellItem->GetDisplayName(type, &lpstrName);
1028
1029 if(SUCCEEDED(hRet))
1030 {
1031 str = lpstrName;
1032 ::CoTaskMemFree(lpstrName);
1033 }
1034
1035 return hRet;
1036 }
1037 #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
1038
1039 // Implementation
1040 void _Advise(DWORD& dwCookie)
1041 {
1042 T* pT = static_cast<T*>(this);
1043 ATLASSERT(pT->m_spFileDlg != NULL);
1044 HRESULT hRet = pT->m_spFileDlg->Advise((IFileDialogEvents*)this, &dwCookie);
1045 ATLVERIFY(SUCCEEDED(hRet));
1046 }
1047
1048 void _Unadvise(DWORD dwCookie)
1049 {
1050 T* pT = static_cast<T*>(this);
1051 ATLASSERT(pT->m_spFileDlg != NULL);
1052 HRESULT hRet = pT->m_spFileDlg->Unadvise(dwCookie);
1053 ATLVERIFY(SUCCEEDED(hRet));
1054 }
1055
1056 void _Init(LPCWSTR lpszFileName, DWORD dwOptions, LPCWSTR lpszDefExt, const COMDLG_FILTERSPEC* arrFilterSpec, UINT uFilterSpecCount)
1057 {
1058 T* pT = static_cast<T*>(this);
1059 ATLASSERT(pT->m_spFileDlg != NULL);
1060
1061 HRESULT hRet = E_FAIL;
1062
1063 if(lpszFileName != NULL)
1064 {
1065 hRet = pT->m_spFileDlg->SetFileName(lpszFileName);
1066 ATLASSERT(SUCCEEDED(hRet));
1067 }
1068
1069 hRet = pT->m_spFileDlg->SetOptions(dwOptions);
1070 ATLASSERT(SUCCEEDED(hRet));
1071
1072 if(lpszDefExt != NULL)
1073 {
1074 hRet = pT->m_spFileDlg->SetDefaultExtension(lpszDefExt);
1075 ATLASSERT(SUCCEEDED(hRet));
1076 }
1077
1078 if(arrFilterSpec != NULL && uFilterSpecCount != 0U)
1079 {
1080 hRet = pT->m_spFileDlg->SetFileTypes(uFilterSpecCount, arrFilterSpec);
1081 ATLASSERT(SUCCEEDED(hRet));
1082 }
1083 }
1084
1085 // Implementation - IUnknown interface
1086 STDMETHOD(QueryInterface)(REFIID riid, void** ppvObject)
1087 {
1088 if(ppvObject == NULL)
1089 return E_POINTER;
1090
1091 T* pT = static_cast<T*>(this);
1092 if(IsEqualGUID(riid, IID_IUnknown) || IsEqualGUID(riid, IID_IFileDialogEvents))
1093 {
1094 *ppvObject = (IFileDialogEvents*)pT;
1095 // AddRef() not needed
1096 return S_OK;
1097 }
1098
1099 return E_NOINTERFACE;
1100 }
1101
1102 virtual ULONG STDMETHODCALLTYPE AddRef()
1103 {
1104 return 1;
1105 }
1106
1107 virtual ULONG STDMETHODCALLTYPE Release()
1108 {
1109 return 1;
1110 }
1111
1112 // Implementation - IFileDialogEvents interface
1113 virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnFileOk(IFileDialog* pfd)
1114 {
1115 T* pT = static_cast<T*>(this);
1116 ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd));
1117 pfd; // avoid level 4 warning
1118 return pT->OnFileOk();
1119 }
1120
1121 virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnFolderChanging(IFileDialog* pfd, IShellItem* psiFolder)
1122 {
1123 T* pT = static_cast<T*>(this);
1124 ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd));
1125 pfd; // avoid level 4 warning
1126 return pT->OnFolderChanging(psiFolder);
1127 }
1128
1129 virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnFolderChange(IFileDialog* pfd)
1130 {
1131 T* pT = static_cast<T*>(this);
1132 ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd));
1133 pfd; // avoid level 4 warning
1134 return pT->OnFolderChange();
1135 }
1136
1137 virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnSelectionChange(IFileDialog* pfd)
1138 {
1139 T* pT = static_cast<T*>(this);
1140 ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd));
1141 pfd; // avoid level 4 warning
1142 return pT->OnSelectionChange();
1143 }
1144
1145 virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnShareViolation(IFileDialog* pfd, IShellItem* psi, FDE_SHAREVIOLATION_RESPONSE* pResponse)
1146 {
1147 T* pT = static_cast<T*>(this);
1148 ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd));
1149 pfd; // avoid level 4 warning
1150 return pT->OnShareViolation(psi, pResponse);
1151 }
1152
1153 virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnTypeChange(IFileDialog* pfd)
1154 {
1155 T* pT = static_cast<T*>(this);
1156 ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd));
1157 pfd; // avoid level 4 warning
1158 return pT->OnTypeChange();
1159 }
1160
1161 virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnOverwrite(IFileDialog* pfd, IShellItem* psi, FDE_OVERWRITE_RESPONSE* pResponse)
1162 {
1163 T* pT = static_cast<T*>(this);
1164 ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd));
1165 pfd; // avoid level 4 warning
1166 return pT->OnOverwrite(psi, pResponse);
1167 }
1168
1169 // Overrideables - Event handlers
1170 HRESULT OnFileOk()
1171 {
1172 return E_NOTIMPL;
1173 }
1174
1175 HRESULT OnFolderChanging(IShellItem* /*psiFolder*/)
1176 {
1177 return E_NOTIMPL;
1178 }
1179
1180 HRESULT OnFolderChange()
1181 {
1182 return E_NOTIMPL;
1183 }
1184
1185 HRESULT OnSelectionChange()
1186 {
1187 return E_NOTIMPL;
1188 }
1189
1190 HRESULT OnShareViolation(IShellItem* /*psi*/, FDE_SHAREVIOLATION_RESPONSE* /*pResponse*/)
1191 {
1192 return E_NOTIMPL;
1193 }
1194
1195 HRESULT OnTypeChange()
1196 {
1197 return E_NOTIMPL;
1198 }
1199
1200 HRESULT OnOverwrite(IShellItem* /*psi*/, FDE_OVERWRITE_RESPONSE* /*pResponse*/)
1201 {
1202 return E_NOTIMPL;
1203 }
1204 };
1205
1206
1207 ///////////////////////////////////////////////////////////////////////////////
1208 // CShellFileOpenDialogImpl - implements new Shell File Open dialog
1209
1210 template <class T>
1211 class ATL_NO_VTABLE CShellFileOpenDialogImpl : public CShellFileDialogImpl< T >
1212 {
1213 public:
1214 ATL::CComPtr<IFileOpenDialog> m_spFileDlg;
1215
1216 CShellFileOpenDialogImpl(LPCWSTR lpszFileName = NULL,
1217 DWORD dwOptions = FOS_FORCEFILESYSTEM | FOS_PATHMUSTEXIST | FOS_FILEMUSTEXIST,
1218 LPCWSTR lpszDefExt = NULL,
1219 const COMDLG_FILTERSPEC* arrFilterSpec = NULL,
1220 UINT uFilterSpecCount = 0U)
1221 {
1222 HRESULT hRet = m_spFileDlg.CoCreateInstance(CLSID_FileOpenDialog);
1223
1224 if(SUCCEEDED(hRet))
1225 _Init(lpszFileName, dwOptions, lpszDefExt, arrFilterSpec, uFilterSpecCount);
1226 }
1227
1228 IFileOpenDialog* GetPtr()
1229 {
1230 return m_spFileDlg;
1231 }
1232 };
1233
1234
1235 ///////////////////////////////////////////////////////////////////////////////
1236 // CShellFileOpenDialog - new Shell File Open dialog without events
1237
1238 class CShellFileOpenDialog : public CShellFileOpenDialogImpl<CShellFileOpenDialog>
1239 {
1240 public:
1241 CShellFileOpenDialog(LPCWSTR lpszFileName = NULL,
1242 DWORD dwOptions = FOS_FORCEFILESYSTEM | FOS_PATHMUSTEXIST | FOS_FILEMUSTEXIST,
1243 LPCWSTR lpszDefExt = NULL,
1244 const COMDLG_FILTERSPEC* arrFilterSpec = NULL,
1245 UINT uFilterSpecCount = 0U) : CShellFileOpenDialogImpl<CShellFileOpenDialog>(lpszFileName, dwOptions, lpszDefExt, arrFilterSpec, uFilterSpecCount)
1246 { }
1247
1248 // Implementation (remove _Advise/_Unadvise code using template magic)
1249 void _Advise(DWORD& /*dwCookie*/)
1250 { }
1251
1252 void _Unadvise(DWORD /*dwCookie*/)
1253 { }
1254 };
1255
1256
1257 ///////////////////////////////////////////////////////////////////////////////
1258 // CShellFileSaveDialogImpl - implements new Shell File Save dialog
1259
1260 template <class T>
1261 class ATL_NO_VTABLE CShellFileSaveDialogImpl : public CShellFileDialogImpl< T >
1262 {
1263 public:
1264 ATL::CComPtr<IFileSaveDialog> m_spFileDlg;
1265
1266 CShellFileSaveDialogImpl(LPCWSTR lpszFileName = NULL,
1267 DWORD dwOptions = FOS_FORCEFILESYSTEM | FOS_PATHMUSTEXIST | FOS_OVERWRITEPROMPT,
1268 LPCWSTR lpszDefExt = NULL,
1269 const COMDLG_FILTERSPEC* arrFilterSpec = NULL,
1270 UINT uFilterSpecCount = 0U)
1271 {
1272 HRESULT hRet = m_spFileDlg.CoCreateInstance(CLSID_FileSaveDialog);
1273
1274 if(SUCCEEDED(hRet))
1275 _Init(lpszFileName, dwOptions, lpszDefExt, arrFilterSpec, uFilterSpecCount);
1276 }
1277
1278 IFileSaveDialog* GetPtr()
1279 {
1280 return m_spFileDlg;
1281 }
1282 };
1283
1284
1285 ///////////////////////////////////////////////////////////////////////////////
1286 // CShellFileSaveDialog - new Shell File Save dialog without events
1287
1288 class CShellFileSaveDialog : public CShellFileSaveDialogImpl<CShellFileSaveDialog>
1289 {
1290 public:
1291 CShellFileSaveDialog(LPCWSTR lpszFileName = NULL,
1292 DWORD dwOptions = FOS_FORCEFILESYSTEM | FOS_PATHMUSTEXIST | FOS_OVERWRITEPROMPT,
1293 LPCWSTR lpszDefExt = NULL,
1294 const COMDLG_FILTERSPEC* arrFilterSpec = NULL,
1295 UINT uFilterSpecCount = 0U) : CShellFileSaveDialogImpl<CShellFileSaveDialog>(lpszFileName, dwOptions, lpszDefExt, arrFilterSpec, uFilterSpecCount)
1296 { }
1297
1298 // Implementation (remove _Advise/_Unadvise code using template magic)
1299 void _Advise(DWORD& /*dwCookie*/)
1300 { }
1301
1302 void _Unadvise(DWORD /*dwCookie*/)
1303 { }
1304 };
1305
1306 #endif // (_WIN32_WINNT >= 0x0600) && !defined(_WIN32_WCE)
1307
1308
1309 ///////////////////////////////////////////////////////////////////////////////
1310 // CFolderDialogImpl - used for browsing for a folder
1311
1312 #ifndef _WIN32_WCE
1313
1314 template <class T>
1315 class ATL_NO_VTABLE CFolderDialogImpl
1316 {
1317 public:
1318 BROWSEINFO m_bi;
1319 LPCTSTR m_lpstrInitialFolder;
1320 LPCITEMIDLIST m_pidlInitialSelection;
1321 bool m_bExpandInitialSelection;
1322 TCHAR m_szFolderDisplayName[MAX_PATH];
1323 TCHAR m_szFolderPath[MAX_PATH];
1324 LPITEMIDLIST m_pidlSelected;
1325 HWND m_hWnd; // used only in the callback function
1326
1327 // Constructor
1328 CFolderDialogImpl(HWND hWndParent = NULL, LPCTSTR lpstrTitle = NULL, UINT uFlags = BIF_RETURNONLYFSDIRS) :
1329 m_lpstrInitialFolder(NULL), m_pidlInitialSelection(NULL), m_bExpandInitialSelection(false), m_pidlSelected(NULL), m_hWnd(NULL)
1330 {
1331 memset(&m_bi, 0, sizeof(m_bi)); // initialize structure to 0/NULL
1332
1333 m_bi.hwndOwner = hWndParent;
1334 m_bi.pidlRoot = NULL;
1335 m_bi.pszDisplayName = m_szFolderDisplayName;
1336 m_bi.lpszTitle = lpstrTitle;
1337 m_bi.ulFlags = uFlags;
1338 m_bi.lpfn = BrowseCallbackProc;
1339 m_bi.lParam = (LPARAM)static_cast<T*>(this);
1340
1341 m_szFolderPath[0] = 0;
1342 m_szFolderDisplayName[0] = 0;
1343 }
1344
1345 ~CFolderDialogImpl()
1346 {
1347 ::CoTaskMemFree(m_pidlSelected);
1348 }
1349
1350 // Operations
1351 INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow())
1352 {
1353 if(m_bi.hwndOwner == NULL) // set only if not specified before
1354 m_bi.hwndOwner = hWndParent;
1355
1356 // Clear out any previous results
1357 m_szFolderPath[0] = 0;
1358 m_szFolderDisplayName[0] = 0;
1359 ::CoTaskMemFree(m_pidlSelected);
1360
1361 INT_PTR nRet = IDCANCEL;
1362 m_pidlSelected = ::SHBrowseForFolder(&m_bi);
1363
1364 if(m_pidlSelected != NULL)
1365 {
1366 nRet = IDOK;
1367
1368 // If BIF_RETURNONLYFSDIRS is set, we try to get the filesystem path.
1369 // Otherwise, the caller must handle the ID-list directly.
1370 if((m_bi.ulFlags & BIF_RETURNONLYFSDIRS) != 0)
1371 {
1372 if(::SHGetPathFromIDList(m_pidlSelected, m_szFolderPath) == FALSE)
1373 nRet = IDCANCEL;
1374 }
1375 }
1376
1377 return nRet;
1378 }
1379
1380 // Methods to call before DoModal
1381 void SetInitialFolder(LPCTSTR lpstrInitialFolder, bool bExpand = true)
1382 {
1383 // lpstrInitialFolder may be a file if BIF_BROWSEINCLUDEFILES is specified
1384 m_lpstrInitialFolder = lpstrInitialFolder;
1385 m_bExpandInitialSelection = bExpand;
1386 }
1387
1388 void SetInitialSelection(LPCITEMIDLIST pidl, bool bExpand = true)
1389 {
1390 m_pidlInitialSelection = pidl;
1391 m_bExpandInitialSelection = bExpand;
1392 }
1393
1394 // Methods to call after DoModal
1395 LPITEMIDLIST GetSelectedItem(bool bDetach = false)
1396 {
1397 LPITEMIDLIST pidl = m_pidlSelected;
1398 if(bDetach)
1399 m_pidlSelected = NULL;
1400
1401 return pidl;
1402 }
1403
1404 LPCTSTR GetFolderPath() const
1405 {
1406 return m_szFolderPath;
1407 }
1408
1409 LPCTSTR GetFolderDisplayName() const
1410 {
1411 return m_szFolderDisplayName;
1412 }
1413
1414 int GetFolderImageIndex() const
1415 {
1416 return m_bi.iImage;
1417 }
1418
1419 // Callback function and overrideables
1420 static int CALLBACK BrowseCallbackProc(HWND hWnd, UINT uMsg, LPARAM lParam, LPARAM lpData)
1421 {
1422 #ifndef BFFM_VALIDATEFAILED
1423 #ifdef UNICODE
1424 const int BFFM_VALIDATEFAILED = 4;
1425 #else
1426 const int BFFM_VALIDATEFAILED = 3;
1427 #endif
1428 #endif // !BFFM_VALIDATEFAILED
1429 #ifndef BFFM_IUNKNOWN
1430 const int BFFM_IUNKNOWN = 5;
1431 #endif // !BFFM_IUNKNOWN
1432 #ifndef BIF_NEWDIALOGSTYLE
1433 const UINT BIF_NEWDIALOGSTYLE = 0x0040;
1434 #endif // !BIF_NEWDIALOGSTYLE
1435
1436 int nRet = 0;
1437 T* pT = (T*)lpData;
1438 bool bClear = false;
1439 if(pT->m_hWnd == NULL)
1440 {
1441 pT->m_hWnd = hWnd;
1442 bClear = true;
1443 }
1444 else
1445 {
1446 ATLASSERT(pT->m_hWnd == hWnd);
1447 }
1448
1449 switch(uMsg)
1450 {
1451 case BFFM_INITIALIZED:
1452 // Set initial selection
1453 // Note that m_pidlInitialSelection, if set, takes precedence over m_lpstrInitialFolder
1454 if(pT->m_pidlInitialSelection != NULL)
1455 pT->SetSelection(pT->m_pidlInitialSelection);
1456 else if(pT->m_lpstrInitialFolder != NULL)
1457 pT->SetSelection(pT->m_lpstrInitialFolder);
1458
1459 // Expand initial selection if appropriate
1460 if(pT->m_bExpandInitialSelection && ((pT->m_bi.ulFlags & BIF_NEWDIALOGSTYLE) != 0))
1461 {
1462 if(pT->m_pidlInitialSelection != NULL)
1463 pT->SetExpanded(pT->m_pidlInitialSelection);
1464 else if(pT->m_lpstrInitialFolder != NULL)
1465 pT->SetExpanded(pT->m_lpstrInitialFolder);
1466 }
1467 pT->OnInitialized();
1468 break;
1469 case BFFM_SELCHANGED:
1470 pT->OnSelChanged((LPITEMIDLIST)lParam);
1471 break;
1472 case BFFM_VALIDATEFAILED:
1473 nRet = pT->OnValidateFailed((LPCTSTR)lParam);
1474 break;
1475 case BFFM_IUNKNOWN:
1476 pT->OnIUnknown((IUnknown*)lParam);
1477 break;
1478 default:
1479 ATLTRACE2(atlTraceUI, 0, _T("Unknown message received in CFolderDialogImpl::BrowseCallbackProc\n"));
1480 break;
1481 }
1482
1483 if(bClear)
1484 pT->m_hWnd = NULL;
1485 return nRet;
1486 }
1487
1488 void OnInitialized()
1489 {
1490 }
1491
1492 void OnSelChanged(LPITEMIDLIST /*pItemIDList*/)
1493 {
1494 }
1495
1496 int OnValidateFailed(LPCTSTR /*lpstrFolderPath*/)
1497 {
1498 return 1; // 1=continue, 0=EndDialog
1499 }
1500
1501 void OnIUnknown(IUnknown* /*pUnknown*/)
1502 {
1503 }
1504
1505 // Commands - valid to call only from handlers
1506 void EnableOK(BOOL bEnable)
1507 {
1508 ATLASSERT(m_hWnd != NULL);
1509 ::SendMessage(m_hWnd, BFFM_ENABLEOK, 0, bEnable);
1510 }
1511
1512 void SetSelection(LPCITEMIDLIST pItemIDList)
1513 {
1514 ATLASSERT(m_hWnd != NULL);
1515 ::SendMessage(m_hWnd, BFFM_SETSELECTION, FALSE, (LPARAM)pItemIDList);
1516 }
1517
1518 void SetSelection(LPCTSTR lpstrFolderPath)
1519 {
1520 ATLASSERT(m_hWnd != NULL);
1521 ::SendMessage(m_hWnd, BFFM_SETSELECTION, TRUE, (LPARAM)lpstrFolderPath);
1522 }
1523
1524 void SetStatusText(LPCTSTR lpstrText)
1525 {
1526 ATLASSERT(m_hWnd != NULL);
1527 ::SendMessage(m_hWnd, BFFM_SETSTATUSTEXT, 0, (LPARAM)lpstrText);
1528 }
1529
1530 void SetOKText(LPCTSTR lpstrOKText)
1531 {
1532 #ifndef BFFM_SETOKTEXT
1533 const UINT BFFM_SETOKTEXT = WM_USER + 105;
1534 #endif
1535 ATLASSERT(m_hWnd != NULL);
1536 USES_CONVERSION;
1537 LPCWSTR lpstr = T2CW(lpstrOKText);
1538 ::SendMessage(m_hWnd, BFFM_SETOKTEXT, (WPARAM)lpstr, 0L);
1539 }
1540
1541 void SetExpanded(LPCITEMIDLIST pItemIDList)
1542 {
1543 #ifndef BFFM_SETEXPANDED
1544 const UINT BFFM_SETEXPANDED = WM_USER + 106;
1545 #endif
1546 ATLASSERT(m_hWnd != NULL);
1547 ::SendMessage(m_hWnd, BFFM_SETEXPANDED, FALSE, (LPARAM)pItemIDList);
1548 }
1549
1550 void SetExpanded(LPCTSTR lpstrFolderPath)
1551 {
1552 #ifndef BFFM_SETEXPANDED
1553 const UINT BFFM_SETEXPANDED = WM_USER + 106;
1554 #endif
1555 ATLASSERT(m_hWnd != NULL);
1556 USES_CONVERSION;
1557 LPCWSTR lpstr = T2CW(lpstrFolderPath);
1558 ::SendMessage(m_hWnd, BFFM_SETEXPANDED, TRUE, (LPARAM)lpstr);
1559 }
1560 };
1561
1562 class CFolderDialog : public CFolderDialogImpl<CFolderDialog>
1563 {
1564 public:
1565 CFolderDialog(HWND hWndParent = NULL, LPCTSTR lpstrTitle = NULL, UINT uFlags = BIF_RETURNONLYFSDIRS)
1566 : CFolderDialogImpl<CFolderDialog>(hWndParent, lpstrTitle, uFlags)
1567 { }
1568 };
1569
1570 #endif // !_WIN32_WCE
1571
1572
1573 ///////////////////////////////////////////////////////////////////////////////
1574 // CCommonDialogImplBase - base class for common dialog classes
1575
1576 class ATL_NO_VTABLE CCommonDialogImplBase : public ATL::CWindowImplBase
1577 {
1578 public:
1579 static UINT_PTR APIENTRY HookProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1580 {
1581 if(uMsg != WM_INITDIALOG)
1582 return 0;
1583 CCommonDialogImplBase* pT = (CCommonDialogImplBase*)ModuleHelper::ExtractCreateWndData();
1584 ATLASSERT(pT != NULL);
1585 ATLASSERT(pT->m_hWnd == NULL);
1586 ATLASSERT(::IsWindow(hWnd));
1587 // subclass dialog's window
1588 if(!pT->SubclassWindow(hWnd))
1589 {
1590 ATLTRACE2(atlTraceUI, 0, _T("Subclassing a common dialog failed\n"));
1591 return 0;
1592 }
1593 // check message map for WM_INITDIALOG handler
1594 LRESULT lRes = 0;
1595 if(pT->ProcessWindowMessage(pT->m_hWnd, uMsg, wParam, lParam, lRes, 0) == FALSE)
1596 return 0;
1597 return lRes;
1598 }
1599
1600 // Special override for common dialogs
1601 BOOL EndDialog(INT_PTR /*nRetCode*/ = 0)
1602 {
1603 ATLASSERT(::IsWindow(m_hWnd));
1604 SendMessage(WM_COMMAND, MAKEWPARAM(IDABORT, 0));
1605 return TRUE;
1606 }
1607
1608 // Implementation - try to override these, to prevent errors
1609 HWND Create(HWND, ATL::_U_RECT, LPCTSTR, DWORD, DWORD, ATL::_U_MENUorID, ATOM, LPVOID)
1610 {
1611 ATLASSERT(FALSE); // should not be called
1612 return NULL;
1613 }
1614
1615 static LRESULT CALLBACK StartWindowProc(HWND /*hWnd*/, UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/)
1616 {
1617 ATLASSERT(FALSE); // should not be called
1618 return 0;
1619 }
1620 };
1621
1622
1623 ///////////////////////////////////////////////////////////////////////////////
1624 // CFontDialogImpl - font selection dialog
1625
1626 #ifndef _WIN32_WCE
1627
1628 template <class T>
1629 class ATL_NO_VTABLE CFontDialogImpl : public CCommonDialogImplBase
1630 {
1631 public:
1632 enum { _cchStyleName = 64 };
1633
1634 CHOOSEFONT m_cf;
1635 TCHAR m_szStyleName[_cchStyleName]; // contains style name after return
1636 LOGFONT m_lf; // default LOGFONT to store the info
1637
1638 // Constructors
1639 CFontDialogImpl(LPLOGFONT lplfInitial = NULL,
1640 DWORD dwFlags = CF_EFFECTS | CF_SCREENFONTS,
1641 HDC hDCPrinter = NULL,
1642 HWND hWndParent = NULL)
1643 {
1644 memset(&m_cf, 0, sizeof(m_cf));
1645 memset(&m_lf, 0, sizeof(m_lf));
1646 memset(&m_szStyleName, 0, sizeof(m_szStyleName));
1647
1648 m_cf.lStructSize = sizeof(m_cf);
1649 m_cf.hwndOwner = hWndParent;
1650 m_cf.rgbColors = RGB(0, 0, 0);
1651 m_cf.lpszStyle = (LPTSTR)&m_szStyleName;
1652 m_cf.Flags = dwFlags | CF_ENABLEHOOK;
1653 m_cf.lpfnHook = (LPCFHOOKPROC)T::HookProc;
1654
1655 if(lplfInitial != NULL)
1656 {
1657 m_cf.lpLogFont = lplfInitial;
1658 m_cf.Flags |= CF_INITTOLOGFONTSTRUCT;
1659 m_lf = *lplfInitial;
1660 }
1661 else
1662 {
1663 m_cf.lpLogFont = &m_lf;
1664 }
1665
1666 if(hDCPrinter != NULL)
1667 {
1668 m_cf.hDC = hDCPrinter;
1669 m_cf.Flags |= CF_PRINTERFONTS;
1670 }
1671 }
1672
1673 // Operations
1674 INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow())
1675 {
1676 ATLASSERT((m_cf.Flags & CF_ENABLEHOOK) != 0);
1677 ATLASSERT(m_cf.lpfnHook != NULL); // can still be a user hook
1678
1679 if(m_cf.hwndOwner == NULL) // set only if not specified before
1680 m_cf.hwndOwner = hWndParent;
1681
1682 ATLASSERT(m_hWnd == NULL);
1683 ModuleHelper::AddCreateWndData(&m_thunk.cd, (CCommonDialogImplBase*)this);
1684
1685 BOOL bRet = ::ChooseFont(&m_cf);
1686
1687 m_hWnd = NULL;
1688
1689 if(bRet) // copy logical font from user's initialization buffer (if needed)
1690 SecureHelper::memcpy_x(&m_lf, sizeof(m_lf), m_cf.lpLogFont, sizeof(m_lf));
1691
1692 return bRet ? IDOK : IDCANCEL;
1693 }
1694
1695 // works only when the dialog is dislayed or after
1696 void GetCurrentFont(LPLOGFONT lplf) const
1697 {
1698 ATLASSERT(lplf != NULL);
1699
1700 if(m_hWnd != NULL)
1701 ::SendMessage(m_hWnd, WM_CHOOSEFONT_GETLOGFONT, 0, (LPARAM)lplf);
1702 else
1703 *lplf = m_lf;
1704 }
1705
1706 // works only when the dialog is dislayed or before
1707 #ifndef _WIN32_WCE
1708 void SetLogFont(LPLOGFONT lplf)
1709 {
1710 ATLASSERT(lplf != NULL);
1711 #ifndef WM_CHOOSEFONT_SETLOGFONT
1712 const UINT WM_CHOOSEFONT_SETLOGFONT = (WM_USER + 101);
1713 #endif
1714 if(m_hWnd != NULL)
1715 {
1716 ::SendMessage(m_hWnd, WM_CHOOSEFONT_SETLOGFONT, 0, (LPARAM)lplf);
1717 }
1718 else
1719 {
1720 m_lf = *lplf;
1721 m_cf.Flags |= CF_INITTOLOGFONTSTRUCT;
1722 }
1723 }
1724
1725 void SetFlags(DWORD dwFlags)
1726 {
1727 #ifndef WM_CHOOSEFONT_SETFLAGS
1728 const UINT WM_CHOOSEFONT_SETFLAGS = (WM_USER + 102);
1729 #endif
1730 if(m_hWnd != NULL)
1731 {
1732 CHOOSEFONT cf = { sizeof(CHOOSEFONT) };
1733 cf.Flags = dwFlags;
1734 ::SendMessage(m_hWnd, WM_CHOOSEFONT_SETFLAGS, 0, (LPARAM)&cf);
1735 }
1736 else
1737 {
1738 m_cf.Flags = dwFlags;
1739 }
1740 }
1741 #endif // !_WIN32_WCE
1742
1743 // Helpers for parsing information after successful return
1744 LPCTSTR GetFaceName() const // return the face name of the font
1745 {
1746 return (LPCTSTR)m_cf.lpLogFont->lfFaceName;
1747 }
1748
1749 LPCTSTR GetStyleName() const // return the style name of the font
1750 {
1751 return m_cf.lpszStyle;
1752 }
1753
1754 int GetSize() const // return the pt size of the font
1755 {
1756 return m_cf.iPointSize;
1757 }
1758
1759 COLORREF GetColor() const // return the color of the font
1760 {
1761 return m_cf.rgbColors;
1762 }
1763
1764 int GetWeight() const // return the chosen font weight
1765 {
1766 return (int)m_cf.lpLogFont->lfWeight;
1767 }
1768
1769 BOOL IsStrikeOut() const // return TRUE if strikeout
1770 {
1771 return (m_cf.lpLogFont->lfStrikeOut) ? TRUE : FALSE;
1772 }
1773
1774 BOOL IsUnderline() const // return TRUE if underline
1775 {
1776 return (m_cf.lpLogFont->lfUnderline) ? TRUE : FALSE;
1777 }
1778
1779 BOOL IsBold() const // return TRUE if bold font
1780 {
1781 return (m_cf.lpLogFont->lfWeight == FW_BOLD) ? TRUE : FALSE;
1782 }
1783
1784 BOOL IsItalic() const // return TRUE if italic font
1785 {
1786 return m_cf.lpLogFont->lfItalic ? TRUE : FALSE;
1787 }
1788 };
1789
1790 class CFontDialog : public CFontDialogImpl<CFontDialog>
1791 {
1792 public:
1793 CFontDialog(LPLOGFONT lplfInitial = NULL,
1794 DWORD dwFlags = CF_EFFECTS | CF_SCREENFONTS,
1795 HDC hDCPrinter = NULL,
1796 HWND hWndParent = NULL)
1797 : CFontDialogImpl<CFontDialog>(lplfInitial, dwFlags, hDCPrinter, hWndParent)
1798 { }
1799
1800 DECLARE_EMPTY_MSG_MAP()
1801 };
1802
1803 #endif // _WIN32_WCE
1804
1805
1806 ///////////////////////////////////////////////////////////////////////////////
1807 // CRichEditFontDialogImpl - font selection for the Rich Edit ctrl
1808
1809 #if defined(_RICHEDIT_) && !defined(_WIN32_WCE)
1810
1811 template <class T>
1812 class ATL_NO_VTABLE CRichEditFontDialogImpl : public CFontDialogImpl< T >
1813 {
1814 public:
1815 CRichEditFontDialogImpl(const CHARFORMAT& charformat,
1816 DWORD dwFlags = CF_SCREENFONTS,
1817 HDC hDCPrinter = NULL,
1818 HWND hWndParent = NULL)
1819 : CFontDialogImpl< T >(NULL, dwFlags, hDCPrinter, hWndParent)
1820 {
1821 m_cf.Flags |= CF_INITTOLOGFONTSTRUCT;
1822 m_cf.Flags |= FillInLogFont(charformat);
1823 m_cf.lpLogFont = &m_lf;
1824
1825 if((charformat.dwMask & CFM_COLOR) != 0)
1826 m_cf.rgbColors = charformat.crTextColor;
1827 }
1828
1829 void GetCharFormat(CHARFORMAT& cf) const
1830 {
1831 USES_CONVERSION;
1832 cf.dwEffects = 0;
1833 cf.dwMask = 0;
1834 if((m_cf.Flags & CF_NOSTYLESEL) == 0)
1835 {
1836 cf.dwMask |= CFM_BOLD | CFM_ITALIC;
1837 cf.dwEffects |= IsBold() ? CFE_BOLD : 0;
1838 cf.dwEffects |= IsItalic() ? CFE_ITALIC : 0;
1839 }
1840 if((m_cf.Flags & CF_NOSIZESEL) == 0)
1841 {
1842 cf.dwMask |= CFM_SIZE;
1843 // GetSize() returns in tenths of points so mulitply by 2 to get twips
1844 cf.yHeight = GetSize() * 2;
1845 }
1846
1847 if((m_cf.Flags & CF_NOFACESEL) == 0)
1848 {
1849 cf.dwMask |= CFM_FACE;
1850 cf.bPitchAndFamily = m_cf.lpLogFont->lfPitchAndFamily;
1851 #if (_RICHEDIT_VER >= 0x0200)
1852 SecureHelper::strcpy_x(cf.szFaceName, _countof(cf.szFaceName), GetFaceName());
1853 #else // !(_RICHEDIT_VER >= 0x0200)
1854 SecureHelper::strcpyA_x(cf.szFaceName, _countof(cf.szFaceName), T2A((LPTSTR)(LPCTSTR)GetFaceName()));
1855 #endif // !(_RICHEDIT_VER >= 0x0200)
1856 }
1857
1858 if((m_cf.Flags & CF_EFFECTS) != 0)
1859 {
1860 cf.dwMask |= CFM_UNDERLINE | CFM_STRIKEOUT | CFM_COLOR;
1861 cf.dwEffects |= IsUnderline() ? CFE_UNDERLINE : 0;
1862 cf.dwEffects |= IsStrikeOut() ? CFE_STRIKEOUT : 0;
1863 cf.crTextColor = GetColor();
1864 }
1865 if((m_cf.Flags & CF_NOSCRIPTSEL) == 0)
1866 {
1867 cf.bCharSet = m_cf.lpLogFont->lfCharSet;
1868 cf.dwMask |= CFM_CHARSET;
1869 }
1870 cf.yOffset = 0;
1871 }
1872
1873 DWORD FillInLogFont(const CHARFORMAT& cf)
1874 {
1875 USES_CONVERSION;
1876 DWORD dwFlags = 0;
1877 if((cf.dwMask & CFM_SIZE) != 0)
1878 {
1879 HDC hDC = ::CreateDC(_T("DISPLAY"), NULL, NULL, NULL);
1880 LONG yPerInch = ::GetDeviceCaps(hDC, LOGPIXELSY);
1881 m_lf.lfHeight = -(int)((cf.yHeight * yPerInch) / 1440);
1882 }
1883 else
1884 m_lf.lfHeight = 0;
1885
1886 m_lf.lfWidth = 0;
1887 m_lf.lfEscapement = 0;
1888 m_lf.lfOrientation = 0;
1889
1890 if((cf.dwMask & (CFM_ITALIC | CFM_BOLD)) == (CFM_ITALIC | CFM_BOLD))
1891 {
1892 m_lf.lfWeight = ((cf.dwEffects & CFE_BOLD) != 0) ? FW_BOLD : FW_NORMAL;
1893 m_lf.lfItalic = (BYTE)(((cf.dwEffects & CFE_ITALIC) != 0) ? TRUE : FALSE);
1894 }
1895 else
1896 {
1897 dwFlags |= CF_NOSTYLESEL;
1898 m_lf.lfWeight = FW_DONTCARE;
1899 m_lf.lfItalic = FALSE;
1900 }
1901
1902 if((cf.dwMask & (CFM_UNDERLINE | CFM_STRIKEOUT | CFM_COLOR)) == (CFM_UNDERLINE|CFM_STRIKEOUT|CFM_COLOR))
1903 {
1904 dwFlags |= CF_EFFECTS;
1905 m_lf.lfUnderline = (BYTE)(((cf.dwEffects & CFE_UNDERLINE) != 0) ? TRUE : FALSE);
1906 m_lf.lfStrikeOut = (BYTE)(((cf.dwEffects & CFE_STRIKEOUT) != 0) ? TRUE : FALSE);
1907 }
1908 else
1909 {
1910 m_lf.lfUnderline = (BYTE)FALSE;
1911 m_lf.lfStrikeOut = (BYTE)FALSE;
1912 }
1913
1914 if((cf.dwMask & CFM_CHARSET) != 0)
1915 m_lf.lfCharSet = cf.bCharSet;
1916 else
1917 dwFlags |= CF_NOSCRIPTSEL;
1918 m_lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
1919 m_lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
1920 m_lf.lfQuality = DEFAULT_QUALITY;
1921 if((cf.dwMask & CFM_FACE) != 0)
1922 {
1923 m_lf.lfPitchAndFamily = cf.bPitchAndFamily;
1924 #if (_RICHEDIT_VER >= 0x0200)
1925 SecureHelper::strcpy_x(m_lf.lfFaceName, _countof(m_lf.lfFaceName), cf.szFaceName);
1926 #else // !(_RICHEDIT_VER >= 0x0200)
1927 SecureHelper::strcpy_x(m_lf.lfFaceName, _countof(m_lf.lfFaceName), A2T((LPSTR)cf.szFaceName));
1928 #endif // !(_RICHEDIT_VER >= 0x0200)
1929 }
1930 else
1931 {
1932 m_lf.lfPitchAndFamily = DEFAULT_PITCH|FF_DONTCARE;
1933 m_lf.lfFaceName[0] = (TCHAR)0;
1934 }
1935 return dwFlags;
1936 }
1937 };
1938
1939 class CRichEditFontDialog : public CRichEditFontDialogImpl<CRichEditFontDialog>
1940 {
1941 public:
1942 CRichEditFontDialog(const CHARFORMAT& charformat,
1943 DWORD dwFlags = CF_SCREENFONTS,
1944 HDC hDCPrinter = NULL,
1945 HWND hWndParent = NULL)
1946 : CRichEditFontDialogImpl<CRichEditFontDialog>(charformat, dwFlags, hDCPrinter, hWndParent)
1947 { }
1948
1949 DECLARE_EMPTY_MSG_MAP()
1950 };
1951
1952 #endif // defined(_RICHEDIT_) && !defined(_WIN32_WCE)
1953
1954
1955 ///////////////////////////////////////////////////////////////////////////////
1956 // CColorDialogImpl - color selection
1957
1958 #if !defined(_WIN32_WCE) || ((_WIN32_WCE > 420) && !(defined(WIN32_PLATFORM_WFSP) && (_WIN32_WCE > 0x0500)))
1959
1960 #ifdef _WIN32_WCE
1961 #pragma comment(lib, "commdlg.lib")
1962
1963 #ifndef SETRGBSTRING
1964 #define SETRGBSTRING _T("commdlg_SetRGBColor")
1965 #endif
1966
1967 #ifndef COLOROKSTRING
1968 #define COLOROKSTRING _T("commdlg_ColorOK")
1969 #endif
1970 #endif
1971
1972 template <class T>
1973 class ATL_NO_VTABLE CColorDialogImpl : public CCommonDialogImplBase
1974 {
1975 public:
1976 CHOOSECOLOR m_cc;
1977
1978 // Constructor
1979 CColorDialogImpl(COLORREF clrInit = 0, DWORD dwFlags = 0, HWND hWndParent = NULL)
1980 {
1981 memset(&m_cc, 0, sizeof(m_cc));
1982
1983 m_cc.lStructSize = sizeof(m_cc);
1984 m_cc.lpCustColors = GetCustomColors();
1985 m_cc.hwndOwner = hWndParent;
1986 m_cc.Flags = dwFlags | CC_ENABLEHOOK;
1987 m_cc.lpfnHook = (LPCCHOOKPROC)T::HookProc;
1988
1989 if(clrInit != 0)
1990 {
1991 m_cc.rgbResult = clrInit;
1992 m_cc.Flags |= CC_RGBINIT;
1993 }
1994 }
1995
1996 // Operations
1997 INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow())
1998 {
1999 ATLASSERT((m_cc.Flags & CC_ENABLEHOOK) != 0);
2000 ATLASSERT(m_cc.lpfnHook != NULL); // can still be a user hook
2001
2002 if(m_cc.hwndOwner == NULL) // set only if not specified before
2003 m_cc.hwndOwner = hWndParent;
2004
2005 ATLASSERT(m_hWnd == NULL);
2006 ModuleHelper::AddCreateWndData(&m_thunk.cd, (CCommonDialogImplBase*)this);
2007
2008 BOOL bRet = ::ChooseColor(&m_cc);
2009
2010 m_hWnd = NULL;
2011
2012 return bRet ? IDOK : IDCANCEL;
2013 }
2014
2015 // Set the current color while dialog is displayed
2016 void SetCurrentColor(COLORREF clr)
2017 {
2018 ATLASSERT(::IsWindow(m_hWnd));
2019 SendMessage(_GetSetRGBMessage(), 0, (LPARAM)clr);
2020 }
2021
2022 // Get the selected color after DoModal returns, or in OnColorOK
2023 COLORREF GetColor() const
2024 {
2025 return m_cc.rgbResult;
2026 }
2027
2028 // Special override for the color dialog
2029 static UINT_PTR APIENTRY HookProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
2030 {
2031 if(uMsg != WM_INITDIALOG && uMsg != _GetColorOKMessage())
2032 return 0;
2033
2034 LPCHOOSECOLOR lpCC = (LPCHOOSECOLOR)lParam;
2035 CCommonDialogImplBase* pT = NULL;
2036
2037 if(uMsg == WM_INITDIALOG)
2038 {
2039 pT = (CCommonDialogImplBase*)ModuleHelper::ExtractCreateWndData();
2040 lpCC->lCustData = (LPARAM)pT;
2041 ATLASSERT(pT != NULL);
2042 ATLASSERT(pT->m_hWnd == NULL);
2043 ATLASSERT(::IsWindow(hWnd));
2044 // subclass dialog's window
2045 if(!pT->SubclassWindow(hWnd))
2046 {
2047 ATLTRACE2(atlTraceUI, 0, _T("Subclassing a Color common dialog failed\n"));
2048 return 0;
2049 }
2050 }
2051 else if(uMsg == _GetColorOKMessage())
2052 {
2053 pT = (CCommonDialogImplBase*)lpCC->lCustData;
2054 ATLASSERT(pT != NULL);
2055 ATLASSERT(::IsWindow(pT->m_hWnd));
2056 }
2057
2058 // pass to the message map
2059 LRESULT lRes;
2060 if(pT->ProcessWindowMessage(pT->m_hWnd, uMsg, wParam, lParam, lRes, 0) == FALSE)
2061 return 0;
2062 return lRes;
2063 }
2064
2065 // Helpers
2066 static COLORREF* GetCustomColors()
2067 {
2068 static COLORREF rgbCustomColors[16] =
2069 {
2070 RGB(255, 255, 255), RGB(255, 255, 255),
2071 RGB(255, 255, 255), RGB(255, 255, 255),
2072 RGB(255, 255, 255), RGB(255, 255, 255),
2073 RGB(255, 255, 255), RGB(255, 255, 255),
2074 RGB(255, 255, 255), RGB(255, 255, 255),
2075 RGB(255, 255, 255), RGB(255, 255, 255),
2076 RGB(255, 255, 255), RGB(255, 255, 255),
2077 RGB(255, 255, 255), RGB(255, 255, 255),
2078 };
2079
2080 return rgbCustomColors;
2081 }
2082
2083 static UINT _GetSetRGBMessage()
2084 {
2085 static UINT uSetRGBMessage = 0;
2086 if(uSetRGBMessage == 0)
2087 {
2088 CStaticDataInitCriticalSectionLock lock;
2089 if(FAILED(lock.Lock()))
2090 {
2091 ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CColorDialogImpl::_GetSetRGBMessage.\n"));
2092 ATLASSERT(FALSE);
2093 return 0;
2094 }
2095
2096 if(uSetRGBMessage == 0)
2097 uSetRGBMessage = ::RegisterWindowMessage(SETRGBSTRING);
2098
2099 lock.Unlock();
2100 }
2101 ATLASSERT(uSetRGBMessage != 0);
2102 return uSetRGBMessage;
2103 }
2104
2105 static UINT _GetColorOKMessage()
2106 {
2107 static UINT uColorOKMessage = 0;
2108 if(uColorOKMessage == 0)
2109 {
2110 CStaticDataInitCriticalSectionLock lock;
2111 if(FAILED(lock.Lock()))
2112 {
2113 ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CColorDialogImpl::_GetColorOKMessage.\n"));
2114 ATLASSERT(FALSE);
2115 return 0;
2116 }
2117
2118 if(uColorOKMessage == 0)
2119 uColorOKMessage = ::RegisterWindowMessage(COLOROKSTRING);
2120
2121 lock.Unlock();
2122 }
2123 ATLASSERT(uColorOKMessage != 0);
2124 return uColorOKMessage;
2125 }
2126
2127 // Message map and handlers
2128 BEGIN_MSG_MAP(CColorDialogImpl)
2129 MESSAGE_HANDLER(_GetColorOKMessage(), _OnColorOK)
2130 END_MSG_MAP()
2131
2132 LRESULT _OnColorOK(UINT, WPARAM, LPARAM, BOOL&)
2133 {
2134 T* pT = static_cast<T*>(this);
2135 return pT->OnColorOK();
2136 }
2137
2138 // Overrideable
2139 BOOL OnColorOK() // validate color
2140 {
2141 return FALSE;
2142 }
2143 };
2144
2145 class CColorDialog : public CColorDialogImpl<CColorDialog>
2146 {
2147 public:
2148 CColorDialog(COLORREF clrInit = 0, DWORD dwFlags = 0, HWND hWndParent = NULL)
2149 : CColorDialogImpl<CColorDialog>(clrInit, dwFlags, hWndParent)
2150 { }
2151
2152 // override base class map and references to handlers
2153 DECLARE_EMPTY_MSG_MAP()
2154 };
2155
2156 #endif // !defined(_WIN32_WCE) || ((_WIN32_WCE > 420) && !(defined(WIN32_PLATFORM_WFSP) && (_WIN32_WCE > 0x0500)))
2157
2158
2159 ///////////////////////////////////////////////////////////////////////////////
2160 // CPrintDialogImpl - used for Print... and PrintSetup...
2161
2162 #ifndef _WIN32_WCE
2163
2164 // global helper
2165 static HDC _AtlCreateDC(HGLOBAL hDevNames, HGLOBAL hDevMode)
2166 {
2167 if(hDevNames == NULL)
2168 return NULL;
2169
2170 LPDEVNAMES lpDevNames = (LPDEVNAMES)::GlobalLock(hDevNames);
2171 LPDEVMODE lpDevMode = (hDevMode != NULL) ? (LPDEVMODE)::GlobalLock(hDevMode) : NULL;
2172
2173 if(lpDevNames == NULL)
2174 return NULL;
2175
2176 HDC hDC = ::CreateDC((LPCTSTR)lpDevNames + lpDevNames->wDriverOffset,
2177 (LPCTSTR)lpDevNames + lpDevNames->wDeviceOffset,
2178 (LPCTSTR)lpDevNames + lpDevNames->wOutputOffset,
2179 lpDevMode);
2180
2181 ::GlobalUnlock(hDevNames);
2182 if(hDevMode != NULL)
2183 ::GlobalUnlock(hDevMode);
2184 return hDC;
2185 }
2186
2187 template <class T>
2188 class ATL_NO_VTABLE CPrintDialogImpl : public CCommonDialogImplBase
2189 {
2190 public:
2191 // print dialog parameter block (note this is a reference)
2192 PRINTDLG& m_pd;
2193
2194 // Constructors
2195 CPrintDialogImpl(BOOL bPrintSetupOnly = FALSE, // TRUE for Print Setup, FALSE for Print Dialog
2196 DWORD dwFlags = PD_ALLPAGES | PD_USEDEVMODECOPIES | PD_NOPAGENUMS | PD_NOSELECTION,
2197 HWND hWndParent = NULL)
2198 : m_pd(m_pdActual)
2199 {
2200 memset(&m_pdActual, 0, sizeof(m_pdActual));
2201
2202 m_pd.lStructSize = sizeof(m_pdActual);
2203 m_pd.hwndOwner = hWndParent;
2204 m_pd.Flags = (dwFlags | PD_ENABLEPRINTHOOK | PD_ENABLESETUPHOOK);
2205 m_pd.lpfnPrintHook = (LPPRINTHOOKPROC)T::HookProc;
2206 m_pd.lpfnSetupHook = (LPSETUPHOOKPROC)T::HookProc;
2207
2208 if(bPrintSetupOnly)
2209 m_pd.Flags |= PD_PRINTSETUP;
2210 else
2211 m_pd.Flags |= PD_RETURNDC;
2212
2213 m_pd.Flags &= ~PD_RETURNIC; // do not support information context
2214 }
2215
2216 // Operations
2217 INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow())
2218 {
2219 ATLASSERT((m_pd.Flags & PD_ENABLEPRINTHOOK) != 0);
2220 ATLASSERT((m_pd.Flags & PD_ENABLESETUPHOOK) != 0);
2221 ATLASSERT(m_pd.lpfnPrintHook != NULL); // can still be a user hook
2222 ATLASSERT(m_pd.lpfnSetupHook != NULL); // can still be a user hook
2223 ATLASSERT((m_pd.Flags & PD_RETURNDEFAULT) == 0); // use GetDefaults for this
2224
2225 if(m_pd.hwndOwner == NULL) // set only if not specified before
2226 m_pd.hwndOwner = hWndParent;
2227
2228 ATLASSERT(m_hWnd == NULL);
2229 ModuleHelper::AddCreateWndData(&m_thunk.cd, (CCommonDialogImplBase*)this);
2230
2231 BOOL bRet = ::PrintDlg(&m_pd);
2232
2233 m_hWnd = NULL;
2234
2235 return bRet ? IDOK : IDCANCEL;
2236 }
2237
2238 // GetDefaults will not display a dialog but will get device defaults
2239 BOOL GetDefaults()
2240 {
2241 m_pd.Flags |= PD_RETURNDEFAULT;
2242 ATLASSERT(m_pd.hDevMode == NULL); // must be NULL
2243 ATLASSERT(m_pd.hDevNames == NULL); // must be NULL
2244
2245 return ::PrintDlg(&m_pd);
2246 }
2247
2248 // Helpers for parsing information after successful return num. copies requested
2249 int GetCopies() const
2250 {
2251 if((m_pd.Flags & PD_USEDEVMODECOPIES) != 0)
2252 {
2253 LPDEVMODE lpDevMode = GetDevMode();
2254 return (lpDevMode != NULL) ? lpDevMode->dmCopies : -1;
2255 }
2256
2257 return m_pd.nCopies;
2258 }
2259
2260 BOOL PrintCollate() const // TRUE if collate checked
2261 {
2262 return ((m_pd.Flags & PD_COLLATE) != 0) ? TRUE : FALSE;
2263 }
2264
2265 BOOL PrintSelection() const // TRUE if printing selection
2266 {
2267 return ((m_pd.Flags & PD_SELECTION) != 0) ? TRUE : FALSE;
2268 }
2269
2270 BOOL PrintAll() const // TRUE if printing all pages
2271 {
2272 return (!PrintRange() && !PrintSelection()) ? TRUE : FALSE;
2273 }
2274
2275 BOOL PrintRange() const // TRUE if printing page range
2276 {
2277 return ((m_pd.Flags & PD_PAGENUMS) != 0) ? TRUE : FALSE;
2278 }
2279
2280 BOOL PrintToFile() const // TRUE if printing to a file
2281 {
2282 return ((m_pd.Flags & PD_PRINTTOFILE) != 0) ? TRUE : FALSE;
2283 }
2284
2285 int GetFromPage() const // starting page if valid
2286 {
2287 return PrintRange() ? m_pd.nFromPage : -1;
2288 }
2289
2290 int GetToPage() const // ending page if valid
2291 {
2292 return PrintRange() ? m_pd.nToPage : -1;
2293 }
2294
2295 LPDEVMODE GetDevMode() const // return DEVMODE
2296 {
2297 if(m_pd.hDevMode == NULL)
2298 return NULL;
2299
2300 return (LPDEVMODE)::GlobalLock(m_pd.hDevMode);
2301 }
2302
2303 LPCTSTR GetDriverName() const // return driver name
2304 {
2305 if(m_pd.hDevNames == NULL)
2306 return NULL;
2307
2308 LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_pd.hDevNames);
2309 if(lpDev == NULL)
2310 return NULL;
2311
2312 return (LPCTSTR)lpDev + lpDev->wDriverOffset;
2313 }
2314
2315 LPCTSTR GetDeviceName() const // return device name
2316 {
2317 if(m_pd.hDevNames == NULL)
2318 return NULL;
2319
2320 LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_pd.hDevNames);
2321 if(lpDev == NULL)
2322 return NULL;
2323
2324 return (LPCTSTR)lpDev + lpDev->wDeviceOffset;
2325 }
2326
2327 LPCTSTR GetPortName() const // return output port name
2328 {
2329 if(m_pd.hDevNames == NULL)
2330 return NULL;
2331
2332 LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_pd.hDevNames);
2333 if(lpDev == NULL)
2334 return NULL;
2335
2336 return (LPCTSTR)lpDev + lpDev->wOutputOffset;
2337 }
2338
2339 HDC GetPrinterDC() const // return HDC (caller must delete)
2340 {
2341 ATLASSERT((m_pd.Flags & PD_RETURNDC) != 0);
2342 return m_pd.hDC;
2343 }
2344
2345 // This helper creates a DC based on the DEVNAMES and DEVMODE structures.
2346 // This DC is returned, but also stored in m_pd.hDC as though it had been
2347 // returned by CommDlg. It is assumed that any previously obtained DC
2348 // has been/will be deleted by the user. This may be
2349 // used without ever invoking the print/print setup dialogs.
2350 HDC CreatePrinterDC()
2351 {
2352 m_pd.hDC = _AtlCreateDC(m_pd.hDevNames, m_pd.hDevMode);
2353 return m_pd.hDC;
2354 }
2355
2356 // Implementation
2357 PRINTDLG m_pdActual; // the Print/Print Setup need to share this
2358
2359 // The following handle the case of print setup... from the print dialog
2360 CPrintDialogImpl(PRINTDLG& pdInit) : m_pd(pdInit)
2361 { }
2362
2363 BEGIN_MSG_MAP(CPrintDialogImpl)
2364 #ifdef psh1
2365 COMMAND_ID_HANDLER(psh1, OnPrintSetup) // print setup button when print is displayed
2366 #else // !psh1
2367 COMMAND_ID_HANDLER(0x0400, OnPrintSetup) // value from dlgs.h
2368 #endif // !psh1
2369 END_MSG_MAP()
2370
2371 LRESULT OnPrintSetup(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& /*bHandled*/)
2372 {
2373 T dlgSetup(m_pd);
2374 ModuleHelper::AddCreateWndData(&dlgSetup.m_thunk.cd, (CCommonDialogImplBase*)&dlgSetup);
2375 return DefWindowProc(WM_COMMAND, MAKEWPARAM(wID, wNotifyCode), (LPARAM)hWndCtl);
2376 }
2377 };
2378
2379 class CPrintDialog : public CPrintDialogImpl<CPrintDialog>
2380 {
2381 public:
2382 CPrintDialog(BOOL bPrintSetupOnly = FALSE,
2383 DWORD dwFlags = PD_ALLPAGES | PD_USEDEVMODECOPIES | PD_NOPAGENUMS | PD_NOSELECTION,
2384 HWND hWndParent = NULL)
2385 : CPrintDialogImpl<CPrintDialog>(bPrintSetupOnly, dwFlags, hWndParent)
2386 { }
2387
2388 CPrintDialog(PRINTDLG& pdInit) : CPrintDialogImpl<CPrintDialog>(pdInit)
2389 { }
2390 };
2391
2392 #endif // _WIN32_WCE
2393
2394
2395 ///////////////////////////////////////////////////////////////////////////////
2396 // CPrintDialogExImpl - new print dialog for Windows 2000
2397
2398 #if (WINVER >= 0x0500) && !defined(_WIN32_WCE)
2399
2400 }; // namespace WTL
2401
2402 #include <atlcom.h>
2403
2404 extern "C" const __declspec(selectany) IID IID_IPrintDialogCallback = {0x5852a2c3, 0x6530, 0x11d1, {0xb6, 0xa3, 0x0, 0x0, 0xf8, 0x75, 0x7b, 0xf9}};
2405 extern "C" const __declspec(selectany) IID IID_IPrintDialogServices = {0x509aaeda, 0x5639, 0x11d1, {0xb6, 0xa1, 0x0, 0x0, 0xf8, 0x75, 0x7b, 0xf9}};
2406
2407 namespace WTL
2408 {
2409
2410 template <class T>
2411 class ATL_NO_VTABLE CPrintDialogExImpl :
2412 public ATL::CWindow,
2413 public ATL::CMessageMap,
2414 public IPrintDialogCallback,
2415 public ATL::IObjectWithSiteImpl< T >
2416 {
2417 public:
2418 PRINTDLGEX m_pdex;
2419
2420 // Constructor
2421 CPrintDialogExImpl(DWORD dwFlags = PD_ALLPAGES | PD_USEDEVMODECOPIES | PD_NOPAGENUMS | PD_NOSELECTION | PD_NOCURRENTPAGE,
2422 HWND hWndParent = NULL)
2423 {
2424 memset(&m_pdex, 0, sizeof(m_pdex));
2425
2426 m_pdex.lStructSize = sizeof(PRINTDLGEX);
2427 m_pdex.hwndOwner = hWndParent;
2428 m_pdex.Flags = dwFlags;
2429 m_pdex.nStartPage = START_PAGE_GENERAL;
2430 // callback object will be set in DoModal
2431
2432 m_pdex.Flags &= ~PD_RETURNIC; // do not support information context
2433 }
2434
2435 // Operations
2436 HRESULT DoModal(HWND hWndParent = ::GetActiveWindow())
2437 {
2438 ATLASSERT(m_hWnd == NULL);
2439 ATLASSERT((m_pdex.Flags & PD_RETURNDEFAULT) == 0); // use GetDefaults for this
2440
2441 if(m_pdex.hwndOwner == NULL) // set only if not specified before
2442 m_pdex.hwndOwner = hWndParent;
2443
2444 T* pT = static_cast<T*>(this);
2445 m_pdex.lpCallback = (IUnknown*)(IPrintDialogCallback*)pT;
2446
2447 HRESULT hResult = ::PrintDlgEx(&m_pdex);
2448
2449 m_hWnd = NULL;
2450
2451 return hResult;
2452 }
2453
2454 BOOL EndDialog(INT_PTR /*nRetCode*/ = 0)
2455 {
2456 ATLASSERT(::IsWindow(m_hWnd));
2457 SendMessage(WM_COMMAND, MAKEWPARAM(IDABORT, 0));
2458 return TRUE;
2459 }
2460
2461 // GetDefaults will not display a dialog but will get device defaults
2462 HRESULT GetDefaults()
2463 {
2464 m_pdex.Flags |= PD_RETURNDEFAULT;
2465 ATLASSERT(m_pdex.hDevMode == NULL); // must be NULL
2466 ATLASSERT(m_pdex.hDevNames == NULL); // must be NULL
2467
2468 return ::PrintDlgEx(&m_pdex);
2469 }
2470
2471 // Helpers for parsing information after successful return num. copies requested
2472 int GetCopies() const
2473 {
2474 if((m_pdex.Flags & PD_USEDEVMODECOPIES) != 0)
2475 {
2476 LPDEVMODE lpDevMode = GetDevMode();
2477 return (lpDevMode != NULL) ? lpDevMode->dmCopies : -1;
2478 }
2479
2480 return m_pdex.nCopies;
2481 }
2482
2483 BOOL PrintCollate() const // TRUE if collate checked
2484 {
2485 return ((m_pdex.Flags & PD_COLLATE) != 0) ? TRUE : FALSE;
2486 }
2487
2488 BOOL PrintSelection() const // TRUE if printing selection
2489 {
2490 return ((m_pdex.Flags & PD_SELECTION) != 0) ? TRUE : FALSE;
2491 }
2492
2493 BOOL PrintAll() const // TRUE if printing all pages
2494 {
2495 return (!PrintRange() && !PrintSelection()) ? TRUE : FALSE;
2496 }
2497
2498 BOOL PrintRange() const // TRUE if printing page range
2499 {
2500 return ((m_pdex.Flags & PD_PAGENUMS) != 0) ? TRUE : FALSE;
2501 }
2502
2503 BOOL PrintToFile() const // TRUE if printing to a file
2504 {
2505 return ((m_pdex.Flags & PD_PRINTTOFILE) != 0) ? TRUE : FALSE;
2506 }
2507
2508 LPDEVMODE GetDevMode() const // return DEVMODE
2509 {
2510 if(m_pdex.hDevMode == NULL)
2511 return NULL;
2512
2513 return (LPDEVMODE)::GlobalLock(m_pdex.hDevMode);
2514 }
2515
2516 LPCTSTR GetDriverName() const // return driver name
2517 {
2518 if(m_pdex.hDevNames == NULL)
2519 return NULL;
2520
2521 LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_pdex.hDevNames);
2522 if(lpDev == NULL)
2523 return NULL;
2524
2525 return (LPCTSTR)lpDev + lpDev->wDriverOffset;
2526 }
2527
2528 LPCTSTR GetDeviceName() const // return device name
2529 {
2530 if(m_pdex.hDevNames == NULL)
2531 return NULL;
2532
2533 LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_pdex.hDevNames);
2534 if(lpDev == NULL)
2535 return NULL;
2536
2537 return (LPCTSTR)lpDev + lpDev->wDeviceOffset;
2538 }
2539
2540 LPCTSTR GetPortName() const // return output port name
2541 {
2542 if(m_pdex.hDevNames == NULL)
2543 return NULL;
2544
2545 LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_pdex.hDevNames);
2546 if(lpDev == NULL)
2547 return NULL;
2548
2549 return (LPCTSTR)lpDev + lpDev->wOutputOffset;
2550 }
2551
2552 HDC GetPrinterDC() const // return HDC (caller must delete)
2553 {
2554 ATLASSERT((m_pdex.Flags & PD_RETURNDC) != 0);
2555 return m_pdex.hDC;
2556 }
2557
2558 // This helper creates a DC based on the DEVNAMES and DEVMODE structures.
2559 // This DC is returned, but also stored in m_pdex.hDC as though it had been
2560 // returned by CommDlg. It is assumed that any previously obtained DC
2561 // has been/will be deleted by the user. This may be
2562 // used without ever invoking the print/print setup dialogs.
2563 HDC CreatePrinterDC()
2564 {
2565 m_pdex.hDC = _AtlCreateDC(m_pdex.hDevNames, m_pdex.hDevMode);
2566 return m_pdex.hDC;
2567 }
2568
2569 // Implementation - interfaces
2570
2571 // IUnknown
2572 STDMETHOD(QueryInterface)(REFIID riid, void** ppvObject)
2573 {
2574 if(ppvObject == NULL)
2575 return E_POINTER;
2576
2577 T* pT = static_cast<T*>(this);
2578 if(IsEqualGUID(riid, IID_IUnknown) || IsEqualGUID(riid, IID_IPrintDialogCallback))
2579 {
2580 *ppvObject = (IPrintDialogCallback*)pT;
2581 // AddRef() not needed
2582 return S_OK;
2583 }
2584 else if(IsEqualGUID(riid, IID_IObjectWithSite))
2585 {
2586 *ppvObject = (IObjectWithSite*)pT;
2587 // AddRef() not needed
2588 return S_OK;
2589 }
2590
2591 return E_NOINTERFACE;
2592 }
2593
2594 virtual ULONG STDMETHODCALLTYPE AddRef()
2595 {
2596 return 1;
2597 }
2598
2599 virtual ULONG STDMETHODCALLTYPE Release()
2600 {
2601 return 1;
2602 }
2603
2604 // IPrintDialogCallback
2605 STDMETHOD(InitDone)()
2606 {
2607 return S_FALSE;
2608 }
2609
2610 STDMETHOD(SelectionChange)()
2611 {
2612 return S_FALSE;
2613 }
2614
2615 STDMETHOD(HandleMessage)(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT* plResult)
2616 {
2617 // set up m_hWnd the first time
2618 if(m_hWnd == NULL)
2619 Attach(hWnd);
2620
2621 // call message map
2622 HRESULT hRet = ProcessWindowMessage(hWnd, uMsg, wParam, lParam, *plResult, 0) ? S_OK : S_FALSE;
2623 if(hRet == S_OK && uMsg == WM_NOTIFY) // return in DWLP_MSGRESULT
2624 ::SetWindowLongPtr(GetParent(), DWLP_MSGRESULT, (LONG_PTR)*plResult);
2625
2626 if(uMsg == WM_INITDIALOG && hRet == S_OK && (BOOL)*plResult != FALSE)
2627 hRet = S_FALSE;
2628
2629 return hRet;
2630 }
2631 };
2632
2633 class CPrintDialogEx : public CPrintDialogExImpl<CPrintDialogEx>
2634 {
2635 public:
2636 CPrintDialogEx(
2637 DWORD dwFlags = PD_ALLPAGES | PD_USEDEVMODECOPIES | PD_NOPAGENUMS | PD_NOSELECTION | PD_NOCURRENTPAGE,
2638 HWND hWndParent = NULL)
2639 : CPrintDialogExImpl<CPrintDialogEx>(dwFlags, hWndParent)
2640 { }
2641
2642 DECLARE_EMPTY_MSG_MAP()
2643 };
2644
2645 #endif // (WINVER >= 0x0500) && !defined(_WIN32_WCE)
2646
2647
2648 ///////////////////////////////////////////////////////////////////////////////
2649 // CPageSetupDialogImpl - Page Setup dialog
2650
2651 #ifndef _WIN32_WCE
2652
2653 template <class T>
2654 class ATL_NO_VTABLE CPageSetupDialogImpl : public CCommonDialogImplBase
2655 {
2656 public:
2657 PAGESETUPDLG m_psd;
2658 ATL::CWndProcThunk m_thunkPaint;
2659
2660 // Constructors
2661 CPageSetupDialogImpl(DWORD dwFlags = PSD_MARGINS | PSD_INWININIINTLMEASURE, HWND hWndParent = NULL)
2662 {
2663 memset(&m_psd, 0, sizeof(m_psd));
2664
2665 m_psd.lStructSize = sizeof(m_psd);
2666 m_psd.hwndOwner = hWndParent;
2667 m_psd.Flags = (dwFlags | PSD_ENABLEPAGESETUPHOOK | PSD_ENABLEPAGEPAINTHOOK);
2668 m_psd.lpfnPageSetupHook = (LPPAGESETUPHOOK)T::HookProc;
2669 m_thunkPaint.Init((WNDPROC)T::PaintHookProc, this);
2670 #if (_ATL_VER >= 0x0700)
2671 m_psd.lpfnPagePaintHook = (LPPAGEPAINTHOOK)m_thunkPaint.GetWNDPROC();
2672 #else
2673 m_psd.lpfnPagePaintHook = (LPPAGEPAINTHOOK)&(m_thunkPaint.thunk);
2674 #endif
2675 }
2676
2677 DECLARE_EMPTY_MSG_MAP()
2678
2679 // Attributes
2680 LPDEVMODE GetDevMode() const // return DEVMODE
2681 {
2682 if(m_psd.hDevMode == NULL)
2683 return NULL;
2684
2685 return (LPDEVMODE)::GlobalLock(m_psd.hDevMode);
2686 }
2687
2688 LPCTSTR GetDriverName() const // return driver name
2689 {
2690 if(m_psd.hDevNames == NULL)
2691 return NULL;
2692
2693 LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_psd.hDevNames);
2694 return (LPCTSTR)lpDev + lpDev->wDriverOffset;
2695 }
2696
2697 LPCTSTR GetDeviceName() const // return device name
2698 {
2699 if(m_psd.hDevNames == NULL)
2700 return NULL;
2701
2702 LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_psd.hDevNames);
2703 return (LPCTSTR)lpDev + lpDev->wDeviceOffset;
2704 }
2705
2706 LPCTSTR GetPortName() const // return output port name
2707 {
2708 if(m_psd.hDevNames == NULL)
2709 return NULL;
2710
2711 LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_psd.hDevNames);
2712 return (LPCTSTR)lpDev + lpDev->wOutputOffset;
2713 }
2714
2715 HDC CreatePrinterDC()
2716 {
2717 return _AtlCreateDC(m_psd.hDevNames, m_psd.hDevMode);
2718 }
2719
2720 SIZE GetPaperSize() const
2721 {
2722 SIZE size;
2723 size.cx = m_psd.ptPaperSize.x;
2724 size.cy = m_psd.ptPaperSize.y;
2725 return size;
2726 }
2727
2728 void GetMargins(LPRECT lpRectMargins, LPRECT lpRectMinMargins) const
2729 {
2730 if(lpRectMargins != NULL)
2731 *lpRectMargins = m_psd.rtMargin;
2732 if(lpRectMinMargins != NULL)
2733 *lpRectMinMargins = m_psd.rtMinMargin;
2734 }
2735
2736 // Operations
2737 INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow())
2738 {
2739 ATLASSERT((m_psd.Flags & PSD_ENABLEPAGESETUPHOOK) != 0);
2740 ATLASSERT((m_psd.Flags & PSD_ENABLEPAGEPAINTHOOK) != 0);
2741 ATLASSERT(m_psd.lpfnPageSetupHook != NULL); // can still be a user hook
2742 ATLASSERT(m_psd.lpfnPagePaintHook != NULL); // can still be a user hook
2743
2744 if(m_psd.hwndOwner == NULL) // set only if not specified before
2745 m_psd.hwndOwner = hWndParent;
2746
2747 ATLASSERT(m_hWnd == NULL);
2748 ModuleHelper::AddCreateWndData(&m_thunk.cd, (CCommonDialogImplBase*)this);
2749
2750 BOOL bRet = ::PageSetupDlg(&m_psd);
2751
2752 m_hWnd = NULL;
2753
2754 return bRet ? IDOK : IDCANCEL;
2755 }
2756
2757 // Implementation
2758 static UINT_PTR CALLBACK PaintHookProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
2759 {
2760 T* pT = (T*)hWnd;
2761 UINT_PTR uRet = 0;
2762 switch(uMsg)
2763 {
2764 case WM_PSD_PAGESETUPDLG:
2765 uRet = pT->PreDrawPage(LOWORD(wParam), HIWORD(wParam), (LPPAGESETUPDLG)lParam);
2766 break;
2767 case WM_PSD_FULLPAGERECT:
2768 case WM_PSD_MINMARGINRECT:
2769 case WM_PSD_MARGINRECT:
2770 case WM_PSD_GREEKTEXTRECT:
2771 case WM_PSD_ENVSTAMPRECT:
2772 case WM_PSD_YAFULLPAGERECT:
2773 uRet = pT->OnDrawPage(uMsg, (HDC)wParam, (LPRECT)lParam);
2774 break;
2775 default:
2776 ATLTRACE2(atlTraceUI, 0, _T("CPageSetupDialogImpl::PaintHookProc - unknown message received\n"));
2777 break;
2778 }
2779 return uRet;
2780 }
2781
2782 // Overridables
2783 UINT_PTR PreDrawPage(WORD /*wPaper*/, WORD /*wFlags*/, LPPAGESETUPDLG /*pPSD*/)
2784 {
2785 // return 1 to prevent any more drawing
2786 return 0;
2787 }
2788
2789 UINT_PTR OnDrawPage(UINT /*uMsg*/, HDC /*hDC*/, LPRECT /*lpRect*/)
2790 {
2791 return 0; // do the default
2792 }
2793 };
2794
2795 class CPageSetupDialog : public CPageSetupDialogImpl<CPageSetupDialog>
2796 {
2797 public:
2798 CPageSetupDialog(DWORD dwFlags = PSD_MARGINS | PSD_INWININIINTLMEASURE, HWND hWndParent = NULL)
2799 : CPageSetupDialogImpl<CPageSetupDialog>(dwFlags, hWndParent)
2800 { }
2801
2802 // override PaintHookProc and references to handlers
2803 static UINT_PTR CALLBACK PaintHookProc(HWND, UINT, WPARAM, LPARAM)
2804 {
2805 return 0;
2806 }
2807 };
2808
2809 #endif // _WIN32_WCE
2810
2811
2812 ///////////////////////////////////////////////////////////////////////////////
2813 // CFindReplaceDialogImpl - Find/FindReplace modeless dialogs
2814
2815 #ifndef _WIN32_WCE
2816
2817 template <class T>
2818 class ATL_NO_VTABLE CFindReplaceDialogImpl : public CCommonDialogImplBase
2819 {
2820 public:
2821 enum { _cchFindReplaceBuffer = 128 };
2822
2823 FINDREPLACE m_fr;
2824 TCHAR m_szFindWhat[_cchFindReplaceBuffer];
2825 TCHAR m_szReplaceWith[_cchFindReplaceBuffer];
2826
2827 // Constructors
2828 CFindReplaceDialogImpl()
2829 {
2830 memset(&m_fr, 0, sizeof(m_fr));
2831 m_szFindWhat[0] = _T('\0');
2832 m_szReplaceWith[0] = _T('\0');
2833
2834 m_fr.lStructSize = sizeof(m_fr);
2835 m_fr.Flags = FR_ENABLEHOOK;
2836 m_fr.lpfnHook = (LPFRHOOKPROC)T::HookProc;
2837 m_fr.lpstrFindWhat = (LPTSTR)m_szFindWhat;
2838 m_fr.wFindWhatLen = _cchFindReplaceBuffer;
2839 m_fr.lpstrReplaceWith = (LPTSTR)m_szReplaceWith;
2840 m_fr.wReplaceWithLen = _cchFindReplaceBuffer;
2841 }
2842
2843 // Note: You must allocate the object on the heap.
2844 // If you do not, you must override OnFinalMessage()
2845 virtual void OnFinalMessage(HWND /*hWnd*/)
2846 {
2847 delete this;
2848 }
2849
2850 HWND Create(BOOL bFindDialogOnly, // TRUE for Find, FALSE for FindReplace
2851 LPCTSTR lpszFindWhat,
2852 LPCTSTR lpszReplaceWith = NULL,
2853 DWORD dwFlags = FR_DOWN,
2854 HWND hWndParent = NULL)
2855 {
2856 ATLASSERT((m_fr.Flags & FR_ENABLEHOOK) != 0);
2857 ATLASSERT(m_fr.lpfnHook != NULL);
2858
2859 m_fr.Flags |= dwFlags;
2860
2861 if(hWndParent == NULL)
2862 m_fr.hwndOwner = ::GetActiveWindow();
2863 else
2864 m_fr.hwndOwner = hWndParent;
2865 ATLASSERT(m_fr.hwndOwner != NULL); // must have an owner for modeless dialog
2866
2867 if(lpszFindWhat != NULL)
2868 SecureHelper::strncpy_x(m_szFindWhat, _countof(m_szFindWhat), lpszFindWhat, _TRUNCATE);
2869
2870 if(lpszReplaceWith != NULL)
2871 SecureHelper::strncpy_x(m_szReplaceWith, _countof(m_szReplaceWith), lpszReplaceWith, _TRUNCATE);
2872
2873 ATLASSERT(m_hWnd == NULL);
2874 ModuleHelper::AddCreateWndData(&m_thunk.cd, (CCommonDialogImplBase*)this);
2875
2876 HWND hWnd = NULL;
2877 if(bFindDialogOnly)
2878 hWnd = ::FindText(&m_fr);
2879 else
2880 hWnd = ::ReplaceText(&m_fr);
2881
2882 ATLASSERT(m_hWnd == hWnd);
2883 return hWnd;
2884 }
2885
2886 static const UINT GetFindReplaceMsg()
2887 {
2888 static const UINT nMsgFindReplace = ::RegisterWindowMessage(FINDMSGSTRING);
2889 return nMsgFindReplace;
2890 }
2891 // call while handling FINDMSGSTRING registered message
2892 // to retreive the object
2893 static T* PASCAL GetNotifier(LPARAM lParam)
2894 {
2895 ATLASSERT(lParam != NULL);
2896 T* pDlg = (T*)(lParam - offsetof(T, m_fr));
2897 return pDlg;
2898 }
2899
2900 // Operations
2901 // Helpers for parsing information after successful return
2902 LPCTSTR GetFindString() const // get find string
2903 {
2904 return (LPCTSTR)m_fr.lpstrFindWhat;
2905 }
2906
2907 LPCTSTR GetReplaceString() const // get replacement string
2908 {
2909 return (LPCTSTR)m_fr.lpstrReplaceWith;
2910 }
2911
2912 BOOL SearchDown() const // TRUE if search down, FALSE is up
2913 {
2914 return ((m_fr.Flags & FR_DOWN) != 0) ? TRUE : FALSE;
2915 }
2916
2917 BOOL FindNext() const // TRUE if command is find next
2918 {
2919 return ((m_fr.Flags & FR_FINDNEXT) != 0) ? TRUE : FALSE;
2920 }
2921
2922 BOOL MatchCase() const // TRUE if matching case
2923 {
2924 return ((m_fr.Flags & FR_MATCHCASE) != 0) ? TRUE : FALSE;
2925 }
2926
2927 BOOL MatchWholeWord() const // TRUE if matching whole words only
2928 {
2929 return ((m_fr.Flags & FR_WHOLEWORD) != 0) ? TRUE : FALSE;
2930 }
2931
2932 BOOL ReplaceCurrent() const // TRUE if replacing current string
2933 {
2934 return ((m_fr. Flags & FR_REPLACE) != 0) ? TRUE : FALSE;
2935 }
2936
2937 BOOL ReplaceAll() const // TRUE if replacing all occurrences
2938 {
2939 return ((m_fr.Flags & FR_REPLACEALL) != 0) ? TRUE : FALSE;
2940 }
2941
2942 BOOL IsTerminating() const // TRUE if terminating dialog
2943 {
2944 return ((m_fr.Flags & FR_DIALOGTERM) != 0) ? TRUE : FALSE ;
2945 }
2946 };
2947
2948 class CFindReplaceDialog : public CFindReplaceDialogImpl<CFindReplaceDialog>
2949 {
2950 public:
2951 DECLARE_EMPTY_MSG_MAP()
2952 };
2953
2954 #endif // !_WIN32_WCE
2955
2956
2957 #if (_ATL_VER >= 0x800)
2958 typedef ATL::_DialogSplitHelper::DLGTEMPLATEEX DLGTEMPLATEEX;
2959 typedef ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX DLGITEMTEMPLATEEX;
2960 #else // (_ATL_VER >= 0x800)
2961 typedef ATL::_DialogSizeHelper::_ATL_DLGTEMPLATEEX DLGTEMPLATEEX;
2962 #pragma pack(push, 4)
2963 struct DLGITEMTEMPLATEEX
2964 {
2965 DWORD helpID;
2966 DWORD exStyle;
2967 DWORD style;
2968 short x;
2969 short y;
2970 short cx;
2971 short cy;
2972 WORD id;
2973 };
2974 #pragma pack(pop)
2975 #endif // (_ATL_VER >= 0x800)
2976
2977
2978 ///////////////////////////////////////////////////////////////////////////////
2979 // CMemDlgTemplate - in-memory dialog template - DLGTEMPLATE or DLGTEMPLATEEX
2980
2981 class CMemDlgTemplate
2982 {
2983 public:
2984 enum StdCtrlType
2985 {
2986 CTRL_BUTTON = 0x0080,
2987 CTRL_EDIT = 0x0081,
2988 CTRL_STATIC = 0x0082,
2989 CTRL_LISTBOX = 0x0083,
2990 CTRL_SCROLLBAR = 0x0084,
2991 CTRL_COMBOBOX = 0x0085
2992 };
2993
2994 CMemDlgTemplate() : m_pData(NULL), m_pPtr(NULL), m_cAllocated(0)
2995 { }
2996
2997 ~CMemDlgTemplate()
2998 {
2999 Reset();
3000 }
3001
3002 bool IsValid() const
3003 {
3004 return (m_pData != NULL);
3005 }
3006
3007 bool IsTemplateEx() const
3008 {
3009 return (IsValid() && ((DLGTEMPLATEEX*)m_pData)->signature == 0xFFFF);
3010 }
3011
3012 LPDLGTEMPLATE GetTemplatePtr()
3013 {
3014 return reinterpret_cast<LPDLGTEMPLATE>(m_pData);
3015 }
3016
3017 DLGTEMPLATEEX* GetTemplateExPtr()
3018 {
3019 return reinterpret_cast<DLGTEMPLATEEX*>(m_pData);
3020 }
3021
3022 void Reset()
3023 {
3024 if (IsValid())
3025 ATLVERIFY(::GlobalFree(m_pData) == NULL);
3026
3027 m_pData = NULL;
3028 m_pPtr = NULL;
3029 m_cAllocated = 0;
3030 }
3031
3032 void Create(bool bDlgEx, LPCTSTR lpszCaption, short nX, short nY, short nWidth, short nHeight, DWORD dwStyle = 0, DWORD dwExStyle = 0,
3033 LPCTSTR lpstrFontName = NULL, WORD wFontSize = 0, WORD wWeight = 0, BYTE bItalic = 0, BYTE bCharset = 0, DWORD dwHelpID = 0,
3034 ATL::_U_STRINGorID ClassName = 0U, ATL::_U_STRINGorID Menu = 0U)
3035 {
3036 // Should have DS_SETFONT style to set the dialog font name and size
3037 if (lpstrFontName != NULL)
3038 {
3039 dwStyle |= DS_SETFONT;
3040 }
3041 else
3042 {
3043 dwStyle &= ~DS_SETFONT;
3044 }
3045
3046 if (bDlgEx)
3047 {
3048 DLGTEMPLATEEX dlg = {1, 0xFFFF, dwHelpID, dwExStyle, dwStyle, 0, nX, nY, nWidth, nHeight};
3049 AddData(&dlg, sizeof(dlg));
3050 }
3051 else
3052 {
3053 DLGTEMPLATE dlg = {dwStyle, dwExStyle, 0, nX, nY, nWidth, nHeight};
3054 AddData(&dlg, sizeof(dlg));
3055 }
3056
3057 #ifndef _WIN32_WCE
3058 if (Menu.m_lpstr == NULL)
3059 {
3060 WORD menuData = 0;
3061 AddData(&menuData, sizeof(WORD));
3062 }
3063 else if (IS_INTRESOURCE(Menu.m_lpstr))
3064 {
3065 WORD menuData[] = {0xFFFF, (WORD)Menu.m_lpstr};
3066 AddData(menuData, sizeof(menuData));
3067 }
3068 else
3069 {
3070 AddString(Menu.m_lpstr);
3071 }
3072 #else // _WIN32_WCE
3073 // Windows CE doesn't support the addition of menus to a dialog box
3074 ATLASSERT(Menu.m_lpstr == NULL);
3075 Menu.m_lpstr; // avoid level 4 warning
3076 WORD menuData = 0;
3077 AddData(&menuData, sizeof(WORD));
3078 #endif // _WIN32_WCE
3079
3080 if (ClassName.m_lpstr == NULL)
3081 {
3082 WORD classData = 0;
3083 AddData(&classData, sizeof(WORD));
3084 }
3085 else if (IS_INTRESOURCE(ClassName.m_lpstr))
3086 {
3087 WORD classData[] = {0xFFFF, (WORD)ClassName.m_lpstr};
3088 AddData(classData, sizeof(classData));
3089 }
3090 else
3091 {
3092 AddString(ClassName.m_lpstr);
3093 }
3094
3095 // Set dialog caption
3096 AddString(lpszCaption);
3097
3098 if (lpstrFontName != NULL)
3099 {
3100 AddData(&wFontSize, sizeof(wFontSize));
3101
3102 if (bDlgEx)
3103 {
3104 AddData(&wWeight, sizeof(wWeight));
3105 AddData(&bItalic, sizeof(bItalic));
3106 AddData(&bCharset, sizeof(bCharset));
3107 }
3108
3109 AddString(lpstrFontName);
3110 }
3111 }
3112
3113 void AddControl(ATL::_U_STRINGorID ClassName, WORD wId, short nX, short nY, short nWidth, short nHeight, DWORD dwStyle, DWORD dwExStyle,
3114 ATL::_U_STRINGorID Text, const WORD* pCreationData = NULL, WORD nCreationData = 0, DWORD dwHelpID = 0)
3115 {
3116 ATLASSERT(IsValid());
3117
3118 // DWORD align data
3119 m_pPtr = (LPBYTE)(DWORD_PTR)((DWORD)(DWORD_PTR)(m_pPtr + 3) & (~3));
3120
3121 if (IsTemplateEx())
3122 {
3123 DLGTEMPLATEEX* dlg = (DLGTEMPLATEEX*)m_pData;
3124 dlg->cDlgItems++;
3125
3126 DLGITEMTEMPLATEEX item = {dwHelpID, ATL::CControlWinTraits::GetWndExStyle(0) | dwExStyle, ATL::CControlWinTraits::GetWndStyle(0) | dwStyle, nX, nY, nWidth, nHeight, wId};
3127 AddData(&item, sizeof(item));
3128 }
3129 else
3130 {
3131 LPDLGTEMPLATE dlg = (LPDLGTEMPLATE)m_pData;
3132 dlg->cdit++;
3133
3134 DLGITEMTEMPLATE item = {ATL::CControlWinTraits::GetWndStyle(0) | dwStyle, ATL::CControlWinTraits::GetWndExStyle(0) | dwExStyle, nX, nY, nWidth, nHeight, wId};
3135 AddData(&item, sizeof(item));
3136 }
3137
3138 ATLASSERT(ClassName.m_lpstr != NULL);
3139 if (IS_INTRESOURCE(ClassName.m_lpstr))
3140 {
3141 WORD wData[] = {0xFFFF, (WORD)ClassName.m_lpstr};
3142 AddData(wData, sizeof(wData));
3143 }
3144 else
3145 {
3146 AddString(ClassName.m_lpstr);
3147 }
3148
3149 if (Text.m_lpstr == NULL)
3150 {
3151 WORD classData = 0;
3152 AddData(&classData, sizeof(WORD));
3153 }
3154 else if (IS_INTRESOURCE(Text.m_lpstr))
3155 {
3156 WORD wData[] = {0xFFFF, (WORD)Text.m_lpstr};
3157 AddData(wData, sizeof(wData));
3158 }
3159 else
3160 {
3161 AddString(Text.m_lpstr);
3162 }
3163
3164 AddData(&nCreationData, sizeof(nCreationData));
3165
3166 if ((nCreationData != 0))
3167 {
3168 ATLASSERT(pCreationData != NULL);
3169 AddData(pCreationData, nCreationData * sizeof(WORD));
3170 }
3171 }
3172
3173 void AddStdControl(StdCtrlType CtrlType, WORD wId, short nX, short nY, short nWidth, short nHeight,
3174 DWORD dwStyle, DWORD dwExStyle, ATL::_U_STRINGorID Text, const WORD* pCreationData = NULL, WORD nCreationData = 0, DWORD dwHelpID = 0)
3175 {
3176 AddControl(CtrlType, wId, nX, nY, nWidth, nHeight, dwStyle, dwExStyle, Text, pCreationData, nCreationData, dwHelpID);
3177 }
3178
3179 protected:
3180 void AddData(LPCVOID pData, size_t nData)
3181 {
3182 ATLASSERT(pData != NULL);
3183
3184 const size_t ALLOCATION_INCREMENT = 1024;
3185
3186 if (m_pData == NULL)
3187 {
3188 m_cAllocated = ((nData / ALLOCATION_INCREMENT) + 1) * ALLOCATION_INCREMENT;
3189 m_pPtr = m_pData = static_cast<LPBYTE>(::GlobalAlloc(GPTR, m_cAllocated));
3190 ATLASSERT(m_pData != NULL);
3191 }
3192 else if (((m_pPtr - m_pData) + nData) > m_cAllocated)
3193 {
3194 size_t ptrPos = (m_pPtr - m_pData);
3195 m_cAllocated += ((nData / ALLOCATION_INCREMENT) + 1) * ALLOCATION_INCREMENT;
3196 m_pData = static_cast<LPBYTE>(::GlobalReAlloc(m_pData, m_cAllocated, 0));
3197 ATLASSERT(m_pData != NULL);
3198 m_pPtr = m_pData + ptrPos;
3199 }
3200
3201 SecureHelper::memcpy_x(m_pPtr, m_cAllocated - (m_pPtr - m_pData), pData, nData);
3202
3203 m_pPtr += nData;
3204 }
3205
3206 void AddString(LPCTSTR lpszStr)
3207 {
3208 if (lpszStr == NULL)
3209 {
3210 WCHAR szEmpty = 0;
3211 AddData(&szEmpty, sizeof(szEmpty));
3212 }
3213 else
3214 {
3215 USES_CONVERSION;
3216 LPCWSTR lpstr = T2CW(lpszStr);
3217 int nSize = lstrlenW(lpstr) + 1;
3218 AddData(lpstr, nSize * sizeof(WCHAR));
3219 }
3220 }
3221
3222 LPBYTE m_pData;
3223 LPBYTE m_pPtr;
3224 SIZE_T m_cAllocated;
3225 };
3226
3227
3228 ///////////////////////////////////////////////////////////////////////////////
3229 // Dialog and control macros for indirect dialogs
3230
3231 // for DLGTEMPLATE
3232 #define BEGIN_DIALOG(x, y, width, height) \
3233 void DoInitTemplate() \
3234 { \
3235 bool bExTemplate = false; \
3236 short nX = x, nY = y, nWidth = width, nHeight = height; \
3237 LPCTSTR szCaption = NULL; \
3238 DWORD dwStyle = WS_POPUP | WS_BORDER | WS_SYSMENU; \
3239 DWORD dwExStyle = 0; \
3240 LPCTSTR szFontName = NULL; \
3241 WORD wFontSize = 0; \
3242 WORD wWeight = 0; \
3243 BYTE bItalic = 0; \
3244 BYTE bCharset = 0; \
3245 DWORD dwHelpID = 0; \
3246 ATL::_U_STRINGorID Menu = 0U; \
3247 ATL::_U_STRINGorID ClassName = 0U;
3248
3249 // for DLGTEMPLATEEX
3250 #define BEGIN_DIALOG_EX(x, y, width, height, helpID) \
3251 void DoInitTemplate() \
3252 { \
3253 bool bExTemplate = true; \
3254 short nX = x, nY = y, nWidth = width, nHeight = height; \
3255 LPCTSTR szCaption = NULL; \
3256 DWORD dwStyle = WS_POPUP | WS_BORDER | WS_SYSMENU; \
3257 DWORD dwExStyle = 0; \
3258 LPCTSTR szFontName = NULL; \
3259 WORD wFontSize = 0; \
3260 WORD wWeight = 0; \
3261 BYTE bItalic = 0; \
3262 BYTE bCharset = 0; \
3263 DWORD dwHelpID = helpID; \
3264 ATL::_U_STRINGorID Menu = 0U; \
3265 ATL::_U_STRINGorID ClassName = 0U;
3266
3267 #define END_DIALOG() \
3268 m_Template.Create(bExTemplate, szCaption, nX, nY, nWidth, nHeight, dwStyle, dwExStyle, szFontName, wFontSize, wWeight, bItalic, bCharset, dwHelpID, ClassName, Menu); \
3269 };
3270
3271 #define DIALOG_CAPTION(caption) \
3272 szCaption = caption;
3273 #define DIALOG_STYLE(style) \
3274 dwStyle = style;
3275 #define DIALOG_EXSTYLE(exStyle) \
3276 dwExStyle = exStyle;
3277 #define DIALOG_FONT(pointSize, typeFace) \
3278 wFontSize = pointSize; \
3279 szFontName = typeFace;
3280 #define DIALOG_FONT_EX(pointsize, typeface, weight, italic, charset) \
3281 ATLASSERT(bExTemplate); \
3282 wFontSize = pointsize; \
3283 szFontName = typeface; \
3284 wWeight = weight; \
3285 bItalic = italic; \
3286 bCharset = charset;
3287 #define DIALOG_MENU(menuName) \
3288 Menu = menuName;
3289 #define DIALOG_CLASS(className) \
3290 ClassName = className;
3291
3292 #define BEGIN_CONTROLS_MAP() \
3293 void DoInitControls() \
3294 {
3295
3296 #define END_CONTROLS_MAP() \
3297 };
3298
3299
3300 #define CONTROL_LTEXT(text, id, x, y, width, height, style, exStyle) \
3301 m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_STATIC, (WORD)id, x, y, width, height, style | SS_LEFT | WS_GROUP, exStyle, text, NULL, 0);
3302 #define CONTROL_CTEXT(text, id, x, y, width, height, style, exStyle) \
3303 m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_STATIC, (WORD)id, x, y, width, height, style | SS_CENTER | WS_GROUP, exStyle, text, NULL, 0);
3304 #define CONTROL_RTEXT(text, id, x, y, width, height, style, exStyle) \
3305 m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_STATIC, (WORD)id, x, y, width, height, style | SS_RIGHT | WS_GROUP, exStyle, text, NULL, 0);
3306 #define CONTROL_PUSHBUTTON(text, id, x, y, width, height, style, exStyle) \
3307 m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_PUSHBUTTON | WS_TABSTOP, exStyle, text, NULL, 0);
3308 #define CONTROL_DEFPUSHBUTTON(text, id, x, y, width, height, style, exStyle) \
3309 m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_DEFPUSHBUTTON | WS_TABSTOP, exStyle, text, NULL, 0);
3310 #ifndef _WIN32_WCE
3311 #define CONTROL_PUSHBOX(text, id, x, y, width, height, style, exStyle) \
3312 m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_PUSHBOX | WS_TABSTOP, exStyle, text, NULL, 0);
3313 #endif // !_WIN32_WCE
3314 #define CONTROL_STATE3(text, id, x, y, width, height, style, exStyle) \
3315 m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_3STATE | WS_TABSTOP, exStyle, text, NULL, 0);
3316 #define CONTROL_AUTO3STATE(text, id, x, y, width, height, style, exStyle) \
3317 m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_AUTO3STATE | WS_TABSTOP, exStyle, text, NULL, 0);
3318 #define CONTROL_CHECKBOX(text, id, x, y, width, height, style, exStyle) \
3319 m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_CHECKBOX | WS_TABSTOP, exStyle, text, NULL, 0);
3320 #define CONTROL_AUTOCHECKBOX(text, id, x, y, width, height, style, exStyle) \
3321 m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_AUTOCHECKBOX | WS_TABSTOP, exStyle, text, NULL, 0);
3322 #define CONTROL_RADIOBUTTON(text, id, x, y, width, height, style, exStyle) \
3323 m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_RADIOBUTTON | WS_TABSTOP, exStyle, text, NULL, 0);
3324 #define CONTROL_AUTORADIOBUTTON(text, id, x, y, width, height, style, exStyle) \
3325 m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_AUTORADIOBUTTON | WS_TABSTOP, exStyle, text, NULL, 0);
3326 #define CONTROL_COMBOBOX(id, x, y, width, height, style, exStyle) \
3327 m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_COMBOBOX, (WORD)id, x, y, width, height, style | CBS_DROPDOWN | WS_TABSTOP, exStyle, (LPCTSTR)NULL, NULL, 0);
3328 #define CONTROL_EDITTEXT(id, x, y, width, height, style, exStyle) \
3329 m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_EDIT, (WORD)id, x, y, width, height, style | ES_LEFT | WS_BORDER | WS_TABSTOP, exStyle, (LPCTSTR)NULL, NULL, 0);
3330 #define CONTROL_GROUPBOX(text, id, x, y, width, height, style, exStyle) \
3331 m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_GROUPBOX, exStyle, text, NULL, 0);
3332 #define CONTROL_LISTBOX(id, x, y, width, height, style, exStyle) \
3333 m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_LISTBOX, (WORD)id, x, y, width, height, style | LBS_NOTIFY | WS_BORDER, exStyle, (LPCTSTR)NULL, NULL, 0);
3334 #define CONTROL_SCROLLBAR(id, x, y, width, height, style, exStyle) \
3335 m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_SCROLLBAR, (WORD)id, x, y, width, height, style | SBS_HORZ, exStyle, (LPCTSTR)NULL, NULL, 0);
3336 #define CONTROL_ICON(text, id, x, y, width, height, style, exStyle) \
3337 m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_STATIC, (WORD)id, x, y, width, height, style | SS_ICON, exStyle, text, NULL, 0);
3338 #define CONTROL_CONTROL(text, id, className, style, x, y, width, height, exStyle) \
3339 m_Template.AddControl(className, (WORD)id, x, y, width, height, style, exStyle, text, NULL, 0);
3340
3341
3342 ///////////////////////////////////////////////////////////////////////////////
3343 // CIndirectDialogImpl - dialogs with template in memory
3344
3345 template <class T, class TDlgTemplate = CMemDlgTemplate, class TBase = ATL::CDialogImpl<T, ATL::CWindow> >
3346 class ATL_NO_VTABLE CIndirectDialogImpl : public TBase
3347 {
3348 public:
3349 enum { IDD = 0 }; // no dialog template resource
3350
3351 TDlgTemplate m_Template;
3352
3353 void CreateTemplate()
3354 {
3355 T* pT = static_cast<T*>(this);
3356 pT->DoInitTemplate();
3357 pT->DoInitControls();
3358 }
3359
3360 INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow(), LPARAM dwInitParam = NULL)
3361 {
3362 T* pT = static_cast<T*>(this);
3363 ATLASSERT(pT->m_hWnd == NULL);
3364
3365 if (!m_Template.IsValid())
3366 CreateTemplate();
3367
3368 #if (_ATL_VER >= 0x0800)
3369 // Allocate the thunk structure here, where we can fail gracefully.
3370 BOOL result = m_thunk.Init(NULL, NULL);
3371 if (result == FALSE)
3372 {
3373 SetLastError(ERROR_OUTOFMEMORY);
3374 return -1;
3375 }
3376 #endif // (_ATL_VER >= 0x0800)
3377
3378 ModuleHelper::AddCreateWndData(&m_thunk.cd, pT);
3379
3380 #ifdef _DEBUG
3381 m_bModal = true;
3382 #endif // _DEBUG
3383
3384 return ::DialogBoxIndirectParam(ModuleHelper::GetResourceInstance(), m_Template.GetTemplatePtr(), hWndParent, (DLGPROC)T::StartDialogProc, dwInitParam);
3385 }
3386
3387 HWND Create(HWND hWndParent, LPARAM dwInitParam = NULL)
3388 {
3389 T* pT = static_cast<T*>(this);
3390 ATLASSERT(pT->m_hWnd == NULL);
3391
3392 if (!m_Template.IsValid())
3393 CreateTemplate();
3394
3395 #if (_ATL_VER >= 0x0800)
3396 // Allocate the thunk structure here, where we can fail gracefully.
3397 BOOL result = m_thunk.Init(NULL, NULL);
3398 if (result == FALSE)
3399 {
3400 SetLastError(ERROR_OUTOFMEMORY);
3401 return NULL;
3402 }
3403 #endif // (_ATL_VER >= 0x0800)
3404
3405 ModuleHelper::AddCreateWndData(&m_thunk.cd, pT);
3406
3407 #ifdef _DEBUG
3408 m_bModal = false;
3409 #endif // _DEBUG
3410
3411 HWND hWnd = ::CreateDialogIndirectParam(ModuleHelper::GetResourceInstance(), (LPCDLGTEMPLATE)m_Template.GetTemplatePtr(), hWndParent, (DLGPROC)T::StartDialogProc, dwInitParam);
3412 ATLASSERT(m_hWnd == hWnd);
3413
3414 return hWnd;
3415 }
3416
3417 // for CComControl
3418 HWND Create(HWND hWndParent, RECT&, LPARAM dwInitParam = NULL)
3419 {
3420 return Create(hWndParent, dwInitParam);
3421 }
3422
3423 void DoInitTemplate()
3424 {
3425 ATLASSERT(FALSE); // MUST be defined in derived class
3426 }
3427
3428 void DoInitControls()
3429 {
3430 ATLASSERT(FALSE); // MUST be defined in derived class
3431 }
3432 };
3433
3434 ///////////////////////////////////////////////////////////////////////////////
3435 // CPropertySheetWindow - client side for a property sheet
3436
3437 class CPropertySheetWindow : public ATL::CWindow
3438 {
3439 public:
3440 // Constructors
3441 CPropertySheetWindow(HWND hWnd = NULL) : ATL::CWindow(hWnd)
3442 { }
3443
3444 CPropertySheetWindow& operator =(HWND hWnd)
3445 {
3446 m_hWnd = hWnd;
3447 return *this;
3448 }
3449
3450 // Attributes
3451 int GetPageCount() const
3452 {
3453 ATLASSERT(::IsWindow(m_hWnd));
3454 HWND hWndTabCtrl = GetTabControl();
3455 ATLASSERT(hWndTabCtrl != NULL);
3456 return (int)::SendMessage(hWndTabCtrl, TCM_GETITEMCOUNT, 0, 0L);
3457 }
3458
3459 HWND GetActivePage() const
3460 {
3461 ATLASSERT(::IsWindow(m_hWnd));
3462 return (HWND)::SendMessage(m_hWnd, PSM_GETCURRENTPAGEHWND, 0, 0L);
3463 }
3464
3465 int GetActiveIndex() const
3466 {
3467 ATLASSERT(::IsWindow(m_hWnd));
3468 HWND hWndTabCtrl = GetTabControl();
3469 ATLASSERT(hWndTabCtrl != NULL);
3470 return (int)::SendMessage(hWndTabCtrl, TCM_GETCURSEL, 0, 0L);
3471 }
3472
3473 BOOL SetActivePage(int nPageIndex)
3474 {
3475 ATLASSERT(::IsWindow(m_hWnd));
3476 return (BOOL)::SendMessage(m_hWnd, PSM_SETCURSEL, nPageIndex, 0L);
3477 }
3478
3479 BOOL SetActivePage(HPROPSHEETPAGE hPage)
3480 {
3481 ATLASSERT(::IsWindow(m_hWnd));
3482 ATLASSERT(hPage != NULL);
3483 return (BOOL)::SendMessage(m_hWnd, PSM_SETCURSEL, 0, (LPARAM)hPage);
3484 }
3485
3486 BOOL SetActivePageByID(int nPageID)
3487 {
3488 ATLASSERT(::IsWindow(m_hWnd));
3489 return (BOOL)::SendMessage(m_hWnd, PSM_SETCURSELID, 0, nPageID);
3490 }
3491
3492 void SetTitle(LPCTSTR lpszText, UINT nStyle = 0)
3493 {
3494 ATLASSERT(::IsWindow(m_hWnd));
3495 ATLASSERT((nStyle & ~PSH_PROPTITLE) == 0); // only PSH_PROPTITLE is valid
3496 ATLASSERT(lpszText != NULL);
3497 ::SendMessage(m_hWnd, PSM_SETTITLE, nStyle, (LPARAM)lpszText);
3498 }
3499
3500 HWND GetTabControl() const
3501 {
3502 ATLASSERT(::IsWindow(m_hWnd));
3503 return (HWND)::SendMessage(m_hWnd, PSM_GETTABCONTROL, 0, 0L);
3504 }
3505
3506 void SetFinishText(LPCTSTR lpszText)
3507 {
3508 ATLASSERT(::IsWindow(m_hWnd));
3509 ::SendMessage(m_hWnd, PSM_SETFINISHTEXT, 0, (LPARAM)lpszText);
3510 }
3511
3512 void SetWizardButtons(DWORD dwFlags)
3513 {
3514 ATLASSERT(::IsWindow(m_hWnd));
3515 ::PostMessage(m_hWnd, PSM_SETWIZBUTTONS, 0, dwFlags);
3516 }
3517
3518 // Operations
3519 BOOL AddPage(HPROPSHEETPAGE hPage)
3520 {
3521 ATLASSERT(::IsWindow(m_hWnd));
3522 ATLASSERT(hPage != NULL);
3523 return (BOOL)::SendMessage(m_hWnd, PSM_ADDPAGE, 0, (LPARAM)hPage);
3524 }
3525
3526 BOOL AddPage(LPCPROPSHEETPAGE pPage)
3527 {
3528 ATLASSERT(::IsWindow(m_hWnd));
3529 ATLASSERT(pPage != NULL);
3530 HPROPSHEETPAGE hPage = ::CreatePropertySheetPage(pPage);
3531 if(hPage == NULL)
3532 return FALSE;
3533 return (BOOL)::SendMessage(m_hWnd, PSM_ADDPAGE, 0, (LPARAM)hPage);
3534 }
3535
3536 #ifndef _WIN32_WCE
3537 BOOL InsertPage(int nNewPageIndex, HPROPSHEETPAGE hPage)
3538 {
3539 ATLASSERT(::IsWindow(m_hWnd));
3540 ATLASSERT(hPage != NULL);
3541 return (BOOL)::SendMessage(m_hWnd, PSM_INSERTPAGE, nNewPageIndex, (LPARAM)hPage);
3542 }
3543
3544 BOOL InsertPage(int nNewPageIndex, LPCPROPSHEETPAGE pPage)
3545 {
3546 ATLASSERT(::IsWindow(m_hWnd));
3547 ATLASSERT(pPage != NULL);
3548 HPROPSHEETPAGE hPage = ::CreatePropertySheetPage(pPage);
3549 if(hPage == NULL)
3550 return FALSE;
3551 return (BOOL)::SendMessage(m_hWnd, PSM_INSERTPAGE, nNewPageIndex, (LPARAM)hPage);
3552 }
3553
3554 BOOL InsertPage(HPROPSHEETPAGE hPageInsertAfter, HPROPSHEETPAGE hPage)
3555 {
3556 ATLASSERT(::IsWindow(m_hWnd));
3557 ATLASSERT(hPage != NULL);
3558 return (BOOL)::SendMessage(m_hWnd, PSM_INSERTPAGE, (WPARAM)hPageInsertAfter, (LPARAM)hPage);
3559 }
3560
3561 BOOL InsertPage(HPROPSHEETPAGE hPageInsertAfter, LPCPROPSHEETPAGE pPage)
3562 {
3563 ATLASSERT(::IsWindow(m_hWnd));
3564 ATLASSERT(pPage != NULL);
3565 HPROPSHEETPAGE hPage = ::CreatePropertySheetPage(pPage);
3566 if(hPage == NULL)
3567 return FALSE;
3568 return (BOOL)::SendMessage(m_hWnd, PSM_INSERTPAGE, (WPARAM)hPageInsertAfter, (LPARAM)hPage);
3569 }
3570 #endif // !_WIN32_WCE
3571
3572 void RemovePage(int nPageIndex)
3573 {
3574 ATLASSERT(::IsWindow(m_hWnd));
3575 ::SendMessage(m_hWnd, PSM_REMOVEPAGE, nPageIndex, 0L);
3576 }
3577
3578 void RemovePage(HPROPSHEETPAGE hPage)
3579 {
3580 ATLASSERT(::IsWindow(m_hWnd));
3581 ATLASSERT(hPage != NULL);
3582 ::SendMessage(m_hWnd, PSM_REMOVEPAGE, 0, (LPARAM)hPage);
3583 }
3584
3585 BOOL PressButton(int nButton)
3586 {
3587 ATLASSERT(::IsWindow(m_hWnd));
3588 return (BOOL)::SendMessage(m_hWnd, PSM_PRESSBUTTON, nButton, 0L);
3589 }
3590
3591 BOOL Apply()
3592 {
3593 ATLASSERT(::IsWindow(m_hWnd));
3594 return (BOOL)::SendMessage(m_hWnd, PSM_APPLY, 0, 0L);
3595 }
3596
3597 void CancelToClose()
3598 {
3599 ATLASSERT(::IsWindow(m_hWnd));
3600 ::SendMessage(m_hWnd, PSM_CANCELTOCLOSE, 0, 0L);
3601 }
3602
3603 void SetModified(HWND hWndPage, BOOL bChanged = TRUE)
3604 {
3605 ATLASSERT(::IsWindow(m_hWnd));
3606 ATLASSERT(::IsWindow(hWndPage));
3607 UINT uMsg = bChanged ? PSM_CHANGED : PSM_UNCHANGED;
3608 ::SendMessage(m_hWnd, uMsg, (WPARAM)hWndPage, 0L);
3609 }
3610
3611 LRESULT QuerySiblings(WPARAM wParam, LPARAM lParam)
3612 {
3613 ATLASSERT(::IsWindow(m_hWnd));
3614 return ::SendMessage(m_hWnd, PSM_QUERYSIBLINGS, wParam, lParam);
3615 }
3616
3617 void RebootSystem()
3618 {
3619 ATLASSERT(::IsWindow(m_hWnd));
3620 ::SendMessage(m_hWnd, PSM_REBOOTSYSTEM, 0, 0L);
3621 }
3622
3623 void RestartWindows()
3624 {
3625 ATLASSERT(::IsWindow(m_hWnd));
3626 ::SendMessage(m_hWnd, PSM_RESTARTWINDOWS, 0, 0L);
3627 }
3628
3629 BOOL IsDialogMessage(LPMSG lpMsg)
3630 {
3631 ATLASSERT(::IsWindow(m_hWnd));
3632 return (BOOL)::SendMessage(m_hWnd, PSM_ISDIALOGMESSAGE, 0, (LPARAM)lpMsg);
3633 }
3634
3635 #if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
3636 int HwndToIndex(HWND hWnd) const
3637 {
3638 ATLASSERT(::IsWindow(m_hWnd));
3639 return (int)::SendMessage(m_hWnd, PSM_HWNDTOINDEX, (WPARAM)hWnd, 0L);
3640 }
3641
3642 HWND IndexToHwnd(int nIndex) const
3643 {
3644 ATLASSERT(::IsWindow(m_hWnd));
3645 return (HWND)::SendMessage(m_hWnd, PSM_INDEXTOHWND, nIndex, 0L);
3646 }
3647
3648 int PageToIndex(HPROPSHEETPAGE hPage) const
3649 {
3650 ATLASSERT(::IsWindow(m_hWnd));
3651 return (int)::SendMessage(m_hWnd, PSM_PAGETOINDEX, 0, (LPARAM)hPage);
3652 }
3653
3654 HPROPSHEETPAGE IndexToPage(int nIndex) const
3655 {
3656 ATLASSERT(::IsWindow(m_hWnd));
3657 return (HPROPSHEETPAGE)::SendMessage(m_hWnd, PSM_INDEXTOPAGE, nIndex, 0L);
3658 }
3659
3660 int IdToIndex(int nID) const
3661 {
3662 ATLASSERT(::IsWindow(m_hWnd));
3663 return (int)::SendMessage(m_hWnd, PSM_IDTOINDEX, 0, nID);
3664 }
3665
3666 int IndexToId(int nIndex) const
3667 {
3668 ATLASSERT(::IsWindow(m_hWnd));
3669 return (int)::SendMessage(m_hWnd, PSM_INDEXTOID, nIndex, 0L);
3670 }
3671
3672 int GetResult() const
3673 {
3674 ATLASSERT(::IsWindow(m_hWnd));
3675 return (int)::SendMessage(m_hWnd, PSM_GETRESULT, 0, 0L);
3676 }
3677
3678 BOOL RecalcPageSizes()
3679 {
3680 ATLASSERT(::IsWindow(m_hWnd));
3681 return (BOOL)::SendMessage(m_hWnd, PSM_RECALCPAGESIZES, 0, 0L);
3682 }
3683
3684 void SetHeaderTitle(int nIndex, LPCTSTR lpstrHeaderTitle)
3685 {
3686 ATLASSERT(::IsWindow(m_hWnd));
3687 ::SendMessage(m_hWnd, PSM_SETHEADERTITLE, nIndex, (LPARAM)lpstrHeaderTitle);
3688 }
3689
3690 void SetHeaderSubTitle(int nIndex, LPCTSTR lpstrHeaderSubTitle)
3691 {
3692 ATLASSERT(::IsWindow(m_hWnd));
3693 ::SendMessage(m_hWnd, PSM_SETHEADERSUBTITLE, nIndex, (LPARAM)lpstrHeaderSubTitle);
3694 }
3695 #endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
3696
3697 // Implementation - override to prevent usage
3698 HWND Create(LPCTSTR, HWND, ATL::_U_RECT = NULL, LPCTSTR = NULL, DWORD = 0, DWORD = 0, ATL::_U_MENUorID = 0U, LPVOID = NULL)
3699 {
3700 ATLASSERT(FALSE);
3701 return NULL;
3702 }
3703 };
3704
3705 ///////////////////////////////////////////////////////////////////////////////
3706 // CPropertySheetImpl - implements a property sheet
3707
3708 template <class T, class TBase = CPropertySheetWindow>
3709 class ATL_NO_VTABLE CPropertySheetImpl : public ATL::CWindowImplBaseT< TBase >
3710 {
3711 public:
3712 PROPSHEETHEADER m_psh;
3713 ATL::CSimpleArray<HPROPSHEETPAGE> m_arrPages;
3714
3715 #if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC specific
3716 #ifndef PROPSHEET_LINK_SIZE
3717 #define PROPSHEET_LINK_SIZE 128
3718 #endif // PROPSHEET_LINK_SIZE
3719 TCHAR m_szLink[PROPSHEET_LINK_SIZE];
3720 static LPCTSTR m_pszTitle;
3721 static LPCTSTR m_pszLink;
3722 #endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__)
3723
3724 // Construction/Destruction
3725 CPropertySheetImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL, UINT uStartPage = 0, HWND hWndParent = NULL)
3726 {
3727 memset(&m_psh, 0, sizeof(PROPSHEETHEADER));
3728 m_psh.dwSize = sizeof(PROPSHEETHEADER);
3729 m_psh.dwFlags = PSH_USECALLBACK;
3730 m_psh.hInstance = ModuleHelper::GetResourceInstance();
3731 m_psh.phpage = NULL; // will be set later
3732 m_psh.nPages = 0; // will be set later
3733 m_psh.pszCaption = title.m_lpstr;
3734 m_psh.nStartPage = uStartPage;
3735 m_psh.hwndParent = hWndParent; // if NULL, will be set in DoModal/Create
3736 m_psh.pfnCallback = T::PropSheetCallback;
3737
3738 #if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC specific
3739 m_psh.dwFlags |= PSH_MAXIMIZE;
3740 m_szLink[0] = 0;
3741 #endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__)
3742 }
3743
3744 ~CPropertySheetImpl()
3745 {
3746 if(m_arrPages.GetSize() > 0) // sheet never created, destroy all pages
3747 {
3748 for(int i = 0; i < m_arrPages.GetSize(); i++)
3749 ::DestroyPropertySheetPage((HPROPSHEETPAGE)m_arrPages[i]);
3750 }
3751 }
3752
3753 // Callback function and overrideables
3754 static int CALLBACK PropSheetCallback(HWND hWnd, UINT uMsg, LPARAM lParam)
3755 {
3756 lParam; // avoid level 4 warning
3757 int nRet = 0;
3758
3759 if(uMsg == PSCB_INITIALIZED)
3760 {
3761 ATLASSERT(hWnd != NULL);
3762 T* pT = (T*)ModuleHelper::ExtractCreateWndData();
3763 // subclass the sheet window
3764 pT->SubclassWindow(hWnd);
3765 // remove page handles array
3766 pT->_CleanUpPages();
3767
3768 #if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC specific
3769 m_pszTitle = pT->m_psh.pszCaption;
3770 if(*pT->m_szLink != 0)
3771 m_pszLink = pT->m_szLink;
3772 #endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC specific
3773
3774 pT->OnSheetInitialized();
3775 }
3776 #if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC specific uMsg
3777 else
3778 {
3779 switch(uMsg)
3780 {
3781 case PSCB_GETVERSION :
3782 nRet = COMCTL32_VERSION;
3783 break;
3784 case PSCB_GETTITLE :
3785 if(m_pszTitle != NULL)
3786 {
3787 lstrcpy((LPTSTR)lParam, m_pszTitle);
3788 m_pszTitle = NULL;
3789 }
3790 break;
3791 case PSCB_GETLINKTEXT:
3792 if(m_pszLink != NULL)
3793 {
3794 lstrcpy((LPTSTR)lParam, m_pszLink);
3795 m_pszLink = NULL;
3796 }
3797 break;
3798 default:
3799 break;
3800 }
3801 }
3802 #endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__)
3803
3804 return nRet;
3805 }
3806
3807 void OnSheetInitialized()
3808 {
3809 }
3810
3811 // Create method
3812 HWND Create(HWND hWndParent = NULL)
3813 {
3814 ATLASSERT(m_hWnd == NULL);
3815
3816 m_psh.dwFlags |= PSH_MODELESS;
3817 if(m_psh.hwndParent == NULL)
3818 m_psh.hwndParent = hWndParent;
3819 m_psh.phpage = (HPROPSHEETPAGE*)m_arrPages.GetData();
3820 m_psh.nPages = m_arrPages.GetSize();
3821
3822 T* pT = static_cast<T*>(this);
3823 ModuleHelper::AddCreateWndData(&pT->m_thunk.cd, pT);
3824
3825 HWND hWnd = (HWND)::PropertySheet(&m_psh);
3826 _CleanUpPages(); // ensure clean-up, required if call failed
3827
3828 ATLASSERT(m_hWnd == hWnd);
3829
3830 return hWnd;
3831 }
3832
3833 INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow())
3834 {
3835 ATLASSERT(m_hWnd == NULL);
3836
3837 m_psh.dwFlags &= ~PSH_MODELESS;
3838 if(m_psh.hwndParent == NULL)
3839 m_psh.hwndParent = hWndParent;
3840 m_psh.phpage = (HPROPSHEETPAGE*)m_arrPages.GetData();
3841 m_psh.nPages = m_arrPages.GetSize();
3842
3843 T* pT = static_cast<T*>(this);
3844 ModuleHelper::AddCreateWndData(&pT->m_thunk.cd, pT);
3845
3846 INT_PTR nRet = ::PropertySheet(&m_psh);
3847 _CleanUpPages(); // ensure clean-up, required if call failed
3848
3849 return nRet;
3850 }
3851
3852 // implementation helper - clean up pages array
3853 void _CleanUpPages()
3854 {
3855 m_psh.nPages = 0;
3856 m_psh.phpage = NULL;
3857 m_arrPages.RemoveAll();
3858 }
3859
3860 // Attributes (extended overrides of client class methods)
3861 // These now can be called before the sheet is created
3862 // Note: Calling these after the sheet is created gives unpredictable results
3863 int GetPageCount() const
3864 {
3865 if(m_hWnd == NULL) // not created yet
3866 return m_arrPages.GetSize();
3867 return TBase::GetPageCount();
3868 }
3869
3870 int GetActiveIndex() const
3871 {
3872 if(m_hWnd == NULL) // not created yet
3873 return m_psh.nStartPage;
3874 return TBase::GetActiveIndex();
3875 }
3876
3877 HPROPSHEETPAGE GetPage(int nPageIndex) const
3878 {
3879 ATLASSERT(m_hWnd == NULL); // can't do this after it's created
3880 return (HPROPSHEETPAGE)m_arrPages[nPageIndex];
3881 }
3882
3883 int GetPageIndex(HPROPSHEETPAGE hPage) const
3884 {
3885 ATLASSERT(m_hWnd == NULL); // can't do this after it's created
3886 return m_arrPages.Find((HPROPSHEETPAGE&)hPage);
3887 }
3888
3889 BOOL SetActivePage(int nPageIndex)
3890 {
3891 if(m_hWnd == NULL) // not created yet
3892 {
3893 ATLASSERT(nPageIndex >= 0 && nPageIndex < m_arrPages.GetSize());
3894 m_psh.nStartPage = nPageIndex;
3895 return TRUE;
3896 }
3897 return TBase::SetActivePage(nPageIndex);
3898 }
3899
3900 BOOL SetActivePage(HPROPSHEETPAGE hPage)
3901 {
3902 ATLASSERT(hPage != NULL);
3903 if (m_hWnd == NULL) // not created yet
3904 {
3905 int nPageIndex = GetPageIndex(hPage);
3906 if(nPageIndex == -1)
3907 return FALSE;
3908
3909 return SetActivePage(nPageIndex);
3910 }
3911 return TBase::SetActivePage(hPage);
3912
3913 }
3914
3915 void SetTitle(LPCTSTR lpszText, UINT nStyle = 0)
3916 {
3917 ATLASSERT((nStyle & ~PSH_PROPTITLE) == 0); // only PSH_PROPTITLE is valid
3918 ATLASSERT(lpszText != NULL);
3919
3920 if(m_hWnd == NULL)
3921 {
3922 // set internal state
3923 m_psh.pszCaption = lpszText; // must exist until sheet is created
3924 m_psh.dwFlags &= ~PSH_PROPTITLE;
3925 m_psh.dwFlags |= nStyle;
3926 }
3927 else
3928 {
3929 // set external state
3930 TBase::SetTitle(lpszText, nStyle);
3931 }
3932 }
3933
3934 #if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC specific Link field
3935 void SetLinkText(LPCTSTR lpszText)
3936 {
3937 ATLASSERT(lpszText != NULL);
3938 ATLASSERT(lstrlen(lpszText) < PROPSHEET_LINK_SIZE);
3939 lstrcpy(m_szLink, lpszText);
3940 }
3941 #endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__)
3942
3943 void SetWizardMode()
3944 {
3945 m_psh.dwFlags |= PSH_WIZARD;
3946 }
3947
3948 void EnableHelp()
3949 {
3950 m_psh.dwFlags |= PSH_HASHELP;
3951 }
3952
3953 // Operations
3954 BOOL AddPage(HPROPSHEETPAGE hPage)
3955 {
3956 ATLASSERT(hPage != NULL);
3957 BOOL bRet = FALSE;
3958 if(m_hWnd != NULL)
3959 bRet = TBase::AddPage(hPage);
3960 else // sheet not created yet, use internal data
3961 bRet = m_arrPages.Add((HPROPSHEETPAGE&)hPage);
3962 return bRet;
3963 }
3964
3965 BOOL AddPage(LPCPROPSHEETPAGE pPage)
3966 {
3967 ATLASSERT(pPage != NULL);
3968 HPROPSHEETPAGE hPage = ::CreatePropertySheetPage(pPage);
3969 if(hPage == NULL)
3970 return FALSE;
3971 BOOL bRet = AddPage(hPage);
3972 if(!bRet)
3973 ::DestroyPropertySheetPage(hPage);
3974 return bRet;
3975 }
3976
3977 BOOL RemovePage(HPROPSHEETPAGE hPage)
3978 {
3979 ATLASSERT(hPage != NULL);
3980 if (m_hWnd == NULL) // not created yet
3981 {
3982 int nPage = GetPageIndex(hPage);
3983 if(nPage == -1)
3984 return FALSE;
3985 return RemovePage(nPage);
3986 }
3987 TBase::RemovePage(hPage);
3988 return TRUE;
3989
3990 }
3991
3992 BOOL RemovePage(int nPageIndex)
3993 {
3994 BOOL bRet = TRUE;
3995 if(m_hWnd != NULL)
3996 TBase::RemovePage(nPageIndex);
3997 else // sheet not created yet, use internal data
3998 bRet = m_arrPages.RemoveAt(nPageIndex);
3999 return bRet;
4000 }
4001
4002 #if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
4003 void SetHeader(LPCTSTR szbmHeader)
4004 {
4005 ATLASSERT(m_hWnd == NULL); // can't do this after it's created
4006
4007 m_psh.dwFlags &= ~PSH_WIZARD;
4008 m_psh.dwFlags |= (PSH_HEADER | PSH_WIZARD97);
4009 m_psh.pszbmHeader = szbmHeader;
4010 }
4011
4012 void SetHeader(HBITMAP hbmHeader)
4013 {
4014 ATLASSERT(m_hWnd == NULL); // can't do this after it's created
4015
4016 m_psh.dwFlags &= ~PSH_WIZARD;
4017 m_psh.dwFlags |= (PSH_HEADER | PSH_USEHBMHEADER | PSH_WIZARD97);
4018 m_psh.hbmHeader = hbmHeader;
4019 }
4020
4021 void SetWatermark(LPCTSTR szbmWatermark, HPALETTE hplWatermark = NULL)
4022 {
4023 ATLASSERT(m_hWnd == NULL); // can't do this after it's created
4024
4025 m_psh.dwFlags &= ~PSH_WIZARD;
4026 m_psh.dwFlags |= PSH_WATERMARK | PSH_WIZARD97;
4027 m_psh.pszbmWatermark = szbmWatermark;
4028
4029 if (hplWatermark != NULL)
4030 {
4031 m_psh.dwFlags |= PSH_USEHPLWATERMARK;
4032 m_psh.hplWatermark = hplWatermark;
4033 }
4034 }
4035
4036 void SetWatermark(HBITMAP hbmWatermark, HPALETTE hplWatermark = NULL)
4037 {
4038 ATLASSERT(m_hWnd == NULL); // can't do this after it's created
4039
4040 m_psh.dwFlags &= ~PSH_WIZARD;
4041 m_psh.dwFlags |= (PSH_WATERMARK | PSH_USEHBMWATERMARK | PSH_WIZARD97);
4042 m_psh.hbmWatermark = hbmWatermark;
4043
4044 if (hplWatermark != NULL)
4045 {
4046 m_psh.dwFlags |= PSH_USEHPLWATERMARK;
4047 m_psh.hplWatermark = hplWatermark;
4048 }
4049 }
4050
4051 void StretchWatermark(bool bStretchWatermark)
4052 {
4053 ATLASSERT(m_hWnd == NULL); // can't do this after it's created
4054 if (bStretchWatermark)
4055 m_psh.dwFlags |= PSH_STRETCHWATERMARK;
4056 else
4057 m_psh.dwFlags &= ~PSH_STRETCHWATERMARK;
4058 }
4059 #endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
4060
4061 // Message map and handlers
4062 BEGIN_MSG_MAP(CPropertySheetImpl)
4063 MESSAGE_HANDLER(WM_COMMAND, OnCommand)
4064 MESSAGE_HANDLER(WM_SYSCOMMAND, OnSysCommand)
4065 END_MSG_MAP()
4066
4067 LRESULT OnCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
4068 {
4069 LRESULT lRet = DefWindowProc(uMsg, wParam, lParam);
4070 if(HIWORD(wParam) == BN_CLICKED && (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) &&
4071 ((m_psh.dwFlags & PSH_MODELESS) != 0) && (GetActivePage() == NULL))
4072 DestroyWindow();
4073 return lRet;
4074 }
4075
4076 LRESULT OnSysCommand(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
4077 {
4078 if(((m_psh.dwFlags & PSH_MODELESS) == PSH_MODELESS) && ((wParam & 0xFFF0) == SC_CLOSE))
4079 SendMessage(WM_CLOSE);
4080 else
4081 bHandled = FALSE;
4082 return 0;
4083 }
4084 };
4085
4086 #if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC static pointers
4087 template < class T, class TBase >
4088 LPCWSTR CPropertySheetImpl<T,TBase>::m_pszTitle = NULL;
4089 template < class T, class TBase>
4090 LPCWSTR CPropertySheetImpl<T,TBase>::m_pszLink = NULL;
4091 #endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__)
4092
4093 // for non-customized sheets
4094 class CPropertySheet : public CPropertySheetImpl<CPropertySheet>
4095 {
4096 public:
4097 CPropertySheet(ATL::_U_STRINGorID title = (LPCTSTR)NULL, UINT uStartPage = 0, HWND hWndParent = NULL)
4098 : CPropertySheetImpl<CPropertySheet>(title, uStartPage, hWndParent)
4099 { }
4100 };
4101
4102
4103 ///////////////////////////////////////////////////////////////////////////////
4104 // CPropertyPageWindow - client side for a property page
4105
4106 class CPropertyPageWindow : public ATL::CWindow
4107 {
4108 public:
4109 // Constructors
4110 CPropertyPageWindow(HWND hWnd = NULL) : ATL::CWindow(hWnd)
4111 { }
4112
4113 CPropertyPageWindow& operator =(HWND hWnd)
4114 {
4115 m_hWnd = hWnd;
4116 return *this;
4117 }
4118
4119 // Attributes
4120 CPropertySheetWindow GetPropertySheet() const
4121 {
4122 ATLASSERT(::IsWindow(m_hWnd));
4123 return CPropertySheetWindow(GetParent());
4124 }
4125
4126 // Operations
4127 BOOL Apply()
4128 {
4129 ATLASSERT(::IsWindow(m_hWnd));
4130 ATLASSERT(GetParent() != NULL);
4131 return GetPropertySheet().Apply();
4132 }
4133
4134 void CancelToClose()
4135 {
4136 ATLASSERT(::IsWindow(m_hWnd));
4137 ATLASSERT(GetParent() != NULL);
4138 GetPropertySheet().CancelToClose();
4139 }
4140
4141 void SetModified(BOOL bChanged = TRUE)
4142 {
4143 ATLASSERT(::IsWindow(m_hWnd));
4144 ATLASSERT(GetParent() != NULL);
4145 GetPropertySheet().SetModified(m_hWnd, bChanged);
4146 }
4147
4148 LRESULT QuerySiblings(WPARAM wParam, LPARAM lParam)
4149 {
4150 ATLASSERT(::IsWindow(m_hWnd));
4151 ATLASSERT(GetParent() != NULL);
4152 return GetPropertySheet().QuerySiblings(wParam, lParam);
4153 }
4154
4155 void RebootSystem()
4156 {
4157 ATLASSERT(::IsWindow(m_hWnd));
4158 ATLASSERT(GetParent() != NULL);
4159 GetPropertySheet().RebootSystem();
4160 }
4161
4162 void RestartWindows()
4163 {
4164 ATLASSERT(::IsWindow(m_hWnd));
4165 ATLASSERT(GetParent() != NULL);
4166 GetPropertySheet().RestartWindows();
4167 }
4168
4169 void SetWizardButtons(DWORD dwFlags)
4170 {
4171 ATLASSERT(::IsWindow(m_hWnd));
4172 ATLASSERT(GetParent() != NULL);
4173 GetPropertySheet().SetWizardButtons(dwFlags);
4174 }
4175
4176 // Implementation - overrides to prevent usage
4177 HWND Create(LPCTSTR, HWND, ATL::_U_RECT = NULL, LPCTSTR = NULL, DWORD = 0, DWORD = 0, ATL::_U_MENUorID = 0U, LPVOID = NULL)
4178 {
4179 ATLASSERT(FALSE);
4180 return NULL;
4181 }
4182 };
4183
4184 ///////////////////////////////////////////////////////////////////////////////
4185 // CPropertyPageImpl - implements a property page
4186
4187 template <class T, class TBase = CPropertyPageWindow>
4188 class ATL_NO_VTABLE CPropertyPageImpl : public ATL::CDialogImplBaseT< TBase >
4189 {
4190 public:
4191 PROPSHEETPAGE m_psp;
4192
4193 operator PROPSHEETPAGE*() { return &m_psp; }
4194
4195 // Construction
4196 CPropertyPageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL)
4197 {
4198 // initialize PROPSHEETPAGE struct
4199 memset(&m_psp, 0, sizeof(PROPSHEETPAGE));
4200 m_psp.dwSize = sizeof(PROPSHEETPAGE);
4201 m_psp.dwFlags = PSP_USECALLBACK;
4202 m_psp.hInstance = ModuleHelper::GetResourceInstance();
4203 T* pT = static_cast<T*>(this);
4204 m_psp.pszTemplate = MAKEINTRESOURCE(pT->IDD);
4205 m_psp.pfnDlgProc = (DLGPROC)T::StartDialogProc;
4206 m_psp.pfnCallback = T::PropPageCallback;
4207 m_psp.lParam = (LPARAM)pT;
4208
4209 if(title.m_lpstr != NULL)
4210 SetTitle(title);
4211 }
4212
4213 // Callback function and overrideables
4214 static UINT CALLBACK PropPageCallback(HWND hWnd, UINT uMsg, LPPROPSHEETPAGE ppsp)
4215 {
4216 hWnd; // avoid level 4 warning
4217 ATLASSERT(hWnd == NULL);
4218 T* pT = (T*)ppsp->lParam;
4219 UINT uRet = 0;
4220
4221 switch(uMsg)
4222 {
4223 case PSPCB_CREATE:
4224 {
4225 ATL::CDialogImplBaseT< TBase >* pPage = (ATL::CDialogImplBaseT< TBase >*)pT;
4226 ModuleHelper::AddCreateWndData(&pPage->m_thunk.cd, pPage);
4227 uRet = pT->OnPageCreate() ? 1 : 0;
4228 }
4229 break;
4230 #if (_WIN32_IE >= 0x0500)
4231 case PSPCB_ADDREF:
4232 pT->OnPageAddRef();
4233 break;
4234 #endif // (_WIN32_IE >= 0x0500)
4235 case PSPCB_RELEASE:
4236 pT->OnPageRelease();
4237 break;
4238 default:
4239 break;
4240 }
4241
4242 return uRet;
4243 }
4244
4245 bool OnPageCreate()
4246 {
4247 return true; // true - allow page to be created, false - prevent creation
4248 }
4249
4250 #if (_WIN32_IE >= 0x0500)
4251 void OnPageAddRef()
4252 {
4253 }
4254 #endif // (_WIN32_IE >= 0x0500)
4255
4256 void OnPageRelease()
4257 {
4258 }
4259
4260 // Create method
4261 HPROPSHEETPAGE Create()
4262 {
4263 return ::CreatePropertySheetPage(&m_psp);
4264 }
4265
4266 // Attributes
4267 void SetTitle(ATL::_U_STRINGorID title)
4268 {
4269 m_psp.pszTitle = title.m_lpstr;
4270 m_psp.dwFlags |= PSP_USETITLE;
4271 }
4272
4273 #if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
4274 void SetHeaderTitle(LPCTSTR lpstrHeaderTitle)
4275 {
4276 ATLASSERT(m_hWnd == NULL); // can't do this after it's created
4277 m_psp.dwFlags |= PSP_USEHEADERTITLE;
4278 m_psp.pszHeaderTitle = lpstrHeaderTitle;
4279 }
4280
4281 void SetHeaderSubTitle(LPCTSTR lpstrHeaderSubTitle)
4282 {
4283 ATLASSERT(m_hWnd == NULL); // can't do this after it's created
4284 m_psp.dwFlags |= PSP_USEHEADERSUBTITLE;
4285 m_psp.pszHeaderSubTitle = lpstrHeaderSubTitle;
4286 }
4287 #endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
4288
4289 // Operations
4290 void EnableHelp()
4291 {
4292 m_psp.dwFlags |= PSP_HASHELP;
4293 }
4294
4295 // Message map and handlers
4296 BEGIN_MSG_MAP(CPropertyPageImpl)
4297 MESSAGE_HANDLER(WM_NOTIFY, OnNotify)
4298 END_MSG_MAP()
4299
4300 // NOTE: Define _WTL_NEW_PAGE_NOTIFY_HANDLERS to use new notification
4301 // handlers that return direct values without any restrictions
4302 LRESULT OnNotify(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
4303 {
4304 #ifndef _WIN32_WCE
4305 // This notification is sometimes received on Windows CE after the window is already destroyed
4306 ATLASSERT(::IsWindow(m_hWnd));
4307 #endif
4308 NMHDR* pNMHDR = (NMHDR*)lParam;
4309
4310 // don't handle messages not from the page/sheet itself
4311 if(pNMHDR->hwndFrom != m_hWnd && pNMHDR->hwndFrom != ::GetParent(m_hWnd))
4312 {
4313 bHandled = FALSE;
4314 return 1;
4315 }
4316 #ifdef _WIN32_WCE
4317 ATLASSERT(::IsWindow(m_hWnd));
4318 #endif
4319
4320 T* pT = static_cast<T*>(this);
4321 LRESULT lResult = 0;
4322 switch(pNMHDR->code)
4323 {
4324 #ifdef _WTL_NEW_PAGE_NOTIFY_HANDLERS
4325 case PSN_SETACTIVE:
4326 lResult = pT->OnSetActive();
4327 break;
4328 case PSN_KILLACTIVE:
4329 lResult = pT->OnKillActive();
4330 break;
4331 case PSN_APPLY:
4332 lResult = pT->OnApply();
4333 break;
4334 case PSN_RESET:
4335 pT->OnReset();
4336 break;
4337 case PSN_QUERYCANCEL:
4338 lResult = pT->OnQueryCancel();
4339 break;
4340 case PSN_WIZNEXT:
4341 lResult = pT->OnWizardNext();
4342 break;
4343 case PSN_WIZBACK:
4344 lResult = pT->OnWizardBack();
4345 break;
4346 case PSN_WIZFINISH:
4347 lResult = pT->OnWizardFinish();
4348 break;
4349 case PSN_HELP:
4350 pT->OnHelp();
4351 break;
4352 #ifndef _WIN32_WCE
4353 #if (_WIN32_IE >= 0x0400)
4354 case PSN_GETOBJECT:
4355 if(!pT->OnGetObject((LPNMOBJECTNOTIFY)lParam))
4356 bHandled = FALSE;
4357 break;
4358 #endif // (_WIN32_IE >= 0x0400)
4359 #if (_WIN32_IE >= 0x0500)
4360 case PSN_TRANSLATEACCELERATOR:
4361 {
4362 LPPSHNOTIFY lpPSHNotify = (LPPSHNOTIFY)lParam;
4363 lResult = pT->OnTranslateAccelerator((LPMSG)lpPSHNotify->lParam);
4364 }
4365 break;
4366 case PSN_QUERYINITIALFOCUS:
4367 {
4368 LPPSHNOTIFY lpPSHNotify = (LPPSHNOTIFY)lParam;
4369 lResult = (LRESULT)pT->OnQueryInitialFocus((HWND)lpPSHNotify->lParam);
4370 }
4371 break;
4372 #endif // (_WIN32_IE >= 0x0500)
4373 #endif // !_WIN32_WCE
4374
4375 #else // !_WTL_NEW_PAGE_NOTIFY_HANDLERS
4376 case PSN_SETACTIVE:
4377 lResult = pT->OnSetActive() ? 0 : -1;
4378 break;
4379 case PSN_KILLACTIVE:
4380 lResult = !pT->OnKillActive();
4381 break;
4382 case PSN_APPLY:
4383 lResult = pT->OnApply() ? PSNRET_NOERROR : PSNRET_INVALID_NOCHANGEPAGE;
4384 break;
4385 case PSN_RESET:
4386 pT->OnReset();
4387 break;
4388 case PSN_QUERYCANCEL:
4389 lResult = !pT->OnQueryCancel();
4390 break;
4391 case PSN_WIZNEXT:
4392 lResult = pT->OnWizardNext();
4393 break;
4394 case PSN_WIZBACK:
4395 lResult = pT->OnWizardBack();
4396 break;
4397 case PSN_WIZFINISH:
4398 lResult = !pT->OnWizardFinish();
4399 break;
4400 case PSN_HELP:
4401 pT->OnHelp();
4402 break;
4403 #ifndef _WIN32_WCE
4404 #if (_WIN32_IE >= 0x0400)
4405 case PSN_GETOBJECT:
4406 if(!pT->OnGetObject((LPNMOBJECTNOTIFY)lParam))
4407 bHandled = FALSE;
4408 break;
4409 #endif // (_WIN32_IE >= 0x0400)
4410 #if (_WIN32_IE >= 0x0500)
4411 case PSN_TRANSLATEACCELERATOR:
4412 {
4413 LPPSHNOTIFY lpPSHNotify = (LPPSHNOTIFY)lParam;
4414 lResult = pT->OnTranslateAccelerator((LPMSG)lpPSHNotify->lParam) ? PSNRET_MESSAGEHANDLED : PSNRET_NOERROR;
4415 }
4416 break;
4417 case PSN_QUERYINITIALFOCUS:
4418 {
4419 LPPSHNOTIFY lpPSHNotify = (LPPSHNOTIFY)lParam;
4420 lResult = (LRESULT)pT->OnQueryInitialFocus((HWND)lpPSHNotify->lParam);
4421 }
4422 break;
4423 #endif // (_WIN32_IE >= 0x0500)
4424 #endif // !_WIN32_WCE
4425
4426 #endif // !_WTL_NEW_PAGE_NOTIFY_HANDLERS
4427 default:
4428 bHandled = FALSE; // not handled
4429 }
4430
4431 return lResult;
4432 }
4433
4434 // Overridables
4435 // NOTE: Define _WTL_NEW_PAGE_NOTIFY_HANDLERS to use new notification
4436 // handlers that return direct values without any restrictions
4437 #ifdef _WTL_NEW_PAGE_NOTIFY_HANDLERS
4438 int OnSetActive()
4439 {
4440 // 0 = allow activate
4441 // -1 = go back that was active
4442 // page ID = jump to page
4443 return 0;
4444 }
4445
4446 BOOL OnKillActive()
4447 {
4448 // FALSE = allow deactivate
4449 // TRUE = prevent deactivation
4450 return FALSE;
4451 }
4452
4453 int OnApply()
4454 {
4455 // PSNRET_NOERROR = apply OK
4456 // PSNRET_INVALID = apply not OK, return to this page
4457 // PSNRET_INVALID_NOCHANGEPAGE = apply not OK, don't change focus
4458 return PSNRET_NOERROR;
4459 }
4460
4461 void OnReset()
4462 {
4463 }
4464
4465 BOOL OnQueryCancel()
4466 {
4467 // FALSE = allow cancel
4468 // TRUE = prevent cancel
4469 return FALSE;
4470 }
4471
4472 int OnWizardBack()
4473 {
4474 // 0 = goto previous page
4475 // -1 = prevent page change
4476 // >0 = jump to page by dlg ID
4477 return 0;
4478 }
4479
4480 int OnWizardNext()
4481 {
4482 // 0 = goto next page
4483 // -1 = prevent page change
4484 // >0 = jump to page by dlg ID
4485 return 0;
4486 }
4487
4488 INT_PTR OnWizardFinish()
4489 {
4490 // FALSE = allow finish
4491 // TRUE = prevent finish
4492 // HWND = prevent finish and set focus to HWND (CommCtrl 5.80 only)
4493 return FALSE;
4494 }
4495
4496 void OnHelp()
4497 {
4498 }
4499
4500 #ifndef _WIN32_WCE
4501 #if (_WIN32_IE >= 0x0400)
4502 BOOL OnGetObject(LPNMOBJECTNOTIFY /*lpObjectNotify*/)
4503 {
4504 return FALSE; // not processed
4505 }
4506 #endif // (_WIN32_IE >= 0x0400)
4507
4508 #if (_WIN32_IE >= 0x0500)
4509 int OnTranslateAccelerator(LPMSG /*lpMsg*/)
4510 {
4511 // PSNRET_NOERROR - message not handled
4512 // PSNRET_MESSAGEHANDLED - message handled
4513 return PSNRET_NOERROR;
4514 }
4515
4516 HWND OnQueryInitialFocus(HWND /*hWndFocus*/)
4517 {
4518 // NULL = set focus to default control
4519 // HWND = set focus to HWND
4520 return NULL;
4521 }
4522 #endif // (_WIN32_IE >= 0x0500)
4523 #endif // !_WIN32_WCE
4524
4525 #else // !_WTL_NEW_PAGE_NOTIFY_HANDLERS
4526 BOOL OnSetActive()
4527 {
4528 return TRUE;
4529 }
4530
4531 BOOL OnKillActive()
4532 {
4533 return TRUE;
4534 }
4535
4536 BOOL OnApply()
4537 {
4538 return TRUE;
4539 }
4540
4541 void OnReset()
4542 {
4543 }
4544
4545 BOOL OnQueryCancel()
4546 {
4547 return TRUE; // ok to cancel
4548 }
4549
4550 int OnWizardBack()
4551 {
4552 // 0 = goto previous page
4553 // -1 = prevent page change
4554 // >0 = jump to page by dlg ID
4555 return 0;
4556 }
4557
4558 int OnWizardNext()
4559 {
4560 // 0 = goto next page
4561 // -1 = prevent page change
4562 // >0 = jump to page by dlg ID
4563 return 0;
4564 }
4565
4566 BOOL OnWizardFinish()
4567 {
4568 return TRUE;
4569 }
4570
4571 void OnHelp()
4572 {
4573 }
4574
4575 #ifndef _WIN32_WCE
4576 #if (_WIN32_IE >= 0x0400)
4577 BOOL OnGetObject(LPNMOBJECTNOTIFY /*lpObjectNotify*/)
4578 {
4579 return FALSE; // not processed
4580 }
4581 #endif // (_WIN32_IE >= 0x0400)
4582
4583 #if (_WIN32_IE >= 0x0500)
4584 BOOL OnTranslateAccelerator(LPMSG /*lpMsg*/)
4585 {
4586 return FALSE; // not translated
4587 }
4588
4589 HWND OnQueryInitialFocus(HWND /*hWndFocus*/)
4590 {
4591 return NULL; // default
4592 }
4593 #endif // (_WIN32_IE >= 0x0500)
4594 #endif // !_WIN32_WCE
4595
4596 #endif // !_WTL_NEW_PAGE_NOTIFY_HANDLERS
4597 };
4598
4599 // for non-customized pages
4600 template <WORD t_wDlgTemplateID>
4601 class CPropertyPage : public CPropertyPageImpl<CPropertyPage<t_wDlgTemplateID> >
4602 {
4603 public:
4604 enum { IDD = t_wDlgTemplateID };
4605
4606 CPropertyPage(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : CPropertyPageImpl<CPropertyPage>(title)
4607 { }
4608
4609 DECLARE_EMPTY_MSG_MAP()
4610 };
4611
4612 ///////////////////////////////////////////////////////////////////////////////
4613 // CAxPropertyPageImpl - property page that hosts ActiveX controls
4614
4615 #ifndef _ATL_NO_HOSTING
4616
4617 // Note: You must #include <atlhost.h> to use these classes
4618
4619 template <class T, class TBase = CPropertyPageWindow>
4620 class ATL_NO_VTABLE CAxPropertyPageImpl : public CPropertyPageImpl< T, TBase >
4621 {
4622 public:
4623 // Data members
4624 HGLOBAL m_hInitData;
4625 HGLOBAL m_hDlgRes;
4626 HGLOBAL m_hDlgResSplit;
4627
4628 // Constructor/destructor
4629 CAxPropertyPageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL) :
4630 CPropertyPageImpl< T, TBase >(title),
4631 m_hInitData(NULL), m_hDlgRes(NULL), m_hDlgResSplit(NULL)
4632 {
4633 T* pT = static_cast<T*>(this);
4634 pT; // avoid level 4 warning
4635
4636 // initialize ActiveX hosting and modify dialog template
4637 ATL::AtlAxWinInit();
4638
4639 HINSTANCE hInstance = ModuleHelper::GetResourceInstance();
4640 LPCTSTR lpTemplateName = MAKEINTRESOURCE(pT->IDD);
4641 HRSRC hDlg = ::FindResource(hInstance, lpTemplateName, (LPTSTR)RT_DIALOG);
4642 if(hDlg != NULL)
4643 {
4644 HRSRC hDlgInit = ::FindResource(hInstance, lpTemplateName, (LPTSTR)_ATL_RT_DLGINIT);
4645
4646 BYTE* pInitData = NULL;
4647 if(hDlgInit != NULL)
4648 {
4649 m_hInitData = ::LoadResource(hInstance, hDlgInit);
4650 pInitData = (BYTE*)::LockResource(m_hInitData);
4651 }
4652
4653 m_hDlgRes = ::LoadResource(hInstance, hDlg);
4654 DLGTEMPLATE* pDlg = (DLGTEMPLATE*)::LockResource(m_hDlgRes);
4655 LPCDLGTEMPLATE lpDialogTemplate = ATL::_DialogSplitHelper::SplitDialogTemplate(pDlg, pInitData);
4656 if(lpDialogTemplate != pDlg)
4657 m_hDlgResSplit = GlobalHandle(lpDialogTemplate);
4658
4659 // set up property page to use in-memory dialog template
4660 if(lpDialogTemplate != NULL)
4661 {
4662 m_psp.dwFlags |= PSP_DLGINDIRECT;
4663 m_psp.pResource = lpDialogTemplate;
4664 }
4665 else
4666 {
4667 ATLASSERT(FALSE && _T("CAxPropertyPageImpl - ActiveX initializtion failed!"));
4668 }
4669 }
4670 else
4671 {
4672 ATLASSERT(FALSE && _T("CAxPropertyPageImpl - Cannot find dialog template!"));
4673 }
4674 }
4675
4676 ~CAxPropertyPageImpl()
4677 {
4678 if(m_hInitData != NULL)
4679 {
4680 UnlockResource(m_hInitData);
4681 FreeResource(m_hInitData);
4682 }
4683 if(m_hDlgRes != NULL)
4684 {
4685 UnlockResource(m_hDlgRes);
4686 FreeResource(m_hDlgRes);
4687 }
4688 if(m_hDlgResSplit != NULL)
4689 {
4690 ::GlobalFree(m_hDlgResSplit);
4691 }
4692 }
4693
4694 // Methods
4695 // call this one to handle keyboard message for ActiveX controls
4696 BOOL PreTranslateMessage(LPMSG pMsg)
4697 {
4698 if ((pMsg->message < WM_KEYFIRST || pMsg->message > WM_KEYLAST) &&
4699 (pMsg->message < WM_MOUSEFIRST || pMsg->message > WM_MOUSELAST))
4700 return FALSE;
4701 // find a direct child of the dialog from the window that has focus
4702 HWND hWndCtl = ::GetFocus();
4703 if (IsChild(hWndCtl) && ::GetParent(hWndCtl) != m_hWnd)
4704 {
4705 do
4706 {
4707 hWndCtl = ::GetParent(hWndCtl);
4708 }
4709 while (::GetParent(hWndCtl) != m_hWnd);
4710 }
4711 // give controls a chance to translate this message
4712 return (BOOL)::SendMessage(hWndCtl, WM_FORWARDMSG, 0, (LPARAM)pMsg);
4713 }
4714
4715 // Overridables
4716 #if (_WIN32_IE >= 0x0500)
4717 // new default implementation for ActiveX hosting pages
4718 #ifdef _WTL_NEW_PAGE_NOTIFY_HANDLERS
4719 int OnTranslateAccelerator(LPMSG lpMsg)
4720 {
4721 T* pT = static_cast<T*>(this);
4722 return (pT->PreTranslateMessage(lpMsg) != FALSE) ? PSNRET_MESSAGEHANDLED : PSNRET_NOERROR;
4723 }
4724 #else // !_WTL_NEW_PAGE_NOTIFY_HANDLERS
4725 BOOL OnTranslateAccelerator(LPMSG lpMsg)
4726 {
4727 T* pT = static_cast<T*>(this);
4728 return pT->PreTranslateMessage(lpMsg);
4729 }
4730 #endif // !_WTL_NEW_PAGE_NOTIFY_HANDLERS
4731 #endif // (_WIN32_IE >= 0x0500)
4732
4733 // Support for new stuff in ATL7
4734 #if (_ATL_VER >= 0x0700)
4735 int GetIDD()
4736 {
4737 return( static_cast<T*>(this)->IDD );
4738 }
4739
4740 virtual DLGPROC GetDialogProc()
4741 {
4742 return DialogProc;
4743 }
4744
4745 static INT_PTR CALLBACK DialogProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
4746 {
4747 CAxPropertyPageImpl< T, TBase >* pThis = (CAxPropertyPageImpl< T, TBase >*)hWnd;
4748 if (uMsg == WM_INITDIALOG)
4749 {
4750 HRESULT hr;
4751 if (FAILED(hr = pThis->CreateActiveXControls(pThis->GetIDD())))
4752 {
4753 ATLASSERT(FALSE);
4754 return FALSE;
4755 }
4756 }
4757 return CPropertyPageImpl< T, TBase >::DialogProc(hWnd, uMsg, wParam, lParam);
4758 }
4759
4760 // ActiveX controls creation
4761 virtual HRESULT CreateActiveXControls(UINT nID)
4762 {
4763 // Load dialog template and InitData
4764 HRSRC hDlgInit = ::FindResource(ATL::_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCE(nID), (LPTSTR)_ATL_RT_DLGINIT);
4765 BYTE* pInitData = NULL;
4766 HGLOBAL hData = NULL;
4767 HRESULT hr = S_OK;
4768 if (hDlgInit != NULL)
4769 {
4770 hData = ::LoadResource(ATL::_AtlBaseModule.GetResourceInstance(), hDlgInit);
4771 if (hData != NULL)
4772 pInitData = (BYTE*) ::LockResource(hData);
4773 }
4774
4775 HRSRC hDlg = ::FindResource(ATL::_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCE(nID), (LPTSTR)RT_DIALOG);
4776 if (hDlg != NULL)
4777 {
4778 HGLOBAL hResource = ::LoadResource(ATL::_AtlBaseModule.GetResourceInstance(), hDlg);
4779 DLGTEMPLATE* pDlg = NULL;
4780 if (hResource != NULL)
4781 {
4782 pDlg = (DLGTEMPLATE*) ::LockResource(hResource);
4783 if (pDlg != NULL)
4784 {
4785 // Get first control on the template
4786 BOOL bDialogEx = ATL::_DialogSplitHelper::IsDialogEx(pDlg);
4787 WORD nItems = ATL::_DialogSplitHelper::DlgTemplateItemCount(pDlg);
4788
4789 // Get first control on the dialog
4790 DLGITEMTEMPLATE* pItem = ATL::_DialogSplitHelper::FindFirstDlgItem(pDlg);
4791 HWND hWndPrev = GetWindow(GW_CHILD);
4792
4793 // Create all ActiveX cotnrols in the dialog template and place them in the correct tab order (z-order)
4794 for (WORD nItem = 0; nItem < nItems; nItem++)
4795 {
4796 DWORD wID = bDialogEx ? ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->id : pItem->id;
4797 if (ATL::_DialogSplitHelper::IsActiveXControl(pItem, bDialogEx))
4798 {
4799 BYTE* pData = NULL;
4800 DWORD dwLen = ATL::_DialogSplitHelper::FindCreateData(wID, pInitData, &pData);
4801 ATL::CComPtr<IStream> spStream;
4802 if (dwLen != 0)
4803 {
4804 HGLOBAL h = GlobalAlloc(GHND, dwLen);
4805 if (h != NULL)
4806 {
4807 BYTE* pBytes = (BYTE*) GlobalLock(h);
4808 BYTE* pSource = pData;
4809 SecureHelper::memcpy_x(pBytes, dwLen, pSource, dwLen);
4810 GlobalUnlock(h);
4811 CreateStreamOnHGlobal(h, TRUE, &spStream);
4812 }
4813 else
4814 {
4815 hr = E_OUTOFMEMORY;
4816 break;
4817 }
4818 }
4819
4820 ATL::CComBSTR bstrLicKey;
4821 hr = ATL::_DialogSplitHelper::ParseInitData(spStream, &bstrLicKey.m_str);
4822 if (SUCCEEDED(hr))
4823 {
4824 ATL::CAxWindow2 wnd;
4825 // Get control caption.
4826 LPWSTR pszClassName =
4827 bDialogEx ?
4828 (LPWSTR)(((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem) + 1) :
4829 (LPWSTR)(pItem + 1);
4830 // Get control rect.
4831 RECT rect;
4832 rect.left =
4833 bDialogEx ?
4834 ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->x :
4835 pItem->x;
4836 rect.top =
4837 bDialogEx ?
4838 ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->y :
4839 pItem->y;
4840 rect.right = rect.left +
4841 (bDialogEx ?
4842 ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->cx :
4843 pItem->cx);
4844 rect.bottom = rect.top +
4845 (bDialogEx ?
4846 ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->cy :
4847 pItem->cy);
4848
4849 // Convert from dialog units to screen units
4850 MapDialogRect(&rect);
4851
4852 // Create AxWindow with a NULL caption.
4853 wnd.Create(m_hWnd,
4854 &rect,
4855 NULL,
4856 (bDialogEx ?
4857 ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->style :
4858 pItem->style) | WS_TABSTOP,
4859 bDialogEx ?
4860 ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->exStyle :
4861 0,
4862 bDialogEx ?
4863 ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->id :
4864 pItem->id,
4865 NULL);
4866
4867 if (wnd != NULL)
4868 {
4869 #ifndef _WIN32_WCE
4870 // Set the Help ID
4871 if (bDialogEx && ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->helpID != 0)
4872 wnd.SetWindowContextHelpId(((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->helpID);
4873 #endif // !_WIN32_WCE
4874 // Try to create the ActiveX control.
4875 hr = wnd.CreateControlLic(pszClassName, spStream, NULL, bstrLicKey);
4876 if (FAILED(hr))
4877 break;
4878 // Set the correct tab position.
4879 if (nItem == 0)
4880 hWndPrev = HWND_TOP;
4881 wnd.SetWindowPos(hWndPrev, 0,0,0,0,SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
4882 hWndPrev = wnd;
4883 }
4884 else
4885 {
4886 hr = ATL::AtlHresultFromLastError();
4887 }
4888 }
4889 }
4890 else
4891 {
4892 if (nItem != 0)
4893 hWndPrev = ::GetWindow(hWndPrev, GW_HWNDNEXT);
4894 }
4895 pItem = ATL::_DialogSplitHelper::FindNextDlgItem(pItem, bDialogEx);
4896 }
4897 }
4898 else
4899 hr = ATL::AtlHresultFromLastError();
4900 }
4901 else
4902 hr = ATL::AtlHresultFromLastError();
4903 }
4904 return hr;
4905 }
4906
4907 // Event handling support
4908 HRESULT AdviseSinkMap(bool bAdvise)
4909 {
4910 if(!bAdvise && m_hWnd == NULL)
4911 {
4912 // window is gone, controls are already unadvised
4913 ATLTRACE2(atlTraceUI, 0, _T("CAxPropertyPageImpl::AdviseSinkMap called after the window was destroyed\n"));
4914 return S_OK;
4915 }
4916 HRESULT hRet = E_NOTIMPL;
4917 __if_exists(T::_GetSinkMapFinder)
4918 {
4919 T* pT = static_cast<T*>(this);
4920 hRet = AtlAdviseSinkMap(pT, bAdvise);
4921 }
4922 return hRet;
4923 }
4924
4925 // Message map and handlers
4926 typedef CPropertyPageImpl< T, TBase> _baseClass;
4927 BEGIN_MSG_MAP(CAxPropertyPageImpl)
4928 MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
4929 MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
4930 CHAIN_MSG_MAP(_baseClass)
4931 END_MSG_MAP()
4932
4933 LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
4934 {
4935 // initialize controls in dialog with DLGINIT resource section
4936 ExecuteDlgInit(static_cast<T*>(this)->IDD);
4937 AdviseSinkMap(true);
4938 bHandled = FALSE;
4939 return 1;
4940 }
4941
4942 LRESULT OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
4943 {
4944 AdviseSinkMap(false);
4945 bHandled = FALSE;
4946 return 1;
4947 }
4948 #endif // (_ATL_VER >= 0x0700)
4949 };
4950
4951 // for non-customized pages
4952 template <WORD t_wDlgTemplateID>
4953 class CAxPropertyPage : public CAxPropertyPageImpl<CAxPropertyPage<t_wDlgTemplateID> >
4954 {
4955 public:
4956 enum { IDD = t_wDlgTemplateID };
4957
4958 CAxPropertyPage(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : CAxPropertyPageImpl<CAxPropertyPage>(title)
4959 { }
4960
4961 #if (_WIN32_IE >= 0x0500) || (_ATL_VER >= 0x0700)
4962 // not empty so we handle accelerators/create controls
4963 BEGIN_MSG_MAP(CAxPropertyPage)
4964 CHAIN_MSG_MAP(CAxPropertyPageImpl<CAxPropertyPage<t_wDlgTemplateID> >)
4965 END_MSG_MAP()
4966 #else // !((_WIN32_IE >= 0x0500) || (_ATL_VER >= 0x0700))
4967 DECLARE_EMPTY_MSG_MAP()
4968 #endif // !((_WIN32_IE >= 0x0500) || (_ATL_VER >= 0x0700))
4969 };
4970
4971 #endif // _ATL_NO_HOSTING
4972
4973
4974 ///////////////////////////////////////////////////////////////////////////////
4975 // Wizard97 Support
4976
4977 #if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
4978
4979 // Sample wizard dialog resources:
4980 //
4981 // IDD_WIZ97_INTERIOR_BLANK DIALOG 0, 0, 317, 143
4982 // STYLE DS_SETFONT | WS_CHILD | WS_DISABLED | WS_CAPTION
4983 // CAPTION "Wizard97 Property Page - Interior"
4984 // FONT 8, "MS Shell Dlg"
4985 // BEGIN
4986 // END
4987 //
4988 // IDD_WIZ97_EXTERIOR_BLANK DIALOGEX 0, 0, 317, 193
4989 // STYLE DS_SETFONT | DS_FIXEDSYS | WS_CHILD | WS_DISABLED | WS_CAPTION
4990 // CAPTION "Wizard97 Property Page - Welcome/Complete"
4991 // FONT 8, "MS Shell Dlg", 0, 0, 0x0
4992 // BEGIN
4993 // LTEXT "Welcome to the X Wizard",IDC_WIZ97_EXTERIOR_TITLE,115,8,
4994 // 195,24
4995 // LTEXT "Wizard Explanation\r\n(The height of the static text should be in multiples of 8 dlus)",
4996 // IDC_STATIC,115,40,195,16
4997 // LTEXT "h",IDC_WIZ97_BULLET1,118,64,8,8
4998 // LTEXT "List Item 1 (the h is turned into a bullet)",IDC_STATIC,
4999 // 127,63,122,8
5000 // LTEXT "h",IDC_WIZ97_BULLET2,118,79,8,8
5001 // LTEXT "List Item 2. Keep 7 dlus between paragraphs",IDC_STATIC,
5002 // 127,78,33,8
5003 // CONTROL "&Do not show this Welcome page again",
5004 // IDC_WIZ97_WELCOME_NOTAGAIN,"Button",BS_AUTOCHECKBOX |
5005 // WS_TABSTOP,115,169,138,10
5006 // END
5007 //
5008 // GUIDELINES DESIGNINFO
5009 // BEGIN
5010 // IDD_WIZ97_INTERIOR_BLANK, DIALOG
5011 // BEGIN
5012 // LEFTMARGIN, 7
5013 // RIGHTMARGIN, 310
5014 // VERTGUIDE, 21
5015 // VERTGUIDE, 31
5016 // VERTGUIDE, 286
5017 // VERTGUIDE, 296
5018 // TOPMARGIN, 7
5019 // BOTTOMMARGIN, 136
5020 // HORZGUIDE, 8
5021 // END
5022 //
5023 // IDD_WIZ97_EXTERIOR_BLANK, DIALOG
5024 // BEGIN
5025 // RIGHTMARGIN, 310
5026 // VERTGUIDE, 115
5027 // VERTGUIDE, 118
5028 // VERTGUIDE, 127
5029 // TOPMARGIN, 7
5030 // BOTTOMMARGIN, 186
5031 // HORZGUIDE, 8
5032 // HORZGUIDE, 32
5033 // HORZGUIDE, 40
5034 // HORZGUIDE, 169
5035 // END
5036 // END
5037
5038 ///////////////////////////////////////////////////////////////////////////////
5039 // CWizard97SheetWindow - client side for a Wizard 97 style wizard sheet
5040
5041 class CWizard97SheetWindow : public CPropertySheetWindow
5042 {
5043 public:
5044 // Constructors
5045 CWizard97SheetWindow(HWND hWnd = NULL) : CPropertySheetWindow(hWnd)
5046 { }
5047
5048 CWizard97SheetWindow& operator =(HWND hWnd)
5049 {
5050 m_hWnd = hWnd;
5051 return *this;
5052 }
5053
5054 // Operations
5055 HFONT GetExteriorPageTitleFont(void)
5056 {
5057 ATLASSERT(::IsWindow(m_hWnd));
5058 return (HFONT)::SendMessage(m_hWnd, GetMessage_GetExteriorPageTitleFont(), 0, 0L);
5059 }
5060
5061 HFONT GetBulletFont(void)
5062 {
5063 ATLASSERT(::IsWindow(m_hWnd));
5064 return (HFONT)::SendMessage(m_hWnd, GetMessage_GetBulletFont(), 0, 0L);
5065 }
5066
5067 // Helpers
5068 static UINT GetMessage_GetExteriorPageTitleFont()
5069 {
5070 static UINT uGetExteriorPageTitleFont = 0;
5071 if(uGetExteriorPageTitleFont == 0)
5072 {
5073 CStaticDataInitCriticalSectionLock lock;
5074 if(FAILED(lock.Lock()))
5075 {
5076 ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CWizard97SheetWindow::GetMessage_GetExteriorPageTitleFont().\n"));
5077 ATLASSERT(FALSE);
5078 return 0;
5079 }
5080
5081 if(uGetExteriorPageTitleFont == 0)
5082 uGetExteriorPageTitleFont = ::RegisterWindowMessage(_T("GetExteriorPageTitleFont_531AF056-B8BE-4c4c-B786-AC608DF0DF12"));
5083
5084 lock.Unlock();
5085 }
5086 ATLASSERT(uGetExteriorPageTitleFont != 0);
5087 return uGetExteriorPageTitleFont;
5088 }
5089
5090 static UINT GetMessage_GetBulletFont()
5091 {
5092 static UINT uGetBulletFont = 0;
5093 if(uGetBulletFont == 0)
5094 {
5095 CStaticDataInitCriticalSectionLock lock;
5096 if(FAILED(lock.Lock()))
5097 {
5098 ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CWizard97SheetWindow::GetMessage_GetBulletFont().\n"));
5099 ATLASSERT(FALSE);
5100 return 0;
5101 }
5102
5103 if(uGetBulletFont == 0)
5104 uGetBulletFont = ::RegisterWindowMessage(_T("GetBulletFont_AD347D08-8F65-45ef-982E-6352E8218AD5"));
5105
5106 lock.Unlock();
5107 }
5108 ATLASSERT(uGetBulletFont != 0);
5109 return uGetBulletFont;
5110 }
5111
5112 // Implementation - override to prevent usage
5113 HWND Create(LPCTSTR, HWND, ATL::_U_RECT = NULL, LPCTSTR = NULL, DWORD = 0, DWORD = 0, ATL::_U_MENUorID = 0U, LPVOID = NULL)
5114 {
5115 ATLASSERT(FALSE);
5116 return NULL;
5117 }
5118 };
5119
5120
5121 ///////////////////////////////////////////////////////////////////////////////
5122 // CWizard97SheetImpl - implements a Wizard 97 style wizard sheet
5123
5124 template <class T, class TBase = CWizard97SheetWindow>
5125 class ATL_NO_VTABLE CWizard97SheetImpl : public CPropertySheetImpl< T, TBase >
5126 {
5127 protected:
5128 // Typedefs
5129 typedef CWizard97SheetImpl< T, TBase > thisClass;
5130 typedef CPropertySheetImpl< T, TBase > baseClass;
5131
5132 // Member variables
5133 CFont m_fontExteriorPageTitle; // Welcome and Completion page title font
5134 CFont m_fontBullet; // Bullet font (used on static text 'h' to produce a small bullet)
5135 bool m_bReceivedFirstSizeMessage;
5136
5137 public:
5138 CWizard97SheetImpl(ATL::_U_STRINGorID title, ATL::_U_STRINGorID headerBitmap, ATL::_U_STRINGorID watermarkBitmap, UINT uStartPage = 0, HWND hWndParent = NULL) :
5139 baseClass(title, uStartPage, hWndParent),
5140 m_bReceivedFirstSizeMessage(false)
5141 {
5142 m_psh.dwFlags &= ~(PSH_NOCONTEXTHELP);
5143 m_psh.dwFlags &= ~(PSH_WIZARD | PSH_WIZARD_LITE);
5144
5145 m_psh.dwFlags |= (PSH_HASHELP | PSH_WIZARDCONTEXTHELP);
5146 m_psh.dwFlags |= PSH_WIZARD97;
5147
5148 baseClass::SetHeader(headerBitmap.m_lpstr);
5149 baseClass::SetWatermark(watermarkBitmap.m_lpstr);
5150 }
5151
5152 // Overrides from base class
5153 void OnSheetInitialized()
5154 {
5155 T* pT = static_cast<T*>(this);
5156 pT->_InitializeFonts();
5157
5158 // We'd like to center the wizard here, but its too early.
5159 // Instead, we'll do CenterWindow upon our first WM_SIZE message
5160 }
5161
5162 // Initialization
5163 void _InitializeFonts()
5164 {
5165 // Setup the Title and Bullet Font
5166 // (Property pages can send the "get external page title font" and "get bullet font" messages)
5167 // The derived class needs to do the actual SetFont for the dialog items)
5168
5169 CFontHandle fontThisDialog = this->GetFont();
5170 CClientDC dcScreen(NULL);
5171
5172 LOGFONT titleLogFont = {0};
5173 LOGFONT bulletLogFont = {0};
5174 fontThisDialog.GetLogFont(&titleLogFont);
5175 fontThisDialog.GetLogFont(&bulletLogFont);
5176
5177 // The Wizard 97 Spec recommends to do the Title Font
5178 // as Verdana Bold, 12pt.
5179 titleLogFont.lfCharSet = DEFAULT_CHARSET;
5180 titleLogFont.lfWeight = FW_BOLD;
5181 SecureHelper::strcpy_x(titleLogFont.lfFaceName, _countof(titleLogFont.lfFaceName), _T("Verdana Bold"));
5182 INT titleFontPointSize = 12;
5183 titleLogFont.lfHeight = -::MulDiv(titleFontPointSize, dcScreen.GetDeviceCaps(LOGPIXELSY), 72);
5184 m_fontExteriorPageTitle.CreateFontIndirect(&titleLogFont);
5185
5186 // The Wizard 97 Spec recommends to do Bullets by having
5187 // static text of "h" in the Marlett font.
5188 bulletLogFont.lfCharSet = DEFAULT_CHARSET;
5189 bulletLogFont.lfWeight = FW_NORMAL;
5190 SecureHelper::strcpy_x(bulletLogFont.lfFaceName, _countof(bulletLogFont.lfFaceName), _T("Marlett"));
5191 INT bulletFontSize = 8;
5192 bulletLogFont.lfHeight = -::MulDiv(bulletFontSize, dcScreen.GetDeviceCaps(LOGPIXELSY), 72);
5193 m_fontBullet.CreateFontIndirect(&bulletLogFont);
5194 }
5195
5196 // Message Handling
5197 BEGIN_MSG_MAP(thisClass)
5198 MESSAGE_HANDLER(CWizard97SheetWindow::GetMessage_GetExteriorPageTitleFont(), OnGetExteriorPageTitleFont)
5199 MESSAGE_HANDLER(CWizard97SheetWindow::GetMessage_GetBulletFont(), OnGetBulletFont)
5200 MESSAGE_HANDLER(WM_SIZE, OnSize)
5201 CHAIN_MSG_MAP(baseClass)
5202 END_MSG_MAP()
5203
5204 LRESULT OnGetExteriorPageTitleFont(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
5205 {
5206 return (LRESULT)(HFONT)m_fontExteriorPageTitle;
5207 }
5208
5209 LRESULT OnGetBulletFont(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
5210 {
5211 return (LRESULT)(HFONT)m_fontBullet;
5212 }
5213
5214 LRESULT OnSize(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
5215 {
5216 if(!m_bReceivedFirstSizeMessage)
5217 {
5218 m_bReceivedFirstSizeMessage = true;
5219 this->CenterWindow();
5220 }
5221
5222 bHandled = FALSE;
5223 return 0;
5224 }
5225 };
5226
5227 // for non-customized sheets
5228 class CWizard97Sheet : public CWizard97SheetImpl<CWizard97Sheet>
5229 {
5230 protected:
5231 // Typedefs
5232 typedef CWizard97Sheet thisClass;
5233 typedef CWizard97SheetImpl<CWizard97Sheet> baseClass;
5234
5235 public:
5236 CWizard97Sheet(ATL::_U_STRINGorID title, ATL::_U_STRINGorID headerBitmap, ATL::_U_STRINGorID watermarkBitmap, UINT uStartPage = 0, HWND hWndParent = NULL) :
5237 baseClass(title, headerBitmap, watermarkBitmap, uStartPage, hWndParent)
5238 { }
5239
5240 BEGIN_MSG_MAP(thisClass)
5241 CHAIN_MSG_MAP(baseClass)
5242 END_MSG_MAP()
5243 };
5244
5245
5246 ///////////////////////////////////////////////////////////////////////////////
5247 // CWizard97PageWindow - client side for a Wizard 97 style wizard page
5248
5249 #define WIZARD97_EXTERIOR_CXDLG 317
5250 #define WIZARD97_EXTERIOR_CYDLG 193
5251
5252 #define WIZARD97_INTERIOR_CXDLG 317
5253 #define WIZARD97_INTERIOR_CYDLG 143
5254
5255 class CWizard97PageWindow : public CPropertyPageWindow
5256 {
5257 public:
5258 // Constructors
5259 CWizard97PageWindow(HWND hWnd = NULL) : CPropertyPageWindow(hWnd)
5260 { }
5261
5262 CWizard97PageWindow& operator =(HWND hWnd)
5263 {
5264 m_hWnd = hWnd;
5265 return *this;
5266 }
5267
5268 // Attributes
5269 CWizard97SheetWindow GetPropertySheet() const
5270 {
5271 ATLASSERT(::IsWindow(m_hWnd));
5272 return CWizard97SheetWindow(GetParent());
5273 }
5274
5275 // Operations
5276 HFONT GetExteriorPageTitleFont(void)
5277 {
5278 ATLASSERT(::IsWindow(m_hWnd));
5279 return GetPropertySheet().GetExteriorPageTitleFont();
5280 }
5281
5282 HFONT GetBulletFont(void)
5283 {
5284 ATLASSERT(::IsWindow(m_hWnd));
5285 return GetPropertySheet().GetBulletFont();
5286 }
5287
5288 // Implementation - overrides to prevent usage
5289 HWND Create(LPCTSTR, HWND, ATL::_U_RECT = NULL, LPCTSTR = NULL, DWORD = 0, DWORD = 0, ATL::_U_MENUorID = 0U, LPVOID = NULL)
5290 {
5291 ATLASSERT(FALSE);
5292 return NULL;
5293 }
5294
5295 };
5296
5297
5298 ///////////////////////////////////////////////////////////////////////////////
5299 // CWizard97PageImpl - implements a Wizard 97 style wizard page
5300
5301 template <class T, class TBase = CWizard97PageWindow>
5302 class ATL_NO_VTABLE CWizard97PageImpl : public CPropertyPageImpl< T, TBase >
5303 {
5304 protected:
5305 // Typedefs
5306 typedef CWizard97PageImpl< T, TBase > thisClass;
5307 typedef CPropertyPageImpl< T, TBase > baseClass;
5308
5309 public:
5310 CWizard97PageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : baseClass(title)
5311 { }
5312
5313 // Message Handling
5314 BEGIN_MSG_MAP(thisClass)
5315 CHAIN_MSG_MAP(baseClass)
5316 END_MSG_MAP()
5317 };
5318
5319
5320 ///////////////////////////////////////////////////////////////////////////////
5321 // CWizard97ExteriorPageImpl - implements a Wizard 97 style exterior wizard page
5322
5323 template <class T, class TBase = CWizard97PageWindow>
5324 class ATL_NO_VTABLE CWizard97ExteriorPageImpl : public CPropertyPageImpl< T, TBase >
5325 {
5326 protected:
5327 // Typedefs
5328 typedef CWizard97ExteriorPageImpl< T, TBase > thisClass;
5329 typedef CPropertyPageImpl< T, TBase > baseClass;
5330
5331 public:
5332 // Constructors
5333 CWizard97ExteriorPageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : baseClass(title)
5334 {
5335 m_psp.dwFlags |= PSP_HASHELP;
5336 m_psp.dwFlags |= PSP_HIDEHEADER;
5337 }
5338
5339 // Message Handling
5340 BEGIN_MSG_MAP(thisClass)
5341 CHAIN_MSG_MAP(baseClass)
5342 END_MSG_MAP()
5343 };
5344
5345
5346 ///////////////////////////////////////////////////////////////////////////////
5347 // CWizard97InteriorPageImpl - implements a Wizard 97 style interior wizard page
5348
5349 template <class T, class TBase = CWizard97PageWindow>
5350 class ATL_NO_VTABLE CWizard97InteriorPageImpl : public CPropertyPageImpl< T, TBase >
5351 {
5352 protected:
5353 // Typedefs
5354 typedef CWizard97InteriorPageImpl< T, TBase > thisClass;
5355 typedef CPropertyPageImpl< T, TBase > baseClass;
5356
5357 public:
5358 // Constructors
5359 CWizard97InteriorPageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : baseClass(title)
5360 {
5361 m_psp.dwFlags |= PSP_HASHELP;
5362 m_psp.dwFlags &= ~PSP_HIDEHEADER;
5363 m_psp.dwFlags |= PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
5364
5365 // Be sure to have the derived class define this in the constructor.
5366 // We'll default it to something obvious in case its forgotten.
5367 baseClass::SetHeaderTitle(_T("Call SetHeaderTitle in Derived Class"));
5368 baseClass::SetHeaderSubTitle(_T("Call SetHeaderSubTitle in the constructor of the Derived Class."));
5369 }
5370
5371 // Message Handling
5372 BEGIN_MSG_MAP(thisClass)
5373 CHAIN_MSG_MAP(baseClass)
5374 END_MSG_MAP()
5375 };
5376
5377 #endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
5378
5379
5380 ///////////////////////////////////////////////////////////////////////////////
5381 // Aero Wizard support
5382
5383 #if (_WIN32_WINNT >= 0x0600) && !defined(_WIN32_WCE)
5384
5385 ///////////////////////////////////////////////////////////////////////////////
5386 // CAeroWizardFrameWindow - client side for an Aero Wizard frame window
5387
5388 class CAeroWizardFrameWindow : public CPropertySheetWindow
5389 {
5390 public:
5391 // Constructors
5392 CAeroWizardFrameWindow(HWND hWnd = NULL) : CPropertySheetWindow(hWnd)
5393 { }
5394
5395 CAeroWizardFrameWindow& operator =(HWND hWnd)
5396 {
5397 m_hWnd = hWnd;
5398 return *this;
5399 }
5400
5401 // Operations - new, Aero Wizard only
5402 void SetNextText(LPCWSTR lpszText)
5403 {
5404 ATLASSERT(::IsWindow(m_hWnd));
5405 ::SendMessage(m_hWnd, PSM_SETNEXTTEXT, 0, (LPARAM)lpszText);
5406 }
5407
5408 void ShowWizardButtons(DWORD dwButtons, DWORD dwStates)
5409 {
5410 ATLASSERT(::IsWindow(m_hWnd));
5411 ::PostMessage(m_hWnd, PSM_SHOWWIZBUTTONS, (WPARAM)dwStates, (LPARAM)dwButtons);
5412 }
5413
5414 void EnableWizardButtons(DWORD dwButtons, DWORD dwStates)
5415 {
5416 ATLASSERT(::IsWindow(m_hWnd));
5417 ::PostMessage(m_hWnd, PSM_ENABLEWIZBUTTONS, (WPARAM)dwStates, (LPARAM)dwButtons);
5418 }
5419
5420 void SetButtonText(DWORD dwButton, LPCWSTR lpszText)
5421 {
5422 ATLASSERT(::IsWindow(m_hWnd));
5423 ::SendMessage(m_hWnd, PSM_SETBUTTONTEXT, (WPARAM)dwButton, (LPARAM)lpszText);
5424 }
5425 };
5426
5427
5428 ///////////////////////////////////////////////////////////////////////////////
5429 // CAeroWizardFrameImpl - implements an Aero Wizard frame
5430
5431 template <class T, class TBase = CAeroWizardFrameWindow>
5432 class ATL_NO_VTABLE CAeroWizardFrameImpl : public CPropertySheetImpl<T, TBase >
5433 {
5434 public:
5435 // Constructor
5436 CAeroWizardFrameImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL, UINT uStartPage = 0, HWND hWndParent = NULL) :
5437 CPropertySheetImpl<T, TBase >(title, uStartPage, hWndParent)
5438 {
5439 m_psh.dwFlags |= PSH_WIZARD | PSH_AEROWIZARD;
5440 }
5441
5442 // Operations
5443 void EnableResizing()
5444 {
5445 ATLASSERT(m_hWnd == NULL); // can't do this after it's created
5446 m_psh.dwFlags |= PSH_RESIZABLE;
5447 }
5448
5449 void UseHeaderBitmap()
5450 {
5451 ATLASSERT(m_hWnd == NULL); // can't do this after it's created
5452 m_psh.dwFlags |= PSH_HEADERBITMAP;
5453 }
5454
5455 void SetNoMargin()
5456 {
5457 ATLASSERT(m_hWnd == NULL); // can't do this after it's created
5458 m_psh.dwFlags |= PSH_NOMARGIN;
5459 }
5460
5461 // Override to prevent use
5462 HWND Create(HWND /*hWndParent*/ = NULL)
5463 {
5464 ATLASSERT(FALSE); // not supported for Aero Wizard
5465 return NULL;
5466 }
5467 };
5468
5469
5470 ///////////////////////////////////////////////////////////////////////////////
5471 // CAeroWizardFrame - for non-customized frames
5472
5473 class CAeroWizardFrame : public CAeroWizardFrameImpl<CAeroWizardFrame>
5474 {
5475 public:
5476 CAeroWizardFrame(ATL::_U_STRINGorID title = (LPCTSTR)NULL, UINT uStartPage = 0, HWND hWndParent = NULL)
5477 : CAeroWizardFrameImpl<CAeroWizardFrame>(title, uStartPage, hWndParent)
5478 { }
5479
5480 BEGIN_MSG_MAP(CAeroWizardFrame)
5481 MESSAGE_HANDLER(WM_COMMAND, CAeroWizardFrameImpl<CAeroWizardFrame>::OnCommand)
5482 END_MSG_MAP()
5483 };
5484
5485
5486 ///////////////////////////////////////////////////////////////////////////////
5487 // CAeroWizardPageWindow - client side for an Aero Wizard page
5488
5489 class CAeroWizardPageWindow : public CPropertyPageWindow
5490 {
5491 public:
5492 // Constructors
5493 CAeroWizardPageWindow(HWND hWnd = NULL) : CPropertyPageWindow(hWnd)
5494 { }
5495
5496 CAeroWizardPageWindow& operator =(HWND hWnd)
5497 {
5498 m_hWnd = hWnd;
5499 return *this;
5500 }
5501
5502 // Attributes
5503 CAeroWizardFrameWindow GetAeroWizardFrame() const
5504 {
5505 ATLASSERT(::IsWindow(m_hWnd));
5506 // This is not really top-level frame window, but it processes all frame messages
5507 return CAeroWizardFrameWindow(GetParent());
5508 }
5509
5510 // Operations - new, Aero Wizard only
5511 void SetNextText(LPCWSTR lpszText)
5512 {
5513 ATLASSERT(::IsWindow(m_hWnd));
5514 ATLASSERT(GetParent() != NULL);
5515 GetAeroWizardFrame().SetNextText(lpszText);
5516 }
5517
5518 void ShowWizardButtons(DWORD dwButtons, DWORD dwStates)
5519 {
5520 ATLASSERT(::IsWindow(m_hWnd));
5521 ATLASSERT(GetParent() != NULL);
5522 GetAeroWizardFrame().ShowWizardButtons(dwButtons, dwStates);
5523 }
5524
5525 void EnableWizardButtons(DWORD dwButtons, DWORD dwStates)
5526 {
5527 ATLASSERT(::IsWindow(m_hWnd));
5528 ATLASSERT(GetParent() != NULL);
5529 GetAeroWizardFrame().EnableWizardButtons(dwButtons, dwStates);
5530 }
5531
5532 void SetButtonText(DWORD dwButton, LPCWSTR lpszText)
5533 {
5534 ATLASSERT(::IsWindow(m_hWnd));
5535 ATLASSERT(GetParent() != NULL);
5536 GetAeroWizardFrame().SetButtonText(dwButton, lpszText);
5537 }
5538 };
5539
5540
5541 ///////////////////////////////////////////////////////////////////////////////
5542 // CAeroWizardPageImpl - implements an Aero Wizard page
5543
5544 template <class T, class TBase = CAeroWizardPageWindow>
5545 class ATL_NO_VTABLE CAeroWizardPageImpl : public CPropertyPageImpl<T, TBase >
5546 {
5547 public:
5548 CAeroWizardPageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : CPropertyPageImpl<T, TBase >(title)
5549 { }
5550 };
5551
5552
5553 ///////////////////////////////////////////////////////////////////////////////
5554 // CAeroWizardPage - for non-customized pages
5555
5556 template <WORD t_wDlgTemplateID>
5557 class CAeroWizardPage : public CAeroWizardPageImpl<CAeroWizardPage<t_wDlgTemplateID> >
5558 {
5559 public:
5560 enum { IDD = t_wDlgTemplateID };
5561
5562 CAeroWizardPage(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : CAeroWizardPageImpl<CAeroWizardPage>(title)
5563 { }
5564
5565 DECLARE_EMPTY_MSG_MAP()
5566 };
5567
5568
5569 #ifndef _ATL_NO_HOSTING
5570
5571 // Note: You must #include <atlhost.h> to use these classes
5572
5573 ///////////////////////////////////////////////////////////////////////////////
5574 // CAeroWizardAxPageImpl - Aero Wizard page that hosts ActiveX controls
5575
5576 template <class T, class TBase = CAeroWizardPageWindow>
5577 class ATL_NO_VTABLE CAeroWizardAxPageImpl : public CAxPropertyPageImpl< T, TBase >
5578 {
5579 public:
5580 CAeroWizardAxPageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : CAxPropertyPageImpl< T, TBase >(title)
5581 { }
5582 };
5583
5584
5585 ///////////////////////////////////////////////////////////////////////////////
5586 // CAeroWizardAxPage - for non-customized pages
5587
5588 template <WORD t_wDlgTemplateID>
5589 class CAeroWizardAxPage : public CAeroWizardAxPageImpl<CAeroWizardAxPage<t_wDlgTemplateID> >
5590 {
5591 public:
5592 enum { IDD = t_wDlgTemplateID };
5593
5594 CAeroWizardAxPage(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : CAeroWizardAxPageImpl<CAeroWizardAxPage>(title)
5595 { }
5596
5597 #if (_WIN32_IE >= 0x0500) || (_ATL_VER >= 0x0700)
5598 // not empty so we handle accelerators/create controls
5599 BEGIN_MSG_MAP(CAeroWizardAxPage)
5600 CHAIN_MSG_MAP(CAeroWizardAxPageImpl<CAeroWizardAxPage<t_wDlgTemplateID> >)
5601 END_MSG_MAP()
5602 #else // !((_WIN32_IE >= 0x0500) || (_ATL_VER >= 0x0700))
5603 DECLARE_EMPTY_MSG_MAP()
5604 #endif // !((_WIN32_IE >= 0x0500) || (_ATL_VER >= 0x0700))
5605 };
5606
5607 #endif // _ATL_NO_HOSTING
5608
5609 #endif // (_WIN32_WINNT >= 0x0600) && !defined(_WIN32_WCE)
5610
5611
5612 ///////////////////////////////////////////////////////////////////////////////
5613 // TaskDialog support
5614
5615 #if ((_WIN32_WINNT >= 0x0600) || defined(_WTL_TASKDIALOG)) && !defined(_WIN32_WCE)
5616
5617 ///////////////////////////////////////////////////////////////////////////////
5618 // AtlTaskDialog - support for TaskDialog() function
5619
5620 inline int AtlTaskDialog(HWND hWndParent,
5621 ATL::_U_STRINGorID WindowTitle, ATL::_U_STRINGorID MainInstructionText, ATL::_U_STRINGorID ContentText,
5622 TASKDIALOG_COMMON_BUTTON_FLAGS dwCommonButtons = 0U, ATL::_U_STRINGorID Icon = (LPCTSTR)NULL)
5623 {
5624 int nRet = -1;
5625
5626 #ifdef _WTL_TASKDIALOG_DIRECT
5627 USES_CONVERSION;
5628 HRESULT hRet = ::TaskDialog(hWndParent, ModuleHelper::GetResourceInstance(), T2CW(WindowTitle.m_lpstr), T2CW(MainInstructionText.m_lpstr), T2CW(ContentText.m_lpstr), dwCommonButtons, T2CW(Icon.m_lpstr), &nRet);
5629 ATLVERIFY(SUCCEEDED(hRet));
5630 #else
5631 // This allows apps to run on older versions of Windows
5632 typedef HRESULT (STDAPICALLTYPE *PFN_TaskDialog)(HWND hwndParent, HINSTANCE hInstance, PCWSTR pszWindowTitle, PCWSTR pszMainInstruction, PCWSTR pszContent, TASKDIALOG_COMMON_BUTTON_FLAGS dwCommonButtons, PCWSTR pszIcon, int* pnButton);
5633
5634 HMODULE m_hCommCtrlDLL = ::LoadLibrary(_T("comctl32.dll"));
5635 if(m_hCommCtrlDLL != NULL)
5636 {
5637 PFN_TaskDialog pfnTaskDialog = (PFN_TaskDialog)::GetProcAddress(m_hCommCtrlDLL, "TaskDialog");
5638 if(pfnTaskDialog != NULL)
5639 {
5640 USES_CONVERSION;
5641 HRESULT hRet = pfnTaskDialog(hWndParent, ModuleHelper::GetResourceInstance(), T2CW(WindowTitle.m_lpstr), T2CW(MainInstructionText.m_lpstr), T2CW(ContentText.m_lpstr), dwCommonButtons, T2CW(Icon.m_lpstr), &nRet);
5642 ATLVERIFY(SUCCEEDED(hRet));
5643 }
5644
5645 ::FreeLibrary(m_hCommCtrlDLL);
5646 }
5647 #endif
5648
5649 return nRet;
5650 }
5651
5652
5653 ///////////////////////////////////////////////////////////////////////////////
5654 // CTaskDialogConfig - TASKDIALOGCONFIG wrapper
5655
5656 class CTaskDialogConfig : public TASKDIALOGCONFIG
5657 {
5658 public:
5659 // Constructor
5660 CTaskDialogConfig()
5661 {
5662 Init();
5663 }
5664
5665 void Init()
5666 {
5667 memset(this, 0, sizeof(TASKDIALOGCONFIG)); // initialize structure to 0/NULL
5668 this->cbSize = sizeof(TASKDIALOGCONFIG);
5669 this->hInstance = ModuleHelper::GetResourceInstance();
5670 }
5671
5672 // Operations - setting values
5673 // common buttons
5674 void SetCommonButtons(TASKDIALOG_COMMON_BUTTON_FLAGS dwCommonButtons)
5675 {
5676 this->dwCommonButtons = dwCommonButtons;
5677 }
5678
5679 // window title text
5680 void SetWindowTitle(UINT nID)
5681 {
5682 this->pszWindowTitle = MAKEINTRESOURCEW(nID);
5683 }
5684
5685 void SetWindowTitle(LPCWSTR lpstrWindowTitle)
5686 {
5687 this->pszWindowTitle = lpstrWindowTitle;
5688 }
5689
5690 // main icon
5691 void SetMainIcon(HICON hIcon)
5692 {
5693 this->dwFlags |= TDF_USE_HICON_MAIN;
5694 this->hMainIcon = hIcon;
5695 }
5696
5697 void SetMainIcon(UINT nID)
5698 {
5699 this->dwFlags &= ~TDF_USE_HICON_MAIN;
5700 this->pszMainIcon = MAKEINTRESOURCEW(nID);
5701 }
5702
5703 void SetMainIcon(LPCWSTR lpstrMainIcon)
5704 {
5705 this->dwFlags &= ~TDF_USE_HICON_MAIN;
5706 this->pszMainIcon = lpstrMainIcon;
5707 }
5708
5709 // main instruction text
5710 void SetMainInstructionText(UINT nID)
5711 {
5712 this->pszMainInstruction = MAKEINTRESOURCEW(nID);
5713 }
5714
5715 void SetMainInstructionText(LPCWSTR lpstrMainInstruction)
5716 {
5717 this->pszMainInstruction = lpstrMainInstruction;
5718 }
5719
5720 // content text
5721 void SetContentText(UINT nID)
5722 {
5723 this->pszContent = MAKEINTRESOURCEW(nID);
5724 }
5725
5726 void SetContentText(LPCWSTR lpstrContent)
5727 {
5728 this->pszContent = lpstrContent;
5729 }
5730
5731 // buttons
5732 void SetButtons(const TASKDIALOG_BUTTON* pButtons, UINT cButtons, int nDefaultButton = 0)
5733 {
5734 this->pButtons = pButtons;
5735 this->cButtons = cButtons;
5736 if(nDefaultButton != 0)
5737 this->nDefaultButton = nDefaultButton;
5738 }
5739
5740 void SetDefaultButton(int nDefaultButton)
5741 {
5742 this->nDefaultButton = nDefaultButton;
5743 }
5744
5745 // radio buttons
5746 void SetRadioButtons(const TASKDIALOG_BUTTON* pRadioButtons, UINT cRadioButtons, int nDefaultRadioButton = 0)
5747 {
5748 this->pRadioButtons = pRadioButtons;
5749 this->cRadioButtons = cRadioButtons;
5750 if(nDefaultRadioButton != 0)
5751 this->nDefaultRadioButton = nDefaultRadioButton;
5752 }
5753
5754 void SetDefaultRadioButton(int nDefaultRadioButton)
5755 {
5756 this->nDefaultRadioButton = nDefaultRadioButton;
5757 }
5758
5759 // verification text
5760 void SetVerificationText(UINT nID)
5761 {
5762 this->pszVerificationText = MAKEINTRESOURCEW(nID);
5763 }
5764
5765 void SetVerificationText(LPCWSTR lpstrVerificationText)
5766 {
5767 this->pszVerificationText = lpstrVerificationText;
5768 }
5769
5770 // expanded information text
5771 void SetExpandedInformationText(UINT nID)
5772 {
5773 this->pszExpandedInformation = MAKEINTRESOURCEW(nID);
5774 }
5775
5776 void SetExpandedInformationText(LPCWSTR lpstrExpandedInformation)
5777 {
5778 this->pszExpandedInformation = lpstrExpandedInformation;
5779 }
5780
5781 // expanded control text
5782 void SetExpandedControlText(UINT nID)
5783 {
5784 this->pszExpandedControlText = MAKEINTRESOURCEW(nID);
5785 }
5786
5787 void SetExpandedControlText(LPCWSTR lpstrExpandedControlText)
5788 {
5789 this->pszExpandedControlText = lpstrExpandedControlText;
5790 }
5791
5792 // collapsed control text
5793 void SetCollapsedControlText(UINT nID)
5794 {
5795 this->pszCollapsedControlText = MAKEINTRESOURCEW(nID);
5796 }
5797
5798 void SetCollapsedControlText(LPCWSTR lpstrCollapsedControlText)
5799 {
5800 this->pszCollapsedControlText = lpstrCollapsedControlText;
5801 }
5802
5803 // footer icon
5804 void SetFooterIcon(HICON hIcon)
5805 {
5806 this->dwFlags |= TDF_USE_HICON_FOOTER;
5807 this->hFooterIcon = hIcon;
5808 }
5809
5810 void SetFooterIcon(UINT nID)
5811 {
5812 this->dwFlags &= ~TDF_USE_HICON_FOOTER;
5813 this->pszFooterIcon = MAKEINTRESOURCEW(nID);
5814 }
5815
5816 void SetFooterIcon(LPCWSTR lpstrFooterIcon)
5817 {
5818 this->dwFlags &= ~TDF_USE_HICON_FOOTER;
5819 this->pszFooterIcon = lpstrFooterIcon;
5820 }
5821
5822 // footer text
5823 void SetFooterText(UINT nID)
5824 {
5825 this->pszFooter = MAKEINTRESOURCEW(nID);
5826 }
5827
5828 void SetFooterText(LPCWSTR lpstrFooterText)
5829 {
5830 this->pszFooter = lpstrFooterText;
5831 }
5832
5833 // width (in DLUs)
5834 void SetWidth(UINT cxWidth)
5835 {
5836 this->cxWidth = cxWidth;
5837 }
5838
5839 // modify flags
5840 void ModifyFlags(DWORD dwRemove, DWORD dwAdd)
5841 {
5842 this->dwFlags = (this->dwFlags & ~dwRemove) | dwAdd;
5843 }
5844 };
5845
5846
5847 ///////////////////////////////////////////////////////////////////////////////
5848 // CTaskDialogImpl - implements a Task Dialog
5849
5850 template <class T>
5851 class ATL_NO_VTABLE CTaskDialogImpl
5852 {
5853 public:
5854 CTaskDialogConfig m_tdc;
5855 HWND m_hWnd; // used only in callback functions
5856
5857 // Constructor
5858 CTaskDialogImpl(HWND hWndParent = NULL) : m_hWnd(NULL)
5859 {
5860 m_tdc.hwndParent = hWndParent;
5861 m_tdc.pfCallback = T::TaskDialogCallback;
5862 m_tdc.lpCallbackData = (LONG_PTR)static_cast<T*>(this);
5863 }
5864
5865 // Operations
5866 HRESULT DoModal(HWND hWndParent = ::GetActiveWindow(), int* pnButton = NULL, int* pnRadioButton = NULL, BOOL* pfVerificationFlagChecked = NULL)
5867 {
5868 if(m_tdc.hwndParent == NULL)
5869 m_tdc.hwndParent = hWndParent;
5870
5871 #ifdef _WTL_TASKDIALOG_DIRECT
5872 return ::TaskDialogIndirect(&m_tdc, pnButton, pnRadioButton, pfVerificationFlagChecked);
5873 #else
5874
5875 // This allows apps to run on older versions of Windows
5876 typedef HRESULT (STDAPICALLTYPE *PFN_TaskDialogIndirect)(const TASKDIALOGCONFIG* pTaskConfig, int* pnButton, int* pnRadioButton, BOOL* pfVerificationFlagChecked);
5877
5878 HRESULT hRet = E_UNEXPECTED;
5879 HMODULE m_hCommCtrlDLL = ::LoadLibrary(_T("comctl32.dll"));
5880 if(m_hCommCtrlDLL != NULL)
5881 {
5882 PFN_TaskDialogIndirect pfnTaskDialogIndirect = (PFN_TaskDialogIndirect)::GetProcAddress(m_hCommCtrlDLL, "TaskDialogIndirect");
5883 if(pfnTaskDialogIndirect != NULL)
5884 hRet = pfnTaskDialogIndirect(&m_tdc, pnButton, pnRadioButton, pfVerificationFlagChecked);
5885
5886 ::FreeLibrary(m_hCommCtrlDLL);
5887 }
5888
5889 return hRet;
5890 #endif
5891 }
5892
5893 // Operations - setting values of TASKDIALOGCONFIG
5894 // common buttons
5895 void SetCommonButtons(TASKDIALOG_COMMON_BUTTON_FLAGS dwCommonButtons)
5896 { m_tdc.SetCommonButtons(dwCommonButtons); }
5897 // window title text
5898 void SetWindowTitle(UINT nID)
5899 { m_tdc.SetWindowTitle(nID); }
5900 void SetWindowTitle(LPCWSTR lpstrWindowTitle)
5901 { m_tdc.SetWindowTitle(lpstrWindowTitle); }
5902 // main icon
5903 void SetMainIcon(HICON hIcon)
5904 { m_tdc.SetMainIcon(hIcon); }
5905 void SetMainIcon(UINT nID)
5906 { m_tdc.SetMainIcon(nID); }
5907 void SetMainIcon(LPCWSTR lpstrMainIcon)
5908 { m_tdc.SetMainIcon(lpstrMainIcon); }
5909 // main instruction text
5910 void SetMainInstructionText(UINT nID)
5911 { m_tdc.SetMainInstructionText(nID); }
5912 void SetMainInstructionText(LPCWSTR lpstrMainInstruction)
5913 { m_tdc.SetMainInstructionText(lpstrMainInstruction); }
5914 // content text
5915 void SetContentText(UINT nID)
5916 { m_tdc.SetContentText(nID); }
5917 void SetContentText(LPCWSTR lpstrContent)
5918 { m_tdc.SetContentText(lpstrContent); }
5919 // buttons
5920 void SetButtons(const TASKDIALOG_BUTTON* pButtons, UINT cButtons, int nDefaultButton = 0)
5921 { m_tdc.SetButtons(pButtons, cButtons, nDefaultButton); }
5922 void SetDefaultButton(int nDefaultButton)
5923 { m_tdc.SetDefaultButton(nDefaultButton); }
5924 // radio buttons
5925 void SetRadioButtons(const TASKDIALOG_BUTTON* pRadioButtons, UINT cRadioButtons, int nDefaultRadioButton = 0)
5926 { m_tdc.SetRadioButtons(pRadioButtons, cRadioButtons, nDefaultRadioButton); }
5927 void SetDefaultRadioButton(int nDefaultRadioButton)
5928 { m_tdc.SetDefaultRadioButton(nDefaultRadioButton); }
5929 // verification text
5930 void SetVerificationText(UINT nID)
5931 { m_tdc.SetVerificationText(nID); }
5932 void SetVerificationText(LPCWSTR lpstrVerificationText)
5933 { m_tdc.SetVerificationText(lpstrVerificationText); }
5934 // expanded information text
5935 void SetExpandedInformationText(UINT nID)
5936 { m_tdc.SetExpandedInformationText(nID); }
5937 void SetExpandedInformationText(LPCWSTR lpstrExpandedInformation)
5938 { m_tdc.SetExpandedInformationText(lpstrExpandedInformation); }
5939 // expanded control text
5940 void SetExpandedControlText(UINT nID)
5941 { m_tdc.SetExpandedControlText(nID); }
5942 void SetExpandedControlText(LPCWSTR lpstrExpandedControlText)
5943 { m_tdc.SetExpandedControlText(lpstrExpandedControlText); }
5944 // collapsed control text
5945 void SetCollapsedControlText(UINT nID)
5946 { m_tdc.SetCollapsedControlText(nID); }
5947 void SetCollapsedControlText(LPCWSTR lpstrCollapsedControlText)
5948 { m_tdc.SetCollapsedControlText(lpstrCollapsedControlText); }
5949 // footer icon
5950 void SetFooterIcon(HICON hIcon)
5951 { m_tdc.SetFooterIcon(hIcon); }
5952 void SetFooterIcon(UINT nID)
5953 { m_tdc.SetFooterIcon(nID); }
5954 void SetFooterIcon(LPCWSTR lpstrFooterIcon)
5955 { m_tdc.SetFooterIcon(lpstrFooterIcon); }
5956 // footer text
5957 void SetFooterText(UINT nID)
5958 { m_tdc.SetFooterText(nID); }
5959 void SetFooterText(LPCWSTR lpstrFooterText)
5960 { m_tdc.SetFooterText(lpstrFooterText); }
5961 // width (in DLUs)
5962 void SetWidth(UINT cxWidth)
5963 { m_tdc.SetWidth(cxWidth); }
5964 // modify flags
5965 void ModifyFlags(DWORD dwRemove, DWORD dwAdd)
5966 { m_tdc.ModifyFlags(dwRemove, dwAdd); }
5967
5968 // Implementation
5969 static HRESULT CALLBACK TaskDialogCallback(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LONG_PTR lpRefData)
5970 {
5971 T* pT = (T*)lpRefData;
5972 ATLASSERT(pT->m_hWnd == NULL || pT->m_hWnd == hWnd);
5973
5974 BOOL bRet = FALSE;
5975 switch(uMsg)
5976 {
5977 case TDN_DIALOG_CONSTRUCTED:
5978 pT->m_hWnd = hWnd;
5979 pT->OnDialogConstructed();
5980 break;
5981 case TDN_CREATED:
5982 pT->OnCreated();
5983 break;
5984 case TDN_BUTTON_CLICKED:
5985 bRet = pT->OnButtonClicked((int)wParam);
5986 break;
5987 case TDN_RADIO_BUTTON_CLICKED:
5988 pT->OnRadioButtonClicked((int)wParam);
5989 break;
5990 case TDN_HYPERLINK_CLICKED:
5991 pT->OnHyperlinkClicked((LPCWSTR)lParam);
5992 break;
5993 case TDN_EXPANDO_BUTTON_CLICKED:
5994 pT->OnExpandoButtonClicked((wParam != 0));
5995 break;
5996 case TDN_VERIFICATION_CLICKED:
5997 pT->OnVerificationClicked((wParam != 0));
5998 break;
5999 case TDN_HELP:
6000 pT->OnHelp();
6001 break;
6002 case TDN_TIMER:
6003 bRet = pT->OnTimer((DWORD)wParam);
6004 break;
6005 case TDN_NAVIGATED:
6006 pT->OnNavigated();
6007 break;
6008 case TDN_DESTROYED:
6009 pT->OnDestroyed();
6010 pT->m_hWnd = NULL;
6011 break;
6012 default:
6013 ATLTRACE2(atlTraceUI, 0, _T("Unknown notification received in CTaskDialogImpl::TaskDialogCallback\n"));
6014 break;
6015 }
6016
6017 return (HRESULT)bRet;
6018 }
6019
6020 // Overrideables - notification handlers
6021 void OnDialogConstructed()
6022 {
6023 }
6024
6025 void OnCreated()
6026 {
6027 }
6028
6029 BOOL OnButtonClicked(int /*nButton*/)
6030 {
6031 return FALSE; // don't prevent dialog to close
6032 }
6033
6034 void OnRadioButtonClicked(int /*nRadioButton*/)
6035 {
6036 }
6037
6038 void OnHyperlinkClicked(LPCWSTR /*pszHREF*/)
6039 {
6040 }
6041
6042 void OnExpandoButtonClicked(bool /*bExpanded*/)
6043 {
6044 }
6045
6046 void OnVerificationClicked(bool /*bChecked*/)
6047 {
6048 }
6049
6050 void OnHelp()
6051 {
6052 }
6053
6054 BOOL OnTimer(DWORD /*dwTickCount*/)
6055 {
6056 return FALSE; // don't reset counter
6057 }
6058
6059 void OnNavigated()
6060 {
6061 }
6062
6063 void OnDestroyed()
6064 {
6065 }
6066
6067 // Commands - valid to call only from handlers
6068 void NavigatePage(TASKDIALOGCONFIG& tdc)
6069 {
6070 ATLASSERT(m_hWnd != NULL);
6071
6072 tdc.cbSize = sizeof(TASKDIALOGCONFIG);
6073 if(tdc.hwndParent == NULL)
6074 tdc.hwndParent = m_tdc.hwndParent;
6075 tdc.pfCallback = m_tdc.pfCallback;
6076 tdc.lpCallbackData = m_tdc.lpCallbackData;
6077 (TASKDIALOGCONFIG)m_tdc = tdc;
6078
6079 ::SendMessage(m_hWnd, TDM_NAVIGATE_PAGE, 0, (LPARAM)&tdc);
6080 }
6081
6082 // modify TASKDIALOGCONFIG values, then call this to update task dialog
6083 void NavigatePage()
6084 {
6085 ATLASSERT(m_hWnd != NULL);
6086 ::SendMessage(m_hWnd, TDM_NAVIGATE_PAGE, 0, (LPARAM)&m_tdc);
6087 }
6088
6089 void ClickButton(int nButton)
6090 {
6091 ATLASSERT(m_hWnd != NULL);
6092 ::SendMessage(m_hWnd, TDM_CLICK_BUTTON, nButton, 0L);
6093 }
6094
6095 void SetMarqueeProgressBar(BOOL bMarquee)
6096 {
6097 ATLASSERT(m_hWnd != NULL);
6098 ::SendMessage(m_hWnd, TDM_SET_MARQUEE_PROGRESS_BAR, bMarquee, 0L);
6099 }
6100
6101 BOOL SetProgressBarState(int nNewState)
6102 {
6103 ATLASSERT(m_hWnd != NULL);
6104 return (BOOL)::SendMessage(m_hWnd, TDM_SET_PROGRESS_BAR_STATE, nNewState, 0L);
6105 }
6106
6107 DWORD SetProgressBarRange(int nMinRange, int nMaxRange)
6108 {
6109 ATLASSERT(m_hWnd != NULL);
6110 return (DWORD)::SendMessage(m_hWnd, TDM_SET_PROGRESS_BAR_RANGE, 0, MAKELPARAM(nMinRange, nMaxRange));
6111 }
6112
6113 int SetProgressBarPos(int nNewPos)
6114 {
6115 ATLASSERT(m_hWnd != NULL);
6116 return (int)::SendMessage(m_hWnd, TDM_SET_PROGRESS_BAR_POS, nNewPos, 0L);
6117 }
6118
6119 BOOL SetProgressBarMarquee(BOOL bMarquee, UINT uSpeed)
6120 {
6121 ATLASSERT(m_hWnd != NULL);
6122 return (BOOL)::SendMessage(m_hWnd, TDM_SET_PROGRESS_BAR_MARQUEE, bMarquee, uSpeed);
6123 }
6124
6125 void SetElementText(TASKDIALOG_ELEMENTS element, LPCWSTR lpstrText)
6126 {
6127 ATLASSERT(m_hWnd != NULL);
6128 ::SendMessage(m_hWnd, TDM_SET_ELEMENT_TEXT, element, (LPARAM)lpstrText);
6129 }
6130
6131 void ClickRadioButton(int nRadioButton)
6132 {
6133 ATLASSERT(m_hWnd != NULL);
6134 ::SendMessage(m_hWnd, TDM_CLICK_RADIO_BUTTON, nRadioButton, 0L);
6135 }
6136
6137 void EnableButton(int nButton, BOOL bEnable)
6138 {
6139 ATLASSERT(m_hWnd != NULL);
6140 ::SendMessage(m_hWnd, TDM_ENABLE_BUTTON, nButton, bEnable);
6141 }
6142
6143 void EnableRadioButton(int nButton, BOOL bEnable)
6144 {
6145 ATLASSERT(m_hWnd != NULL);
6146 ::SendMessage(m_hWnd, TDM_ENABLE_RADIO_BUTTON, nButton, bEnable);
6147 }
6148
6149 void ClickVerification(BOOL bCheck, BOOL bFocus)
6150 {
6151 ATLASSERT(m_hWnd != NULL);
6152 ::SendMessage(m_hWnd, TDM_CLICK_VERIFICATION, bCheck, bFocus);
6153 }
6154
6155 void UpdateElementText(TASKDIALOG_ELEMENTS element, LPCWSTR lpstrText)
6156 {
6157 ATLASSERT(m_hWnd != NULL);
6158 ::SendMessage(m_hWnd, TDM_UPDATE_ELEMENT_TEXT, element, (LPARAM)lpstrText);
6159 }
6160
6161 void SetButtonElevationRequiredState(int nButton, BOOL bElevation)
6162 {
6163 ATLASSERT(m_hWnd != NULL);
6164 ::SendMessage(m_hWnd, TDM_SET_BUTTON_ELEVATION_REQUIRED_STATE, nButton, bElevation);
6165 }
6166
6167 void UpdateIcon(TASKDIALOG_ICON_ELEMENTS element, HICON hIcon)
6168 {
6169 ATLASSERT(m_hWnd != NULL);
6170 #ifdef _DEBUG
6171 if(element == TDIE_ICON_MAIN)
6172 ATLASSERT((m_tdc.dwFlags & TDF_USE_HICON_MAIN) != 0);
6173 else if(element == TDIE_ICON_FOOTER)
6174 ATLASSERT((m_tdc.dwFlags & TDF_USE_HICON_FOOTER) != 0);
6175 #endif // _DEBUG
6176 ::SendMessage(m_hWnd, TDM_UPDATE_ICON, element, (LPARAM)hIcon);
6177 }
6178
6179 void UpdateIcon(TASKDIALOG_ICON_ELEMENTS element, LPCWSTR lpstrIcon)
6180 {
6181 ATLASSERT(m_hWnd != NULL);
6182 #ifdef _DEBUG
6183 if(element == TDIE_ICON_MAIN)
6184 ATLASSERT((m_tdc.dwFlags & TDF_USE_HICON_MAIN) == 0);
6185 else if(element == TDIE_ICON_FOOTER)
6186 ATLASSERT((m_tdc.dwFlags & TDF_USE_HICON_FOOTER) == 0);
6187 #endif // _DEBUG
6188 ::SendMessage(m_hWnd, TDM_UPDATE_ICON, element, (LPARAM)lpstrIcon);
6189 }
6190 };
6191
6192
6193 ///////////////////////////////////////////////////////////////////////////////
6194 // CTaskDialog - for non-customized task dialogs
6195
6196 class CTaskDialog : public CTaskDialogImpl<CTaskDialog>
6197 {
6198 public:
6199 CTaskDialog(HWND hWndParent = NULL) : CTaskDialogImpl<CTaskDialog>(hWndParent)
6200 {
6201 m_tdc.pfCallback = NULL;
6202 }
6203 };
6204
6205 #endif // ((_WIN32_WINNT >= 0x0600) || defined(_WTL_TASKDIALOG)) && !defined(_WIN32_WCE)
6206
6207 }; // namespace WTL
6208
6209 #endif // __ATLDLGS_H__