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

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

对话框与窗口

开发平台：

Visual C++

XTSplitterWnd.cpp：源码内容
  1. // SplitterWndXT.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. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  23. #include "Common/XTPColorManager.h"
  24. #include "Common/XTPSystemHelpers.h"
  26. #include "XTGlobal.h"
  27. #include "XTSplitterWnd.h"
  28. #include "XTSplitterWndTheme.h"
  30. #ifdef _DEBUG
  31. #define new DEBUG_NEW
  32. #undef THIS_FILE
  33. static char THIS_FILE[] = __FILE__;
  34. #endif
  36. /////////////////////////////////////////////////////////////////////////////
  37. // Visual attributes and other constants
  39. // HitTest return values (values and spacing between values is important)
  40. enum HitTestValue
  41. {
  42. noHit = 0,
  43. vSplitterBox = 1,
  44. hSplitterBox = 2,
  45. bothSplitterBox = 3, // just for keyboard
  46. vSplitterBar1 = 101,
  47. vSplitterBar15 = 115,
  48. hSplitterBar1 = 201,
  49. hSplitterBar15 = 215,
  50. splitterIntersection1 = 301,
  51. splitterIntersection225 = 525
  52. };
  54. /////////////////////////////////////////////////////////////////////////////
  55. // CXTSplitterWnd
  57. IMPLEMENT_THEME_HOST(CXTSplitterWnd)
  58. IMPLEMENT_THEME_REFRESH(CXTSplitterWnd, CSplitterWnd)
  60. CXTSplitterWnd::CXTSplitterWnd()
  61. : CXTThemeManagerStyleHost(GetThemeFactoryClass())
  62. {
  63. m_nHiddenCol = -1;
  64. m_nHiddenRow = -1;
  65. m_point = CPoint(-1, -1);
  66. m_dwxStyle = XT_SPLIT_NOFULLDRAG;
  67. m_bFlatSplit = TRUE;
  68. m_cxSplitter = 6;
  69. m_cySplitter = 6;
  70. m_cxSplitterGap = 6;
  71. m_cySplitterGap = 6;
  73. // Get system settings for full drag.
  74. ::SystemParametersInfo(SPI_GETDRAGFULLWINDOWS,
  75. 0, &m_bFullDrag, 0);
  76. m_bForceFullDrag = FALSE;
  77. m_bClipStyles = FALSE;
  78. }
  80. CXTSplitterWnd::~CXTSplitterWnd()
  81. {
  82. }
  84. IMPLEMENT_DYNAMIC(CXTSplitterWnd, CSplitterWnd)
  86. BEGIN_MESSAGE_MAP(CXTSplitterWnd, CSplitterWnd)
  87. //{{AFX_MSG_MAP(CXTSplitterWnd)
  88. ON_WM_SETTINGCHANGE()
  89. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  90. ON_WM_MOUSEMOVE()
  91. ON_WM_NCHITTEST_EX()
  92. ON_WM_LBUTTONUP()
  93. //}}AFX_MSG_MAP
  94. END_MESSAGE_MAP()
  96. /////////////////////////////////////////////////////////////////////////////
  97. // CXTSplitterWnd message handlers
  99. LRESULT CXTSplitterWnd::OnPrintClient(WPARAM wParam, LPARAM /*lParam*/)
  100. {
  101. CDC* pDC = CDC::FromHandle((HDC)wParam);
  102. if (pDC)
  103. {
  104. CRect rectClient;
  105. GetClientRect(&rectClient);
  106. rectClient.InflateRect(-m_cxBorder, -m_cyBorder);
  108. CRect rectInside;
  109. GetInsideRect(rectInside);
  111. // draw the splitter boxes
  112. if (m_bHasVScroll && m_nRows < m_nMaxRows)
  113. {
  114. OnDrawSplitter(pDC, splitBox,
  115. CRect(rectInside.right, rectClient.top,
  116. rectClient.right, rectClient.top + m_cySplitter));
  117. }
  119. if (m_bHasHScroll && m_nCols < m_nMaxCols)
  120. {
  121. OnDrawSplitter(pDC, splitBox,
  122. CRect(rectClient.left, rectInside.bottom,
  123. rectClient.left + m_cxSplitter, rectClient.bottom));
  124. }
  126. // extend split bars to window border (past margins)
  127. DrawAllSplitBars(pDC, rectInside.right, rectInside.bottom);
  128. }
  130. return TRUE;
  131. }
  133. void CXTSplitterWnd::ShowColumn()
  134. {
  135. ASSERT_VALID(this);
  136. if (m_nCols == m_nMaxCols && m_nHiddenCol == -1)
  137. {
  138. return;
  139. }
  140. ASSERT(m_nHiddenCol != -1);
  142. int nShowCol = m_nHiddenCol;
  143. m_nHiddenCol = -1;
  145. int cxNew = m_pColInfo[m_nCols].nCurSize;
  146. m_nCols++;  // add a column
  148. ASSERT(m_nCols == m_nMaxCols);
  150. int nCol;
  152. // Show the hidden column
  153. int nRow;
  154. for (nRow = 0; nRow < m_nRows; ++nRow)
  155. {
  156. int nShowRow = m_nHiddenRow != -1 && m_nHiddenRow <= nRow ? nRow + 1 : nRow;
  157. CWnd* pPaneShow = GetDlgItem(AFX_IDW_PANE_FIRST + nShowRow * 16 + m_nCols);
  159. ASSERT(pPaneShow != NULL);
  160. if (!pPaneShow)
  161. return;
  162. pPaneShow->ShowWindow(SW_SHOWNA);
  164. for (nCol = m_nCols - 2; nCol >= nShowCol; --nCol)
  165. {
  166. CWnd* pPane = GetPane(nRow, nCol);
  167. ASSERT(pPane != NULL);
  168. if (!pPane)
  169. return;
  170. pPane->SetDlgCtrlID(IdFromRowCol(nRow, nCol + 1));
  171. }
  173. pPaneShow->SetDlgCtrlID(IdFromRowCol(nRow, nShowCol));
  174. }
  176. if (m_nHiddenRow != -1)
  177. {
  178. CWnd* pPaneHide = GetDlgItem(AFX_IDW_PANE_FIRST + m_nHiddenRow * 16 + m_nCols);
  179. if (pPaneHide)
  180. {
  181. pPaneHide->SetDlgCtrlID(AFX_IDW_PANE_FIRST + m_nMaxRows * 16 + nShowCol);
  182. }
  183. }
  185. // new panes have been created -- recalculate layout
  186. for (nCol = nShowCol + 1; nCol < m_nCols; nCol++)
  187. m_pColInfo[nCol].nIdealSize = m_pColInfo[nCol - 1].nCurSize;
  189. m_pColInfo[nShowCol].nIdealSize = cxNew;
  190. RecalcLayout();
  191. }
  193. void CXTSplitterWnd::HideColumn(int nColHide)
  194. {
  195. ASSERT_VALID(this);
  196. if (m_nHiddenCol != -1)
  197. {
  198. // return if the requested one is hidden
  199. if (m_nHiddenCol == nColHide)
  200. {
  201. return;
  202. }
  203. ShowColumn();
  204. }
  205. ASSERT(m_nCols > 1);
  206. ASSERT(nColHide < m_nCols);
  207. ASSERT(m_nHiddenCol == -1);
  208. m_nHiddenCol = nColHide;
  210. // if the column has an active window -- change it
  211. int nActiveRow, nActiveCol;
  212. if (GetActivePane(&nActiveRow, &nActiveCol) != NULL)
  213. {
  214. if (nActiveCol == nColHide)
  215. {
  216. if (++nActiveCol >= m_nCols)
  217. nActiveCol = 0;
  218. SetActivePane(nActiveRow, nActiveCol);
  219. }
  220. }
  222. // hide all column panes
  223. int nRow;
  224. for (nRow = 0; nRow < m_nRows; nRow++)
  225. {
  226. CWnd* pPaneHide = GetPane(nRow, nColHide);
  227. ASSERT(pPaneHide != NULL);
  228. if (!pPaneHide)
  229. return;
  230. pPaneHide->ShowWindow(SW_HIDE);
  231. int nRowHide = m_nHiddenRow != -1 && m_nHiddenRow <= nRow ? nRow + 1 : nRow;
  232. pPaneHide->SetDlgCtrlID(AFX_IDW_PANE_FIRST + nRowHide * 16 + m_nCols);
  234. int nCol;
  235. for (nCol = nColHide + 1; nCol < m_nCols; nCol++)
  236. {
  237. CWnd* pPane = GetPane(nRow, nCol);
  238. ASSERT(pPane != NULL);
  239. if (!pPane)
  240. return;
  242. pPane->SetDlgCtrlID(IdFromRowCol(nRow, nCol - 1));
  243. }
  244. }
  246. m_nCols--;
  247. m_pColInfo[m_nCols].nCurSize = m_pColInfo[nColHide].nCurSize;
  248. RecalcLayout();
  249. }
  251. void CXTSplitterWnd::ShowRow()
  252. {
  253. ASSERT_VALID(this);
  254. if (m_nRows == m_nMaxRows && m_nHiddenRow == -1)
  255. {
  256. return;
  257. }
  258. ASSERT(m_nHiddenRow != -1);
  260. int nShowRow = m_nHiddenRow;
  261. m_nHiddenRow = -1;
  263. int cyNew = m_pRowInfo[m_nRows].nCurSize;
  264. m_nRows++;  // add a nRow
  266. ASSERT(m_nRows == m_nMaxRows);
  268. int nRow;
  270. // Show the hidden nRow
  271. int nCol;
  272. for (nCol = 0; nCol < m_nCols; ++nCol)
  273. {
  274. int nShowCol = m_nHiddenCol != -1 && m_nHiddenCol <= nCol ? nCol + 1 : nCol;
  275. CWnd* pPaneShow = GetDlgItem(AFX_IDW_PANE_FIRST + m_nRows * 16 + nShowCol);
  277. ASSERT(pPaneShow != NULL);
  278. if (!pPaneShow)
  279. return;
  280. pPaneShow->ShowWindow(SW_SHOWNA);
  282. for (nRow = m_nRows - 2; nRow >= nShowRow; --nRow)
  283. {
  284. CWnd* pPane = GetPane(nRow, nCol);
  285. ASSERT(pPane != NULL);
  286. if (!pPane)
  287. return;
  288. pPane->SetDlgCtrlID(IdFromRowCol(nRow + 1, nCol));
  289. }
  291. pPaneShow->SetDlgCtrlID(IdFromRowCol(nShowRow, nCol));
  292. }
  294. if (m_nHiddenCol != -1)
  295. {
  296. CWnd* pPaneHide = GetDlgItem(AFX_IDW_PANE_FIRST + m_nRows * 16 + m_nHiddenCol);
  297. if (pPaneHide)
  298. {
  299. pPaneHide->SetDlgCtrlID(AFX_IDW_PANE_FIRST + nShowRow * 16 + m_nMaxCols);
  300. }
  301. }
  303. // new panes have been created -- recalculate layout
  304. for (nRow = nShowRow + 1; nRow < m_nRows; nRow++)
  305. m_pRowInfo[nRow].nIdealSize = m_pRowInfo[nRow - 1].nCurSize;
  307. m_pRowInfo[nShowRow].nIdealSize = cyNew;
  308. RecalcLayout();
  309. }
  311. void CXTSplitterWnd::HideRow(int nRowHide)
  312. {
  313. ASSERT_VALID(this);
  314. if (m_nHiddenRow != -1)
  315. {
  316. // return if the requested one is hidden
  317. if (m_nHiddenRow == nRowHide)
  318. {
  319. return;
  320. }
  321. ShowRow();
  322. }
  323. ASSERT(m_nRows > 1);
  324. ASSERT(nRowHide < m_nRows);
  325. ASSERT(m_nHiddenRow == -1);
  326. m_nHiddenRow = nRowHide;
  328. int nActiveRow, nActiveCol;
  330. // if the nRow has an active window -- change it
  331. if (GetActivePane(&nActiveRow, &nActiveCol) != NULL)
  332. {
  333. if (nActiveRow == nRowHide)
  334. {
  335. if (++nActiveRow >= m_nRows)
  336. nActiveRow = 0;
  337. SetActivePane(nActiveRow, nActiveCol);
  338. }
  339. }
  341. // hide all nRow panes.
  342. int nCol;
  343. for (nCol = 0; nCol < m_nCols; ++nCol)
  344. {
  345. CWnd* pPaneHide = GetPane(nRowHide, nCol);
  346. ASSERT(pPaneHide != NULL);
  347. if (!pPaneHide)
  348. return;
  350. pPaneHide->ShowWindow(SW_HIDE);
  351. int nColHide = m_nHiddenCol != -1 && m_nHiddenCol <= nCol ? nCol + 1 : nCol;
  352. pPaneHide->SetDlgCtrlID(AFX_IDW_PANE_FIRST + m_nRows * 16 + nColHide);
  354. int nRow;
  355. for (nRow = nRowHide + 1; nRow < m_nRows; ++nRow)
  356. {
  357. CWnd* pPane = GetPane(nRow, nCol);
  358. ASSERT(pPane != NULL);
  359. if (!pPane)
  360. return;
  362. pPane->SetDlgCtrlID(IdFromRowCol(nRow-1, nCol));
  363. }
  364. }
  366. m_nRows--;
  367. m_pRowInfo[m_nRows].nCurSize = m_pRowInfo[nRowHide].nCurSize;
  368. RecalcLayout();
  369. }
  371. BOOL CXTSplitterWnd::SwitchView(int nRow, int nCol, CView* pNewView)
  372. {
  373. CView *pOldView = DYNAMIC_DOWNCAST(CView, GetPane(nRow, nCol));
  374. ASSERT_KINDOF(CView, pOldView);
  376. if (pOldView == pNewView)
  377. return FALSE;
  379. int nOldID = pOldView->GetDlgCtrlID();
  380. int nNewID = pNewView->GetDlgCtrlID();
  382. // hide the views.
  383. pOldView->ShowWindow(SW_HIDE);
  384. pNewView->ShowWindow(SW_HIDE);
  386. // swap ids.
  387. pOldView->SetDlgCtrlID(nNewID);
  388. pNewView->SetDlgCtrlID(nOldID);
  390. // show the views.
  391. pOldView->ShowWindow(SW_SHOW);
  392. pNewView->ShowWindow(SW_SHOW);
  394. RecalcLayout();
  396. return TRUE;
  397. }
  399. CView* CXTSplitterWnd::ReplaceView(int nRow, int nCol, CView* pNewView)
  400. {
  401. CView* pOldView = DYNAMIC_DOWNCAST(CView, GetPane (nRow, nCol));
  402. ASSERT_KINDOF (CView, pOldView);
  404. if (pOldView == pNewView)
  405. return NULL;
  407. int nCtrlID = pOldView->GetDlgCtrlID();
  409. // swap ids.
  410. pOldView->SetDlgCtrlID(0);
  411. pNewView->SetDlgCtrlID(nCtrlID);
  413. // show the views.
  414. pOldView->ShowWindow(SW_HIDE);
  415. pNewView->ShowWindow(SW_SHOW);
  417. RecalcLayout();
  419. return pOldView;
  420. }
  422. CView* CXTSplitterWnd::ReplaceView(int nRow, int nCol, CRuntimeClass* pViewClass)
  423. {
  424. CView* pOldView = DYNAMIC_DOWNCAST(CView, GetPane (nRow, nCol));
  425. ASSERT_KINDOF (CView, pOldView);
  427. if (pOldView->IsKindOf(pViewClass))
  428. return NULL;
  430. // Get pointer to CDocument object so that it can be used in the creation
  431. // process of the new view
  432. CDocument* pDocument = pOldView->GetDocument();
  434. int nCtrlID = pOldView->GetDlgCtrlID();
  435. int nWidth, nHeight, nMinWidth, nMinHeight;
  437. GetRowInfo(nRow, nWidth, nMinWidth);
  438. GetColumnInfo(nCol, nHeight, nMinHeight);
  440. // Create new view
  441. CCreateContext contextT;
  442. contextT.m_pLastView = NULL;
  443. contextT.m_pCurrentDoc = pDocument;
  444. contextT.m_pNewViewClass = pViewClass;
  445. contextT.m_pNewDocTemplate = pDocument ? pDocument->GetDocTemplate() : NULL;
  446. contextT.m_pCurrentFrame = NULL;
  448. CWnd* pWnd = NULL;
  449. TRY
  450. {
  451. pWnd = (CWnd*)pViewClass->CreateObject();
  452. if (pWnd == NULL)
  453. AfxThrowMemoryException();
  454. }
  455. CATCH_ALL(e)
  456. {
  457. TRACE0("Out of memory creating a view.n");
  458. // Note: DELETE_EXCEPTION(e) not required
  459. return NULL;
  460. }
  461. END_CATCH_ALL
  463. ASSERT_KINDOF(CWnd, pWnd);
  464. ASSERT(pWnd->m_hWnd == NULL); // not yet created.
  466. // Create with the right size (wrong position)
  467. if (!pWnd->Create(NULL, NULL, WS_CHILD | WS_VISIBLE,
  468. CRect(0, 0, 0, 0), this, nCtrlID, &contextT))
  469. {
  470. TRACE0("Warning: couldn't create new view.n");
  471. // pWnd will be cleaned up by PostNcDestroy
  472. return NULL;
  473. }
  475. // Hide the old view.
  476. pOldView->ShowWindow(SW_HIDE);
  477. pOldView->SetDlgCtrlID(0);
  479. SetRowInfo (nRow, nWidth, nMinWidth);
  480. SetColumnInfo (nCol, nHeight, nMinHeight);
  481. RecalcLayout ();
  483. CView* pNewView = DYNAMIC_DOWNCAST (CView, GetPane (nRow, nCol));
  484. ASSERT_KINDOF (CView, pNewView);
  485. pNewView->OnInitialUpdate();
  487. return pOldView;
  488. }
  490. void CXTSplitterWnd::SetSplitCursor(int ht)
  491. {
  492. if (ht == vSplitterBox || ht >= vSplitterBar1 && ht <= vSplitterBar15)
  493. {
  494. SetCursor(XTAuxData().hcurVSplitBar);
  495. }
  496. else if (ht == hSplitterBox || ht >= hSplitterBar1 && ht <= hSplitterBar15)
  497. {
  498. SetCursor(XTAuxData().hcurHSplitBar);
  499. }
  500. else
  501. {
  502. CSplitterWnd::SetSplitCursor(ht);
  503. }
  504. }
  506. void CXTSplitterWnd::OnSettingChange(UINT uFlags, LPCTSTR lpszSection)
  507. {
  508. CSplitterWnd::OnSettingChange(uFlags, lpszSection);
  510. if (!m_bForceFullDrag)
  511. {
  512. // Get system settings for full drag.
  513. ::SystemParametersInfo(SPI_GETDRAGFULLWINDOWS,
  514. 0, &m_bFullDrag, 0);
  516. // Force no display of windows contents while dragging,
  517. // regardless of windows setting.
  518. if (m_dwxStyle & XT_SPLIT_NOFULLDRAG)
  519. {
  520. m_bFullDrag = FALSE;
  521. }
  522. }
  523. }
  525. void CXTSplitterWnd::SetFullDrag(BOOL bFullDrag)
  526. {
  527. m_bFullDrag = bFullDrag;
  528. m_bForceFullDrag = TRUE;
  529. }
  532. void CXTSplitterWnd::DrawTracker(const CRect& rect, CBrush* pBrush)
  533. {
  534. if (m_bFullDrag == FALSE)
  535. {
  536. ASSERT_VALID(this);
  537. ASSERT(!rect.IsRectEmpty());
  538. ASSERT((GetStyle() & WS_CLIPCHILDREN) == 0);
  540. CWindowDC dc(this);
  541. int nSavedDC = dc.SaveDC();
  543. if (m_dwxStyle & XT_SPLIT_DOTTRACKER)
  544. {
  545. CRect rc;
  546. GetInsideRect(rc);
  548. if (rect.Width() < rect.Height())
  549. {
  550. rc.right = rect.right;
  551. }
  552. else
  553. {
  554. rc.bottom = rect.top;
  555. }
  557. dc.DrawFocusRect(rc);
  558. }
  559. else
  560. {
  561. CRect rcTracker(&rect);
  563. BOOL bVert = rcTracker.Height() > rcTracker.Width();
  565. if (bVert)
  566. {
  567. if (rcTracker.Width() != 4)
  568. {
  569. rcTracker.left = rcTracker.right - 4;
  570. }
  571. }
  572. else
  573. {
  574. if (rcTracker.Height() != 4)
  575. {
  576. rcTracker.bottom = rcTracker.top + 4;
  577. }
  578. }
  580. dc.SelectObject(pBrush);
  581. dc.PatBlt(rcTracker.left, rcTracker.top, rcTracker.Width(), rcTracker.Height(), PATINVERT);
  582. }
  584. dc.RestoreDC(nSavedDC);
  585. }
  586. }
  588. void CXTSplitterWnd::OnInvertTracker(const CRect& rect)
  589. {
  590. CBrush* pBrush = NULL;
  592. if (m_bFlatSplit)
  593. {
  594. pBrush = CBrush::FromHandle((HBRUSH)::GetStockObject(WHITE_BRUSH));
  595. }
  596. else
  597. {
  598. pBrush = CDC::GetHalftoneBrush();
  599. }
  601. DrawTracker(rect, pBrush);
  602. }
  604. void CXTSplitterWnd::OnMouseMove(UINT nFlags, CPoint point)
  605. {
  606. if (m_bFullDrag == FALSE)
  607. {
  608. CSplitterWnd::OnMouseMove(nFlags, point);
  609. return;
  610. }
  612. if (GetCapture() != this)
  613. {
  614. StopTracking(FALSE);
  615. }
  617. if (m_bTracking)
  618. {
  619. // move tracker to current cursor position
  620. point.Offset(m_ptTrackOffset); // point is the upper right of hit detect
  622. // limit the point to the valid split range
  623. if (point.y < m_rectLimit.top)
  624. {
  625. point.y = m_rectLimit.top;
  626. }
  627. else if (point.y > m_rectLimit.bottom)
  628. {
  629. point.y = m_rectLimit.bottom;
  630. }
  631. if (point.x < m_rectLimit.left)
  632. {
  633. point.x = m_rectLimit.left;
  634. }
  635. else if (point.x > m_rectLimit.right)
  636. {
  637. point.x = m_rectLimit.right;
  638. }
  640. if (m_htTrack == vSplitterBox || m_htTrack >= vSplitterBar1 && m_htTrack <= vSplitterBar15)
  641. {
  642. if (m_rectTracker.top != point.y)
  643. {
  644. OnInvertTracker(m_rectTracker);
  645. m_rectTracker.OffsetRect(0, point.y - m_rectTracker.top);
  646. OnInvertTracker(m_rectTracker);
  647. }
  648. }
  649. else if (m_htTrack == hSplitterBox || m_htTrack >= hSplitterBar1 && m_htTrack <= hSplitterBar15)
  650. {
  651. if (m_rectTracker.left != point.x)
  652. {
  653. OnInvertTracker(m_rectTracker);
  654. m_rectTracker.OffsetRect(point.x - m_rectTracker.left, 0);
  655. OnInvertTracker(m_rectTracker);
  656. }
  657. }
  658. else if (m_htTrack == bothSplitterBox || (m_htTrack >= splitterIntersection1 && m_htTrack <= splitterIntersection225))
  659. {
  660. if (m_rectTracker.top != point.y)
  661. {
  662. OnInvertTracker(m_rectTracker);
  663. m_rectTracker.OffsetRect(0, point.y - m_rectTracker.top);
  664. OnInvertTracker(m_rectTracker);
  665. }
  666. if (m_rectTracker2.left != point.x)
  667. {
  668. OnInvertTracker(m_rectTracker2);
  669. m_rectTracker2.OffsetRect(point.x - m_rectTracker2.left, 0);
  670. OnInvertTracker(m_rectTracker2);
  671. }
  672. }
  674. OnLButtonUp(MK_LBUTTON, point);
  675. OnLButtonDown(MK_LBUTTON, point);
  677. if (m_point != point)
  678. {
  679. RedrawWindow(NULL, NULL, RDW_ALLCHILDREN | RDW_UPDATENOW);
  680. m_point = point;
  681. }
  682. }
  683. else
  684. {
  685. // simply hit-test and set appropriate cursor
  686. int ht = HitTest(point);
  687. SetSplitCursor(ht);
  688. }
  689. }
  691. void CXTSplitterWnd::StartTracking(int ht)
  692. {
  693. m_bClipStyles = FALSE;
  695. if (!m_bFullDrag)
  696. {
  697. if (GetStyle() & WS_CLIPCHILDREN)
  698. {
  699. ModifyStyle(WS_CLIPCHILDREN | WS_CLIPSIBLINGS, 0);
  700. m_bClipStyles = TRUE;
  701. }
  703. CSplitterWnd::StartTracking(ht);
  704. return;
  705. }
  708. ASSERT_VALID(this);
  709. if (ht == noHit)
  710. {
  711. return;
  712. }
  714. // GetHitRect will restrict 'm_rectLimit' as appropriate
  715. GetInsideRect(m_rectLimit);
  717. if (ht >= splitterIntersection1 && ht <= splitterIntersection225)
  718. {
  719. // split two directions (two tracking rectangles)
  720. int row = (ht - splitterIntersection1) / 15;
  721. int col = (ht - splitterIntersection1) % 15;
  723. GetHitRect(row + vSplitterBar1, m_rectTracker);
  724. int yTrackOffset = m_ptTrackOffset.y;
  725. m_bTracking2 = TRUE;
  726. GetHitRect(col + hSplitterBar1, m_rectTracker2);
  727. m_ptTrackOffset.y = yTrackOffset;
  728. }
  729. else if (ht == bothSplitterBox)
  730. {
  731. // hit on splitter boxes (for keyboard)
  732. GetHitRect(vSplitterBox, m_rectTracker);
  733. int yTrackOffset = m_ptTrackOffset.y;
  734. m_bTracking2 = TRUE;
  735. GetHitRect(hSplitterBox, m_rectTracker2);
  736. m_ptTrackOffset.y = yTrackOffset;
  738. // center it
  739. m_rectTracker.OffsetRect(0, m_rectLimit.Height()/2);
  740. m_rectTracker2.OffsetRect(m_rectLimit.Width()/2, 0);
  741. }
  742. else
  743. {
  744. // only hit one bar
  745. GetHitRect(ht, m_rectTracker);
  746. }
  748. // steal focus and capture
  749. SetCapture();
  751. // set tracking state and appropriate cursor
  752. m_bTracking = TRUE;
  753. m_htTrack = ht;
  754. SetSplitCursor(ht);
  755. }
  757. void CXTSplitterWnd::StopTracking(BOOL bAccept)
  758. {
  759. if (!m_bFullDrag)
  760. {
  761. CSplitterWnd::StopTracking(bAccept);
  763. if (m_bClipStyles)
  764. {
  765. ModifyStyle(0, WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
  766. m_bClipStyles = FALSE;
  767. }
  768. return;
  769. }
  771. ASSERT_VALID(this);
  773. if (!m_bTracking)
  774. {
  775. return;
  776. }
  778. ReleaseCapture();
  780. // erase tracker rectangle
  781. OnInvertTracker(m_rectTracker);
  782. if (m_bTracking2)
  783. OnInvertTracker(m_rectTracker2);
  785. m_bTracking = m_bTracking2 = FALSE;
  787. // save old active view
  788. CWnd* pOldActiveView = GetActivePane();
  790. // m_rectTracker is set to the new splitter position (without border)
  791. // (so, adjust relative to where the border will be)
  792. m_rectTracker.OffsetRect(-CX_BORDER , -CY_BORDER);
  793. m_rectTracker2.OffsetRect(-CX_BORDER, -CY_BORDER);
  795. if (bAccept)
  796. {
  797. if (m_htTrack == vSplitterBox)
  798. {
  799. SplitRow(m_rectTracker.top);
  800. }
  801. else if (m_htTrack >= vSplitterBar1 && m_htTrack <= vSplitterBar15)
  802. {
  803. // adjust the tracking rect for flat splitter.
  804. if (m_bFlatSplit)
  805. {
  806. m_rectTracker.top = m_rectTracker.bottom - 4;
  807. }
  809. // set row height
  810. TrackRowSize(m_rectTracker.top, m_htTrack - vSplitterBar1);
  811. RecalcLayout();
  812. }
  813. else if (m_htTrack == hSplitterBox)
  814. {
  815. SplitColumn(m_rectTracker.left);
  816. }
  817. else if (m_htTrack >= hSplitterBar1 && m_htTrack <= hSplitterBar15)
  818. {
  819. // adjust the tracking rect for flat splitter.
  820. if (m_bFlatSplit)
  821. {
  822. m_rectTracker.left = m_rectTracker.right - 4;
  823. }
  825. // set column width
  826. TrackColumnSize(m_rectTracker.left, m_htTrack - hSplitterBar1);
  827. RecalcLayout();
  828. }
  829. else if (m_htTrack >= splitterIntersection1 &&
  830. m_htTrack <= splitterIntersection225)
  831. {
  832. // set row height and column width
  833. int row = (m_htTrack - splitterIntersection1) / 15;
  834. int col = (m_htTrack - splitterIntersection1) % 15;
  836. TrackRowSize(m_rectTracker.top, row);
  837. TrackColumnSize(m_rectTracker2.left, col);
  838. RecalcLayout();
  839. }
  840. else if (m_htTrack == bothSplitterBox)
  841. {
  842. // rectTracker is vSplitter (splits rows)
  843. // rectTracker2 is hSplitter (splits cols)
  844. SplitRow(m_rectTracker.top);
  845. SplitColumn(m_rectTracker2.left);
  846. }
  847. }
  849. if ((pOldActiveView == GetActivePane()) &&
  850. (pOldActiveView != NULL))
  851. {
  852. SetActivePane(-1, -1, pOldActiveView); // re-activate
  853. }
  854. }
  856. void CXTSplitterWnd::SetSplitterStyle(DWORD dwxStyle)
  857. {
  858. m_dwxStyle = dwxStyle;
  860. // Force no display of windows contents while dragging,
  861. // regardless of windows setting.
  862. if (m_dwxStyle & XT_SPLIT_NOFULLDRAG)
  863. {
  864. m_bFullDrag = FALSE;
  865. }
  866. else
  867. {
  868. // Get system settings for full drag.
  869. ::SystemParametersInfo(SPI_GETDRAGFULLWINDOWS,
  870. 0, &m_bFullDrag, 0);
  871. }
  872. }
  874. LRESULT CXTSplitterWnd::OnNcHitTest(CPoint point)
  875. {
  876. // If XT_SPLIT_NOSIZE style is defined, just return a border
  877. // hit so can at least activate the app if needed.
  878. if ((m_dwxStyle & XT_SPLIT_NOSIZE) == XT_SPLIT_NOSIZE)
  879. {
  880. return HTBORDER;
  881. }
  882. return (LRESULT)CSplitterWnd::OnNcHitTest(point);
  883. }
  885. void CXTSplitterWnd::EnableFlatLook(BOOL bFlatSplitter)
  886. {
  887. m_bFlatSplit = bFlatSplitter;
  888. m_cxSplitter = m_bFlatSplit ? 6 : 7;
  889. m_cySplitter = m_bFlatSplit ? 6 : 7;
  890. m_cxSplitterGap = m_bFlatSplit ? 6 : 7;
  891. m_cySplitterGap = m_bFlatSplit ? 6 : 7;
  892. RecalcLayout();
  893. }
  895. void CXTSplitterWnd::OnDrawSplitter(CDC* pDC, ESplitType nType, const CRect& rectArg)
  896. {
  897. COLORREF clr3DFace = GetTheme()->m_clrSplitterFace;
  898. COLORREF clr3DShadow = GetTheme()->m_clrSplitterBorders;
  901. // if pDC == NULL, then just invalidate
  902. if (pDC == NULL)
  903. {
  904. RedrawWindow(rectArg, NULL, RDW_INVALIDATE | RDW_NOCHILDREN);
  905. return;
  906. }
  907. ASSERT_VALID(pDC);
  909. // otherwise, actually draw
  910. CRect rect = rectArg;
  911. switch (nType)
  912. {
  913. case splitBorder:
  914. if (m_bFlatSplit)
  915. {
  916. if (!(m_dwxStyle & XT_SPLIT_NOBORDER))
  917. {
  918. pDC->Draw3dRect(rect, clr3DFace, clr3DFace);
  919. rect.InflateRect(-CX_BORDER, -CY_BORDER);
  920. pDC->Draw3dRect(rect, clr3DShadow, GetXtremeColor(COLOR_3DHILIGHT));
  921. }
  922. else
  923. {
  924. pDC->Draw3dRect(rect, clr3DFace, clr3DFace);
  925. rect.InflateRect(-CX_BORDER, -CY_BORDER);
  926. pDC->Draw3dRect(rect, clr3DFace, clr3DFace);
  927. }
  928. }
  929. else
  930. {
  931. pDC->Draw3dRect(rect, clr3DShadow, GetXtremeColor(COLOR_3DHILIGHT));
  932. rect.InflateRect(-CX_BORDER, -CY_BORDER);
  933. pDC->Draw3dRect(rect, GetXtremeColor(COLOR_WINDOWFRAME), clr3DFace);
  934. }
  935. return;
  937. case splitIntersection:
  938. ASSERT(!XTOSVersionInfo()->IsWin95OrGreater());
  939. break;
  941. case splitBox:
  942. if (m_bFlatSplit)
  943. {
  944. pDC->Draw3dRect(rect, clr3DFace, clr3DFace);
  945. rect.InflateRect(-CX_BORDER, -CY_BORDER);
  946. pDC->Draw3dRect(rect, GetXtremeColor(COLOR_3DHILIGHT), clr3DShadow);
  947. rect.InflateRect(-CX_BORDER, -CY_BORDER);
  948. }
  949. else
  950. {
  951. pDC->Draw3dRect(rect, clr3DFace, GetXtremeColor(COLOR_WINDOWFRAME));
  952. rect.InflateRect(-CX_BORDER, -CY_BORDER);
  953. pDC->Draw3dRect(rect, GetXtremeColor(COLOR_3DHILIGHT), clr3DShadow);
  954. rect.InflateRect(-CX_BORDER, -CY_BORDER);
  955. }
  956. break;
  958. case splitBar:
  959. break;
  961. default:
  962. ASSERT(FALSE);  // unknown splitter type
  963. }
  965. // fill the middle
  966. COLORREF clr = clr3DFace;
  967. pDC->FillSolidRect(rect, clr);
  968. }
  970. void CXTSplitterWnd::OnLButtonUp(UINT nFlags, CPoint point)
  971. {
  972. CSplitterWnd::OnLButtonUp(nFlags, point);
  973. Invalidate();
  974. }
  976. void CXTSplitterWnd::SetActivePane(int row, int col, CWnd* pWnd/*= NULL*/)
  977. {
  978. // set the focus to the pane
  979. CWnd* pPane = pWnd == NULL ? GetPane(row, col) : pWnd;
  980. if (pPane->IsKindOf(RUNTIME_CLASS(CView)))
  981. {
  982. CFrameWnd* pFrameWnd = GetParentFrame();
  983. ASSERT_VALID(pFrameWnd);
  984. pFrameWnd->SetActiveView((CView*)pPane);
  985. }
  986. else
  987. {
  988. pPane->SetFocus();
  989. }
  990. }
  992. //////////////////////////////////////////////////////////////////////
  993. // CXTSplitterWndEx
  994. //
  996. IMPLEMENT_DYNAMIC(CXTSplitterWndEx, CXTSplitterWnd)
  998. BEGIN_MESSAGE_MAP(CXTSplitterWndEx, CXTSplitterWnd)
  999. //{{AFX_MSG_MAP(CXTSplitterWndEx)
  1000. ON_WM_ERASEBKGND()
  1001. ON_WM_PAINT()
  1002. //}}AFX_MSG_MAP
  1003. END_MESSAGE_MAP()
  1005. CXTSplitterWndEx::CXTSplitterWndEx()
  1006. {
  1007. m_cxBorder = 0;
  1008. m_cyBorder = 0;
  1009. m_cxSplitter = 4;
  1010. m_cySplitter = 4;
  1011. m_cxSplitterGap = 4;
  1012. m_cySplitterGap = 4;
  1013. m_cyTopBorderGap = 6;
  1014. m_bShowTopBorder = true;
  1015. }
  1017. CXTSplitterWndEx::~CXTSplitterWndEx()
  1018. {
  1020. }
  1022. void CXTSplitterWndEx::OnDrawSplitter(CDC* pDC, ESplitType nType, const CRect& rectArg)
  1023. {
  1024. COLORREF clr3DFace = GetTheme()->m_clrSplitterFace;
  1025. COLORREF clr3DShadow = GetTheme()->m_clrSplitterBorders;
  1027. if (pDC == NULL)
  1028. {
  1029. RedrawWindow(rectArg, NULL, RDW_INVALIDATE | RDW_NOCHILDREN);
  1030. return;
  1031. }
  1032. ASSERT_VALID(pDC);
  1033. CRect rect = rectArg;
  1034. switch (nType)
  1035. {
  1036. case splitBorder:
  1037. return;
  1038. case splitBox:
  1039. pDC->Draw3dRect(rect, clr3DFace, GetXtremeColor(COLOR_WINDOWFRAME));
  1040. rect.InflateRect(-CX_BORDER, -CY_BORDER);
  1041. pDC->Draw3dRect(rect, GetXtremeColor(COLOR_3DHILIGHT), clr3DShadow);
  1042. rect.InflateRect(-CX_BORDER, -CY_BORDER);
  1043. break;
  1044. }
  1046. pDC->FillSolidRect(rect, clr3DFace);
  1047. }
  1049. // Generic routine:
  1050. //  for X direction: pInfo = m_pColInfo, nMax = m_nMaxCols, nSize = cx
  1051. //  for Y direction: pInfo = m_pRowInfo, nMax = m_nMaxRows, nSize = cy
  1052. void CXTSplitterWndEx::LayoutRowCol(CSplitterWnd::CRowColInfo* pInfoArray,
  1053. int nMax, int nSize, int nSizeSplitter)
  1054. {
  1055. ASSERT(pInfoArray != NULL);
  1056. ASSERT(nMax > 0);
  1057. ASSERT(nSizeSplitter > 0);
  1059. if (!pInfoArray)
  1060. return;
  1062. CSplitterWnd::CRowColInfo* pInfo = NULL;
  1063. int i;
  1065. if (nSize < 0)
  1066. nSize = 0;  // if really too small, layout as zero size
  1068. // start with ideal sizes
  1069. for (i = 0, pInfo = pInfoArray; i < nMax-1; i++, pInfo++)
  1070. {
  1071. if (pInfo->nIdealSize < pInfo->nMinSize)
  1072. pInfo->nIdealSize = 0;      // too small to see
  1073. pInfo->nCurSize = pInfo->nIdealSize;
  1074. }
  1075. if (!pInfo)
  1076. return;
  1078. pInfo->nCurSize = INT_MAX;  // last row/column takes the rest
  1080. for (i = 0, pInfo = pInfoArray; i < nMax; i++, pInfo++)
  1081. {
  1082. ASSERT(nSize >= 0);
  1083. if (nSize == 0)
  1084. {
  1085. // no more room (set pane to be invisible)
  1086. pInfo->nCurSize = 0;
  1087. continue;       // don't worry about splitters
  1088. }
  1089. else if (nSize < pInfo->nMinSize && i != 0)
  1090. {
  1091. // additional panes below the recommended minimum size
  1092. //   aren't shown and the size goes to the previous pane
  1093. pInfo->nCurSize = 0;
  1095. // previous pane already has room for splitter + border
  1096. //   add remaining size and remove the extra border
  1097. ASSERT(CX_BORDER * 2 == CY_BORDER * 2);
  1098. (pInfo-1)->nCurSize += nSize + CX_BORDER * 2;
  1099. nSize = 0;
  1100. }
  1101. else
  1102. {
  1103. // otherwise we can add the second pane
  1104. ASSERT(nSize > 0);
  1105. if (pInfo->nCurSize == 0)
  1106. {
  1107. // too small to see
  1108. if (i != 0)
  1109. pInfo->nCurSize = 0;
  1110. }
  1111. else if (nSize < pInfo->nCurSize)
  1112. {
  1113. // this row/col won't fit completely - make as small as possible
  1114. pInfo->nCurSize = nSize;
  1115. nSize = 0;
  1116. }
  1117. else
  1118. {
  1119. // can fit everything
  1120. nSize -= pInfo->nCurSize;
  1121. }
  1122. }
  1124. // see if we should add a splitter
  1125. ASSERT(nSize >= 0);
  1126. if (i != nMax - 1)
  1127. {
  1128. // should have a splitter
  1129. if (nSize > nSizeSplitter)
  1130. {
  1131. nSize -= nSizeSplitter; // leave room for splitter + border
  1132. ASSERT(nSize > 0);
  1133. }
  1134. else
  1135. {
  1136. // not enough room - add left over less splitter size
  1137. ASSERT(CX_BORDER * 2 == CY_BORDER * 2);
  1138. pInfo->nCurSize += nSize;
  1139. if (pInfo->nCurSize > (nSizeSplitter - CX_BORDER * 2))
  1140. pInfo->nCurSize -= (nSizeSplitter - CY_BORDER * 2);
  1141. nSize = 0;
  1142. }
  1143. }
  1144. }
  1145. ASSERT(nSize == 0); // all space should be allocated
  1146. }
  1148. // repositions client area of specified window
  1149. // assumes everything has WS_BORDER or is inset like it does
  1150. //  (includes scroll bars)
  1151. void CXTSplitterWndEx::DeferClientPos(AFX_SIZEPARENTPARAMS* lpLayout,
  1152. CWnd* pWnd, int x, int y, int cx, int cy, BOOL bScrollBar)
  1153. {
  1154. ASSERT(pWnd != NULL);
  1155. if (!pWnd)
  1156. return;
  1157. ASSERT(pWnd->m_hWnd != NULL);
  1159. if (bScrollBar)
  1160. {
  1161. // if there is enough room, draw scroll bar without border
  1162. // if there is not enough room, set the WS_BORDER bit so that
  1163. //   we will at least get a proper border drawn
  1164. BOOL bNeedBorder = (cx <= CX_BORDER || cy <= CY_BORDER);
  1165. pWnd->ModifyStyle(bNeedBorder ? 0 : WS_BORDER,
  1166. bNeedBorder ? WS_BORDER : 0);
  1167. }
  1168. CRect rect(x, y, x + cx, y + cy);
  1170. // adjust for border size (even if zero client size)
  1172. // adjust for 3d border (splitter windows have implied border)
  1173. if ((pWnd->GetExStyle() & WS_EX_CLIENTEDGE) ||
  1174. pWnd->IsKindOf(RUNTIME_CLASS(CSplitterWnd)))
  1175. rect.InflateRect(CX_BORDER * 2, CY_BORDER * 2);
  1177. // first check if the new rectangle is the same as the current
  1178. CRect rectOld;
  1179. pWnd->GetWindowRect(rectOld);
  1180. pWnd->GetParent()->ScreenToClient(&rectOld);
  1181. if (rect != rectOld)
  1182. AfxRepositionWindow(lpLayout, pWnd->m_hWnd, rect);
  1183. }
  1185. void CXTSplitterWndEx::RecalcLayout()
  1186. {
  1187. ASSERT_VALID(this);
  1188. ASSERT(m_nRows > 0 && m_nCols > 0); // must have at least one pane
  1190. CRect rectClient;
  1191. GetClientRect(rectClient);
  1192. rectClient.InflateRect(-m_cxBorder, -m_cyBorder);
  1193. rectClient.top += m_cyTopBorderGap;
  1195. CRect rectInside;
  1196. GetInsideRect(rectInside);
  1198. // layout columns (restrict to possible sizes)
  1199. LayoutRowCol(m_pColInfo, m_nCols, rectInside.Width(), m_cxSplitterGap);
  1200. LayoutRowCol(m_pRowInfo, m_nRows, rectInside.Height(), m_cySplitterGap);
  1202. // adjust the panes (and optionally scroll bars)
  1204. // give the hint for the maximum number of HWNDs
  1205. AFX_SIZEPARENTPARAMS layout;
  1206. layout.hDWP = ::BeginDeferWindowPos((m_nCols + 1) * (m_nRows + 1) + 1);
  1208. // size of scrollbars
  1209. int cx = (rectClient.right - rectInside.right);
  1210. int cy = (rectClient.bottom - rectInside.bottom);
  1212. // reposition size box
  1213. if (m_bHasHScroll && m_bHasVScroll)
  1214. {
  1215. CWnd* pScrollBar = GetDlgItem(AFX_IDW_SIZE_BOX);
  1216. ASSERT(pScrollBar != NULL);
  1218. // fix style if necessary
  1219. BOOL bSizingParent = (GetSizingParent() != NULL);
  1220. // modifyStyle returns TRUE if style changes
  1221. if (pScrollBar->ModifyStyle(SBS_SIZEGRIP | SBS_SIZEBOX,
  1222. bSizingParent ? SBS_SIZEGRIP : SBS_SIZEBOX))
  1223. pScrollBar->Invalidate();
  1224. pScrollBar->EnableWindow(bSizingParent);
  1226. // reposition the size box
  1227. DeferClientPos(&layout, pScrollBar,
  1228. rectInside.right, rectInside.bottom, cx, cy, TRUE);
  1229. }
  1231. // reposition scroll bars
  1232. if (m_bHasHScroll)
  1233. {
  1234. int cxSplitterBox = m_cxSplitter;// split box bigger
  1235. int x = rectClient.left;
  1236. int y = rectInside.bottom;
  1237. int col;
  1238. for (col = 0; col < m_nCols; col++)
  1239. {
  1240. CWnd* pScrollBar = GetDlgItem(AFX_IDW_HSCROLL_FIRST + col);
  1241. ASSERT(pScrollBar != NULL);
  1242. int cxColumn = m_pColInfo[col].nCurSize;
  1243. if (col == 0 && m_nCols < m_nMaxCols)
  1244. x += cxSplitterBox, cxColumn -= cxSplitterBox;
  1245. DeferClientPos(&layout, pScrollBar, x, y, cxColumn, cy, TRUE);
  1246. x += cxColumn + m_cxSplitterGap;
  1247. }
  1248. }
  1250. if (m_bHasVScroll)
  1251. {
  1252. int cySplitterBox = m_cySplitter;// split box bigger
  1253. int x = rectInside.right;
  1254. int y = rectClient.top;
  1255. int row;
  1256. for (row = 0; row < m_nRows; row++)
  1257. {
  1258. CWnd* pScrollBar = GetDlgItem(AFX_IDW_VSCROLL_FIRST + row);
  1259. ASSERT(pScrollBar != NULL);
  1260. int cyColumn = m_pRowInfo[row].nCurSize;
  1261. if (row == 0 && m_nRows < m_nMaxRows)
  1262. y += cySplitterBox, cyColumn -= cySplitterBox;
  1263. DeferClientPos(&layout, pScrollBar, x, y, cx, cyColumn, TRUE);
  1264. y += cyColumn + m_cySplitterGap;
  1265. }
  1266. }
  1268. //BLOCK: Reposition all the panes
  1269. {
  1270. int x = rectClient.left;
  1271. int col;
  1272. for (col = 0; col < m_nCols; col++)
  1273. {
  1274. int cxColumn = m_pColInfo[col].nCurSize;
  1275. int y = rectClient.top;
  1276. int row;
  1277. for (row = 0; row < m_nRows; row++)
  1278. {
  1279. int cyColumn = m_pRowInfo[row].nCurSize;
  1280. CWnd* pWnd = GetPane(row, col);
  1281. DeferClientPos(&layout, pWnd, x, y, cxColumn, cyColumn, FALSE);
  1282. y += cyColumn + m_cySplitterGap;
  1283. }
  1284. x += cxColumn + m_cxSplitterGap;
  1285. }
  1286. }
  1288. // move and resize all the windows at once!
  1289. if (layout.hDWP == NULL || !::EndDeferWindowPos(layout.hDWP))
  1290. TRACE0("Warning: DeferWindowPos failed - low system resources.n");
  1292. // invalidate all the splitter bars (with NULL pDC)
  1293. DrawAllSplitBars(NULL, rectInside.right, rectInside.bottom);
  1294. }
  1296. void CXTSplitterWndEx::GetInsideRect(CRect& rect) const
  1297. {
  1298. CSplitterWnd::GetInsideRect(rect);
  1299. rect.top += m_cyTopBorderGap;
  1300. }
  1302. void CXTSplitterWndEx::OnPaint()
  1303. {
  1304. CSplitterWnd::OnPaint();
  1306. if (m_bShowTopBorder)
  1307. {
  1308. CClientDC dc(this);
  1310. int iSavedDC = dc.SaveDC();
  1312. CRect rectClient;
  1313. GetClientRect(rectClient);
  1315. if (GetTheme()->GetTheme() == xtThemeDefault)
  1316. {
  1317. CPen penShadow(PS_SOLID, 1, GetXtremeColor(COLOR_3DSHADOW));
  1318. dc.SelectObject(&penShadow);
  1319. dc.MoveTo(rectClient.left, rectClient.top);
  1320. dc.LineTo(rectClient.right, rectClient.top);
  1321. }
  1323. CPen penHilight(PS_SOLID, 1, GetXtremeColor(COLOR_3DHILIGHT));
  1324. dc.SelectObject(&penHilight);
  1325. dc.MoveTo(rectClient.left, rectClient.top + 1);
  1326. dc.LineTo(rectClient.right, rectClient.top + 1);
  1328. dc.RestoreDC(iSavedDC);
  1329. }
  1330. }
  1332. BOOL CXTSplitterWndEx::OnEraseBkgnd(CDC* pDC)
  1333. {
  1334. CRect rectClient;
  1335. GetClientRect(rectClient);
  1336. rectClient.InflateRect(-m_cxBorder, -m_cyBorder);
  1337. rectClient.bottom = rectClient.top + m_cyTopBorderGap;
  1339. COLORREF clr3DFace = GetTheme()->m_clrSplitterFace;
  1340. pDC->FillSolidRect(rectClient, clr3DFace);
  1343. return TRUE;
  1344. }