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

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

对话框与窗口

开发平台：

Visual C++

XTPTaskDialogClient.cpp：源码内容
  1. // XTPTaskDialogClient.cpp: implementation of the CXTPTaskDialogClient 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/XTPImageManager.h"
  25. #include "Common/XTPDrawHelpers.h"
  26. #include "Common/XTPSystemHelpers.h"
  27. #include "Common/XTPResourceManager.h"
  28. #include "Common/XTPMarkupRender.h"
  30. #include "Controls/XTThemeManager.h"
  31. #include "Controls/XTButtonTheme.h"
  32. #include "Controls/XTButton.h"
  34. #ifdef _XTP_INCLUDE_MARKUP
  35. #include "Markup/XTPMarkupContext.h"
  36. #include "Markup/XTPMarkupInline.h"
  37. #endif
  39. #include "XTPTaskDialogAPI.h"
  40. #include "XTPTaskDialogClient.h"
  42. #ifdef _DEBUG
  43. #define new DEBUG_NEW
  44. #undef THIS_FILE
  45. static char THIS_FILE[] = __FILE__;
  46. #endif
  48. //---------------------------------------------------------------------------
  49. // dialog units used for dynamic layout.
  50. //---------------------------------------------------------------------------
  51. enum XTPDluMetrics
  52. {
  53. xtpDluMinClient        = 180, // minimum client width.
  54. xtpDluMaxClient        = 265, // maximum client width when using command links.
  55. xtpDluMaxVerify        = 146, // maximum width for verify and expando buttons.
  56. xtpDluPadding          = 2,   // padding used for button and content.
  57. xtpDluBtnSpacing       = 3,   // spacing between common buttons.
  58. xtpDluMargin           = 5,   // non-client margin.
  59. };
  62. #ifndef LAYOUT_BITMAPORIENTATIONPRESERVED
  63. #define LAYOUT_BITMAPORIENTATIONPRESERVED 0x00000008
  64. #endif
  66. CXTPTaskDialogClient::CStringMarkup::CStringMarkup()
  67. {
  68. m_pUIElement = NULL;
  69. m_pClient = NULL;
  70. }
  72. CXTPTaskDialogClient::CStringMarkup::~CStringMarkup()
  73. {
  74. XTPMarkupReleaseElement(m_pUIElement);
  75. }
  77. void CXTPTaskDialogClient::CStringMarkup::SetCaption(const CString& strCaption)
  78. {
  79. m_strCaption = strCaption;
  80. XTPMarkupReleaseElement(m_pUIElement);
  82. if (!m_strCaption.IsEmpty() && m_pClient && m_pClient->m_pMarkupContext)
  83. {
  84. m_pUIElement = XTPMarkupParseText(m_pClient->m_pMarkupContext, m_strCaption);
  85. }
  86. }
  88. void CXTPTaskDialogClient::CStringMarkup::SetFinalRect(const CRect& rcFinalRect)
  89. {
  90. m_rcFinalRect = rcFinalRect;
  91. }
  93. //===========================================================================
  94. // CXTPTaskDialogClient
  95. //===========================================================================
  96. CXTPTaskDialogClient::CXTPTaskDialogClient()
  97. : m_nSection(xtpNone)
  98. , m_nMaxClientWidth(0)
  99. , m_nMinClientWidth(0)
  100. , m_nPadding(2)
  101. , m_bExpanded(FALSE)
  102. , m_bVerification(FALSE)
  103. , m_bUseSysIcons(FALSE)
  104. , m_bThemeReady(FALSE)
  105. , m_hIconFooter(NULL)
  106. , m_hIconMain(NULL)
  107. , m_crContext(COLORREF_NULL)
  108. , m_crContextText(COLORREF_NULL)
  109. , m_crFooter(COLORREF_NULL)
  110. , m_crFooterText(COLORREF_NULL)
  111. , m_crMainText(COLORREF_NULL)
  112. , m_cr3DLight(COLORREF_NULL)
  113. , m_cr3DShadow(COLORREF_NULL)
  114. , m_cr3DHighLight(COLORREF_NULL)
  115. , m_ptMargin(0,0)
  116. , m_ptPadding(0,0)
  117. , m_ptBtnSpacing(0,0)
  118. , m_ptBorder(0,0)
  119. , m_pBtnVerify(NULL)
  120. , m_pBtnExpando(NULL)
  121. , m_pConfig(NULL)
  122. {
  123. m_rcMainInstruction.SetRectEmpty();
  124. m_rcContent.SetRectEmpty();
  125. m_rcCommandButtons.SetRectEmpty();
  126. m_rcFooter.SetRectEmpty();
  127. m_rcExpandedInformation.SetRectEmpty();
  128. m_rcLinkButtons.SetRectEmpty();
  129. m_rcRadioButtons.SetRectEmpty();
  131. m_sizeCommandButton = CSize(0, 0);
  132. m_sizeIconFooter = CSize(0, 0);
  133. m_sizeIconMain = CSize(0, 0);
  135. m_nSelRadioButtonID = 0;
  137. m_pMarkupContext = NULL;
  139. m_pIconLinkGlyph = NULL;
  140. m_bMessageBoxStyle = FALSE;
  142. m_strMainInstruction.m_pClient = this;
  143. m_strContent.m_pClient = this;
  144. m_strFooter.m_pClient = this;
  145. m_strVerificationText.m_pClient = this;
  146. m_strExpandedInformation.m_pClient = this;
  147. m_strExpandedControlText.m_pClient = this;
  148. m_strCollapsedControlText.m_pClient = this;
  150. m_bEnableMarkup = FALSE;
  151. }
  153. #define SAFE_DELETE_WINDOW(ptr) if (ptr) { ptr->DestroyWindow(); delete ptr; ptr = NULL; }
  155. void CXTPTaskDialogClient::DeleteControls()
  156. {
  157. SAFE_DELETE_WINDOW(m_pBtnVerify);
  158. SAFE_DELETE_WINDOW(m_pBtnExpando);
  160. CMDTARGET_RELEASE(m_pIconLinkGlyph);
  162. int i;
  163. for (i = 0; i < m_arrLinkButtons.GetSize(); ++i)
  164. {
  165. CButton* pButton = m_arrLinkButtons[i];
  166. SAFE_DELETE_WINDOW(pButton);
  167. }
  168. m_arrLinkButtons.RemoveAll();
  170. for (i = 0; i < m_arrRadioButtons.GetSize(); ++i)
  171. {
  172. CButton* pButton = m_arrRadioButtons[i];
  173. SAFE_DELETE_WINDOW(pButton);
  174. }
  175. m_arrRadioButtons.RemoveAll();
  177. for (i = 0; i < m_arrCommandButtons.GetSize(); ++i)
  178. {
  179. CButton* pButton = m_arrCommandButtons[i];
  180. SAFE_DELETE_WINDOW(pButton);
  181. }
  182. m_arrCommandButtons.RemoveAll();
  184. SAFE_DELETE_HICON(m_hIconFooter);
  185. SAFE_DELETE_HICON(m_hIconMain);
  187. CMDTARGET_RELEASE(m_pIconLinkGlyph);
  189. m_wndProgressBar.DestroyWindow();
  190. m_wndFooter.DestroyWindow();
  191. m_wndExpandedInformation.DestroyWindow();
  192. m_wndContent.DestroyWindow();
  194. m_strMainInstruction.SetCaption(_T(""));
  195. m_strContent.SetCaption(_T(""));
  196. m_strFooter.SetCaption(_T(""));
  197. m_strVerificationText.SetCaption(_T(""));
  198. m_strExpandedInformation.SetCaption(_T(""));
  199. m_strExpandedControlText.SetCaption(_T(""));
  200. m_strCollapsedControlText.SetCaption(_T(""));
  201. XTPMarkupReleaseContext(m_pMarkupContext);
  203. m_mapWndSize.RemoveAll();
  204. }
  206. CXTPTaskDialogClient::~CXTPTaskDialogClient()
  207. {
  208. DeleteControls();
  209. DestroyWindow();
  210. }
  212. BEGIN_MESSAGE_MAP(CXTPTaskDialogClient, CWnd)
  213. //{{AFX_MSG_MAP(CXTPTaskDialogClient)
  214. ON_WM_SETTINGCHANGE()
  215. ON_WM_SYSCOLORCHANGE()
  216. ON_WM_ERASEBKGND()
  217. ON_WM_PAINT()
  218. ON_WM_CTLCOLOR()
  219. //}}AFX_MSG_MAP
  220. END_MESSAGE_MAP()
  222. //---------------------------------------------------------------------------
  223. // CXTPTaskDialogClient message handlers
  224. //---------------------------------------------------------------------------
  226. void CXTPTaskDialogClient::OnSettingChange(UINT uFlags, LPCTSTR lpszSection)
  227. {
  228. CDialog::OnSettingChange(uFlags, lpszSection);
  229. RefreshMetrics();
  230. }
  232. void CXTPTaskDialogClient::OnSysColorChange()
  233. {
  234. CDialog::OnSysColorChange();
  235. RefreshColors();
  236. }
  238. BOOL CXTPTaskDialogClient::OnEraseBkgnd(CDC* pDC)
  239. {
  240. UNREFERENCED_PARAMETER(pDC);
  241. return TRUE;
  242. }
  244. void CXTPTaskDialogClient::OnPaint()
  245. {
  246. CPaintDC dc(this); // device context for painting
  247. CXTPBufferDC memDC(dc);
  249. CXTPClientRect rcClient(this);
  251. if (!memDC.GetSafeHdc())
  252. return;
  254. DrawBackground(&memDC, rcClient);
  255. memDC.SetBkMode(TRANSPARENT);
  258. DrawMainInstruction(&memDC);
  259. DrawContent(&memDC);
  260. DrawExpandedInfo(&memDC);
  261. DrawFootNote(&memDC);
  262. }
  264. HBRUSH CXTPTaskDialogClient::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
  265. {
  266. int i;
  268. for (i = 0; i < m_arrRadioButtons.GetSize(); i++)
  269. {
  270. if (m_arrRadioButtons[i] == pWnd)
  271. {
  272. pDC->SetBkColor(m_crContext);
  273. return GetSysColorBrush(m_bThemeReady ? COLOR_WINDOW : COLOR_3DFACE);
  274. }
  275. }
  277. for (i = 0; i < m_arrLinkButtons.GetSize(); i++)
  278. {
  279. if (m_arrLinkButtons[i] == pWnd)
  280. {
  281. pDC->SetBkColor(m_crContext);
  282. return GetSysColorBrush(m_bThemeReady ? COLOR_WINDOW : COLOR_3DFACE);
  283. }
  284. }
  287. return CWnd::OnCtlColor(pDC, pWnd, nCtlColor);
  289. }
  291. HRESULT CXTPTaskDialogClient::SendNotify(UINT uNotify, WPARAM wParam /*=0*/, LPARAM lParam /*=0*/)
  292. {
  293. if (m_pConfig->pfCallback)
  294. {
  295. return m_pConfig->pfCallback(m_hWnd, uNotify,
  296. wParam, lParam, m_pConfig->lpCallbackData);
  297. }
  298. return E_FAIL;
  299. }
  301. BOOL CXTPTaskDialogClient::CanCancel() const
  302. {
  303. if (GetDlgItem(IDCANCEL))
  304. return TRUE;
  306. return ((m_pConfig->dwFlags & TDF_ALLOW_DIALOG_CANCELLATION) != 0);
  307. }
  309. void CXTPTaskDialogClient::OnMarkupHyperlinkClick(CXTPMarkupObject* pSender, CXTPMarkupRoutedEventArgs* pArgs)
  310. {
  311. pSender;
  312. pArgs;
  314. #ifdef _XTP_INCLUDE_MARKUP
  315. if (pSender->IsKindOf(MARKUP_TYPE(CXTPMarkupHyperlink)))
  316. {
  317. CXTPMarkupString* pTag = MARKUP_STATICCAST(CXTPMarkupString, ((CXTPMarkupHyperlink*)pSender)->GetTag());
  318. SendNotify(TDN_HYPERLINK_CLICKED, (WPARAM)0, (LPARAM)(pTag ? (LPCWSTR)*pTag : (LPCWSTR)NULL));
  320. pArgs->SetHandled();
  321. }
  322. #endif
  323. }
  325. BOOL CXTPTaskDialogClient::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  326. {
  327. // To Handle Hyperlinks:
  328. if (m_pMarkupContext)
  329. {
  330. if (XTPMarkupRelayMessage(m_strMainInstruction.m_pUIElement, message, wParam, lParam, pResult))
  331. return TRUE;
  333. if (XTPMarkupRelayMessage(m_strContent.m_pUIElement, message, wParam, lParam, pResult))
  334. return TRUE;
  336. if (XTPMarkupRelayMessage(m_strFooter.m_pUIElement, message, wParam, lParam, pResult))
  337. return TRUE;
  339. if (XTPMarkupRelayMessage(m_strVerificationText.m_pUIElement, message, wParam, lParam, pResult))
  340. return TRUE;
  342. if (XTPMarkupRelayMessage(m_strExpandedInformation.m_pUIElement, message, wParam, lParam, pResult))
  343. return TRUE;
  345. if (XTPMarkupRelayMessage(m_strExpandedControlText.m_pUIElement, message, wParam, lParam, pResult))
  346. return TRUE;
  348. if (XTPMarkupRelayMessage(m_strCollapsedControlText.m_pUIElement, message, wParam, lParam, pResult))
  349. return TRUE;
  350. }
  352. return CDialog::OnWndMsg(message, wParam, lParam, pResult);
  353. }
  356. LRESULT CXTPTaskDialogClient::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
  357. {
  358. switch (message)
  359. {
  360. case WM_COMMAND:
  361. {
  362. if (HIWORD(wParam) == BN_CLICKED)
  363. {
  364. int nID = (int)LOWORD(wParam);
  365. HWND hWnd = (HWND)lParam;
  367. if (hWnd && m_arrRadioButtons.GetSize() > 0)
  368. {
  369. for (int i = 0; i < m_arrRadioButtons.GetSize(); i++)
  370. {
  371. if (m_arrRadioButtons[i]->GetSafeHwnd() == hWnd )
  372. {
  373. if (m_arrRadioButtons[i]->GetCheck())
  374. {
  375. m_nSelRadioButtonID = nID;
  376. SendNotify(TDN_RADIO_BUTTON_CLICKED, (WPARAM)m_nSelRadioButtonID);
  377. }
  378. return TRUE;
  379. }
  380. }
  381. }
  384. if (hWnd && (hWnd == m_wndFooter.GetSafeHwnd()
  385. || hWnd == m_wndContent.GetSafeHwnd()
  386. || hWnd == m_wndExpandedInformation.GetSafeHwnd()))
  387. {
  388. CXTPTaskDialogLinkCtrl* pWnd = (CXTPTaskDialogLinkCtrl*)CWnd::FromHandle(hWnd);
  389. CXTPTaskDialogLinkCtrl::LINKITEM* pItem = pWnd->GetFocusedLink();
  390. if (pItem)
  391. {
  392. SendNotify(TDN_HYPERLINK_CLICKED, (WPARAM)0, (LPARAM)XTP_CT2CW(pItem->strUrl));
  393. return 1;
  394. }
  395. }
  397. switch (nID)
  398. {
  399. case XTP_IDC_VERIFY:
  400. if (m_pBtnVerify && m_pBtnVerify->GetSafeHwnd() == hWnd)
  401. {
  402. m_bVerification = !m_bVerification;
  403. SendNotify(TDN_VERIFICATION_CLICKED, m_bVerification);
  404. return 0;
  405. }
  407. case XTP_IDC_EXPANDO:
  408. if (m_pBtnExpando && m_pBtnExpando->GetSafeHwnd() == hWnd)
  409. {
  410. m_bExpanded = !m_bExpanded;
  411. SendNotify(TDN_EXPANDO_BUTTON_CLICKED, m_bExpanded);
  412. OnExpandExpandoClicked();
  413. return 0;
  414. }
  416. case IDCANCEL:
  417. if (!CanCancel())
  418. return FALSE;
  419. // Fall thru
  421. default:
  422. if (SendNotify(TDN_BUTTON_CLICKED, (WPARAM)nID) == 0)
  423. {
  424. if (nID == IDCANCEL)
  425. {
  426. OnCancel();
  427. }
  428. else if (nID == IDOK)
  429. {
  430. OnOK();
  431. }
  432. else
  433. {
  434. EndDialog(nID);
  435. }
  436. }
  437. return 0;
  438. }
  439. }
  440. break;
  441. }
  442. }
  444. return CDialog::WindowProc(message, wParam, lParam);
  445. }
  448. //---------------------------------------------------------------------------
  449. // Initialization
  450. //---------------------------------------------------------------------------
  452. void CXTPTaskDialogClient::RefreshMetrics()
  453. {
  454. CXTPWinThemeWrapper themeApi;
  455. m_bThemeReady = m_bMessageBoxStyle || themeApi.IsAppThemeReady();
  457. m_ptBorder.x      = ::GetSystemMetrics(SM_CXEDGE) + ::GetSystemMetrics(SM_CXBORDER);
  458. m_ptBorder.y      = ::GetSystemMetrics(SM_CYEDGE) + ::GetSystemMetrics(SM_CYBORDER);
  459. m_sizeIconFooter.cx     = ::GetSystemMetrics(SM_CXSMICON);
  460. m_sizeIconFooter.cy     = ::GetSystemMetrics(SM_CYSMICON);
  461. m_sizeIconMain.cx = ::GetSystemMetrics(SM_CXICON);
  462. m_sizeIconMain.cy = ::GetSystemMetrics(SM_CYICON);
  464. m_ptMargin     = XTPDlu2Pix(xtpDluMargin, xtpDluMargin);
  465. m_ptPadding    = XTPDlu2Pix(xtpDluPadding, xtpDluPadding);
  467. m_ptBtnSpacing = CPoint(XTPDlu2Pix(xtpDluBtnSpacing, xtpDluBtnSpacing).x, 0);
  469. if (!m_bThemeReady)
  470. m_ptBtnSpacing = CPoint(m_ptMargin.x, 2);
  472. m_nMinClientWidth = XTPDlu2Pix(xtpDluMinClient, 0).x - m_ptMargin.x * 2;
  475. CRect rcScreen = XTPMultiMonitor()->GetWorkArea(m_pConfig->hwndParent);
  476. m_nMaxClientWidth = rcScreen.Width() - ((m_ptBorder.x*2) + (m_ptMargin.x*2));
  478. if (m_nMinClientWidth > m_nMaxClientWidth)
  479. m_nMinClientWidth = m_nMaxClientWidth;
  480. }
  482. void CXTPTaskDialogClient::RefreshColors()
  483. {
  484. XTPColorManager()->RefreshColors();
  486. COLORREF crWindow = GetXtremeColor(COLOR_WINDOW);
  487. COLORREF crWindowText = GetXtremeColor(COLOR_WINDOWTEXT);
  488. COLORREF crBtnFace = GetXtremeColor(COLOR_BTNFACE);
  489. COLORREF crBtnText = GetXtremeColor(COLOR_BTNTEXT);
  490. m_cr3DShadow = GetXtremeColor(COLOR_3DSHADOW);
  491. m_cr3DHighLight = GetXtremeColor(COLOR_3DHILIGHT);
  492. m_cr3DLight  = XTPColorManager()->LightColor(crBtnFace, m_cr3DShadow, 750);
  494. m_crContext = m_bThemeReady? crWindow : crBtnFace;
  495. m_crContextText = m_bThemeReady? crWindowText : crBtnText;
  496. m_crMainText = m_bThemeReady ? RGB(0x00, 0x33, 0x99) : m_crContextText;
  497. m_crFooter = crBtnFace;
  498. m_crFooterText = crBtnText;
  500. m_wndContent.SetBackColor(m_crContext);
  501. m_wndContent.SetTextColor(m_crContextText);
  502. m_wndExpandedInformation.SetBackColor(IsExpandFooterArea() ? m_crFooter : m_crContext);
  503. m_wndExpandedInformation.SetTextColor(IsExpandFooterArea() ? m_crFooterText : m_crContextText);
  504. m_wndFooter.SetBackColor(m_crFooter);
  505. m_wndFooter.SetTextColor(m_crFooterText);
  506. }
  508. CString CXTPTaskDialogClient::LoadItemString(PCWSTR pszBuffer)
  509. {
  510. CString strItem;
  512. if (pszBuffer && IS_INTRESOURCE(pszBuffer))
  513. {
  514. UINT uID = (UINT)(UINT_PTR)pszBuffer;
  516. if (::FindResource(m_pConfig->hInstance, MAKEINTRESOURCE((uID>>4)+1), RT_STRING))
  517. XTPLoadStringInst(m_pConfig->hInstance, uID, &strItem);
  518. else
  519. XTPResourceManager()->LoadString(&strItem, uID);
  521. ASSERT(!strItem.IsEmpty());
  522. }
  523. else
  524. {
  525. strItem = pszBuffer;
  526. }
  528. return strItem;
  529. }
  531. void CXTPTaskDialogClient::LoadStrings()
  532. {
  533. m_strMainInstruction.SetCaption(LoadItemString(m_pConfig->pszMainInstruction));
  534. m_strContent.SetCaption(LoadItemString(m_pConfig->pszContent));
  535. m_strFooter.SetCaption(LoadItemString(m_pConfig->pszFooter));
  536. m_strVerificationText.SetCaption(LoadItemString(m_pConfig->pszVerificationText));
  537. m_strExpandedInformation.SetCaption(LoadItemString(m_pConfig->pszExpandedInformation));
  539. if (!m_strExpandedInformation.IsEmpty())
  540. {
  541. m_strExpandedControlText.SetCaption(LoadItemString(m_pConfig->pszExpandedControlText));
  542. m_strCollapsedControlText.SetCaption(LoadItemString(m_pConfig->pszCollapsedControlText));
  544. if (m_strExpandedControlText.IsEmpty() && m_strCollapsedControlText.IsEmpty())
  545. {
  546. VERIFY(XTPResourceManager()->LoadString(&m_strExpandedControlText.m_strCaption, XTP_IDS_TASK_HIDE_DETAILS));
  547. VERIFY(XTPResourceManager()->LoadString(&m_strCollapsedControlText.m_strCaption, XTP_IDS_TASK_SEE_DETAILS));
  548. }
  549. else if (m_strExpandedControlText.IsEmpty())
  550. {
  551. m_strExpandedControlText = m_strCollapsedControlText;
  552. }
  553. else if (m_strCollapsedControlText.IsEmpty())
  554. {
  555. m_strCollapsedControlText = m_strExpandedControlText;
  556. }
  557. }
  558. }
  560. BOOL CXTPTaskDialogClient::CreateCommandButtons()
  561. {
  562. if ((m_pConfig->dwCommonButtons & TDCBF_OK_BUTTON) || (!m_pConfig->pButtons && !m_pConfig->dwCommonButtons))
  563. {
  564. if (AddCommandButton(IDOK, XTP_IDS_TASK_OK, m_sizeCommandButton) == NULL)
  565. {
  566. TRACE0("Failed to create OK button.n");
  567. return FALSE;
  568. }
  569. }
  571. if (m_pConfig->dwCommonButtons & TDCBF_YES_BUTTON)
  572. {
  573. if (AddCommandButton(IDYES, XTP_IDS_TASK_YES, m_sizeCommandButton) == NULL)
  574. {
  575. TRACE0("Failed to create YES button.n");
  576. return FALSE;
  577. }
  578. }
  580. if (m_pConfig->dwCommonButtons & TDCBF_NO_BUTTON)
  581. {
  582. if (AddCommandButton(IDNO, XTP_IDS_TASK_NO, m_sizeCommandButton) == NULL)
  583. {
  584. TRACE0("Failed to create NO button.n");
  585. return FALSE;
  586. }
  587. }
  589. if (m_pConfig->dwCommonButtons & TDCBF_RETRY_BUTTON)
  590. {
  591. if (AddCommandButton(IDRETRY, XTP_IDS_TASK_RETRY, m_sizeCommandButton) == NULL)
  592. {
  593. TRACE0("Failed to create RETRY button.n");
  594. return FALSE;
  595. }
  596. }
  598. if (m_pConfig->dwCommonButtons & TDCBF_CANCEL_BUTTON)
  599. {
  600. if (AddCommandButton(IDCANCEL, XTP_IDS_TASK_CANCEL, m_sizeCommandButton) == NULL)
  601. {
  602. TRACE0("Failed to create CANCEL button.n");
  603. return FALSE;
  604. }
  605. }
  607. if (m_pConfig->dwCommonButtons & TDCBF_CLOSE_BUTTON)
  608. {
  609. if (AddCommandButton(IDCLOSE, XTP_IDS_TASK_CLOSE, m_sizeCommandButton) == NULL)
  610. {
  611. TRACE0("Failed to create CLOSE button.n");
  612. return FALSE;
  613. }
  614. }
  617. return TRUE;
  618. }
  620. BOOL CXTPTaskDialogClient::CreateLinkButtons()
  621. {
  622. if (m_pConfig->pButtons == NULL || m_pConfig->cButtons == 0)
  623. return TRUE;
  625. for (UINT i = 0; i < m_pConfig->cButtons; ++i)
  626. {
  627. CString strButtonText = LoadItemString(m_pConfig->pButtons[i].pszButtonText);
  629. if (IsLinkButtonsUsed())
  630. {
  631. CXTPTaskButtonTheme* pTheme = new CXTPTaskButtonTheme(m_bThemeReady);
  632. pTheme->SetTitleFont(&m_fontLarge);
  634. CButton* pButton = CreateButton(m_pConfig->pButtons[i].nButtonID,
  635. strButtonText, CSize(0, 0), BS_PUSHBUTTON | BS_MULTILINE | WS_TABSTOP, pTheme);
  637. if (pButton == NULL)
  638. {
  639. TRACE0("Error creating command link button.n");
  640. return FALSE;
  641. }
  643. if (m_pIconLinkGlyph)
  644. {
  645. CXTButton* pXTButton = DYNAMIC_DOWNCAST(CXTButton, pButton);
  646. if (pXTButton == NULL)
  647. {
  648. TRACE0("Error creating command link button.n");
  649. SAFE_DELETE(pButton);
  650. return FALSE;
  651. }
  653. CSize sizeGlyph = m_pIconLinkGlyph->GetExtent();
  655. m_pIconLinkGlyph->InternalAddRef(); // Lets share one icon!
  656. pXTButton->SetIcon(sizeGlyph, m_pIconLinkGlyph);
  657. pXTButton->SetImageGap(sizeGlyph.cx / 2);
  658. }
  659. m_arrLinkButtons.Add(pButton);
  660. }
  661. else
  662. {
  663. CSize sizeButton = CalcButtonSize(strButtonText);
  664. sizeButton.cx = max(m_sizeCommandButton.cx, sizeButton.cx);
  666. if (AddCommandButton(m_pConfig->pButtons[i].nButtonID, strButtonText, sizeButton) == NULL)
  667. {
  668. TRACE0("Failed to create OK button.n");
  669. return FALSE;
  670. }
  671. }
  672. }
  674. return TRUE;
  675. }
  677. #ifndef PBS_MARQUEE
  678. #define PBS_MARQUEE             0x08
  679. #endif
  681. BOOL CXTPTaskDialogClient::CreateProgressBar()
  682. {
  683. if (!IsProgressBarVisible())
  684. return TRUE;
  686. if (!m_wndProgressBar.Create(WS_CHILD | WS_VISIBLE |
  687. (m_pConfig->dwFlags & TDF_SHOW_MARQUEE_PROGRESS_BAR ? PBS_MARQUEE : 0), CRect(0, 0, 0, 0), this, 0))
  688. return FALSE;
  690. return TRUE;
  691. }
  693. BOOL CXTPTaskDialogClient::CreateRadioButtons()
  694. {
  695. if (m_pConfig->pRadioButtons == NULL)
  696. return TRUE;
  698. for (UINT i = 0; i < m_pConfig->cRadioButtons; ++i)
  699. {
  700. CString strButton = LoadItemString(m_pConfig->pRadioButtons[i].pszButtonText);
  702. int nButtonID = m_pConfig->pRadioButtons[i].nButtonID;
  704. CPoint point(10,2);
  705. CButton* pButton = CreateButton(nButtonID, strButton,
  706. CalcButtonSize(strButton, &point), BS_AUTORADIOBUTTON | BS_TEXT | BS_MULTILINE);
  708. if (pButton == NULL)
  709. {
  710. TRACE0("Error creating radio button.n");
  711. return FALSE;
  712. }
  714. if ((m_pConfig->dwFlags & TDF_NO_DEFAULT_RADIO_BUTTON) == 0)
  715. {
  716. if (m_pConfig->nDefaultRadioButton == nButtonID)
  717. {
  718. pButton->SetCheck(TRUE);
  719. m_nSelRadioButtonID = nButtonID;
  720. pButton->ModifyStyle(0, WS_TABSTOP);
  721. }
  722. if (m_pConfig->nDefaultRadioButton == 0 && i == 0)
  723. {
  724. pButton->SetCheck(TRUE);
  725. m_nSelRadioButtonID = nButtonID;
  726. pButton->ModifyStyle(0, WS_TABSTOP);
  727. }
  728. }
  729. else if (i == 0)
  730. {
  731. pButton->ModifyStyle(0, WS_TABSTOP);
  732. }
  734. m_arrRadioButtons.Add(pButton);
  735. }
  737. return TRUE;
  738. }
  740. BOOL CXTPTaskDialogClient::CreateVerifyExpandButtons()
  741. {
  742. // create expando button.
  743. if (!m_strExpandedInformation.IsEmpty())
  744. {
  745. CString strButtonText = IsExpandedByDefault()? m_strExpandedControlText: m_strCollapsedControlText;
  747. CString strButtonSize = m_strExpandedControlText.m_strCaption.GetLength() > m_strCollapsedControlText.m_strCaption.GetLength()
  748. ? m_strExpandedControlText : m_strCollapsedControlText;
  750. CSize sizeButton = CalcButtonSize(strButtonSize, NULL, XTPDlu2Pix(xtpDluMaxVerify,0).x);
  752. CButton* pButton = CreateButton(XTP_IDC_EXPANDO, strButtonText, sizeButton,
  753. BS_PUSHBUTTON | BS_MULTILINE | WS_TABSTOP, new CXTPTaskButtonThemeExpando);
  755. if (pButton == NULL)
  756. {
  757. TRACE0("Error creating Expando button.n");
  758. return FALSE;
  759. }
  761. m_pBtnExpando = DYNAMIC_DOWNCAST(CXTButton, pButton);
  762. if (m_pBtnExpando == NULL)
  763. {
  764. TRACE0("Error creating Expando button.n");
  765. SAFE_DELETE(pButton);
  766. return FALSE;
  767. }
  769. m_pBtnExpando->SetXButtonStyle(BS_XT_WINXP_COMPAT);
  771. m_bExpanded = IsExpandedByDefault();
  772. }
  774. // create verification text check box.
  775. if (!m_strVerificationText.IsEmpty())
  776. {
  777. CString strButtonText = m_strVerificationText;
  778. CPoint point(10, 2);
  779. CSize sizeButton = CalcButtonSize(strButtonText, &point, XTPDlu2Pix(xtpDluMaxVerify,0).x);
  781. CButton* pButton = CreateButton(XTP_IDC_VERIFY, strButtonText, sizeButton,
  782. BS_AUTOCHECKBOX | BS_MULTILINE | BS_TOP | BS_LEFT | WS_TABSTOP);
  784. if (pButton == NULL)
  785. {
  786. TRACE0("Error creating Verification check box.n");
  787. return FALSE;
  788. }
  790. m_bVerification = ((m_pConfig->dwFlags & TDF_VERIFICATION_FLAG_CHECKED) != 0);
  791. m_pBtnVerify = pButton;
  792. m_pBtnVerify->SetCheck(m_bVerification);
  793. }
  795. return TRUE;
  796. }
  798. BOOL CXTPTaskDialogClient::CreateClient(BOOL bMoveWindow)
  799. {
  800. DeleteControls();
  802. if (m_bEnableMarkup)
  803. {
  804. m_pMarkupContext = XTPMarkupCreateContext(m_hWnd);
  805. }
  807. #ifdef _XTP_INCLUDE_MARKUP
  808. if (m_pMarkupContext)
  809. {
  810. m_pMarkupContext->AddHandler(CXTPMarkupHyperlink::m_pClickEvent, CreateMarkupClassDelegate(this, &CXTPTaskDialogClient::OnMarkupHyperlinkClick));
  811. }
  812. #endif
  814. RefreshMetrics();
  815. RefreshColors();
  817. LoadStrings();
  818. CreateIcons();
  819. CreateFonts();
  821. m_sizeCommandButton = CalcCommandButtonSize();
  823. if (!CreateLinkButtons() ||         // create command link buttons.
  824. !CreateCommandButtons())        // create common buttons OK, Cancel, etc.
  825. {
  826. return FALSE;
  827. }
  829. // If hyperlinks are enabled, creating the links now with a zero size
  830. // will extract all hyperlink information from the string so the layout
  831. // can be determined correctly. The links will be resized when RecalcLayout
  832. // is called.
  834. if (IsHyperlinksEnabled())
  835. {
  836. CXTPEmptyRect rect;
  837. m_wndContent.Create(rect, m_strContent.m_strCaption, &m_font, this);
  838. m_wndExpandedInformation.Create(rect, m_strExpandedInformation.m_strCaption, &m_font, this);
  839. m_wndFooter.Create(rect, m_strFooter.m_strCaption, &m_font, this);
  840. }
  842. if (!CreateProgressBar() ||
  843. !CreateRadioButtons() ||        // create radio buttons.
  844. !CreateVerifyExpandButtons())   // create verify and expando buttons.
  845. {
  846. return FALSE;
  847. }
  850. RecalcLayout(bMoveWindow);
  852. return TRUE;
  853. }
  855. void CXTPTaskDialogClient::UpdateZOrder()
  856. {
  857. ZOrder(&m_wndContent);
  859. if (!IsExpandFooterArea())
  860. ZOrder(&m_wndExpandedInformation);
  862. ZOrder(&m_wndProgressBar);
  864. int i;
  866. for (i = 0; i < (int)m_arrRadioButtons.GetSize(); i++)
  867. {
  868. ZOrder(m_arrRadioButtons[i]);
  869. }
  871. for (i = 0; i < (int)m_arrLinkButtons.GetSize(); i++)
  872. {
  873. ZOrder(m_arrLinkButtons[i]);
  874. }
  876. ZOrder(m_pBtnExpando);
  877. ZOrder(m_pBtnVerify);
  879. for (i = 0; i < (int)m_arrCommandButtons.GetSize(); i++)
  880. {
  881. ZOrder(m_arrCommandButtons[i]);
  882. }
  884. ZOrder(&m_wndFooter);
  886. if (IsExpandFooterArea())
  887. ZOrder(&m_wndExpandedInformation);
  889. }
  892. void CXTPTaskDialogClient::ZOrder(CWnd* pWnd)
  893. {
  894. if (!pWnd || !pWnd->GetSafeHwnd() )
  895. return;
  897. pWnd->SetWindowPos(&CWnd::wndBottom, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOSIZE);
  898. }
  900. HICON CXTPTaskDialogClient::CreateIcon(HICON hIcon, PCWSTR lpwzIcon, CSize sizeIcon, BOOL bUseHandle)
  901. {
  902. HICON hNewIcon = NULL;
  904. if (bUseHandle && hIcon != NULL)
  905. {
  906. hNewIcon = ::CopyIcon(hIcon);
  907. }
  908. else if (!bUseHandle)
  909. {
  910. if (m_pConfig->hInstance == NULL || lpwzIcon == NULL || !IS_INTRESOURCE(lpwzIcon))
  911. {
  912. return FALSE;
  913. }
  915. if (lpwzIcon == TD_ERROR_ICON ||
  916. lpwzIcon == TD_WARNING_ICON ||
  917. lpwzIcon == TD_INFORMATION_ICON ||
  918. lpwzIcon == TD_SHIELD_ICON)
  919. {
  920. DWORD dwID = 0;
  922. if (m_bUseSysIcons)
  923. {
  924. switch ((ULONG_PTR)lpwzIcon)
  925. {
  926. case (ULONG_PTR)TD_ERROR_ICON:       dwID = 0x0067; break;
  927. case (ULONG_PTR)TD_WARNING_ICON:     dwID = 0x0065; break;
  928. case (ULONG_PTR)TD_INFORMATION_ICON: dwID = 0x0068; break;
  929. case (ULONG_PTR)TD_SHIELD_ICON:      dwID = 0x006a; break; // vista and later.
  930. }
  932. hNewIcon = XTPResourceManager()->CreateIconFromResource(
  933. CXTPModuleHandle(_T("user32.dll")), MAKEINTRESOURCE(dwID), sizeIcon);
  934. }
  936. if (hNewIcon == NULL)
  937. {
  938. switch ((ULONG_PTR)lpwzIcon)
  939. {
  940. case (ULONG_PTR)TD_ERROR_ICON:       dwID = XTP_IDI_TASKERROR;  break;
  941. case (ULONG_PTR)TD_WARNING_ICON:     dwID = XTP_IDI_TASKWARN;   break;
  942. case (ULONG_PTR)TD_INFORMATION_ICON: dwID = XTP_IDI_TASKINFO;   break;
  943. case (ULONG_PTR)TD_SHIELD_ICON:      dwID = XTP_IDI_TASKSHIELD; break;
  944. }
  946. hNewIcon = XTPResourceManager()->LoadIcon(MAKEINTRESOURCE(dwID), sizeIcon);
  947. }
  948. }
  949. else
  950. {
  951. hNewIcon = XTPResourceManager()->CreateIconFromResource(
  952. m_pConfig->hInstance, (LPTSTR)lpwzIcon, sizeIcon);
  953. }
  954. }
  956. ASSERT(hNewIcon != NULL);
  957. return hNewIcon;
  958. }
  960. void CXTPTaskDialogClient::CreateIcons()
  961. {
  962. // create small icon.
  963. SAFE_DELETE_HICON(m_hIconFooter);
  964. m_hIconFooter = CreateIcon(m_pConfig->hFooterIcon, m_pConfig->pszFooterIcon, m_sizeIconFooter, IsFooterIconHandleUsed());
  966. // create large icon.
  967. SAFE_DELETE_HICON(m_hIconMain);
  968. m_hIconMain = CreateIcon(m_pConfig->hMainIcon, m_pConfig->pszMainIcon, m_sizeIconMain, IsMainIconHandleUsed());
  970. if (IsLinkButtonsUsed() && IsLinkButtonsIconVisible() && m_pIconLinkGlyph == 0)
  971. {
  972. m_pIconLinkGlyph = new CXTPImageManagerIcon(0, 20, 20);
  974. BOOL bRTLLayout = (m_pConfig->dwFlags & TDF_RTL_LAYOUT);
  976. CXTPImageManagerIconHandle hIconGlyph;
  977. CXTPImageManagerIconHandle hIconGlyphHot;
  979. HBITMAP hBitmap = (HBITMAP)CXTPImageManagerIcon::LoadAlphaBitmap(XTP_IDB_GLYPH);
  980. if (bRTLLayout)
  981. {
  982. hIconGlyph = CXTPImageManagerIcon::InvertAlphaBitmap(hBitmap);
  983. DeleteObject(hBitmap);
  984. }
  985. else
  986. {
  987. hIconGlyph = hBitmap;
  988. }
  990. hBitmap = (HBITMAP)CXTPImageManagerIcon::LoadAlphaBitmap(XTP_IDB_GLYPH_HOT);
  992. if (bRTLLayout)
  993. {
  994. hIconGlyphHot = CXTPImageManagerIcon::InvertAlphaBitmap(hBitmap);
  995. DeleteObject(hBitmap);
  996. }
  997. else
  998. {
  999. hIconGlyphHot = hBitmap;
  1000. }
  1002. m_pIconLinkGlyph->SetIcon(hIconGlyph);
  1003. m_pIconLinkGlyph->SetHotIcon(hIconGlyphHot);
  1004. }
  1005. }
  1007. void CXTPTaskDialogClient::CreateFonts()
  1008. {
  1009. NONCLIENTMETRICS ncm;
  1010. ncm.cbSize = sizeof(NONCLIENTMETRICS);
  1011. ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
  1013. m_font.DeleteObject();
  1014. m_fontLarge.DeleteObject();
  1016. if (m_bThemeReady)
  1017. {
  1018. CWindowDC dc(NULL);
  1020. if (_tcscmp(ncm.lfMenuFont.lfFaceName, _T("Segoe UI")) == 0)
  1021. ncm.lfMenuFont.lfQuality = 5;
  1023. ncm.lfMenuFont.lfWeight = FW_NORMAL;
  1024. ncm.lfMenuFont.lfItalic = 0;
  1025. m_font.CreateFontIndirect(&ncm.lfMenuFont);
  1027. ncm.lfMenuFont.lfHeight = ::MulDiv(-12, ::GetDeviceCaps(dc.m_hDC, LOGPIXELSY), 72);
  1029. if (_tcscmp(ncm.lfMenuFont.lfFaceName, _T("Segoe UI")) != 0)
  1030. ncm.lfMenuFont.lfWeight = FW_BOLD;
  1031. m_fontLarge.CreateFontIndirect(&ncm.lfMenuFont);
  1032. }
  1033. else
  1034. {
  1035. m_font.CreateFontIndirect(&ncm.lfMenuFont);
  1036. m_fontLarge.CreateFontIndirect(&ncm.lfCaptionFont);
  1037. }
  1038. }
  1040. //---------------------------------------------------------------------------
  1041. // Button
  1042. //---------------------------------------------------------------------------
  1044. CButton *CXTPTaskDialogClient::CreateButton(int nButtonID, LPCTSTR lpszLabel, CSize sizeButton, DWORD dwButtonStyle /*=BS_PUSHBUTTON | BS_MULTILINE*/, CXTButtonTheme* pTheme /*=NULL*/)
  1045. {
  1046. CButton* pButton = pTheme? new CXTButton: new CButton;
  1048. if (pTheme)
  1049. dwButtonStyle |= BS_LEFT;
  1051. CRect rcButton = XTPSize2Rect(sizeButton);
  1052. if (pButton->Create(lpszLabel, WS_CHILD | WS_VISIBLE |
  1053. dwButtonStyle, rcButton, this, nButtonID))
  1054. {
  1055. m_mapWndSize[pButton] = sizeButton;
  1057. if (pTheme)
  1058. ((CXTButton*)pButton)->SetTheme(pTheme);
  1060. pButton->SetFont(&m_font);
  1061. return pButton;
  1062. }
  1064. SAFE_DELETE(pButton);
  1065. return NULL;
  1066. }
  1068. CButton *CXTPTaskDialogClient::AddCommandButton(int nButtonID, int nIDLabel, CSize sizeButton)
  1069. {
  1070. CString strButton;
  1071. XTPResourceManager()->LoadString(&strButton, nIDLabel);
  1072. ASSERT(!strButton.IsEmpty());
  1074. return AddCommandButton(nButtonID, strButton, sizeButton);
  1075. }
  1077. CButton *CXTPTaskDialogClient::AddCommandButton(int nButtonID, LPCTSTR lpszLabel, CSize sizeButton)
  1078. {
  1079. CButton* pButton = CreateButton(nButtonID, lpszLabel, sizeButton, BS_PUSHBUTTON | BS_MULTILINE | WS_TABSTOP);
  1080. if (pButton)
  1081. {
  1082. m_arrCommandButtons.Add(pButton);
  1083. return pButton;
  1084. }
  1086. return NULL;
  1087. }
  1089. CSize CXTPTaskDialogClient::CalcButtonSize(CString strButton, CPoint* pMarginButton /*=NULL*/, int nMaxWidth /*=0*/)
  1090. {
  1091. CPoint ptMarginButton;
  1092. ptMarginButton.x = m_ptBtnSpacing.x + m_ptMargin.x;
  1093. ptMarginButton.y = m_ptPadding.y;
  1095. if (pMarginButton == NULL)
  1096. pMarginButton = &ptMarginButton;
  1098. CXTPEmptySize sizeCaptText;
  1099. CString strCaptText = XTPExtractSubString(strButton, 0);
  1100. if (!strCaptText.IsEmpty())
  1101. {
  1102. sizeCaptText.cx = nMaxWidth;
  1104. XTPDrawHelpers()->StripMnemonics(strCaptText);
  1106. if (nMaxWidth == 0)
  1107. XTPCalcIdealTextSize(strCaptText, sizeCaptText, m_font, 330, 7);
  1108. else
  1109. XTPCalcTextSize(strCaptText, sizeCaptText, m_font);
  1110. }
  1112. CXTPEmptySize sizeNoteText;
  1113. CString strNoteText = XTPExtractSubString(strButton, 1);
  1114. if (!strNoteText.IsEmpty())
  1115. {
  1116. sizeNoteText.cx = nMaxWidth;
  1118. if (nMaxWidth == 0)
  1119. XTPCalcIdealTextSize(strNoteText, sizeNoteText, m_font, 330, 7);
  1120. else
  1121. XTPCalcTextSize(strNoteText, sizeNoteText, m_font);
  1122. }
  1124. CXTPEmptySize sizeButton;
  1125. sizeButton.cx = max(sizeCaptText.cx, sizeNoteText.cx) + (pMarginButton->x * 2);
  1126. sizeButton.cy = sizeCaptText.cy + sizeNoteText.cy + (pMarginButton->y * 2);
  1128. return sizeButton;
  1129. }
  1131. CSize CXTPTaskDialogClient::CalcCommandButtonSize()
  1132. {
  1133. CXTPEmptySize sizeCommon;
  1135. for (int nIDString = XTP_IDS_TASK_OK; nIDString <= XTP_IDS_TASK_CLOSE; ++nIDString)
  1136. {
  1137. CString strButton;
  1138. XTPResourceManager()->LoadString(&strButton, nIDString);
  1139. ASSERT(!strButton.IsEmpty());
  1141. CSize sizeButton = CalcButtonSize(strButton);
  1142. sizeCommon.cx = max(sizeCommon.cx, sizeButton.cx);
  1143. sizeCommon.cy = max(sizeCommon.cy, sizeButton.cy);
  1144. }
  1146. return sizeCommon;
  1147. }
  1149. int CXTPTaskDialogClient::CalcLinkButtonIdealWidth(CString strButton, int cxWidth)
  1150. {
  1151. if (strButton.IsEmpty() || !HasLinkButtons())
  1152. return 0;
  1154. cxWidth -= ((m_ptMargin.x*2) + m_nPadding);
  1156. if (m_pIconLinkGlyph)
  1157. cxWidth -= m_pIconLinkGlyph->GetExtent().cx - m_nPadding;
  1159. CString strCaptText = XTPExtractSubString(strButton, 0);
  1161. int nCaptionWidth = 0;
  1162. CSize sizeText(cxWidth, 0);
  1163. if (XTPCalcIdealTextSize(strCaptText, sizeText, m_fontLarge, 120, 30))
  1164. {
  1165. nCaptionWidth = sizeText.cx;
  1166. }
  1168. CStringMarkup strNoteText;
  1169. strNoteText.SetCaption(XTPExtractSubString(strButton, 1));
  1170. int nNoteWidth = CalcIdealTextWidth(strNoteText, cxWidth, FALSE);
  1172. cxWidth = max(nCaptionWidth, nNoteWidth);
  1173. if (m_pIconLinkGlyph)
  1174. cxWidth += m_pIconLinkGlyph->GetExtent().cx;
  1176. return cxWidth + m_ptMargin.x * 2 + m_nPadding;
  1177. }
  1179. CSize CXTPTaskDialogClient::CalcLinkButtonSize(CString strButton, int cxMaxWidth)
  1180. {
  1181. if (strButton.IsEmpty() || !HasLinkButtons())
  1182. return CXTPEmptySize();
  1184. cxMaxWidth -= ((m_ptMargin.x*2) + m_nPadding);
  1186. if (m_pIconLinkGlyph)
  1187. cxMaxWidth -= m_pIconLinkGlyph->GetExtent().cx;
  1189. // get the initial text size.
  1190. CXTPEmptySize sizeButton;
  1192. BOOL bWordWrap = FALSE;
  1194. // extract the title string and determine text size.
  1195. CString strCaptText = XTPExtractSubString(strButton, 0);
  1196. CSize sizeCaptText(cxMaxWidth, 0);
  1197. if (XTPCalcTextSize(strCaptText, sizeCaptText, m_fontLarge, &bWordWrap))
  1198. {
  1199. // if the string spans multiple rows, set the max width.
  1200. if (bWordWrap)
  1201. sizeCaptText.cx = cxMaxWidth;
  1202. }
  1203. else
  1204. {
  1205. sizeCaptText.cx = 0;
  1206. }
  1208. // extract the note string and determine text size.
  1209. CString strNoteText = XTPExtractSubString(strButton, 1);
  1210. CSize sizeNoteText(cxMaxWidth, 0);
  1211. if (XTPCalcTextSize(strNoteText, sizeNoteText, m_font, &bWordWrap))
  1212. {
  1213. // if the string spans multiple rows, set the max width.
  1214. if (bWordWrap)
  1215. sizeNoteText.cx = cxMaxWidth;
  1216. }
  1217. else
  1218. {
  1219. sizeNoteText.cx = 0;
  1220. }
  1222. // add padding around text.
  1223. sizeButton.cx = max(sizeCaptText.cx, sizeNoteText.cx) + m_ptMargin.x * 2 + m_nPadding;
  1224. sizeButton.cy = sizeCaptText.cy + sizeNoteText.cy + m_ptMargin.y * 2 /*+ m_nPadding*/;
  1226. return sizeButton;
  1227. }
  1229. BOOL CXTPTaskDialogClient::MoveButton(CButton* pButton, int x, int y, int cx, int cy, BOOL bRedraw /*=FALSE*/)
  1230. {
  1231. // position the button.
  1232. if (IsWindow(pButton) && pButton->SetWindowPos(NULL, x, y, cx, cy, SWP_FRAMECHANGED | SWP_NOZORDER | SWP_NOACTIVATE))
  1233. {
  1234. // invalidate.
  1235. if (bRedraw)
  1236. pButton->RedrawWindow();
  1238. return TRUE;
  1239. }
  1241. return FALSE;
  1242. }
  1244. void CXTPTaskDialogClient::SetCommandButtonPos()
  1245. {
  1246. int x = m_rcCommandButtons.left, y = m_rcCommandButtons.top +  m_ptMargin.y - 1;
  1248. int i, nCount = (int)m_arrCommandButtons.GetSize();
  1249. for (i = 0; i < nCount; i++)
  1250. {
  1251. CButton* pButton = m_arrCommandButtons[i];
  1253. CXTPEmptySize sizeButton;
  1254. if (m_mapWndSize.Lookup(pButton, sizeButton))
  1255. {
  1256. // no more room, adjust height.
  1257. if (x !=  m_rcCommandButtons.left && x + sizeButton.cx > m_rcCommandButtons.right)
  1258. {
  1259. x = m_rcCommandButtons.left;
  1260. y += sizeButton.cy + m_ptBtnSpacing.y;
  1261. }
  1263. MoveButton(pButton, x, y, sizeButton.cx, sizeButton.cy);
  1265. x += sizeButton.cx + m_ptBtnSpacing.x;
  1266. }
  1267. }
  1268. }
  1270. void CXTPTaskDialogClient::SetLinkButtonPos()
  1271. {
  1272. int nTop = m_rcLinkButtons.top + m_ptMargin.x + m_ptPadding.y / 2 + 2;
  1274. int nCount = (int)m_arrLinkButtons.GetSize();
  1275. for (int i = 0; i < nCount; ++i)
  1276. {
  1277. CSize sizeButton;
  1278. if (m_mapWndSize.Lookup(m_arrLinkButtons[i], sizeButton))
  1279. {
  1280. MoveButton(m_arrLinkButtons[i], m_rcLinkButtons.left, nTop, m_rcLinkButtons.Width(), sizeButton.cy);
  1281. nTop += sizeButton.cy;
  1282. }
  1283. }
  1284. }
  1286. void CXTPTaskDialogClient::SetVerifyButtonPos()
  1287. {
  1288. CXTPEmptySize sizeVerify;
  1289. if (IsWindow(m_pBtnVerify) && m_mapWndSize.Lookup(m_pBtnVerify, sizeVerify))
  1290. {
  1291. CXTPEmptyRect rcButton;
  1292. rcButton.left = m_ptMargin.x + 3;
  1293. rcButton.right = rcButton.left + sizeVerify.cx;
  1295. // vertically center.
  1296. rcButton.top = m_rcCommandButtons.top + (m_rcCommandButtons.Height() - sizeVerify.cy)/2;
  1298. CXTPEmptySize sizeExpando;
  1299. if (IsWindow(m_pBtnExpando) && m_mapWndSize.Lookup(m_pBtnExpando, sizeExpando))
  1300. {
  1301. rcButton.top = m_rcCommandButtons.top + m_ptMargin.y + sizeExpando.cy;
  1302. }
  1304. rcButton.bottom = rcButton.top + sizeVerify.cy;
  1305. MoveButton(m_pBtnVerify, rcButton);
  1306. }
  1307. }
  1309. void CXTPTaskDialogClient::SetExpandoButtonPos()
  1310. {
  1311. CXTPEmptySize sizeExpando;
  1312. if (IsWindow(m_pBtnExpando) && m_mapWndSize.Lookup(m_pBtnExpando, sizeExpando))
  1313. {
  1314. CXTPEmptyRect rcButton;
  1315. rcButton.left = m_ptMargin.x + 3;
  1316. rcButton.right = rcButton.left + sizeExpando.cx;
  1318. // vertically center.
  1319. rcButton.top = m_rcCommandButtons.top + (m_rcCommandButtons.Height()-sizeExpando.cy)/2;
  1321. CXTPEmptySize sizeVerify;
  1322. if (IsWindow(m_pBtnVerify) && m_mapWndSize.Lookup(m_pBtnVerify, sizeVerify))
  1323. {
  1324. rcButton.top = m_rcCommandButtons.top + m_ptMargin.y;
  1325. }
  1327. rcButton.bottom = rcButton.top + sizeExpando.cy;
  1328. MoveButton(m_pBtnExpando, rcButton);
  1329. }
  1330. }
  1332. void CXTPTaskDialogClient::SetLinkCtrlPos()
  1333. {
  1334. if (IsHyperlinksEnabled())
  1335. {
  1336. if (m_wndContent) m_wndContent.MoveWindow(m_rcContent);
  1337. if (m_wndExpandedInformation) m_wndExpandedInformation.MoveWindow(m_rcExpandedInformation);
  1338. if (m_wndFooter) m_wndFooter.MoveWindow(m_rcFooter);
  1340. if (m_wndExpandedInformation) m_wndExpandedInformation.ShowWindow(m_bExpanded ? SW_SHOWNOACTIVATE : SW_HIDE);
  1341. }
  1342. }
  1344. //---------------------------------------------------------------------------
  1345. // Layout
  1346. //---------------------------------------------------------------------------
  1348. int CXTPTaskDialogClient::CalcIdealTextWidth(const CStringMarkup& strItemText, int nMinWidth, BOOL bLargeFont)
  1349. {
  1350. if (strItemText.IsEmpty())
  1351. return nMinWidth;
  1353. CSize sizeText(nMinWidth, 0);
  1355. if (strItemText.m_pUIElement)
  1356. {
  1357. if (XTPCalcIdealTextSize(m_pMarkupContext, strItemText.m_pUIElement, sizeText,
  1358. bLargeFont? m_fontLarge: m_font,
  1359. bLargeFont? 275: 330,
  1360. bLargeFont? 14: 7))
  1361. {
  1362. nMinWidth = max(nMinWidth, sizeText.cx);
  1363. }
  1364. }
  1365. else
  1366. {
  1367. if (XTPCalcIdealTextSize(strItemText, sizeText,
  1368. bLargeFont? m_fontLarge: m_font,
  1369. bLargeFont? 275: 330,
  1370. bLargeFont? 14: 7))
  1371. {
  1372. nMinWidth = max(nMinWidth, sizeText.cx);
  1373. }
  1374. }
  1375. return nMinWidth;
  1376. }
  1377. CRect CXTPTaskDialogClient::CalcTextRect(const CStringMarkup& strItemText, int nWidth, BOOL bLargeFont)
  1378. {
  1379. CRect rcItemText(0, 0, 0, 0);
  1381. if (strItemText.m_pUIElement)
  1382. {
  1383. XTPMarkupSetDefaultFont(m_pMarkupContext, bLargeFont? m_fontLarge: m_font, COLORREF_NULL);
  1385. CSize sizeText = XTPMarkupMeasureElement(strItemText.m_pUIElement, nWidth, INT_MAX);
  1386. rcItemText.SetRect(0, 0, nWidth, sizeText.cy);
  1387. }
  1388. else
  1389. {
  1390. CSize sizeText(nWidth, 0);
  1391. if (XTPCalcTextSize(strItemText, sizeText, bLargeFont? m_fontLarge: m_font))
  1392. {
  1393. rcItemText.SetRect(0, 0, nWidth, sizeText.cy);
  1394. }
  1395. }
  1397. return rcItemText;
  1398. }
  1400. CRect CXTPTaskDialogClient::CalcCommandRect(int nWidth)
  1401. {
  1402. CRect rcCommand(0, 0, nWidth, 0);
  1404. if (m_pBtnExpando == 0 && m_pBtnVerify == 0 && m_arrCommandButtons.GetSize() == 0)
  1405. return rcCommand;
  1407. int nMinHeight = 0;
  1408. int nLeftMargin = 0;
  1410. CXTPEmptySize sizeButton;
  1411. if (m_pBtnVerify && m_mapWndSize.Lookup(m_pBtnVerify, sizeButton))
  1412. {
  1413. nMinHeight = sizeButton.cy;
  1414. nLeftMargin = sizeButton.cx;
  1415. }
  1417. if (m_pBtnExpando && m_mapWndSize.Lookup(m_pBtnExpando, sizeButton))
  1418. {
  1419. nMinHeight += sizeButton.cy;
  1420. nLeftMargin = max(nLeftMargin, sizeButton.cx);
  1421. }
  1423. if (nLeftMargin)
  1424. nWidth -= nLeftMargin + m_ptBtnSpacing.x;
  1426. int i, nCount = (int)m_arrCommandButtons.GetSize();
  1427. int x = 0;
  1428. int nMaxWidth = 0;
  1430. for (i = 0; i < nCount; i++)
  1431. {
  1432. CButton* pButton = m_arrCommandButtons[i];
  1434. if (m_mapWndSize.Lookup(pButton, sizeButton))
  1435. {
  1436. // no more room, adjust height.
  1437. if (x != 0 && x + sizeButton.cx > nWidth)
  1438. {
  1439. nMaxWidth = max(nMaxWidth, x - m_ptBtnSpacing.x);
  1440. x = 0;
  1441. rcCommand.bottom += m_ptBtnSpacing.y;
  1442. }
  1444. // first button in row, adjust height.
  1445. if (x == 0)
  1446. rcCommand.bottom += sizeButton.cy;
  1448. x += sizeButton.cx + m_ptBtnSpacing.x;
  1449. }
  1450. }
  1451. nMaxWidth = max(nMaxWidth, x - m_ptBtnSpacing.x);
  1453. rcCommand.left = nWidth - nMaxWidth;
  1454. if (nLeftMargin)
  1455. rcCommand.left += nLeftMargin + m_ptBtnSpacing.x;
  1457. if (nMinHeight > rcCommand.Height())
  1458. rcCommand.bottom = rcCommand.top + nMinHeight;
  1460. rcCommand.bottom += m_ptMargin.y * 2 - 2;
  1462. return rcCommand;
  1463. }
  1465. int CXTPTaskDialogClient::CalcClientWidth()
  1466. {
  1467. int nIdealWidth = m_nMinClientWidth;
  1469. if (HasFixedWidth())
  1470. {
  1471. CSize sizeBase = ::GetDialogBaseUnits();
  1472. int cxWidth = ::MulDiv(m_pConfig->cxWidth, sizeBase.cx, 4);
  1474. nIdealWidth = max(cxWidth - m_ptMargin.x * 2, nIdealWidth);
  1475. return nIdealWidth;
  1476. }
  1478. int nCommandButtonWidth = -m_ptBtnSpacing.x + m_ptMargin.x * 2, nCount, i;
  1480. nCount = (int)m_arrCommandButtons.GetSize();
  1481. for (i = 0; i < nCount; ++i)
  1482. {
  1483. CSize size;
  1484. if (m_mapWndSize.Lookup(m_arrCommandButtons[i], size))
  1485. nCommandButtonWidth += size.cx + m_ptBtnSpacing.x;
  1486. }
  1488. if (!HasLinkButtons())
  1489. {
  1490. nIdealWidth = max(nIdealWidth, nCommandButtonWidth);
  1491. }
  1493. if (m_pBtnVerify->GetSafeHwnd())
  1494. {
  1495. CSize size;
  1496. if (m_mapWndSize.Lookup(m_pBtnVerify, size))
  1497. {
  1498. nIdealWidth = max(nIdealWidth, size.cx + nCommandButtonWidth + m_ptMargin.x);
  1499. }
  1500. }
  1502. if (m_pBtnExpando->GetSafeHwnd())
  1503. {
  1504. CSize size;
  1505. if (m_mapWndSize.Lookup(m_pBtnExpando , size))
  1506. {
  1507. nIdealWidth = max(nIdealWidth, size.cx + nCommandButtonWidth + m_ptMargin.x);
  1508. }
  1509. }
  1511. int nMainIconMargin = (m_hIconMain ? (m_sizeIconMain.cx + m_ptMargin.x): 0);
  1512. int nFooterIconMargin = (m_hIconFooter ? (m_sizeIconFooter.cx + m_ptMargin.x): 0);
  1513. int nExpanIconMargin = IsExpandFooterArea() ? nFooterIconMargin : nMainIconMargin;
  1515. nCount = (int)m_arrRadioButtons.GetSize();
  1516. for (i = 0; i < nCount; ++i)
  1517. {
  1518. CSize size;
  1519. if (m_mapWndSize.Lookup(m_arrRadioButtons[i], size))
  1520. nIdealWidth = max(nIdealWidth, size.cx + nMainIconMargin);
  1521. }
  1525. CXTPEmptySize size;
  1526. if (m_mapWndSize.Lookup(m_pBtnVerify, size))
  1527. nIdealWidth = max(nIdealWidth, size.cx);
  1529. if (m_mapWndSize.Lookup(m_pBtnExpando, size))
  1530. nIdealWidth = max(nIdealWidth, size.cx);
  1533. int nWidth = CalcIdealTextWidth(m_strMainInstruction, nIdealWidth - nMainIconMargin, TRUE);
  1534. nIdealWidth = max(nIdealWidth, nWidth + nMainIconMargin);
  1536. nWidth = CalcIdealTextWidth(m_strContent, nIdealWidth - nMainIconMargin, FALSE);
  1537. nIdealWidth = max(nIdealWidth, nWidth + nMainIconMargin);
  1539. if (HasLinkButtons())
  1540. {
  1541. for (i = 0; i < (int)m_pConfig->cButtons; ++i)
  1542. {
  1543. CString strButton = LoadItemString(m_pConfig->pButtons[i].pszButtonText);
  1545. nWidth = CalcLinkButtonIdealWidth(strButton, nIdealWidth - nMainIconMargin);
  1546. nIdealWidth = max(nIdealWidth, nWidth + nMainIconMargin);
  1547. }
  1548. }
  1551. nWidth = CalcIdealTextWidth(m_strExpandedInformation, nIdealWidth - nExpanIconMargin, FALSE);
  1552. nIdealWidth = max(nIdealWidth, nWidth + nExpanIconMargin);
  1554. nWidth = CalcIdealTextWidth(m_strFooter, nIdealWidth - nFooterIconMargin, FALSE);
  1555. nIdealWidth = max(nIdealWidth, nWidth + nFooterIconMargin);
  1557. nIdealWidth = min(nIdealWidth, m_nMaxClientWidth);
  1559. return nIdealWidth;
  1560. }
  1563. CSize CXTPTaskDialogClient::CalcDynamicLayout(int nIdealWidth)
  1564. {
  1565. int nMainIconMargin = m_hIconMain ? (m_sizeIconMain.cx + m_ptMargin.x) : 0;
  1566. int nFooterIconMargin = m_hIconFooter ? (m_sizeIconFooter.cx + m_ptMargin.x) : 0;
  1568. m_rcMainInstruction = CalcTextRect(m_strMainInstruction, nIdealWidth - nMainIconMargin, TRUE);
  1569. if (!m_rcMainInstruction.IsRectEmpty())
  1570. m_rcMainInstruction.OffsetRect(m_ptMargin.x + nMainIconMargin, m_ptMargin.y);
  1572. m_rcContent = CalcTextRect(m_strContent, nIdealWidth - nMainIconMargin, FALSE);
  1573. m_rcContent.OffsetRect(m_ptMargin.x + nMainIconMargin,
  1574. m_rcMainInstruction.bottom + m_ptMargin.y + 1);
  1576. int nLinkTop = m_rcContent.bottom + m_ptPadding.y;
  1578. if (nLinkTop < m_ptMargin.y * 4 - 3)
  1579. nLinkTop = m_ptMargin.y * 4 - 3;
  1581. if (!IsExpandFooterArea())
  1582. {
  1583. if (!m_strExpandedInformation.IsEmpty())
  1584. {
  1585. if (m_bExpanded)
  1586. {
  1587. m_rcExpandedInformation = CalcTextRect(m_strExpandedInformation, nIdealWidth - nMainIconMargin, FALSE);
  1588. m_rcExpandedInformation.OffsetRect(m_ptMargin.x + nMainIconMargin, nLinkTop + m_ptPadding.y);
  1589. }
  1590. else
  1591. {
  1592. m_rcExpandedInformation.SetRect(m_rcContent.left, nLinkTop, m_rcContent.right, nLinkTop + m_ptPadding.y);
  1593. }
  1595. nLinkTop += m_rcExpandedInformation.Height() + m_ptPadding.y;
  1596. }
  1597. else
  1598. {
  1599. m_rcExpandedInformation.SetRect(m_rcContent.left, nLinkTop, m_rcContent.right, nLinkTop);
  1600. }
  1601. }
  1603. if (m_wndProgressBar.GetSafeHwnd())
  1604. {
  1605. CRect rcProgressBar(m_rcContent.left, nLinkTop + m_ptMargin.y, nIdealWidth + m_ptMargin.x, nLinkTop + m_ptMargin.y * 5/2);
  1606. m_wndProgressBar.MoveWindow(rcProgressBar);
  1608. nLinkTop += rcProgressBar.Height() + m_ptMargin.y;
  1609. }
  1611. if (m_arrRadioButtons.GetSize() > 0)
  1612. {
  1613. nLinkTop +=  m_ptMargin.y;
  1614. m_rcRadioButtons = CRect(m_rcContent.left + m_ptMargin.x, nLinkTop, nIdealWidth, nLinkTop);
  1616. for (int i = 0; i < m_arrRadioButtons.GetSize(); i++)
  1617. {
  1618. CButton* pButton = m_arrRadioButtons[i];
  1620. CSize sizeButton;
  1621. if (m_mapWndSize.Lookup(pButton, sizeButton))
  1622. {
  1623. pButton->MoveWindow(m_rcRadioButtons.left, nLinkTop, sizeButton.cx, sizeButton.cy);
  1625. nLinkTop += sizeButton.cy + 3;
  1626. }
  1627. }
  1628. m_rcRadioButtons.bottom = nLinkTop;
  1629. }
  1630. else
  1631. {
  1632. m_rcRadioButtons = CRect(m_rcContent.left + 1, nLinkTop, m_rcContent.right, nLinkTop);
  1633. }
  1635. m_rcLinkButtons = CRect(m_rcContent.left + 1, nLinkTop + 1, m_ptMargin.y + nIdealWidth - 1, nLinkTop + 1);
  1637. for (int i = 0; i < (int)m_arrLinkButtons.GetSize(); ++i)
  1638. {
  1639. CString strButton = LoadItemString(m_pConfig->pButtons[i].pszButtonText);
  1640. CButton* pButton = m_arrLinkButtons[i];
  1642. CSize sizeButton = CalcLinkButtonSize(strButton, m_rcLinkButtons.Width());
  1643. sizeButton.cx = m_rcLinkButtons.Width();
  1645. m_mapWndSize[pButton] = sizeButton;
  1647. m_rcLinkButtons.bottom += sizeButton.cy;
  1648. }
  1649. if (m_arrLinkButtons.GetSize() > 0) m_rcLinkButtons.bottom += m_ptMargin.y;
  1651. m_rcCommandButtons = CalcCommandRect(nIdealWidth);
  1652. m_rcCommandButtons.OffsetRect(m_ptMargin.x, m_rcLinkButtons.bottom  + m_ptMargin.y + m_ptPadding.y);
  1654. int nBottom = m_rcCommandButtons.bottom;
  1655. if (!m_strFooter.IsEmpty())
  1656. {
  1657. m_rcFooter = CalcTextRect(m_strFooter, nIdealWidth - nFooterIconMargin, FALSE);
  1658. m_rcFooter.OffsetRect(m_ptMargin.x + nFooterIconMargin - 1, nBottom + m_ptMargin.y + 1);
  1660. nBottom += m_rcFooter.Height() + 2 * m_ptMargin.y + 1;
  1661. }
  1663. if (IsExpandFooterArea())
  1664. {
  1665. if (!m_strExpandedInformation.IsEmpty() && m_bExpanded)
  1666. {
  1667. m_rcExpandedInformation = CalcTextRect(m_strExpandedInformation, nIdealWidth, FALSE);
  1668. m_rcExpandedInformation.OffsetRect(m_ptMargin.x, nBottom + m_ptMargin.y);
  1669. nBottom += m_rcExpandedInformation.Height() + 2 * m_ptMargin.y;
  1670. }
  1671. else
  1672. {
  1673. m_rcExpandedInformation.SetRect(m_rcFooter.left, nBottom, m_rcFooter.right, nBottom);
  1674. }
  1676. }
  1678. return CSize(nIdealWidth + m_ptMargin.x * 2, nBottom);
  1679. }
  1681. void CXTPTaskDialogClient::RecalcLayout(BOOL bMoveWindow)
  1682. {
  1683. UpdateZOrder();
  1685. CSize szClient = CalcDynamicLayout(CalcClientWidth());
  1687. SetCommandButtonPos();
  1688. SetLinkButtonPos();
  1689. SetVerifyButtonPos();
  1690. SetExpandoButtonPos();
  1691. SetLinkCtrlPos();
  1693. m_strContent.SetFinalRect(m_rcContent);
  1694. m_strMainInstruction.SetFinalRect(m_rcMainInstruction);
  1695. m_strExpandedInformation.SetFinalRect(m_rcExpandedInformation);
  1696. m_strFooter.SetFinalRect(m_rcFooter);
  1698. ResizeParentToFit(szClient, bMoveWindow);
  1699. RedrawWindow(0, 0, RDW_ALLCHILDREN | RDW_INVALIDATE);
  1700. }
  1702. BOOL CXTPTaskDialogClient::ResizeParentToFit(CSize szClient, BOOL bMoveWindow)
  1703. {
  1704. CXTPWindowRect rc(this);
  1706. CRect rcParent = IsPositionRelativeToWindow()?
  1707. CXTPWindowRect(m_pConfig->hwndParent): XTPMultiMonitor()->GetWorkArea(m_pConfig->hwndParent);
  1709. CPoint ptPos((rcParent.left + rcParent.right - szClient.cx) / 2 - 3,
  1710. (rcParent.top + rcParent.bottom - szClient.cy) / 2 - 12);
  1712. CRect rcWindow(ptPos, szClient);
  1714. AdjustWindowRectEx(rcWindow, GetStyle(), FALSE, GetExStyle());
  1715. //rcWindow.InflateRect(m_ptMargin.x, m_ptMargin.y);
  1717. if (bMoveWindow)
  1718. MoveWindow(rcWindow);
  1719. else
  1720. SetWindowPos(0, 0, 0, rcWindow.Width(), rcWindow.Height(), SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
  1721. return TRUE;
  1722. }
  1724. //---------------------------------------------------------------------------
  1725. // Rendering
  1726. //---------------------------------------------------------------------------
  1728. void CXTPTaskDialogClient::DrawBackground(CDC* pDC, CRect rect)
  1729. {
  1730. pDC->FillSolidRect(&rect, m_crFooter);
  1732. if (m_bThemeReady)
  1733. {
  1734. pDC->FillSolidRect(rect.left, rect.top, rect.Width(), m_rcCommandButtons.top, m_crContext);
  1736. if (m_rcCommandButtons.top != m_rcCommandButtons.bottom)
  1737. {
  1738. pDC->FillSolidRect(rect.left, m_rcCommandButtons.top,  rect.Width(), 1, m_cr3DLight);
  1739. }
  1741. if (!m_rcFooter.IsRectEmpty())
  1742. {
  1743. pDC->FillSolidRect(rect.left, m_rcCommandButtons.bottom,  rect.Width(), 1, m_cr3DLight);
  1744. pDC->FillSolidRect(rect.left, m_rcCommandButtons.bottom + 1,  rect.Width(), 1, m_cr3DHighLight);
  1745. }
  1747. if (m_bExpanded && !m_strExpandedInformation.IsEmpty() && IsExpandFooterArea() && !m_rcExpandedInformation.IsRectEmpty())
  1748. {
  1749. pDC->FillSolidRect(rect.left, m_rcExpandedInformation.top - m_ptMargin.y,  rect.Width(), 1, m_cr3DLight);
  1750. pDC->FillSolidRect(rect.left, m_rcExpandedInformation.top - m_ptMargin.y + 1,  rect.Width(), 1, m_cr3DHighLight);
  1751. }
  1752. }
  1753. else
  1754. {
  1755. if (!m_rcFooter.IsRectEmpty())
  1756. {
  1757. pDC->FillSolidRect(rect.left, m_rcCommandButtons.bottom + 1, rect.Width(), 1, m_cr3DShadow);
  1758. }
  1759. if (m_bExpanded && !m_strExpandedInformation.IsEmpty() && IsExpandFooterArea() && !m_rcExpandedInformation.IsRectEmpty())
  1760. {
  1761. pDC->FillSolidRect(rect.left, m_rcExpandedInformation.top - m_ptMargin.y,  rect.Width(), 1, m_cr3DShadow);
  1762. }
  1763. }
  1764. }
  1766. void CXTPTaskDialogClient::DrawIcon(CDC* pDC, HICON hIcon, CPoint pt, CSize sz)
  1767. {
  1768. DWORD dwLayout = XTPDrawHelpers()->IsContextRTL(pDC);
  1769. if (dwLayout & LAYOUT_RTL)
  1770. XTPDrawHelpers()->SetContextRTL(pDC, dwLayout | LAYOUT_BITMAPORIENTATIONPRESERVED);
  1772. ::DrawIconEx(*pDC, pt.x, pt.y, hIcon, sz.cx, sz.cy, 0, NULL, DI_NORMAL);
  1774. if (dwLayout & LAYOUT_RTL)
  1775. XTPDrawHelpers()->SetContextRTL(pDC, dwLayout);
  1777. }
  1779. void CXTPTaskDialogClient::DrawText(CDC* pDC, const CStringMarkup& strItemText, CRect rcItem, COLORREF clrText, CFont* pFont)
  1780. {
  1781. if (!rcItem.IsRectEmpty() && !strItemText.IsEmpty())
  1782. {
  1783. if (strItemText.m_pUIElement)
  1784. {
  1785. XTPMarkupSetDefaultFont(m_pMarkupContext, (HFONT)pFont->GetSafeHandle(), clrText);
  1786. XTPMarkupRenderElement(strItemText.m_pUIElement, pDC->GetSafeHdc(), strItemText.m_rcFinalRect);
  1787. }
  1788. else
  1789. {
  1790. pDC->SetTextColor(clrText);
  1792. CXTPFontDC fontDC(pDC, pFont);
  1793. pDC->DrawText(strItemText, rcItem, DT_LEFT | DT_NOPREFIX | DT_WORDBREAK | DT_TOP);
  1794. }
  1795. }
  1796. }
  1798. void CXTPTaskDialogClient::DrawMainInstruction(CDC* pDC)
  1799. {
  1800. if (m_hIconMain)
  1801. {
  1802. DrawIcon(pDC, m_hIconMain, m_ptMargin, m_sizeIconMain);
  1803. }
  1805. DrawText(pDC, m_strMainInstruction, m_rcMainInstruction, m_crMainText, &m_fontLarge);
  1806. }
  1808. void CXTPTaskDialogClient::DrawContent(CDC* pDC)
  1809. {
  1810. if (m_rcContent.IsRectEmpty())
  1811. return;
  1813. if (!::IsWindow(m_wndContent.m_hWnd))
  1814. {
  1815. DrawText(pDC, m_strContent, m_rcContent, m_crContextText, &m_font);
  1816. }
  1817. }
  1819. void CXTPTaskDialogClient::DrawExpandedInfo(CDC* pDC)
  1820. {
  1821. if (m_rcExpandedInformation.IsRectEmpty() || m_strExpandedInformation.IsEmpty() || !m_bExpanded)
  1822. return;
  1824. if (!::IsWindow(m_wndExpandedInformation.m_hWnd))
  1825. {
  1826. DrawText(pDC, m_strExpandedInformation, m_rcExpandedInformation, IsExpandFooterArea() ? m_crFooterText : m_crContextText, &m_font);
  1827. }
  1828. }
  1830. void CXTPTaskDialogClient::DrawFootNote(CDC* pDC)
  1831. {
  1832. if (m_rcFooter.IsRectEmpty())
  1833. return;
  1835. if (m_hIconFooter)
  1836. {
  1837. DrawIcon(pDC, m_hIconFooter, CPoint(m_ptMargin.x + 2, m_rcFooter.top), m_sizeIconFooter);
  1838. }
  1840. if (!::IsWindow(m_wndFooter.m_hWnd))
  1841. {
  1842. DrawText(pDC, m_strFooter, m_rcFooter, m_crFooterText, &m_font);
  1843. }
  1844. }
  1846. void CXTPTaskDialogClient::OnExpandExpandoClicked()
  1847. {
  1848. if (!m_pBtnExpando)
  1849. return;
  1851. CString strButtonText = m_bExpanded ? m_strExpandedControlText: m_strCollapsedControlText;
  1852. m_pBtnExpando->SetWindowText(strButtonText);
  1853. m_pBtnExpando->SetChecked(m_bExpanded);
  1855. RecalcLayout();
  1856. }