开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
XTPTaskDialog.cpp
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：22k
源码类别：

对话框与窗口

开发平台：

Visual C++

XTPTaskDialog.cpp：源码内容
  1. // XTPTaskDialog.cpp: implementation of the CXTPTaskDialog class.
  2. //
  3. // This file is a part of the XTREME CONTROLS MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include "Resource.h"
  24. #include "Common/XTPSystemHelpers.h"
  25. #include "Common/XTPVc80Helpers.h"
  26. #include "Common/XTPVc50Helpers.h"
  27. #include "Common/XTPPropExchange.h"
  28. #include "Common/XTPResourceManager.h"
  30. #include "XTPTaskDialogAPI.h"
  31. #include "XTPTaskDialog.h"
  33. #ifdef _DEBUG
  34. #define new DEBUG_NEW
  35. #undef THIS_FILE
  36. static char THIS_FILE[] = __FILE__;
  37. #endif
  39. //===========================================================================
  40. // CXTPTaskDialog
  41. //===========================================================================
  43. CXTPTaskDialog::CXTPTaskDialog(CWnd* pWndParent)
  44. : CXTPTaskDialogFrame(&m_config)
  45. {
  46. m_pParentWnd = pWndParent;
  48. m_hwndTaskDialog = NULL;
  49. ::ZeroMemory(&m_config, sizeof(TASKDIALOGCONFIG));
  50. m_config.cbSize = sizeof(TASKDIALOGCONFIG);
  51. m_config.hInstance = AfxGetInstanceHandle();
  52. m_config.hwndParent = pWndParent->GetSafeHwnd();
  54. m_config.pfCallback = (PFTASKDIALOGCALLBACK)&TaskDialogCallbackProc;
  55. m_config.lpCallbackData = (LONG_PTR)this;
  57. m_nSelButtonID      = 0;
  60. SetWindowTitle(AfxGetApp()->m_pszAppName);
  62. ModifyTaskStyle(0, TDF_POSITION_RELATIVE_TO_WINDOW);
  63. }
  65. CXTPTaskDialog::~CXTPTaskDialog()
  66. {
  67. ResetContent();
  68. }
  70. #ifndef UNALIGNED
  71. #define UNALIGNED
  72. #endif
  74. static void XTPTaskDialogSetConfigText(UNALIGNED PCWSTR& lpszConfig, LPCTSTR strText)
  75. {
  76. if (lpszConfig)
  77. {
  78. if (!IS_INTRESOURCE(lpszConfig))
  79. delete [] (LPWSTR)lpszConfig;
  80. lpszConfig = NULL;
  81. }
  83. if (!strText)
  84. return;
  86. if (IS_INTRESOURCE(strText))
  87. {
  88. lpszConfig = (LPWSTR)strText;
  89. return;
  90. }
  92. int nLength = (int)_tcslen(strText);
  93. if (nLength == 0)
  94. return;
  96. lpszConfig = (PCWSTR) new WCHAR[nLength + 1];
  98. #ifdef _UNICODE
  99. STRCPY_S((LPWSTR)lpszConfig, nLength + 1, strText);
  100. #else
  101. MultiByteToWideChar(CP_ACP, 0, strText, -1, (LPWSTR)lpszConfig, nLength + 1);
  102. #endif
  103. }
  105. /////////////////////////////////////////////////////////////////////////////
  106. // CXTPTaskDialog message handlers
  108. HRESULT CALLBACK CXTPTaskDialog::TaskDialogCallbackProc(HWND hwnd, UINT uNotification, WPARAM wParam, LPARAM lParam, DWORD_PTR dwRefData)
  109. {   ASSERT(0 != dwRefData);
  111. CXTPTaskDialog* pThis = (CXTPTaskDialog*)dwRefData;
  112. if (!pThis)
  113. return E_FAIL;
  115. if (uNotification == TDN_DIALOG_CONSTRUCTED)
  116. {
  117. ASSERT(0 != hwnd);
  118. pThis->OnAttach(hwnd);
  119. }
  121. if (uNotification == TDN_DESTROYED)
  122. {
  123. pThis->OnDialogDestroyed();
  124. pThis->OnDetach();
  125. return S_OK;
  126. }
  128. return pThis->OnDialogNotify(uNotification, wParam, lParam);
  129. }
  131. HRESULT CXTPTaskDialog::OnDialogNotify(UINT uNotification, WPARAM wParam, LPARAM lParam)
  132. {
  133. UNREFERENCED_PARAMETER(lParam);
  134. HRESULT hResult = S_OK;
  136. switch (uNotification)
  137. {
  138. case TDN_DIALOG_CONSTRUCTED:
  139. {
  140. OnDialogConstructed();
  141. break;
  142. }
  143. case TDN_NAVIGATED:
  144. {
  145. OnNavigated();
  146. break;
  147. }
  148. case TDN_BUTTON_CLICKED:
  149. {
  150. BOOL bCloseDialog = TRUE;
  151. OnButtonClicked((int)wParam, bCloseDialog);
  152. hResult = (HRESULT)(int)(!bCloseDialog);
  153. break;
  154. }
  155. case TDN_HYPERLINK_CLICKED:
  156. {
  157. OnHyperlinkClicked(XTP_CW2CT((PCWSTR)lParam));
  158. break;
  159. }
  160. case TDN_TIMER:
  161. {
  162. ASSERT(UINT_MAX >= wParam);
  163. BOOL bReset = FALSE;
  164. OnTimer((DWORD)wParam, bReset);
  165. hResult = (HRESULT)(int)bReset;
  166. break;
  167. }
  168. case TDN_RADIO_BUTTON_CLICKED:
  169. {
  170. OnRadioButtonClicked((int)wParam);
  171. break;
  172. }
  173. case TDN_CREATED:
  174. {
  175. break;
  176. }
  177. case TDN_VERIFICATION_CLICKED:
  178. {
  179. OnVerificationClicked(wParam != 0);
  180. break;
  181. }
  182. case TDN_HELP:
  183. {
  184. OnHelp();
  185. break;
  186. }
  187. case TDN_EXPANDO_BUTTON_CLICKED:
  188. {
  189. OnExpandoButtonClicked(wParam != 0);
  190. break;
  191. }
  192. default:
  193. {
  194. TRACE0("CXTPTaskDialog::TaskDialogCallbackProc -- Unhandled notification encountered.n");
  195. return E_NOTIMPL;
  196. }
  197. }
  198. return hResult;
  199. }
  201. BOOL CXTPTaskDialog::OnAttach(HWND hWndNew)
  202. {
  203. ASSERT(m_hwndTaskDialog == NULL || m_hwndTaskDialog == hWndNew);
  205. if (hWndNew == NULL)
  206. return FALSE;
  208. m_hwndTaskDialog = hWndNew;
  209. return TRUE;
  210. }
  212. HWND CXTPTaskDialog::OnDetach()
  213. {
  214. HWND hWnd = m_hwndTaskDialog;
  215. if (hWnd != NULL)
  216. {
  217. m_hwndTaskDialog = NULL;
  218. }
  219. return hWnd;
  220. }
  222. void CXTPTaskDialog::ResetContent()
  223. {
  224. XTPTaskDialogSetConfigText(m_config.pszWindowTitle, NULL);
  225. XTPTaskDialogSetConfigText(m_config.pszMainInstruction, NULL);
  226. XTPTaskDialogSetConfigText(m_config.pszContent, NULL);
  227. XTPTaskDialogSetConfigText(m_config.pszVerificationText, NULL);
  228. XTPTaskDialogSetConfigText(m_config.pszExpandedInformation, NULL);
  229. XTPTaskDialogSetConfigText(m_config.pszExpandedControlText, NULL);
  230. XTPTaskDialogSetConfigText(m_config.pszCollapsedControlText, NULL);
  231. XTPTaskDialogSetConfigText(m_config.pszFooter, NULL);
  233. m_config.dwFlags = TDF_POSITION_RELATIVE_TO_WINDOW;
  235. m_config.hMainIcon = 0;
  236. m_config.hFooterIcon = 0;
  237. m_config.cxWidth = 0;
  238. m_config.cButtons = 0;
  239. m_config.cRadioButtons = 0;
  240. m_config.dwCommonButtons = 0;
  243. int i;
  244. for (i = 0; i < m_arrButtons.GetSize(); i++)
  245. {
  246. XTPTaskDialogSetConfigText(m_arrButtons[i].pszButtonText, NULL);
  247. }
  248. m_arrButtons.RemoveAll();
  250. for (i = 0; i < m_arrRadioButtons.GetSize(); i++)
  251. {
  252. XTPTaskDialogSetConfigText(m_arrRadioButtons[i].pszButtonText, NULL);
  253. }
  254. m_arrRadioButtons.RemoveAll();
  256. m_nSelButtonID      = 0;
  257. }
  260. void CXTPTaskDialog::SetWindowTitle(LPCTSTR pszText)
  261. {
  262. CString strText = pszText;
  264. if (pszText && IS_INTRESOURCE(pszText))
  265. {
  266. XTPLoadStringInst(m_config.hInstance, (UINT)(UINT_PTR)pszText, &strText);
  267. }
  269. XTPTaskDialogSetConfigText(m_config.pszWindowTitle, strText);
  271. if (::IsWindow(m_hwndTaskDialog))
  272. {
  273. ::SetWindowText(m_hwndTaskDialog, strText);
  274. }
  275. }
  277. BOOL CXTPTaskDialog::SetMainInstruction(LPCTSTR pszText)
  278. {
  279. XTPTaskDialogSetConfigText(m_config.pszMainInstruction, pszText);
  281. if (::IsWindow(m_hwndTaskDialog))
  282. {
  283. return (::SendMessage(m_hwndTaskDialog, TDM_SET_ELEMENT_TEXT,
  284. TDE_MAIN_INSTRUCTION, (LPARAM)(LPCWSTR)m_config.pszMainInstruction) != 0);
  285. }
  287. return TRUE;
  288. }
  290. BOOL CXTPTaskDialog::SetContent(LPCTSTR pszText)
  291. {
  292. XTPTaskDialogSetConfigText(m_config.pszContent, pszText);
  294. if (::IsWindow(m_hwndTaskDialog))
  295. {
  296. return (::SendMessage(m_hwndTaskDialog, TDM_SET_ELEMENT_TEXT,
  297. TDE_CONTENT, (LPARAM)(LPCWSTR)m_config.pszContent) != 0);
  298. }
  300. return TRUE;
  301. }
  303. BOOL CXTPTaskDialog::SetExpandedInformation(LPCTSTR pszText)
  304. {
  305. XTPTaskDialogSetConfigText(m_config.pszExpandedInformation, pszText);
  307. if (::IsWindow(m_hwndTaskDialog))
  308. {
  309. return (::SendMessage(m_hwndTaskDialog, TDM_SET_ELEMENT_TEXT,
  310. TDE_EXPANDED_INFORMATION, (LPARAM)(LPCWSTR)m_config.pszExpandedInformation) != 0);
  311. }
  313. return TRUE;
  314. }
  316. BOOL CXTPTaskDialog::SetFooter(LPCTSTR pszText)
  317. {
  318. XTPTaskDialogSetConfigText(m_config.pszFooter, pszText);
  320. if (::IsWindow(m_hwndTaskDialog))
  321. {
  322. return (::SendMessage(m_hwndTaskDialog, TDM_SET_ELEMENT_TEXT,
  323. TDE_FOOTER, (LPARAM)(LPCWSTR)m_config.pszFooter) != 0);
  324. }
  326. return TRUE;
  327. }
  329. BOOL CXTPTaskDialog::SetMainIcon(HICON hIcon)
  330. {
  331. ModifyTaskStyle(TDF_USE_HICON_MAIN, hIcon == 0 ? 0: TDF_USE_HICON_MAIN);
  333. m_config.hMainIcon = hIcon;
  335. if (::IsWindow(m_hwndTaskDialog))
  336. {
  337. return (::SendMessage(m_hwndTaskDialog, TDM_UPDATE_ICON,
  338. TDIE_ICON_MAIN, (LPARAM)hIcon) != 0);
  339. }
  341. return TRUE;
  342. }
  344. BOOL CXTPTaskDialog::SetMainIcon(LPCWSTR pszResource)
  345. {
  346. ASSERT(IS_INTRESOURCE(pszResource));
  348. ModifyTaskStyle(TDF_USE_HICON_MAIN, 0);
  350. m_config.pszMainIcon = pszResource;
  352. if (::IsWindow(m_hwndTaskDialog))
  353. {
  354. return (::SendMessage(m_hwndTaskDialog, TDM_UPDATE_ICON,
  355. TDIE_ICON_MAIN, (LPARAM)pszResource) != 0);
  356. }
  358. return TRUE;
  359. }
  361. BOOL CXTPTaskDialog::SetFooterIcon(HICON hIcon)
  362. {
  363. ModifyTaskStyle(TDF_USE_HICON_FOOTER, (hIcon == 0) ? 0 : TDF_USE_HICON_FOOTER);
  365. m_config.hFooterIcon = hIcon;
  367. if (::IsWindow(m_hwndTaskDialog))
  368. {
  369. return (::SendMessage(m_hwndTaskDialog, TDM_UPDATE_ICON,
  370. TDIE_ICON_FOOTER, (LPARAM)hIcon) != NULL);
  371. }
  373. return TRUE;
  374. }
  376. BOOL CXTPTaskDialog::SetFooterIcon(LPCWSTR pszResource)
  377. {
  378. ASSERT(IS_INTRESOURCE(pszResource));
  380. ModifyTaskStyle(TDF_USE_HICON_FOOTER, 0);
  382. m_config.pszFooterIcon = pszResource;
  384. if (::IsWindow(m_hwndTaskDialog))
  385. {
  386. return (::SendMessage(m_hwndTaskDialog, TDM_UPDATE_ICON,
  387. TDIE_ICON_FOOTER, (LPARAM)pszResource) != 0);
  388. }
  390. return TRUE;
  391. }
  393. void CXTPTaskDialog::SetWidth(int cxWidth, BOOL bPixelToDLU /*=FALSE*/)
  394. {
  395. if (bPixelToDLU)
  396. {
  397. CSize sizeBase = ::GetDialogBaseUnits();
  398. cxWidth = ::MulDiv(cxWidth, 4, sizeBase.cx);
  399. }
  400. m_config.cxWidth = cxWidth;
  401. }
  403. void CXTPTaskDialog::AddButton(LPCTSTR pszText, int nButtonID)
  404. {
  405. for (int i = 0; i < (int)m_arrButtons.GetSize(); i++)
  406. {
  407. if (m_arrButtons[i].nButtonID == nButtonID)
  408. {
  409. XTPTaskDialogSetConfigText(m_arrButtons[i].pszButtonText, pszText);
  410. return;
  411. }
  412. }
  414. TASKDIALOG_BUTTON button;
  415. ZeroMemory(&button, sizeof(TASKDIALOG_BUTTON));
  417. XTPTaskDialogSetConfigText(button.pszButtonText, pszText);
  418. button.nButtonID = nButtonID;
  419. m_arrButtons.Add(button);
  421. m_config.pButtons      = m_arrButtons.GetData();
  422. m_config.cButtons      = (UINT)m_arrButtons.GetSize();
  423. }
  425. void CXTPTaskDialog::AddRadioButton(LPCTSTR pszText, int nButtonID)
  426. {
  427. for (int i = 0; i < (int)m_arrRadioButtons.GetSize(); i++)
  428. {
  429. if (m_arrRadioButtons[i].nButtonID == nButtonID)
  430. {
  431. XTPTaskDialogSetConfigText(m_arrRadioButtons[i].pszButtonText, pszText);
  432. return;
  433. }
  434. }
  436. TASKDIALOG_BUTTON radioButton;
  437. ZeroMemory(&radioButton, sizeof(TASKDIALOG_BUTTON));
  439. XTPTaskDialogSetConfigText(radioButton.pszButtonText, pszText);
  440. radioButton.nButtonID = nButtonID;
  441. m_arrRadioButtons.Add(radioButton);
  443. m_config.pRadioButtons = m_arrRadioButtons.GetData();
  444. m_config.cRadioButtons = (UINT)m_arrRadioButtons.GetSize();
  445. }
  447. void CXTPTaskDialog::SetVerificationText(LPCTSTR pszText)
  448. {
  449. XTPTaskDialogSetConfigText(m_config.pszVerificationText, pszText);
  450. }
  452. void CXTPTaskDialog::SetExpandedControlText(LPCTSTR pszText)
  453. {
  454. XTPTaskDialogSetConfigText(m_config.pszExpandedControlText, pszText);
  455. }
  457. void CXTPTaskDialog::SetCollapsedControlText(LPCTSTR pszText)
  458. {
  459. XTPTaskDialogSetConfigText(m_config.pszCollapsedControlText, pszText);
  460. }
  462. BOOL CXTPTaskDialog::Create(CWnd* pParentWnd /*= NULL*/)
  463. {
  464. return CXTPTaskDialogFrame::Create(pParentWnd);
  465. }
  467. INT_PTR CXTPTaskDialog::DoModal(BOOL bUseComCtl32 /*=TRUE*/)
  468. {
  469. ASSERT(m_hwndTaskDialog == NULL);
  471. m_config.pButtons      = m_arrButtons.GetData();
  472. m_config.cButtons      = (UINT)m_arrButtons.GetSize();
  473. m_config.pRadioButtons = m_arrRadioButtons.GetData();
  474. m_config.cRadioButtons = (UINT)m_arrRadioButtons.GetSize();
  476. if (m_bEnableMarkup) bUseComCtl32 = FALSE;
  478. // You can only use comctl32.dll task dialog when system is vista or newer...
  480. if (bUseComCtl32 && (XTPSystemVersion()->dwMajorVersion >= 5))
  481. {
  482. HRESULT (WINAPI* pfnTaskDialogIndirect)(const TASKDIALOGCONFIG*, int*, int*, BOOL*);
  483. CXTPModuleHandle modComCtl32(_T("ComCtl32.dll"));
  484. if (modComCtl32.GetProcAddress((FARPROC*)&pfnTaskDialogIndirect, "TaskDialogIndirect", MAKELONG(0,6)))
  485. {
  486. if (FAILED(pfnTaskDialogIndirect(&m_config,
  487. &m_nSelButtonID, &m_nSelRadioButtonID, &m_bVerification)))
  488. {
  489. return 0;
  490. }
  491. return m_nSelButtonID;
  492. }
  493. }
  495. m_nSelButtonID = (int)CXTPTaskDialogFrame::DoModal();
  497. return m_nSelButtonID;
  498. }
  500. BOOL CXTPTaskDialog::ModifyTaskStyle(TASKDIALOG_FLAGS dwRemove, TASKDIALOG_FLAGS dwAdd)
  501. {
  502. TASKDIALOG_FLAGS dwStyle = m_config.dwFlags;
  503. TASKDIALOG_FLAGS dwNewStyle = (dwStyle & ~dwRemove) | dwAdd;
  505. if (dwStyle != dwNewStyle)
  506. {
  507. m_config.dwFlags = dwNewStyle;
  508. return TRUE;
  509. }
  511. return FALSE;
  512. }
  514. void CXTPTaskDialog::EnableHyperlinks(BOOL bEnable)
  515. {
  516. ModifyTaskStyle(TDF_ENABLE_HYPERLINKS, bEnable? TDF_ENABLE_HYPERLINKS: 0);
  517. }
  519. void CXTPTaskDialog::EnableMarkup(BOOL bEnable)
  520. {
  521. m_bEnableMarkup = bEnable;
  522. }
  524. void CXTPTaskDialog::EnableCancellation(BOOL bEnable)
  525. {
  526. ModifyTaskStyle(TDF_ALLOW_DIALOG_CANCELLATION, bEnable? TDF_ALLOW_DIALOG_CANCELLATION: 0);
  527. }
  529. void CXTPTaskDialog::EnableRelativePosition(BOOL bEnable)
  530. {
  531. ModifyTaskStyle(TDF_POSITION_RELATIVE_TO_WINDOW, bEnable? TDF_POSITION_RELATIVE_TO_WINDOW: 0);
  532. }
  534. void CXTPTaskDialog::ShowProgressBar(BOOL bShow, BOOL bMarquee /*=FALSE*/)
  535. {
  536. if (bMarquee)
  537. {
  538. ModifyTaskStyle(TDF_SHOW_PROGRESS_BAR | TDF_SHOW_MARQUEE_PROGRESS_BAR,
  539. bShow? TDF_SHOW_MARQUEE_PROGRESS_BAR: 0);
  540. }
  541. else
  542. {
  543. ModifyTaskStyle(TDF_SHOW_MARQUEE_PROGRESS_BAR | TDF_SHOW_PROGRESS_BAR,
  544. bShow? TDF_SHOW_PROGRESS_BAR: 0);
  545. }
  546. }
  548. void CXTPTaskDialog::EnableRtlLayout(BOOL bEnable)
  549. {
  550. ModifyTaskStyle(TDF_RTL_LAYOUT, bEnable? TDF_RTL_LAYOUT: 0);
  551. }
  553. void CXTPTaskDialog::ExpandedByDefault(BOOL bExpanded)
  554. {
  555. ModifyTaskStyle(TDF_EXPANDED_BY_DEFAULT, bExpanded? TDF_EXPANDED_BY_DEFAULT: 0);
  556. }
  558. void CXTPTaskDialog::ExpandFooterArea(BOOL bExpandFooter)
  559. {
  560. ModifyTaskStyle(TDF_EXPAND_FOOTER_AREA, bExpandFooter? TDF_EXPAND_FOOTER_AREA: 0);
  561. }
  563. void CXTPTaskDialog::SetCommonButtons(BOOL bOk, BOOL bYes, BOOL bNo, BOOL bCancel, BOOL bRetry, BOOL bClose)
  564. {
  565. m_config.dwCommonButtons = 0;
  567. if (bOk)     m_config.dwCommonButtons |= TDCBF_OK_BUTTON;
  568. if (bYes)    m_config.dwCommonButtons |= TDCBF_YES_BUTTON;
  569. if (bNo)     m_config.dwCommonButtons |= TDCBF_NO_BUTTON;
  570. if (bCancel) m_config.dwCommonButtons |= TDCBF_CANCEL_BUTTON;
  571. if (bRetry)  m_config.dwCommonButtons |= TDCBF_RETRY_BUTTON;
  572. if (bClose)  m_config.dwCommonButtons |= TDCBF_CLOSE_BUTTON;
  573. }
  575. void CXTPTaskDialog::SetCommonButtons(TASKDIALOG_COMMON_BUTTON_FLAGS dwButtons)
  576. {
  577. m_config.dwCommonButtons = dwButtons;
  578. }
  580. void CXTPTaskDialog::EnableCommandLinks(BOOL bEnable, BOOL bShowIcon)
  581. {
  582. if (bShowIcon)
  583. {
  584. ModifyTaskStyle(TDF_USE_COMMAND_LINKS | TDF_USE_COMMAND_LINKS_NO_ICON,
  585. bEnable? TDF_USE_COMMAND_LINKS: 0);
  586. }
  587. else
  588. {
  589. ModifyTaskStyle(TDF_USE_COMMAND_LINKS_NO_ICON | TDF_USE_COMMAND_LINKS,
  590. bEnable? TDF_USE_COMMAND_LINKS_NO_ICON: 0);
  591. }
  592. }
  594. void CXTPTaskDialog::SetDefaultButton(int nButtonID)
  595. {
  596. m_config.nDefaultButton = nButtonID;
  597. }
  599. void CXTPTaskDialog::SetDefaultRadioButton(int nButtonID)
  600. {
  601. m_config.nDefaultRadioButton = nButtonID;
  602. NoDefaultRadioButton(nButtonID == 0);
  603. }
  605. void CXTPTaskDialog::NoDefaultRadioButton(BOOL bNoDefault)
  606. {
  607. ModifyTaskStyle(TDF_NO_DEFAULT_RADIO_BUTTON, bNoDefault? TDF_NO_DEFAULT_RADIO_BUTTON: 0);
  609. if (bNoDefault)
  610. m_config.nDefaultRadioButton = 0;
  611. }
  613. void CXTPTaskDialog::SetVerifyCheckState(BOOL bChecked)
  614. {
  615. ModifyTaskStyle(TDF_VERIFICATION_FLAG_CHECKED, bChecked? TDF_VERIFICATION_FLAG_CHECKED: 0);
  616. }
  618. void CXTPTaskDialog::EnableCallbackTimer(BOOL bEnable)
  619. {
  620. ModifyTaskStyle(TDF_CALLBACK_TIMER, bEnable? TDF_CALLBACK_TIMER: 0);
  621. }
  623. void CXTPTaskDialog::EnableMinimize(BOOL bEnable)
  624. {
  625. ModifyTaskStyle(TDF_CAN_BE_MINIMIZED, bEnable? TDF_CAN_BE_MINIMIZED: 0);
  626. }
  628. AFX_INLINE CString GetPropExchangeString(CXTPPropExchange* pPX, LPCTSTR lpsz, LPCTSTR const* rglpsz, int nString)
  629. {
  630. CString str;
  632. if (lpsz)
  633. {
  634. CXTPPropExchangeSection px(pPX->GetSection(lpsz));
  635. PX_String(&px, NULL, str);
  636. }
  637. else
  638. {
  639. PX_String(pPX, NULL, str);
  640. }
  641. if (nString > 0 && FIND_S(str, _T('%'), 0) != -1)
  642. {
  643. CString strFormat = str;
  644. AfxFormatStrings(str, strFormat, rglpsz, nString);
  645. }
  646. return str;
  647. }
  649. AFX_INLINE int GetPropExchangeInt(CXTPPropExchange* pPX, LPCTSTR lpsz)
  650. {
  651. CString str;
  652. PX_String(pPX, lpsz, str);
  653. return _ttoi(str);
  654. }
  656. AFX_INLINE BOOL GetPropExchangeFlag(CXTPPropExchange* pPX, LPCTSTR lpsz)
  657. {
  658. CString str;
  659. PX_String(pPX, lpsz, str);
  660. return str.CompareNoCase(_T("True")) == 0 || str.CompareNoCase(_T("1")) == 0;
  661. }
  663. AFX_INLINE LPCWSTR GetPropExchangeIcon(CXTPPropExchange* pPX, LPCTSTR lpsz)
  664. {
  665. CString str;
  666. CXTPPropExchangeSection px(pPX->GetSection(lpsz));
  667. PX_String(&px, _T("Image"), str);
  669. if (str.IsEmpty())
  670. return NULL;
  672. if (str.CompareNoCase(_T("*Information")) == 0)
  673. return TD_INFORMATION_ICON;
  674. if (str.CompareNoCase(_T("*Error")) == 0)
  675. return TD_ERROR_ICON;
  676. if (str.CompareNoCase(_T("*Shield")) == 0)
  677. return TD_SHIELD_ICON;
  678. if (str.CompareNoCase(_T("*Warning")) == 0)
  679. return TD_WARNING_ICON;
  681. return NULL;
  682. }
  684. BOOL CXTPTaskDialog::CreateFromResource(UINT nIDResource, LPCTSTR lpszDialog)
  685. {
  686. return CreateFromResourceParam(AfxGetInstanceHandle(), nIDResource, lpszDialog, NULL, 0);
  687. }
  689. BOOL CXTPTaskDialog::CreateFromResource(HINSTANCE hInstance, UINT nIDResource, LPCTSTR lpszDialog)
  690. {
  691. return CreateFromResourceParam(hInstance, nIDResource, lpszDialog, NULL, 0);
  692. }
  694. BOOL CXTPTaskDialog::CreateFromResourceParam(HINSTANCE hInstance, UINT nIDResource, LPCTSTR lpszDialog, LPCTSTR const* rglpsz, int nString)
  695. {
  696. CXTPPropExchangeXMLNode px(TRUE, NULL, _T("Dialogs"));
  698. if (!px.LoadFromResource(hInstance, MAKEINTRESOURCE(nIDResource), RT_HTML))
  699. return FALSE;
  701. if (!px.OnBeforeExchange())
  702. return FALSE;
  704. px.SetCompactMode(TRUE);
  706. CString strDialogSection;
  707. strDialogSection.Format(_T("Dialog[@Name='%s']"), lpszDialog);
  708. if (!px.IsSectionExists(strDialogSection))
  709. return FALSE;
  711. CXTPPropExchangeSection pxDialog(px.GetSection(strDialogSection));
  712. if (!pxDialog->OnBeforeExchange())
  713. return FALSE;
  715. return CreateFromResourceParam((CXTPPropExchangeXMLNode*)&pxDialog, rglpsz, nString);
  716. }
  718. BOOL CXTPTaskDialog::CreateFromResourceParam(CXTPPropExchangeXMLNode* pPX, LPCTSTR const* rglpsz, int nString)
  719. {
  720. if (!pPX)
  721. return FALSE;
  723. EnableHyperlinks(GetPropExchangeFlag(pPX, _T("EnableHyperlinks")));
  724. EnableCancellation(GetPropExchangeFlag(pPX, _T("AllowCancel")));
  725. ShowProgressBar(GetPropExchangeFlag(pPX, _T("ProgressBar")), FALSE);
  726. SetWidth(GetPropExchangeInt(pPX, _T("Width")), TRUE);
  727. EnableRelativePosition(GetPropExchangeFlag(pPX, _T("RelativeToWindow")));
  728. EnableRtlLayout(GetPropExchangeFlag(pPX, _T("RTLLayout")));
  729. NoDefaultRadioButton(GetPropExchangeFlag(pPX, _T("NoDefaultRadioButton")));
  730. EnableMessageBoxStyle(GetPropExchangeFlag(pPX, _T("MessageBoxStyle")));
  732. SetWindowTitle(GetPropExchangeString(pPX, _T("WindowTitle"), rglpsz, nString));
  733. SetMainInstruction(GetPropExchangeString(pPX, _T("MainInstruction"), rglpsz, nString));
  734. SetContent(GetPropExchangeString(pPX, _T("Content"), rglpsz, nString));
  735. SetFooter(GetPropExchangeString(pPX, _T("Footer"), rglpsz, nString));
  737. SetMainIcon(GetPropExchangeIcon(pPX, _T("MainInstruction")));
  738. SetFooterIcon(GetPropExchangeIcon(pPX, _T("Footer")));
  740. CXTPPropExchangeSection pxButtons(pPX->GetSection(_T("Buttons")));
  741. CXTPPropExchangeEnumeratorPtr enumButton(pxButtons->GetEnumerator(NULL));
  743. POSITION pos = enumButton->GetPosition(0);
  744. while (pos)
  745. {
  746. CXTPPropExchangeSection secButton(enumButton->GetNext(pos));
  748. CString strSection = ((CXTPPropExchangeXMLNode*)&secButton)->GetSectionName();
  750. int nID = GetPropExchangeInt(&secButton, _T("ID"));
  752. if (strSection.CompareNoCase(_T("Button")) == 0 && (nID != 0))
  753. {
  754. AddButton(GetPropExchangeString(&secButton, NULL, NULL, 0), nID);
  755. }
  756. else if (strSection.CompareNoCase(_T("CommandLink")) == 0 && (nID != 0))
  757. {
  758. CString strText = GetPropExchangeString(&secButton, _T("Text"), rglpsz, nString);
  759. CString strExplanation = GetPropExchangeString(&secButton, _T("Explanation"), rglpsz, nString);
  761. if (!strExplanation.IsEmpty()) strText += _T("n") + strExplanation;
  763. AddButton(strText, nID);
  765. EnableCommandLinks(TRUE, !GetPropExchangeFlag(pPX, _T("NoCommandLinkGlyph")));
  766. }
  767. else if (strSection.CompareNoCase(_T("Ok")) == 0)
  768. {
  769. m_config.dwCommonButtons |= TDCBF_OK_BUTTON;
  770. }
  771. else if (strSection.CompareNoCase(_T("Yes")) == 0)
  772. {
  773. m_config.dwCommonButtons |= TDCBF_YES_BUTTON;
  774. }
  775. else if (strSection.CompareNoCase(_T("No")) == 0)
  776. {
  777. m_config.dwCommonButtons |= TDCBF_NO_BUTTON;
  778. }
  779. else if (strSection.CompareNoCase(_T("Cancel")) == 0)
  780. {
  781. m_config.dwCommonButtons |= TDCBF_CANCEL_BUTTON;
  782. }
  783. else if (strSection.CompareNoCase(_T("Retry")) == 0)
  784. {
  785. m_config.dwCommonButtons |= TDCBF_RETRY_BUTTON;
  786. }
  787. else if (strSection.CompareNoCase(_T("Close")) == 0)
  788. {
  789. m_config.dwCommonButtons |= TDCBF_CLOSE_BUTTON;
  790. }
  791. }
  792. SetDefaultButton(GetPropExchangeInt(&pxButtons, _T("Default")));
  795. CXTPPropExchangeSection pxRadioButtons(pPX->GetSection(_T("RadioButtons")));
  796. CXTPPropExchangeEnumeratorPtr enumRadioButton(pxRadioButtons->GetEnumerator(_T("RadioButton")));
  798. pos = enumRadioButton->GetPosition(0);
  799. while (pos)
  800. {
  801. CXTPPropExchangeSection secButton(enumRadioButton->GetNext(pos));
  803. int nID = GetPropExchangeInt(&secButton, _T("ID"));
  805. if (nID != 0)
  806. {
  807. AddRadioButton(GetPropExchangeString(&secButton, NULL, NULL, 0), nID);
  808. }
  809. }
  810. SetDefaultRadioButton(GetPropExchangeInt(&pxRadioButtons, _T("Default")));
  812. if (pPX->IsSectionExists(_T("ExpandedInformation")))
  813. {
  814. CXTPPropExchangeSection pxExpandedInformation(pPX->GetSection(_T("ExpandedInformation")));
  816. SetExpandedInformation(GetPropExchangeString(&pxExpandedInformation, NULL, rglpsz, nString));
  817. ExpandFooterArea(GetPropExchangeFlag(&pxExpandedInformation, _T("Footer")));
  818. ExpandedByDefault(GetPropExchangeFlag(&pxExpandedInformation, _T("Expanded")));
  820. SetExpandedControlText(GetPropExchangeString(pPX, _T("ExpandedText"), rglpsz, nString));
  821. SetCollapsedControlText(GetPropExchangeString(pPX, _T("CollapsedText"), rglpsz, nString));
  822. }
  824. if (pPX->IsSectionExists(_T("Verification")))
  825. {
  826. CXTPPropExchangeSection pxVerification(pPX->GetSection(_T("Verification")));
  828. SetVerificationText(GetPropExchangeString(&pxVerification, NULL, rglpsz, nString));
  829. SetVerifyCheckState(GetPropExchangeFlag(&pxVerification, _T("Checked")));
  830. }
  832. return TRUE;
  833. }