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

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

对话框与窗口

开发平台：

Visual C++

XTPPropertyPage.cpp：源码内容
  1. // XTPPropertyPage.cpp : implementation file
  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. /////////////////////////////////////////////////////////////////////////////
  22. #include "stdafx.h"
  24. #include "Common/XTPDrawHelpers.h"
  26. #include "XTGlobal.h"
  28. #include "XTPPropertyPage.h"
  29. #include "XTPPropertySheet.h"
  30. #include "XTPPropertyPageNavigator.h"
  32. #ifdef _DEBUG
  33. #define new DEBUG_NEW
  34. #undef THIS_FILE
  35. static char THIS_FILE[] = __FILE__;
  36. #endif
  38. #pragma warning(disable: 4355) // 'this' : used in base member initializer list
  40. /////////////////////////////////////////////////////////////////////////////
  41. // CXTPPropertyPage property page
  43. IMPLEMENT_DYNCREATE(CXTPPropertyPage, CPropertyPage)
  45. CXTPPropertyPage::CXTPPropertyPage()
  46. : CPropertyPage(), CXTResize(this, xtResizeNoClipChildren | xtResizeNoSizeIcon)
  47. {
  48. CommonConstruct();
  49. }
  50. CXTPPropertyPage::CXTPPropertyPage(UINT nIDTemplate, UINT nIDCaption)
  51. : CPropertyPage(nIDTemplate, nIDCaption), CXTResize(this, xtResizeNoClipChildren | xtResizeNoSizeIcon)
  52. {
  53. CommonConstruct();
  54. }
  55. CXTPPropertyPage::CXTPPropertyPage(LPCTSTR lpszTemplateName, UINT nIDCaption)
  56. : CPropertyPage(lpszTemplateName, nIDCaption), CXTResize(this, xtResizeNoClipChildren | xtResizeNoSizeIcon)
  57. {
  58. CommonConstruct();
  59. }
  61. void CXTPPropertyPage::CommonConstruct()
  62. {
  63. m_pSheet = 0;
  64. m_dwData = 0;
  65. m_bModified = FALSE;
  66. m_bInsideUpdate = FALSE;
  67. m_totalDev = CSize(0, 0);
  68. }
  71. CXTPPropertyPage::~CXTPPropertyPage()
  72. {
  73. }
  75. void CXTPPropertyPage::SetCaption(LPCTSTR lpszCaption)
  76. {
  77. m_strCaption = lpszCaption;
  78. m_psp.pszTitle = m_strCaption;
  79. m_psp.dwFlags |= PSP_USETITLE;
  80. }
  82. CString CXTPPropertyPage::GetCaption() const
  83. {
  84. CString strCaption;
  85. if (m_psp.dwFlags & PSP_USETITLE)
  86. {
  87. strCaption = m_psp.pszTitle;
  88. }
  89. else
  90. {
  91. GetWindowText(strCaption);
  92. }
  93. return strCaption;
  94. }
  96. void CXTPPropertyPage::DoDataExchange(CDataExchange* pDX)
  97. {
  98. CPropertyPage::DoDataExchange(pDX);
  99. //{{AFX_DATA_MAP(CXTPPropertyPage)
  100. // NOTE: the ClassWizard will add DDX and DDV calls here
  101. //}}AFX_DATA_MAP
  102. }
  103. struct DLGEXTEMPLATE
  104. {
  105. WORD dlgVer;
  106. WORD wSignature;
  107. DWORD helpID;
  108. DWORD exStyle;
  109. DWORD dwStyle;
  110. WORD cDlgItems;
  111. short x;
  112. short y;
  113. short cx;
  114. short cy;
  115. };
  118. BOOL CXTPPropertyPage::CreatePage(CWnd* pParentWnd)
  119. {
  120. if (GetSafeHwnd())
  121. return TRUE;
  123. HGLOBAL hTemplate = 0;
  124. HINSTANCE hInst = AfxGetInstanceHandle();
  126. if ((m_psp.dwFlags & PSP_DLGINDIRECT) && m_psp.pResource)
  127. {
  128. CDialogTemplate dlgTemp((LPCDLGTEMPLATE)m_psp.pResource);
  129. hTemplate = dlgTemp.Detach();
  130. }
  131. else
  132. {
  134. hInst = AfxFindResourceHandle(m_psp.pszTemplate, RT_DIALOG);
  135. if (!hInst)
  136. return FALSE;
  138. HRSRC hResource = ::FindResource(hInst, m_psp.pszTemplate, RT_DIALOG);
  139. if (!hResource)
  140. return FALSE;
  142. hTemplate = LoadResource(hInst, hResource);
  143. if (!hTemplate)
  144. return FALSE;
  146. DLGTEMPLATE* pTemplate = (DLGTEMPLATE*)LockResource(hTemplate);
  148. CDialogTemplate dlgTemp(pTemplate);
  150. UnlockResource(hTemplate);
  151. FreeResource(hTemplate);
  153. hTemplate = dlgTemp.Detach();
  154. }
  156. if (!hTemplate)
  157. return FALSE;
  159. DLGTEMPLATE* lpDialogTemplate = (DLGTEMPLATE*)GlobalLock(hTemplate);
  160. if (!lpDialogTemplate)
  161. return FALSE;
  163. DLGEXTEMPLATE* lpDialogExTemplate = (DLGEXTEMPLATE*)lpDialogTemplate;
  165. DWORD lSaveStyle;
  166. if (lpDialogExTemplate->wSignature == 0xFFFF)
  167. lSaveStyle = lpDialogExTemplate->dwStyle;
  168. else
  169. lSaveStyle = lpDialogTemplate->style;
  171. DWORD dwNewStyle = (lSaveStyle & (DS_LOCALEDIT | WS_CLIPCHILDREN | DS_SETFONT | DS_FIXEDSYS))
  172. | WS_CHILD | WS_TABSTOP | DS_3DLOOK | DS_CONTROL;
  174. if (lpDialogExTemplate->wSignature == 0xFFFF)
  175. lpDialogExTemplate->dwStyle = dwNewStyle;
  176. else
  177. lpDialogTemplate->style = dwNewStyle;
  179. BOOL bResult = CreateDlgIndirect(lpDialogTemplate, pParentWnd, hInst);
  181. GlobalUnlock(hTemplate);
  182. GlobalFree(hTemplate);
  184. m_totalDev = m_hWnd ? CXTPWindowRect(this).Size() : CSize(0, 0);
  185. m_lineDev = CXTPDrawHelpers::Dlu2Pix(5, 5);
  188. return bResult;
  189. }
  191. void CXTPPropertyPage::EndDialog(int nID)
  192. {
  193. // Normally you shouldn't call EndDialog from a page. But in case it does
  194. // happen during error situations, call CPropertySheet::EndDialog instead.
  196. CXTPPropertySheet* pParent = DYNAMIC_DOWNCAST(CXTPPropertySheet, GetParent());
  197. if (pParent != NULL)
  198. pParent->EndDialog(nID);
  199. }
  201. BEGIN_MESSAGE_MAP(CXTPPropertyPage, CPropertyPage)
  202. //{{AFX_MSG_MAP(CXTPPropertyPage)
  203. ON_WM_ERASEBKGND()
  204. ON_WM_CTLCOLOR()
  205. ON_WM_SIZE()
  206. ON_WM_HSCROLL()
  207. ON_WM_VSCROLL()
  208. ON_WM_MOUSEWHEEL()
  209. ON_WM_NCPAINT()
  210. ON_WM_NCCALCSIZE()
  211. //}}AFX_MSG_MAP
  212. END_MESSAGE_MAP()
  214. /////////////////////////////////////////////////////////////////////////////
  215. // CXTPPropertyPage message handlers
  217. BOOL CXTPPropertyPage::OnEraseBkgnd(CDC* pDC)
  218. {
  219. HBRUSH hBrush = m_pSheet->GetNavigator()->GetPageBrush(pDC, this);
  220. if (hBrush)
  221. {
  222. CXTPClientRect rc(this);
  223. ::FillRect(pDC->GetSafeHdc(), rc, hBrush);
  224. return TRUE;
  225. }
  227. return CPropertyPage::OnEraseBkgnd(pDC);
  228. }
  230. HBRUSH CXTPPropertyPage::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
  231. {
  232. if ((nCtlColor == CTLCOLOR_BTN || nCtlColor == CTLCOLOR_DLG ||
  233. nCtlColor == CTLCOLOR_STATIC ))
  234. {
  235. HBRUSH hBrush = m_pSheet->GetNavigator()->GetPageBrush(pDC, this);
  236. if (hBrush)
  237. {
  238. CXTPWindowRect rcPaint(pWnd);
  239. CXTPWindowRect rcBrush(m_hWnd);
  240. ::SetBrushOrgEx(pDC->GetSafeHdc(), rcBrush.left - rcPaint.left, rcBrush.top - rcPaint.top, NULL);
  242. ::SetBkMode(pDC->GetSafeHdc(), TRANSPARENT);
  243. ::SetTextColor(pDC->GetSafeHdc(), GetSysColor(COLOR_BTNTEXT));
  244. return hBrush;
  245. }
  246. }
  248. return CPropertyPage::OnCtlColor(pDC, pWnd, nCtlColor);
  249. }
  251. LRESULT CXTPPropertyPage::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
  252. {
  253. // TODO: Add your specialized code here and/or call the base class
  255. return CPropertyPage::WindowProc(message, wParam, lParam);
  256. }
  258. BOOL CXTPPropertyPage::OnInitDialog()
  259. {
  260. CPropertyPage::OnInitDialog();
  261. CXTResize::Init();
  263. return TRUE;
  264. }
  266. void CXTPPropertyPage::AjustResizeRect(CSize& szWindow)
  267. {
  268. CSize szMin = m_totalDev;
  269. szWindow.cx = max(szWindow.cx, szMin.cx);
  270. szWindow.cy = max(szWindow.cy, szMin.cy);
  271. }
  274. void CXTPPropertyPage::OnSize(UINT nType, int cx, int cy)
  275. {
  276. CPropertyPage::OnSize(nType, cx, cy);
  278. // UpdateBars() handles locking out recursion
  279. UpdateBars();
  281. CXTResize::Size();
  283. }
  286. void CXTPPropertyPage::GetScrollBarSizes(CSize& sizeSb)
  287. {
  288. sizeSb.cx = sizeSb.cy = 0;
  289. DWORD dwStyle = GetStyle();
  291. if (GetScrollBarCtrl(SB_VERT) == NULL)
  292. {
  293. // vert scrollbars will impact client area of this window
  294. sizeSb.cx = GetSystemMetrics(SM_CXVSCROLL);
  295. if (dwStyle & WS_BORDER)
  296. sizeSb.cx -= CX_BORDER;
  297. }
  298. if (GetScrollBarCtrl(SB_HORZ) == NULL)
  299. {
  300. // horz scrollbars will impact client area of this window
  301. sizeSb.cy = GetSystemMetrics(SM_CYHSCROLL);
  302. if (dwStyle & WS_BORDER)
  303. sizeSb.cy -= CY_BORDER;
  304. }
  305. }
  307. BOOL CXTPPropertyPage::GetTrueClientSize(CSize& size, CSize& sizeSb)
  308. // return TRUE if enough room to add scrollbars if needed
  309. {
  310. CRect rect;
  311. GetClientRect(&rect);
  312. ASSERT(rect.top == 0 && rect.left == 0);
  313. size.cx = rect.right;
  314. size.cy = rect.bottom;
  315. DWORD dwStyle = GetStyle();
  317. // first get the size of the scrollbars for this window
  318. GetScrollBarSizes(sizeSb);
  320. // first calculate the size of a potential scrollbar
  321. // (scroll bar controls do not get turned on/off)
  322. if (sizeSb.cx != 0 && (dwStyle & WS_VSCROLL))
  323. {
  324. // vert scrollbars will impact client area of this window
  325. size.cx += sizeSb.cx;   // currently on - adjust now
  326. }
  327. if (sizeSb.cy != 0 && (dwStyle & WS_HSCROLL))
  328. {
  329. // horz scrollbars will impact client area of this window
  330. size.cy += sizeSb.cy;   // currently on - adjust now
  331. }
  333. // return TRUE if enough room
  334. return (size.cx > sizeSb.cx && size.cy > sizeSb.cy);
  335. }
  337. CPoint CXTPPropertyPage::GetDeviceScrollPosition() const
  338. {
  339. CPoint pt(GetScrollPos(SB_HORZ), GetScrollPos(SB_VERT));
  340. ASSERT(pt.x >= 0 && pt.y >= 0);
  342. return pt;
  343. }
  345. // helper to return the state of the scrollbars without actually changing
  346. //  the state of the scrollbars
  347. void CXTPPropertyPage::GetScrollBarState(CSize sizeClient, CSize& needSb,
  348. CSize& sizeRange, CPoint& ptMove, BOOL bInsideClient)
  349. {
  350. // get scroll bar sizes (the part that is in the client area)
  351. CSize sizeSb;
  352. GetScrollBarSizes(sizeSb);
  354. // enough room to add scrollbars
  355. sizeRange = m_totalDev - sizeClient;
  356. // > 0 => need to scroll
  357. ptMove = GetDeviceScrollPosition();
  358. // point to move to (start at current scroll pos)
  360. BOOL bNeedH = sizeRange.cx > 0;
  361. if (!bNeedH)
  362. ptMove.x = 0;                       // jump back to origin
  363. else if (bInsideClient)
  364. sizeRange.cy += sizeSb.cy;          // need room for a scroll bar
  366. BOOL bNeedV = sizeRange.cy > 0;
  367. if (!bNeedV)
  368. ptMove.y = 0;                       // jump back to origin
  369. else if (bInsideClient)
  370. sizeRange.cx += sizeSb.cx;          // need room for a scroll bar
  372. if (bNeedV && !bNeedH && sizeRange.cx > 0)
  373. {
  374. ASSERT(bInsideClient);
  375. // need a horizontal scrollbar after all
  376. bNeedH = TRUE;
  377. sizeRange.cy += sizeSb.cy;
  378. }
  380. // if current scroll position will be past the limit, scroll to limit
  381. if (sizeRange.cx > 0 && ptMove.x >= sizeRange.cx)
  382. ptMove.x = sizeRange.cx;
  383. if (sizeRange.cy > 0 && ptMove.y >= sizeRange.cy)
  384. ptMove.y = sizeRange.cy;
  386. // now update the bars as appropriate
  387. needSb.cx = bNeedH;
  388. needSb.cy = bNeedV;
  390. // needSb, sizeRange, and ptMove area now all updated
  391. }
  393. void CXTPPropertyPage::ScrollToDevicePosition(POINT ptDev)
  394. {
  395. ASSERT(ptDev.x >= 0);
  396. ASSERT(ptDev.y >= 0);
  398. // Note: ScrollToDevicePosition can and is used to scroll out-of-range
  399. //  areas as far as CXTPPropertyPage is concerned -- specifically in
  400. //  the print-preview code.  Since OnScrollBy makes sure the range is
  401. //  valid, ScrollToDevicePosition does not vector through OnScrollBy.
  403. int xOrig = GetScrollPos(SB_HORZ);
  404. SetScrollPos(SB_HORZ, ptDev.x);
  405. int yOrig = GetScrollPos(SB_VERT);
  406. SetScrollPos(SB_VERT, ptDev.y);
  407. ScrollPage(xOrig - ptDev.x, yOrig - ptDev.y);
  408. }
  410. void CXTPPropertyPage::ScrollPage(int xAmount, int yAmount)
  411. {
  412. if (xAmount == 0 && yAmount == 0)
  413. return;
  415. ScrollWindow(xAmount, yAmount);
  417. for (int i = 0; i < (int)m_arrItems.GetSize(); i++)
  418. {
  419. CXTResizeRect& rrcWindow = m_arrItems[i]->m_rrcWindow;
  420. rrcWindow.left += xAmount;
  421. rrcWindow.right += xAmount;
  422. rrcWindow.top += yAmount;
  423. rrcWindow.bottom += yAmount;
  424. }
  425. }
  427. void CXTPPropertyPage::UpdateBars()
  428. {
  429. if (m_totalDev == CSize(0, 0))
  430. return;
  432. // UpdateBars may cause window to be resized - ignore those resizings
  433. if (m_bInsideUpdate)
  434. return;         // Do not allow recursive calls
  436. // Lock out recursion
  437. m_bInsideUpdate = TRUE;
  439. // update the horizontal to reflect reality
  440. // NOTE: turning on/off the scrollbars will cause 'OnSize' callbacks
  441. ASSERT(m_totalDev.cx >= 0 && m_totalDev.cy >= 0);
  443. CRect rectClient;
  444. BOOL bCalcClient = TRUE;
  446. CSize sizeClient;
  447. CSize sizeSb;
  449. // get client rect
  450. if (!GetTrueClientSize(sizeClient, sizeSb))
  451. {
  452. // no room for scroll bars (common for zero sized elements)
  453. CRect rect;
  454. GetClientRect(&rect);
  455. if (rect.right > 0 && rect.bottom > 0)
  456. {
  457. // if entire client area is not invisible, assume we have
  458. //  control over our scrollbars
  459. EnableScrollBarCtrl(SB_BOTH, FALSE);
  460. }
  461. m_bInsideUpdate = FALSE;
  462. return;
  463. }
  465. // enough room to add scrollbars
  466. CSize sizeRange;
  467. CPoint ptMove;
  468. CSize needSb;
  470. // get the current scroll bar state given the true client area
  471. GetScrollBarState(sizeClient, needSb, sizeRange, ptMove, bCalcClient);
  472. if (needSb.cx)
  473. sizeClient.cy -= sizeSb.cy;
  474. if (needSb.cy)
  475. sizeClient.cx -= sizeSb.cx;
  477. // first scroll the window as needed
  478. ScrollToDevicePosition(ptMove); // will set the scroll bar positions too
  480. // this structure needed to update the scrollbar page range
  481. SCROLLINFO info;
  482. info.fMask = SIF_PAGE|SIF_RANGE;
  483. info.nMin = 0;
  485. // now update the bars as appropriate
  486. EnableScrollBarCtrl(SB_HORZ, needSb.cx);
  487. if (needSb.cx)
  488. {
  489. info.nPage = sizeClient.cx;
  490. info.nMax = m_totalDev.cx-1;
  491. if (!SetScrollInfo(SB_HORZ, &info, TRUE))
  492. SetScrollRange(SB_HORZ, 0, sizeRange.cx, TRUE);
  493. }
  494. EnableScrollBarCtrl(SB_VERT, needSb.cy);
  495. if (needSb.cy)
  496. {
  497. info.nPage = sizeClient.cy;
  498. info.nMax = m_totalDev.cy-1;
  499. if (!SetScrollInfo(SB_VERT, &info, TRUE))
  500. SetScrollRange(SB_VERT, 0, sizeRange.cy, TRUE);
  501. }
  503. // remove recursion lockout
  504. m_bInsideUpdate = FALSE;
  505. }
  506. void CXTPPropertyPage::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
  507. {
  508. if (pScrollBar != NULL && pScrollBar->SendChildNotifyLastMsg())
  509. return;     // eat it
  511. // ignore scroll bar msgs from other controls
  512. if (pScrollBar != GetScrollBarCtrl(SB_HORZ))
  513. return;
  515. OnScroll(MAKEWORD(nSBCode, -1), nPos);
  516. }
  518. void CXTPPropertyPage::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
  519. {
  520. if (pScrollBar != NULL && pScrollBar->SendChildNotifyLastMsg())
  521. return;     // eat it
  523. // ignore scroll bar msgs from other controls
  524. if (pScrollBar != GetScrollBarCtrl(SB_VERT))
  525. return;
  527. OnScroll(MAKEWORD(-1, nSBCode), nPos);
  528. }
  530. BOOL CXTPPropertyPage::OnMouseWheel(UINT fFlags, short zDelta, CPoint point)
  531. {
  532. // we don't handle anything but scrolling just now
  533. if (fFlags & (MK_SHIFT | MK_CONTROL))
  534. return FALSE;
  536. // we can't get out of it--perform the scroll ourselves
  537. return DoMouseWheel(fFlags, zDelta, point);
  538. }
  540. // This function isn't virtual. If you need to override it,
  541. // you really need to override OnMouseWheel() here or in
  542. // CSplitterWnd.
  544. BOOL CXTPPropertyPage::DoMouseWheel(UINT fFlags, short zDelta, CPoint point)
  545. {
  546. UNUSED_ALWAYS(point);
  547. UNUSED_ALWAYS(fFlags);
  549. // if we have a vertical scroll bar, the wheel scrolls that
  550. // if we have _only_ a horizontal scroll bar, the wheel scrolls that
  551. // otherwise, don't do any work at all
  553. DWORD dwStyle = GetStyle();
  554. CScrollBar* pBar = GetScrollBarCtrl(SB_VERT);
  555. BOOL bHasVertBar = ((pBar != NULL) && pBar->IsWindowEnabled()) ||
  556. (dwStyle & WS_VSCROLL);
  558. pBar = GetScrollBarCtrl(SB_HORZ);
  559. BOOL bHasHorzBar = ((pBar != NULL) && pBar->IsWindowEnabled()) ||
  560. (dwStyle & WS_HSCROLL);
  562. if (!bHasVertBar && !bHasHorzBar)
  563. return FALSE;
  565. BOOL bResult = FALSE;
  566. UINT uWheelScrollLines = 3;
  568. if (bHasVertBar)
  569. {
  570. bResult = OnScrollBy(CSize(0, (zDelta < 0 ? 1 : -1) * m_lineDev.cy * uWheelScrollLines), TRUE);
  571. }
  572. else if (bHasHorzBar)
  573. {
  574. bResult = OnScrollBy(CSize((zDelta < 0 ? 1 : -1) * m_lineDev.cy * uWheelScrollLines, 0), TRUE);
  575. }
  577. if (bResult)
  578. UpdateWindow();
  580. return bResult;
  581. }
  584. BOOL CXTPPropertyPage::OnScroll(UINT nScrollCode, UINT nPos, BOOL bDoScroll)
  585. {
  586. // calc new x position
  587. int x = GetScrollPos(SB_HORZ);
  588. int xOrig = x;
  590. switch (LOBYTE(nScrollCode))
  591. {
  592. case SB_TOP:
  593. x = 0;
  594. break;
  595. case SB_BOTTOM:
  596. x = INT_MAX;
  597. break;
  598. case SB_LINEUP:
  599. x -= m_lineDev.cx;
  600. break;
  601. case SB_LINEDOWN:
  602. x += m_lineDev.cx;
  603. break;
  604. case SB_PAGEUP:
  605. x -= CXTPClientRect(this).Width();
  606. break;
  607. case SB_PAGEDOWN:
  608. x += CXTPClientRect(this).Width();
  609. break;
  610. case SB_THUMBTRACK:
  611. x = nPos;
  612. break;
  613. }
  615. // calc new y position
  616. int y = GetScrollPos(SB_VERT);
  617. int yOrig = y;
  619. switch (HIBYTE(nScrollCode))
  620. {
  621. case SB_TOP:
  622. y = 0;
  623. break;
  624. case SB_BOTTOM:
  625. y = INT_MAX;
  626. break;
  627. case SB_LINEUP:
  628. y -= m_lineDev.cy;
  629. break;
  630. case SB_LINEDOWN:
  631. y += m_lineDev.cy;
  632. break;
  633. case SB_PAGEUP:
  634. y -= CXTPClientRect(this).Height();
  635. break;
  636. case SB_PAGEDOWN:
  637. y += CXTPClientRect(this).Height();
  638. break;
  639. case SB_THUMBTRACK:
  640. y = nPos;
  641. break;
  642. }
  644. BOOL bResult = OnScrollBy(CSize(x - xOrig, y - yOrig), bDoScroll);
  645. if (bResult && bDoScroll)
  646. UpdateWindow();
  648. return bResult;
  649. }
  651. BOOL CXTPPropertyPage::OnScrollBy(CSize sizeScroll, BOOL bDoScroll)
  652. {
  653. int xOrig, x;
  654. int yOrig, y;
  656. // don't scroll if there is no valid scroll range (ie. no scroll bar)
  657. CScrollBar* pBar;
  658. DWORD dwStyle = GetStyle();
  659. pBar = GetScrollBarCtrl(SB_VERT);
  660. if ((pBar != NULL && !pBar->IsWindowEnabled()) ||
  661. (pBar == NULL && !(dwStyle & WS_VSCROLL)))
  662. {
  663. // vertical scroll bar not enabled
  664. sizeScroll.cy = 0;
  665. }
  666. pBar = GetScrollBarCtrl(SB_HORZ);
  667. if ((pBar != NULL && !pBar->IsWindowEnabled()) ||
  668. (pBar == NULL && !(dwStyle & WS_HSCROLL)))
  669. {
  670. // horizontal scroll bar not enabled
  671. sizeScroll.cx = 0;
  672. }
  674. // adjust current x position
  675. xOrig = x = GetScrollPos(SB_HORZ);
  676. int xMax = GetScrollLimit(SB_HORZ);
  677. x += sizeScroll.cx;
  678. if (x < 0)
  679. x = 0;
  680. else if (x > xMax)
  681. x = xMax;
  683. // adjust current y position
  684. yOrig = y = GetScrollPos(SB_VERT);
  685. int yMax = GetScrollLimit(SB_VERT);
  686. y += sizeScroll.cy;
  687. if (y < 0)
  688. y = 0;
  689. else if (y > yMax)
  690. y = yMax;
  692. // did anything change?
  693. if (x == xOrig && y == yOrig)
  694. return FALSE;
  696. if (bDoScroll)
  697. {
  698. // do scroll and update scroll positions
  699. ScrollPage(-(x-xOrig), -(y-yOrig));
  700. if (x != xOrig)
  701. SetScrollPos(SB_HORZ, x);
  702. if (y != yOrig)
  703. SetScrollPos(SB_VERT, y);
  704. }
  705. return TRUE;
  706. }
  708. void CXTPPropertyPage::OnNcPaint()
  709. {
  710. Default();
  712. CWindowDC dc(this);
  713. CXTPWindowRect rcPage(this);
  714. rcPage.OffsetRect(-rcPage.TopLeft());
  716. if (m_pSheet->GetPageBorderStyle() == xtpPageBorderFrame)
  717. {
  718. BOOL bFrame = FALSE;
  719. CXTPWinThemeWrapper wrpTreeView;
  720. wrpTreeView.OpenTheme(0, L"LISTBOX");
  721. if (wrpTreeView.IsAppThemed())
  722. {
  723. COLORREF clr;
  724. if (SUCCEEDED(wrpTreeView.GetThemeColor(0, 0, TMT_BORDERCOLOR, &clr)))
  725. {
  726. dc.Draw3dRect(rcPage, clr, clr);
  727. rcPage.DeflateRect(1, 1);
  728. dc.Draw3dRect(rcPage, GetXtremeColor(COLOR_WINDOW), GetXtremeColor(COLOR_WINDOW));
  729. rcPage.DeflateRect(1, 1);
  730. bFrame = TRUE;
  731. }
  732. }
  733. if (!bFrame)
  734. {
  735. dc.DrawEdge(rcPage, EDGE_SUNKEN, BF_RECT);
  736. rcPage.DeflateRect(2, 2);
  737. }
  738. }
  739. else if (m_pSheet->GetPageBorderStyle() == xtpPageBorderBottomLine)
  740. {
  741. dc.FillSolidRect(rcPage.left, rcPage.bottom - 2, rcPage.Width(), 1, GetXtremeColor(COLOR_BTNSHADOW));
  742. dc.FillSolidRect(rcPage.left, rcPage.bottom - 1, rcPage.Width(), 1, GetXtremeColor(COLOR_BTNHIGHLIGHT));
  743. rcPage.DeflateRect(0, 0, 0, 2);
  744. }
  746. if ((GetStyle() & (WS_HSCROLL | WS_VSCROLL)) == (WS_HSCROLL | WS_VSCROLL))
  747. {
  748. CRect rcSizeIcon(rcPage.right - GetSystemMetrics(SM_CXVSCROLL),
  749. rcPage.bottom - GetSystemMetrics(SM_CYHSCROLL), rcPage.right, rcPage.bottom);
  751. HBRUSH hBrush = m_pSheet->GetNavigator()->GetPageBrush(&dc, this);
  752. if (hBrush)
  753. {
  754. CXTPClientRect rc(this);
  755. ::FillRect(dc, rcSizeIcon, hBrush);
  756. }
  757. else
  758. {
  759. dc.FillSolidRect(rcSizeIcon, GetXtremeColor(COLOR_3DFACE));
  760. }
  762. }
  763. }
  765. void CXTPPropertyPage::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS* lpncsp)
  766. {
  767. if (m_pSheet->GetPageBorderStyle() == xtpPageBorderFrame)
  768. {
  769. RECT& rc = lpncsp->rgrc[0];
  770. rc.left   += 2;
  771. rc.top    += 2;
  772. rc.right  -= 2;
  773. rc.bottom -= 2;
  774. }
  776. if (m_pSheet->GetPageBorderStyle() == xtpPageBorderBottomLine)
  777. {
  778. lpncsp->rgrc[0].bottom -= 2;
  779. }
  781. CWnd::OnNcCalcSize(bCalcValidRects, lpncsp);
  782. }
  784. void CXTPPropertyPage::OnChildSetFocus(HWND hWndFocus)
  785. {
  786. if ((GetStyle() & (WS_HSCROLL | WS_VSCROLL)) == 0)
  787. return;
  789. CWnd* pWnd = CWnd::FromHandle(hWndFocus);
  790. if (!pWnd)
  791. return;
  793. CRect rc;
  794. pWnd->GetWindowRect(rc);
  795. ScreenToClient(rc);
  797. CXTPClientRect rcClient(this);
  799. CSize szScroll(0, 0);
  801. if (rc.bottom > rcClient.bottom)
  802. szScroll.cy = rc.bottom - rcClient.bottom;
  803. if (rc.top - szScroll.cy < rcClient.top)
  804. szScroll.cy = rc.top - rcClient.top;
  806. if (rc.right > rcClient.right)
  807. szScroll.cx = rc.right - rcClient.right;
  808. if (rc.left - szScroll.cx < rcClient.left)
  809. szScroll.cx = rc.left - rcClient.left;
  811. if (szScroll != CSize(0, 0))
  812. {
  813. OnScrollBy(szScroll, TRUE);
  814. }
  815. }
  820. //////////////////////////////////////////////////////////////////////////
  821. // CXTPPropertyPageCaption
  823. CXTPPropertyPageStaticCaption::CXTPPropertyPageStaticCaption()
  824. {
  826. };
  828. BEGIN_MESSAGE_MAP(CXTPPropertyPageStaticCaption, CWnd)
  829. ON_WM_PAINT()
  830. ON_WM_ERASEBKGND()
  831. END_MESSAGE_MAP()
  833. BOOL CXTPPropertyPageStaticCaption::OnEraseBkgnd(CDC* /*pDC*/)
  834. {
  835. return TRUE;
  836. }
  838. void CXTPPropertyPageStaticCaption::OnPaint()
  839. {
  840. CPaintDC dcPaint(this);
  841. CXTPBufferDC dc(dcPaint);
  842. CXTPClientRect rc(this);
  844. dc.FillSolidRect(rc, RGB(221, 231, 238));
  845. dc.FillSolidRect(rc.left, rc.bottom - 1, rc.Width(), 1, RGB(197, 197, 197));
  846. rc.DeflateRect(7, 0);
  848. CString strText;
  849. GetWindowText(strText);
  851. dc.SetBkMode(TRANSPARENT);
  852. dc.SetTextColor(RGB(0, 21, 110));
  853. CXTPFontDC font(&dc, &XTAuxData().fontBold);
  854. dc.DrawText(strText, rc, DT_VCENTER | DT_SINGLELINE);
  855. }