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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
ExtSplitterWnd.cpp
资源名称：profuis288_freeware.zip　[点击查看]
上传用户：sesekoo
上传日期：2020-07-18
资源大小：21543k
文件大小：64k
源码类别：

界面编程

开发平台：

Visual C++

ExtSplitterWnd.cpp：源码内容
  1. // This is part of the Professional User Interface Suite library.
  2. // Copyright (C) 2001-2009 FOSS Software, Inc.
  3. // All rights reserved.
  4. //
  5. // http://www.prof-uis.com
  6. // mailto:support@prof-uis.com
  7. //
  8. // This source code can be used, modified and redistributed
  9. // under the terms of the license agreement that is included
  10. // in the Professional User Interface Suite package.
  11. //
  12. // Warranties and Disclaimers:
  13. // THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND
  14. // INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY,
  15. // FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  16. // IN NO EVENT WILL FOSS SOFTWARE INC. BE LIABLE FOR ANY DIRECT,
  17. // INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES,
  18. // INCLUDING DAMAGES FOR LOSS OF PROFITS, LOSS OR INACCURACY OF DATA,
  19. // INCURRED BY ANY PERSON FROM SUCH PERSON'S USAGE OF THIS SOFTWARE
  20. // EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
  22. #include "StdAfx.h"
  24. #if (!defined __EXT_MFC_NO_SPLITTER_WND)
  26. #if (!defined __EXT_SPLITTER_WND_H)
  27. #include <ExtSplitterWnd.h>
  28. #endif
  30. #if (!defined __EXT_SCROLLWND_H)
  31. #include <ExtScrollWnd.h>
  32. #endif 
  34. #if (!defined __EXT_PAINT_MANAGER_H)
  35. #include <ExtPaintManager.h>
  36. #endif
  38. #if (!defined __EXT_RESIZABLE_DIALOG_H)
  39. #include <ExtResizableDialog.h>
  40. #endif
  42. #if _MFC_VER < 0x700
  43. #include <../src/AfxImpl.h>
  44. #else
  45. #include <../src/mfc/AfxImpl.h>
  46. #endif
  48. #if (!defined __AFXPRIV_H__)
  49. #include <AfxPriv.h>
  50. #endif
  52. #ifdef _DEBUG
  53. #define new DEBUG_NEW
  54. #undef THIS_FILE
  55. static char THIS_FILE[] = __FILE__;
  56. #endif
  58. /////////////////////////////////////////////////////////////////////////////
  59. // CExtSplitterBaseWnd
  61. IMPLEMENT_DYNCREATE( CExtSplitterBaseWnd, CSplitterWnd );
  62. IMPLEMENT_CExtPmBridge_MEMBERS( CExtSplitterBaseWnd );
  64. HCURSOR CExtSplitterBaseWnd::g_split_hcurLast = NULL;
  65. HCURSOR CExtSplitterBaseWnd::g_split_hcurDestroy = NULL;
  66. UINT CExtSplitterBaseWnd::g_split_idcPrimaryLast = 0;
  68. CExtSplitterBaseWnd::CExtSplitterBaseWnd()
  69. : m_clrBackground( COLORREF(-1L) )
  70. {
  71. //AFX_ZERO_INIT_OBJECT( CWnd );
  72. #if _MFC_VER < 0x700
  73. if( ! afxData.bWin4 )
  74. {
  75. m_cxSplitter = m_cySplitter = 4;
  76. m_cxBorderShare = m_cyBorderShare = 1;
  77. m_cxSplitterGap = m_cySplitterGap = 4 + 1 + 1;
  78. ASSERT( m_cxBorder == 0 && m_cyBorder == 0 );
  79. }
  80. else
  81. #endif //_MFC_VER < 0x700
  82. {
  83. m_cxSplitter = m_cySplitter = 3 + 2 + 2;
  84. m_cxBorderShare = m_cyBorderShare = 0;
  85. m_cxSplitterGap = m_cySplitterGap = 3 + 2 + 2;
  86. m_cxBorder = m_cyBorder = 2;
  87. }
  88. #ifdef _DEBUG
  89. if( GetSystemMetrics(SM_CXBORDER) != 1
  90. || GetSystemMetrics(SM_CYBORDER) != 1
  91. )
  92. {
  93. TRACE0( "Warning: CExtSplitterBaseWnd assumes 1 pixel border.n" );
  94. }
  95. #endif
  96. PmBridge_Install();
  97. }
  99. CExtSplitterBaseWnd::~CExtSplitterBaseWnd()
  100. {
  101. // delete[] m_pRowInfo;
  102. // delete[] m_pColInfo;
  103. PmBridge_Uninstall();
  104. }
  106. COLORREF CExtSplitterBaseWnd::OnQueryBackgroundColor() const
  107. {
  108. ASSERT_VALID( this );
  109. return m_clrBackground;
  110. }
  112. int CExtSplitterBaseWnd::stat_CanSplitRowCol( CExtSplitterBaseWnd::CRowColInfo * pInfoBefore, int nBeforeSize, int nSizeSplitter )
  113. {
  114. ASSERT( pInfoBefore->nCurSize > 0 );
  115. ASSERT( pInfoBefore->nMinSize > 0 );
  116. ASSERT( nBeforeSize <= pInfoBefore->nCurSize );
  117. if( nBeforeSize < pInfoBefore->nMinSize )
  118. {
  119. TRACE0("Warning: split too small to fit in a new pane.n");
  120. return -1;
  121. }
  122. int nNewSize = pInfoBefore->nCurSize - nBeforeSize - nSizeSplitter;
  123. if( nBeforeSize < pInfoBefore->nMinSize )
  124. {
  125. TRACE0("Warning: split too small to shrink old pane.n");
  126. return -1;
  127. }
  128. if( nNewSize < (pInfoBefore+1)->nMinSize )
  129. {
  130. TRACE0("Warning: split too small to create new pane.n");
  131. return -1;
  132. }
  133. return nNewSize;
  134. }
  136. void CExtSplitterBaseWnd::stat_LayoutRowCol( CExtSplitterBaseWnd::CRowColInfo * pInfoArray, int nMax, int nSize, int nSizeSplitter )
  137. {
  138. ASSERT( pInfoArray != NULL );
  139. ASSERT( nMax > 0);
  140. ASSERT( nSizeSplitter > 0 );
  141. CExtSplitterBaseWnd::CRowColInfo * pInfo;
  142. int i;
  143. if( nSize < 0 )
  144. nSize = 0;
  145. for( i = 0, pInfo = pInfoArray; i < nMax-1; i++, pInfo++ )
  146. {
  147. if( pInfo->nIdealSize < pInfo->nMinSize )
  148. pInfo->nIdealSize = 0;
  149. pInfo->nCurSize = pInfo->nIdealSize;
  150. }
  151. pInfo->nCurSize = INT_MAX;
  152. for( i = 0, pInfo = pInfoArray; i < nMax; i++, pInfo++ )
  153. {
  154. ASSERT(nSize >= 0);
  155. if( nSize == 0)
  156. {
  157. // no more room (set pane to be invisible)
  158. pInfo->nCurSize = 0;
  159. continue;       // don't worry about splitters
  160. }
  161. else if( nSize < pInfo->nMinSize && i != 0 )
  162. {
  163. pInfo->nCurSize = 0;
  164. ASSERT( afxData.cxBorder2 == afxData.cyBorder2 );
  165. (pInfo-1)->nCurSize += nSize + afxData.cxBorder2;
  166. nSize = 0;
  167. }
  168. else
  169. {
  170. ASSERT(nSize > 0 );
  171. if( pInfo->nCurSize == 0)
  172. {
  173. if( i != 0 )
  174. pInfo->nCurSize = 0;
  175. }
  176. else if( nSize < pInfo->nCurSize )
  177. {
  178. pInfo->nCurSize = nSize;
  179. nSize = 0;
  180. }
  181. else
  182. nSize -= pInfo->nCurSize;
  183. }
  184. ASSERT( nSize >= 0 );
  185. if( i != nMax - 1 )
  186. {
  187. if( nSize > nSizeSplitter )
  188. {
  189. nSize -= nSizeSplitter;
  190. ASSERT( nSize > 0 );
  191. }
  192. else
  193. {
  194. ASSERT( afxData.cxBorder2 == afxData.cyBorder2 );
  195. pInfo->nCurSize += nSize;
  196. if( pInfo->nCurSize > (nSizeSplitter - afxData.cxBorder2))
  197. pInfo->nCurSize -= (nSizeSplitter - afxData.cyBorder2);
  198. nSize = 0;
  199. }
  200. }
  201. }
  202. ASSERT(nSize == 0);
  203. }
  205. void CExtSplitterBaseWnd::stat_DeferClientPos( AFX_SIZEPARENTPARAMS* lpLayout, CWnd * pWnd, int x, int y, int cx, int cy, BOOL bScrollBar )
  206. {
  207. ASSERT( pWnd != NULL );
  208. ASSERT( pWnd->m_hWnd != NULL );
  209. if( bScrollBar )
  210. {
  211. BOOL bNeedBorder = ( cx <= __EXT_MFC_CX_BORDER || cy <= __EXT_MFC_CY_BORDER );
  212. pWnd->ModifyStyle( bNeedBorder ? 0 : WS_BORDER, bNeedBorder ? WS_BORDER : 0 );
  213. }
  214. CRect rect( x, y, x+cx, y+cy );
  215. #if _MFC_VER < 0x700
  216. if( ! afxData.bWin4 )
  217. {
  218. if( bScrollBar )
  219. rect.InflateRect( __EXT_MFC_CX_BORDER, __EXT_MFC_CY_BORDER );
  220. else
  221. pWnd->CalcWindowRect( &rect );
  222. }
  223. #endif //_MFC_VER < 0x700
  224. if( ( pWnd->GetExStyle() & WS_EX_CLIENTEDGE ) || pWnd->IsKindOf( RUNTIME_CLASS( CExtSplitterBaseWnd ) ) )
  225. rect.InflateRect( afxData.cxBorder2, afxData.cyBorder2 );
  226. CRect rectOld;
  227. pWnd->GetWindowRect( rectOld );
  228. pWnd->GetParent()->ScreenToClient( &rectOld );
  229. if( rect != rectOld )
  230. AfxRepositionWindow( lpLayout, pWnd->m_hWnd, rect );
  231. }
  233. BEGIN_MESSAGE_MAP( CExtSplitterBaseWnd, CSplitterWnd )
  234. //{{AFX_MSG_MAP(CExtSplitterBaseWnd)
  235. ON_WM_SETCURSOR()
  236. ON_WM_MOUSEMOVE()
  237. ON_WM_PAINT()
  238. ON_WM_LBUTTONDOWN()
  239. ON_WM_LBUTTONDBLCLK()
  240. ON_WM_LBUTTONUP()
  241. ON_WM_KEYDOWN()
  242. ON_WM_SIZE()
  243. ON_WM_HSCROLL()
  244. ON_WM_VSCROLL()
  245. ON_WM_NCCREATE()
  246. ON_WM_SYSCOMMAND()
  247. ON_WM_CANCELMODE()
  248. ON_WM_MOUSEWHEEL()
  249. //}}AFX_MSG_MAP
  250. ON_MESSAGE_VOID( WM_DISPLAYCHANGE, OnDisplayChange )
  251. ON_MESSAGE_VOID( WM_WININICHANGE, OnDisplayChange )
  252. ON_MESSAGE_VOID( WM_SETTINGCHANGE, OnDisplayChange )
  253. ON_MESSAGE( WM_NEXTDLGCTL, OnNextDlgCtrl )
  254. END_MESSAGE_MAP()
  256. #ifdef _DEBUG
  258. void CExtSplitterBaseWnd::AssertValid() const
  259. {
  260. CWnd::AssertValid();
  261. ASSERT( m_nMaxRows >= 0 );
  262. ASSERT( m_nMaxCols >= 0 );
  263. ASSERT( m_nMaxCols >= 0 && m_nMaxRows >= 0 );
  264. ASSERT( m_nRows >= 0 );
  265. ASSERT( m_nCols >= 0 );
  266. ASSERT( m_nRows <= m_nMaxRows );
  267. ASSERT( m_nCols <= m_nMaxCols );
  268. }
  270. void CExtSplitterBaseWnd::Dump( CDumpContext & dc ) const
  271. {
  272. CSplitterWnd::Dump( dc );
  273. if( m_pDynamicViewClass != NULL )
  274. dc << "m_pDynamicViewClass = " << m_pDynamicViewClass->m_lpszClassName;
  275. dc << "nm_nMaxRows = " << m_nMaxRows;
  276. dc << "nm_nMaxCols = " << m_nMaxCols;
  277. dc << "nm_nRows = " << m_nRows;
  278. dc << "nm_nCols = " << m_nCols;
  279. dc << "nm_bHasHScroll = " << m_bHasHScroll;
  280. dc << "nm_bHasVScroll = " << m_bHasVScroll;
  281. dc << "nm_cxSplitter = " << m_cxSplitter;
  282. dc << "nm_cySplitter = " << m_cySplitter;
  283. if( m_bTracking )
  284. {
  285. dc << "nTRACKING: m_htTrack = " << m_htTrack;
  286. dc << "nm_rectLimit = " << m_rectLimit;
  287. dc << "nm_ptTrackOffset = " << m_ptTrackOffset;
  288. dc << "nm_rectTracker = " << m_rectTracker;
  289. if( m_bTracking2)
  290. dc << "nm_rectTracker2 = " << m_rectTracker2;
  291. }
  292. dc << "n";
  293. }
  295. #endif
  297. BOOL CExtSplitterBaseWnd::Create(
  298. CWnd * pParentWnd,
  299. int nMaxRows,
  300. int nMaxCols,
  301. SIZE sizeMin,
  302. CCreateContext * pContext,
  303. DWORD dwStyle,
  304. UINT nID
  305. )
  306. {
  307. ASSERT( pParentWnd != NULL );
  308. ASSERT( sizeMin.cx > 0 && sizeMin.cy > 0 );
  309. ASSERT( pContext != NULL );
  310. ASSERT( pContext->m_pNewViewClass != NULL );
  311. ASSERT( dwStyle & WS_CHILD );
  312. ASSERT( dwStyle & SPLS_DYNAMIC_SPLIT );
  313. ASSERT( nMaxRows >= 1 && nMaxRows <= 2 );
  314. ASSERT( nMaxCols >= 1 && nMaxCols <= 2 );
  315. ASSERT( nMaxCols > 1 || nMaxRows > 1 );
  316. m_nMaxRows = nMaxRows;
  317. m_nMaxCols = nMaxCols;
  318. ASSERT( m_nRows == 0 && m_nCols == 0 );
  319. m_nRows = m_nCols = 1;
  320. if( ! CreateCommon( pParentWnd, sizeMin, dwStyle, nID ) )
  321. return FALSE;
  322. ASSERT( m_nRows == 1 && m_nCols == 1 );
  323. ASSERT( pContext->m_pNewViewClass->IsDerivedFrom( RUNTIME_CLASS( CWnd ) ) );
  324. m_pDynamicViewClass = pContext->m_pNewViewClass;
  325. if( ! CreateView( 0, 0, m_pDynamicViewClass, sizeMin, pContext ) )
  326. {
  327. DestroyWindow();
  328. return FALSE;
  329. }
  330. m_pColInfo[0].nIdealSize = sizeMin.cx;
  331. m_pRowInfo[0].nIdealSize = sizeMin.cy;
  332. return TRUE;
  333. }
  335. BOOL CExtSplitterBaseWnd::CreateStatic(
  336. CWnd * pParentWnd,
  337. int nRows,
  338. int nCols,
  339. DWORD dwStyle,
  340. UINT nID
  341. )
  342. {
  343. ASSERT( pParentWnd != NULL );
  344. ASSERT( nRows >= 1 && nRows <= 16 );
  345. ASSERT( nCols >= 1 && nCols <= 16 );
  346. ASSERT( nCols > 1 || nRows > 1 );
  347. ASSERT( dwStyle & WS_CHILD );
  348. ASSERT( !(dwStyle & SPLS_DYNAMIC_SPLIT ) );
  349. ASSERT( m_nRows == 0 && m_nCols == 0 );
  350. m_nRows = m_nMaxRows = nRows;
  351. m_nCols = m_nMaxCols = nCols;
  352. if( ! CreateCommon( pParentWnd, CSize( 0, 0 ), dwStyle, nID ) )
  353. return FALSE;
  354. return TRUE;
  355. }
  357. BOOL CExtSplitterBaseWnd::CreateCommon( CWnd * pParentWnd, SIZE sizeMin, DWORD dwStyle, UINT nID )
  358. {
  359. ASSERT( pParentWnd != NULL );
  360. ASSERT( sizeMin.cx >= 0 && sizeMin.cy >= 0 );
  361. ASSERT( dwStyle & WS_CHILD );
  362. ASSERT( nID != 0 );
  363. ASSERT( m_pColInfo == NULL && m_pRowInfo == NULL );
  364. ASSERT( m_nMaxCols > 0 && m_nMaxRows > 0 );
  365. DWORD dwCreateStyle = dwStyle & ~(WS_HSCROLL|WS_VSCROLL);
  366. #if _MFC_VER < 0x700
  367. if( afxData.bWin4 )
  368. #endif //_MFC_VER < 0x700
  369. dwCreateStyle &= ~WS_BORDER;
  370. VERIFY( AfxDeferRegisterClass( AFX_WNDMDIFRAME_REG ) );
  371. static const TCHAR _afxWndMDIFrame[] = AFX_WNDMDIFRAME;
  372. if( ! CreateEx( WS_EX_CONTROLPARENT, _afxWndMDIFrame, NULL, dwCreateStyle, 0, 0, 0, 0, pParentWnd->m_hWnd, (HMENU)nID, NULL ) )
  373. return FALSE;
  374. TRY
  375. {
  376. m_pColInfo = new CRowColInfo[ m_nMaxCols ];
  377. for( int col = 0; col < m_nMaxCols; col++ )
  378. {
  379. m_pColInfo[col].nMinSize = m_pColInfo[col].nIdealSize = sizeMin.cx;
  380. m_pColInfo[col].nCurSize = -1;
  381. }
  382. m_pRowInfo = new CRowColInfo[m_nMaxRows];
  383. for( int row = 0; row < m_nMaxRows; row++ )
  384. {
  385. m_pRowInfo[row].nMinSize = m_pRowInfo[row].nIdealSize = sizeMin.cy;
  386. m_pRowInfo[row].nCurSize = -1;
  387. }
  388. SetScrollStyle( dwStyle );
  389. }
  390. CATCH_ALL( e )
  391. {
  392. DestroyWindow();
  393. return FALSE;
  394. }
  395. END_CATCH_ALL
  396. return TRUE;
  397. }
  399. BOOL CExtSplitterBaseWnd::OnNcCreate( LPCREATESTRUCT lpcs )
  400. {
  401. if( ! CSplitterWnd::OnNcCreate( lpcs ) )
  402. return FALSE;
  403. CWnd * pParent = GetParent();
  404. ASSERT_VALID( pParent );
  405. pParent->ModifyStyleEx( WS_EX_CLIENTEDGE, 0, SWP_DRAWFRAME );
  406. return TRUE;
  407. }
  409. BOOL CExtSplitterBaseWnd::CreateView(
  410. int row,
  411. int col,
  412. CRuntimeClass * pViewClass,
  413. SIZE sizeInit,
  414. CCreateContext * pContext
  415. )
  416. {
  417. ASSERT_VALID( this );
  418. ASSERT( row >= 0 && row < m_nRows );
  419. ASSERT( col >= 0 && col < m_nCols );
  420. ASSERT( pViewClass != NULL );
  421. ASSERT( pViewClass->IsDerivedFrom( RUNTIME_CLASS( CWnd ) ) );
  422. ASSERT( AfxIsValidAddress( pViewClass, sizeof( CRuntimeClass ), FALSE ) );
  423. #ifdef _DEBUG
  424. if( GetDlgItem( IdFromRowCol( row, col ) ) != NULL )
  425. {
  426. TRACE2(" Error: CreateView - pane already exists for row %d, col %d.n", row, col );
  427. ASSERT( FALSE );
  428. return FALSE;
  429. }
  430. #endif
  431. m_pColInfo[col].nIdealSize = sizeInit.cx;
  432. m_pRowInfo[row].nIdealSize = sizeInit.cy;
  433. BOOL bSendInitialUpdate = FALSE;
  434. CCreateContext contextT;
  435. if( pContext == NULL )
  436. {
  437. CView * pOldView = (CView*)GetActivePane();
  438. if( pOldView != NULL && pOldView->IsKindOf( RUNTIME_CLASS( CView ) ) )
  439. {
  440. ASSERT( contextT.m_pCurrentFrame == NULL );
  441. contextT.m_pLastView = pOldView;
  442. contextT.m_pCurrentDoc = pOldView->GetDocument();
  443. if( contextT.m_pCurrentDoc != NULL )
  444. contextT.m_pNewDocTemplate = contextT.m_pCurrentDoc->GetDocTemplate();
  445. }
  446. pContext = &contextT;
  447. bSendInitialUpdate = TRUE;
  448. }
  449. CWnd * pWnd = NULL;
  450. TRY
  451. {
  452. pWnd = (CWnd*)pViewClass->CreateObject();
  453. if( pWnd == NULL )
  454. AfxThrowMemoryException();
  455. }
  456. CATCH_ALL(e)
  457. {
  458. TRACE0("Out of memory creating a splitter pane.n");
  459. // Note: DELETE_EXCEPTION(e) not required
  460. return FALSE;
  461. }
  462. END_CATCH_ALL
  463. ASSERT_KINDOF( CWnd, pWnd );
  464. ASSERT( pWnd->m_hWnd == NULL );
  465. DWORD dwStyle = AFX_WS_DEFAULT_VIEW;
  466. #if _MFC_VER < 0x700
  467. if( afxData.bWin4 )
  468. #endif //_MFC_VER < 0x700
  469. dwStyle &= ~WS_BORDER;
  470. CRect rect(CPoint(0,0), sizeInit);
  471. if( ! pWnd->Create( NULL, NULL, dwStyle, rect, this, IdFromRowCol(row, col), pContext ) )
  472. {
  473. TRACE0("Warning: couldn't create client pane for splitter.n");
  474. return FALSE;
  475. }
  476. ASSERT( (int)_AfxGetDlgCtrlID( pWnd->m_hWnd ) == IdFromRowCol( row, col ) );
  477. if( bSendInitialUpdate )
  478. pWnd->SendMessage( WM_INITIALUPDATE );
  479. return TRUE;
  480. }
  482. BOOL CExtSplitterBaseWnd::CreateScrollBarCtrl( DWORD dwStyle, UINT nID )
  483. {
  484. ASSERT_VALID( this );
  485. ASSERT(m_hWnd != NULL);
  486. HWND hWnd =
  487. ::CreateWindow(
  488. _T("SCROLLBAR"),
  489. NULL,
  490. dwStyle|WS_VISIBLE|WS_CHILD|WS_CLIPSIBLINGS|WS_CLIPCHILDREN,
  491. 0, 0, 1, 1,
  492. m_hWnd,
  493. (HMENU)nID,
  494. AfxGetInstanceHandle(),
  495. NULL
  496. );
  497. #ifdef _DEBUG
  498. if( hWnd == NULL )
  499. TRACE1( "Warning: Window creation failed: GetLastError returns 0x%8.8Xn", GetLastError() );
  500. #endif
  501. return hWnd != NULL;
  502. }
  504. int CExtSplitterBaseWnd::IdFromRowCol( int row, int col ) const
  505. {
  506. ASSERT_VALID( this );
  507. ASSERT( row >= 0 );
  508. ASSERT( row < m_nRows );
  509. ASSERT( col >= 0 );
  510. ASSERT( col < m_nCols );
  511. return AFX_IDW_PANE_FIRST + row * 16 + col;
  512. }
  514. CWnd * CExtSplitterBaseWnd::GetPane( int row, int col ) const
  515. {
  516. ASSERT_VALID( this );
  517. CWnd * pView = GetDlgItem( IdFromRowCol(row, col) );
  518. ASSERT( pView != NULL );
  519. return pView;
  520. }
  522. BOOL CExtSplitterBaseWnd::IsChildPane( CWnd * pWnd, int * pRow, int * pCol )
  523. {
  524. ASSERT_VALID( this );
  525. ASSERT_VALID( pWnd );
  526. UINT nID = _AfxGetDlgCtrlID( pWnd->m_hWnd );
  527. if( IsChild( pWnd ) && nID >= AFX_IDW_PANE_FIRST && nID <= AFX_IDW_PANE_LAST )
  528. {
  529. if( pRow != NULL )
  530. *pRow = (nID - AFX_IDW_PANE_FIRST) / 16;
  531. if( pCol != NULL )
  532. *pCol = (nID - AFX_IDW_PANE_FIRST) % 16;
  533. ASSERT( pRow == NULL || *pRow < m_nRows );
  534. ASSERT( pCol == NULL || *pCol < m_nCols );
  535. return TRUE;
  536. }
  537. else
  538. {
  539. if( pRow != NULL )
  540. *pRow = -1;
  541. if( pCol != NULL )
  542. *pCol = -1;
  543. return FALSE;
  544. }
  545. }
  547. void CExtSplitterBaseWnd::GetRowInfo( int row, int & cyCur, int & cyMin) const
  548. {
  549. ASSERT_VALID( this );
  550. ASSERT( row >= 0 && row < m_nMaxRows );
  551. cyCur = m_pRowInfo[row].nCurSize;
  552. cyMin = m_pRowInfo[row].nMinSize;
  553. }
  555. void CExtSplitterBaseWnd::SetRowInfo(int row, int cyIdeal, int cyMin)
  556. {
  557. ASSERT_VALID( this );
  558. ASSERT( row >= 0 && row < m_nMaxRows );
  559. ASSERT( cyIdeal >= 0 );
  560. ASSERT( cyMin >= 0 );
  561. m_pRowInfo[row].nIdealSize = cyIdeal;
  562. m_pRowInfo[row].nMinSize = cyMin;
  563. }
  565. void CExtSplitterBaseWnd::GetColumnInfo(int col, int& cxCur, int& cxMin) const
  566. {
  567. ASSERT_VALID( this );
  568. ASSERT( col >= 0 && col < m_nMaxCols );
  569. cxCur = m_pColInfo[col].nCurSize;
  570. cxMin = m_pColInfo[col].nMinSize;
  571. }
  573. void CExtSplitterBaseWnd::SetColumnInfo(int col, int cxIdeal, int cxMin)
  574. {
  575. ASSERT_VALID( this );
  576. ASSERT( col >= 0 && col < m_nMaxCols );
  577. ASSERT( cxIdeal >= 0 );
  578. ASSERT( cxMin >= 0 );
  579. m_pColInfo[col].nIdealSize = cxIdeal;
  580. m_pColInfo[col].nMinSize = cxMin;
  581. }
  583. DWORD CExtSplitterBaseWnd::GetScrollStyle() const
  584. {
  585. DWORD dwStyle = 0;
  586. if( m_bHasHScroll )
  587. dwStyle |= WS_HSCROLL;
  588. if( m_bHasVScroll )
  589. dwStyle |= WS_VSCROLL;
  590. return dwStyle;
  591. }
  593. void CExtSplitterBaseWnd::SetScrollStyle( DWORD dwStyle )
  594. {
  595. dwStyle &= (WS_HSCROLL|WS_VSCROLL);
  596. if( GetScrollStyle() == dwStyle )
  597. return;
  598. m_bHasHScroll = (dwStyle & WS_HSCROLL) != 0;
  599. m_bHasVScroll = (dwStyle & WS_VSCROLL) != 0;
  600. CWnd * pScrollBar = NULL;
  601. for( int col = 0; col < m_nCols; col++ )
  602. {
  603. pScrollBar = GetDlgItem( AFX_IDW_HSCROLL_FIRST + col );
  604. if( pScrollBar == NULL )
  605. {
  606. if( ! CreateScrollBarCtrl( SBS_HORZ, AFX_IDW_HSCROLL_FIRST + col ) )
  607. AfxThrowResourceException();
  608. pScrollBar = GetDlgItem( AFX_IDW_HSCROLL_FIRST + col );
  609. }
  610. pScrollBar->ShowWindow( m_bHasHScroll ? SW_SHOW : SW_HIDE );
  611. }
  612. for( int row = 0; row < m_nRows; row++ )
  613. {
  614. pScrollBar = GetDlgItem( AFX_IDW_VSCROLL_FIRST + row );
  615. if( pScrollBar == NULL )
  616. {
  617. if( ! CreateScrollBarCtrl( SBS_VERT, AFX_IDW_VSCROLL_FIRST + row ) )
  618. AfxThrowResourceException();
  619. pScrollBar = GetDlgItem( AFX_IDW_VSCROLL_FIRST + row );
  620. }
  621. pScrollBar->ShowWindow( m_bHasVScroll ? SW_SHOW : SW_HIDE );
  622. }
  623. if( m_bHasVScroll && m_bHasHScroll )
  624. {
  625. pScrollBar = GetDlgItem( AFX_IDW_SIZE_BOX );
  626. if( pScrollBar == NULL )
  627. {
  628. if( ! CreateScrollBarCtrl( SBS_SIZEBOX|WS_DISABLED, AFX_IDW_SIZE_BOX ) )
  629. AfxThrowResourceException();
  630. pScrollBar = GetDlgItem( AFX_IDW_SIZE_BOX );
  631. }
  632. pScrollBar->ShowWindow( SW_SHOW );
  633. }
  634. else
  635. {
  636. pScrollBar = GetDlgItem( AFX_IDW_SIZE_BOX );
  637. if( pScrollBar != NULL )
  638. pScrollBar->DestroyWindow();
  639. }
  640. }
  642. void CExtSplitterBaseWnd::DeleteView( int row, int col )
  643. {
  644. ASSERT_VALID( this );
  645. CWnd* pPane = GetPane(row, col);
  646. ASSERT_KINDOF( CView, pPane );
  647. if( GetActivePane() == pPane )
  648. ActivateNext( FALSE );
  649. pPane->DestroyWindow();
  650. }
  652. void CExtSplitterBaseWnd::OnDrawSplitter( CDC * pDC, CExtSplitterBaseWnd::ESplitType nType, const CRect & rectArg )
  653. {
  654. nType;
  655. if( pDC == NULL )
  656. {
  657. RedrawWindow( rectArg, NULL, RDW_INVALIDATE|RDW_NOCHILDREN );
  658. return;
  659. }
  660. // ASSERT_VALID( pDC );
  661. //CRect rect = rectArg;
  662. // switch( nType )
  663. // {
  664. // case splitBorder:
  665. //#if _MFC_VER < 0x700
  666. // ASSERT( afxData.bWin4 );
  667. //#endif //_MFC_VER < 0x700
  668. // pDC->Draw3dRect( rect, afxData.clrBtnShadow, afxData.clrBtnHilite );
  669. // rect.InflateRect( -__EXT_MFC_CX_BORDER, -__EXT_MFC_CY_BORDER );
  670. // pDC->Draw3dRect( rect, afxData.clrWindowFrame, afxData.clrBtnFace );
  671. // return;
  672. // case splitIntersection:
  673. //#if _MFC_VER < 0x700
  674. // ASSERT( ! afxData.bWin4 );
  675. //#endif //_MFC_VER < 0x700
  676. // break;
  677. // case splitBox:
  678. //#if _MFC_VER < 0x700
  679. // if( afxData.bWin4 )
  680. //#endif //_MFC_VER < 0x700
  681. // {
  682. // pDC->Draw3dRect(rect, afxData.clrBtnFace, afxData.clrWindowFrame);
  683. // rect.InflateRect(-__EXT_MFC_CX_BORDER, -__EXT_MFC_CY_BORDER);
  684. // pDC->Draw3dRect(rect, afxData.clrBtnHilite, afxData.clrBtnShadow);
  685. // rect.InflateRect(-__EXT_MFC_CX_BORDER, -__EXT_MFC_CY_BORDER);
  686. // break;
  687. // }
  688. // // fall through...
  689. // case splitBar:
  690. //#if _MFC_VER < 0x700
  691. // if( ! afxData.bWin4 )
  692. // {
  693. // pDC->Draw3dRect(rect, afxData.clrBtnHilite, afxData.clrBtnShadow);
  694. // rect.InflateRect(-__EXT_MFC_CX_BORDER, -__EXT_MFC_CY_BORDER);
  695. // }
  696. //#endif //_MFC_VER < 0x700
  697. // break;
  698. // default:
  699. // ASSERT(FALSE);
  700. // break;
  701. // }
  702. //COLORREF clr = afxData.clrBtnFace;
  703. // pDC->FillSolidRect( rect, clr );
  704. }
  706. BOOL CExtSplitterBaseWnd::SplitRow( int cyBefore )
  707. {
  708. ASSERT_VALID( this );
  709. ASSERT( GetStyle() & SPLS_DYNAMIC_SPLIT );
  710. ASSERT( m_pDynamicViewClass != NULL );
  711. ASSERT( m_nRows < m_nMaxRows );
  712. cyBefore -= m_cyBorder;
  713. int rowNew = m_nRows;
  714. int cyNew = stat_CanSplitRowCol( &m_pRowInfo[rowNew-1], cyBefore, m_cySplitter );
  715. if( cyNew == -1 )
  716. return FALSE;
  717. if( m_bHasVScroll
  718. && (! CreateScrollBarCtrl( SBS_VERT, AFX_IDW_VSCROLL_FIRST + rowNew ) )
  719. )
  720. {
  721. TRACE0("Warning: SplitRow failed to create scroll bar.n");
  722. return FALSE;
  723. }
  724. m_nRows++;
  725. for( int col = 0; col < m_nCols; col++ )
  726. {
  727. CSize size( m_pColInfo[col].nCurSize, cyNew );
  728. if( ! CreateView( rowNew, col, m_pDynamicViewClass, size, NULL ) )
  729. {
  730. TRACE0("Warning: SplitRow failed to create new row.n");
  731. while( col > 0 )
  732. DeleteView( rowNew, --col );
  733. if( m_bHasVScroll )
  734. GetDlgItem( AFX_IDW_VSCROLL_FIRST + rowNew )->DestroyWindow();
  735. m_nRows--;
  736. return FALSE;
  737. }
  738. }
  739. m_pRowInfo[rowNew-1].nIdealSize = cyBefore;
  740. m_pRowInfo[rowNew].nIdealSize = cyNew;
  741. ASSERT(m_nRows == rowNew+1);
  742. RecalcLayout();
  743. return TRUE;
  744. }
  746. BOOL CExtSplitterBaseWnd::SplitColumn( int cxBefore )
  747. {
  748. ASSERT_VALID( this );
  749. ASSERT( GetStyle() & SPLS_DYNAMIC_SPLIT );
  750. ASSERT( m_pDynamicViewClass != NULL );
  751. ASSERT( m_nCols < m_nMaxCols );
  752. cxBefore -= m_cxBorder;
  753. int colNew = m_nCols;
  754. int cxNew = stat_CanSplitRowCol(&m_pColInfo[colNew-1], cxBefore, m_cxSplitter);
  755. if( cxNew == -1 )
  756. return FALSE;
  757. if( m_bHasHScroll
  758. && (! CreateScrollBarCtrl( SBS_HORZ, AFX_IDW_HSCROLL_FIRST + colNew ) )
  759. )
  760. {
  761. TRACE0("Warning: SplitRow failed to create scroll bar.n");
  762. return FALSE;
  763. }
  764. m_nCols++;
  765. for( int row = 0; row < m_nRows; row++ )
  766. {
  767. CSize size( cxNew, m_pRowInfo[row].nCurSize );
  768. if( ! CreateView( row, colNew, m_pDynamicViewClass, size, NULL ) )
  769. {
  770. TRACE0("Warning: SplitColumn failed to create new column.n");
  771. while( row > 0 )
  772. DeleteView( --row, colNew );
  773. if( m_bHasHScroll )
  774. GetDlgItem( AFX_IDW_HSCROLL_FIRST + colNew )->DestroyWindow();
  775. m_nCols--;
  776. return FALSE;
  777. }
  778. }
  779. m_pColInfo[colNew-1].nIdealSize = cxBefore;
  780. m_pColInfo[colNew].nIdealSize = cxNew;
  781. ASSERT( m_nCols == colNew+1 );
  782. RecalcLayout();
  783. return TRUE;
  784. }
  786. void CExtSplitterBaseWnd::DeleteRow(int rowDelete)
  787. {
  788. ASSERT_VALID( this );
  789. ASSERT( GetStyle() & SPLS_DYNAMIC_SPLIT );
  790. ASSERT( m_nRows > 1 );
  791. ASSERT( rowDelete < m_nRows );
  792. int rowActive, colActive;
  793. if( GetActivePane( &rowActive, &colActive ) != NULL && rowActive == rowDelete )
  794. {
  795. if( ++rowActive >= m_nRows )
  796. rowActive = 0;
  797. SetActivePane( rowActive, colActive );
  798. }
  799. CWnd * pScrollDel = m_bHasVScroll ? GetDlgItem( AFX_IDW_VSCROLL_FIRST + rowDelete ) : NULL;
  800. for( int col = 0; col < m_nCols; col++ )
  801. {
  802. DeleteView( rowDelete, col );
  803. for( int row = rowDelete+1; row < m_nRows; row++ )
  804. {
  805. CWnd * pPane = GetPane( row, col );
  806. ASSERT( pPane != NULL );
  807. pPane->SetDlgCtrlID( IdFromRowCol( row-1, col ) );
  808. if( m_bHasVScroll && col == m_nCols-1 )
  809. {
  810. CWnd * pScroll = GetDlgItem( AFX_IDW_VSCROLL_FIRST + row );
  811. if( pScroll != NULL )
  812. pScroll->SetDlgCtrlID( AFX_IDW_VSCROLL_FIRST + row - 1 );
  813. }
  814. }
  815. }
  816. m_nRows--;
  817. if( pScrollDel != NULL )
  818. pScrollDel->DestroyWindow();
  819. RecalcLayout();
  820. }
  822. void CExtSplitterBaseWnd::DeleteColumn( int colDelete )
  823. {
  824. ASSERT_VALID( this );
  825. ASSERT( GetStyle() & SPLS_DYNAMIC_SPLIT );
  826. ASSERT( m_nCols > 1 );
  827. ASSERT( colDelete < m_nCols );
  828. int rowActive, colActive;
  829. if( GetActivePane( &rowActive, &colActive ) != NULL && colActive == colDelete )
  830. {
  831. if( ++colActive >= m_nCols )
  832. colActive = 0;
  833. SetActivePane( rowActive, colActive );
  834. }
  835. CWnd * pScrollDel = m_bHasHScroll ? GetDlgItem( AFX_IDW_HSCROLL_FIRST + colDelete ) : NULL;
  836. for( int row = 0; row < m_nRows; row++ )
  837. {
  838. DeleteView( row, colDelete );
  839. for( int col = colDelete+1; col < m_nCols; col++ )
  840. {
  841. CWnd * pPane = GetPane( row, col );
  842. ASSERT( pPane != NULL );
  843. pPane->SetDlgCtrlID( IdFromRowCol( row, col-1 ) );
  844. if( m_bHasHScroll && row == m_nRows - 1 )
  845. {
  846. CWnd * pScroll = GetDlgItem( AFX_IDW_HSCROLL_FIRST + col );
  847. if( pScroll != NULL )
  848. pScroll->SetDlgCtrlID( AFX_IDW_HSCROLL_FIRST + col - 1 );
  849. }
  850. }
  851. }
  852. m_nCols--;
  853. if( pScrollDel != NULL )
  854. pScrollDel->DestroyWindow();
  855. RecalcLayout();
  856. }
  858. void CExtSplitterBaseWnd::GetInsideRect( CRect & rect ) const
  859. {
  860. ASSERT_VALID( this );
  861. GetClientRect( rect );
  862. ASSERT( rect.left == 0 && rect.top == 0 );
  863. rect.InflateRect( -m_cxBorder, -m_cyBorder );
  864. if( m_bHasVScroll )
  865. rect.right -= afxData.cxVScroll - __EXT_MFC_CX_BORDER;
  866. if( m_bHasHScroll )
  867. rect.bottom -= afxData.cyHScroll - __EXT_MFC_CY_BORDER;
  868. }
  870. void CExtSplitterBaseWnd::StartTracking( int ht )
  871. {
  872. ASSERT_VALID( this );
  873. if( ht == noHit )
  874. return;
  875. GetInsideRect( m_rectLimit );
  876. if( ht >= splitterIntersection1 && ht <= splitterIntersection225 )
  877. {
  878. int row = (ht - splitterIntersection1) / 15;
  879. int col = (ht - splitterIntersection1) % 15;
  880. GetHitRect( row + vSplitterBar1, m_rectTracker );
  881. int yTrackOffset = m_ptTrackOffset.y;
  882. m_bTracking2 = TRUE;
  883. GetHitRect( col + hSplitterBar1, m_rectTracker2 );
  884. m_ptTrackOffset.y = yTrackOffset;
  885. }
  886. else if( ht == bothSplitterBox )
  887. {
  888. GetHitRect(vSplitterBox, m_rectTracker);
  889. int yTrackOffset = m_ptTrackOffset.y;
  890. m_bTracking2 = TRUE;
  891. GetHitRect( hSplitterBox, m_rectTracker2 );
  892. m_ptTrackOffset.y = yTrackOffset;
  893. m_rectTracker.OffsetRect( 0, m_rectLimit.Height()/2 );
  894. m_rectTracker2.OffsetRect( m_rectLimit.Width()/2, 0 );
  895. }
  896. else
  897. GetHitRect(ht, m_rectTracker);
  898. CView * pView = (CView*)GetActivePane();
  899. if( pView != NULL && pView->IsKindOf( RUNTIME_CLASS( CView ) )  )
  900. {
  901. ASSERT_VALID( pView );
  902. CFrameWnd * pFrameWnd = GetParentFrame();
  903. if( pFrameWnd != NULL )
  904. {
  905. ASSERT_VALID( pFrameWnd );
  906. ((friently_view_t*)pView)->OnActivateFrame( WA_INACTIVE, pFrameWnd );
  907. }
  908. }
  909. SetCapture();
  910. SetFocus();
  911. RedrawWindow( NULL, NULL, RDW_ALLCHILDREN | RDW_UPDATENOW );
  912. m_bTracking = TRUE;
  913. OnInvertTracker( m_rectTracker );
  914. if( m_bTracking2 )
  915. OnInvertTracker( m_rectTracker2 );
  916. m_htTrack = ht;
  917. SetSplitCursor( ht );
  918. }
  920. void CExtSplitterBaseWnd::TrackRowSize( int y, int row )
  921. {
  922. ASSERT_VALID( this );
  923. ASSERT( m_nRows > 1 );
  924. CPoint pt( 0, y );
  925. ClientToScreen( & pt);
  926. GetPane( row, 0 )->ScreenToClient( &pt );
  927. m_pRowInfo[row].nIdealSize = pt.y;
  928. if( pt.y < m_pRowInfo[row].nMinSize )
  929. {
  930. m_pRowInfo[row].nIdealSize = 0;
  931. if( GetStyle() & SPLS_DYNAMIC_SPLIT )
  932. DeleteRow( row );
  933. }
  934. else if( m_pRowInfo[row].nCurSize + m_pRowInfo[row+1].nCurSize < pt.y + m_pRowInfo[row+1].nMinSize )
  935. {
  936. if( GetStyle() & SPLS_DYNAMIC_SPLIT )
  937. DeleteRow( row + 1 );
  938. }
  939. }
  941. void CExtSplitterBaseWnd::TrackColumnSize( int x, int col )
  942. {
  943. ASSERT_VALID( this );
  944. ASSERT(m_nCols > 1);
  945. CPoint pt(x, 0);
  946. ClientToScreen(&pt);
  947. GetPane( 0, col )->ScreenToClient( &pt );
  948. m_pColInfo[col].nIdealSize = pt.x;
  949. if( pt.x < m_pColInfo[col].nMinSize )
  950. {
  951. m_pColInfo[col].nIdealSize = 0;
  952. if( GetStyle() & SPLS_DYNAMIC_SPLIT )
  953. DeleteColumn(col);
  954. }
  955. else if( m_pColInfo[col].nCurSize + m_pColInfo[col+1].nCurSize < pt.x + m_pColInfo[col+1].nMinSize )
  956. {
  957. if( GetStyle() & SPLS_DYNAMIC_SPLIT )
  958. DeleteColumn(col + 1);
  959. }
  960. }
  962. void CExtSplitterBaseWnd::StopTracking(BOOL bAccept)
  963. {
  964. ASSERT_VALID( this );
  965. if( ! m_bTracking )
  966. return;
  967. ReleaseCapture();
  968. OnInvertTracker( m_rectTracker );
  969. if( m_bTracking2 )
  970. OnInvertTracker( m_rectTracker2 );
  971. m_bTracking = m_bTracking2 = FALSE;
  972. CWnd * pOldActiveView = GetActivePane();
  973. m_rectTracker.OffsetRect( -__EXT_MFC_CX_BORDER , -__EXT_MFC_CY_BORDER );
  974. m_rectTracker2.OffsetRect( -__EXT_MFC_CX_BORDER, -__EXT_MFC_CY_BORDER );
  975. if( bAccept )
  976. {
  977. if( m_htTrack == vSplitterBox )
  978. SplitRow( m_rectTracker.top );
  979. else if( m_htTrack >= vSplitterBar1 && m_htTrack <= vSplitterBar15 )
  980. {
  981. TrackRowSize( m_rectTracker.top, m_htTrack - vSplitterBar1 );
  982. RecalcLayout();
  983. }
  984. else if( m_htTrack == hSplitterBox )
  985. SplitColumn(m_rectTracker.left);
  986. else if( m_htTrack >= hSplitterBar1 && m_htTrack <= hSplitterBar15 )
  987. {
  988. TrackColumnSize( m_rectTracker.left, m_htTrack - hSplitterBar1 );
  989. RecalcLayout();
  990. }
  991. else if( m_htTrack >= splitterIntersection1 && m_htTrack <= splitterIntersection225 )
  992. {
  993. int row = (m_htTrack - splitterIntersection1) / 15;
  994. int col = (m_htTrack - splitterIntersection1) % 15;
  995. TrackRowSize( m_rectTracker.top, row );
  996. TrackColumnSize( m_rectTracker2.left, col );
  997. RecalcLayout();
  998. }
  999. else if( m_htTrack == bothSplitterBox )
  1000. {
  1001. SplitRow( m_rectTracker.top );
  1002. SplitColumn( m_rectTracker2.left );
  1003. }
  1004. }
  1005. if( pOldActiveView == GetActivePane() )
  1006. {
  1007. if( pOldActiveView != NULL)
  1008. {
  1009. SetActivePane( -1, -1, pOldActiveView );
  1010. pOldActiveView->SetFocus();
  1011. }
  1012. }
  1013. }
  1015. void CExtSplitterBaseWnd::GetHitRect( int ht, CRect & rectHit )
  1016. {
  1017. ASSERT_VALID( this );
  1018. CRect rectClient;
  1019. GetClientRect( &rectClient );
  1020. rectClient.InflateRect( -m_cxBorder, -m_cyBorder );
  1021. int cx = rectClient.Width();
  1022. int cy = rectClient.Height();
  1023. int x = rectClient.top;
  1024. int y = rectClient.left;
  1025. m_ptTrackOffset.x = 0;
  1026. m_ptTrackOffset.y = 0;
  1027. if( ht == vSplitterBox )
  1028. {
  1029. cy =
  1030. m_cySplitter - ( 2*m_cyBorder -
  1031. #if _MFC_VER < 0x700
  1032. afxData.bWin4
  1033. #else
  1034. 1
  1035. #endif
  1036. );
  1037. m_ptTrackOffset.y = -(cy / 2);
  1038. ASSERT( m_pRowInfo[0].nCurSize > 0 );
  1039. m_rectLimit.bottom -= cy;
  1040. }
  1041. else if( ht == hSplitterBox )
  1042. {
  1043. cx =
  1044. m_cxSplitter - ( 2*m_cxBorder -
  1045. #if _MFC_VER < 0x700
  1046. afxData.bWin4
  1047. #else
  1048. 1
  1049. #endif
  1050. );
  1051. m_ptTrackOffset.x = -(cx / 2);
  1052. ASSERT( m_pColInfo[0].nCurSize > 0 );
  1053. m_rectLimit.right -= cx;
  1054. }
  1055. else if( ht >= vSplitterBar1 && ht <= vSplitterBar15 )
  1056. {
  1057. cy =
  1058. m_cySplitter - ( 2*m_cyBorder -
  1059. #if _MFC_VER < 0x700
  1060. afxData.bWin4
  1061. #else
  1062. 1
  1063. #endif
  1064. );
  1065. m_ptTrackOffset.y = -(cy / 2);
  1066. int row = 0;
  1067. for( ; row < ht - vSplitterBar1; row++ )
  1068. y += m_pRowInfo[row].nCurSize + m_cySplitterGap;
  1069. m_rectLimit.top = y;
  1070. y +=
  1071. m_pRowInfo[row].nCurSize + m_cyBorderShare +
  1072. #if _MFC_VER < 0x700
  1073. afxData.bWin4
  1074. #else
  1075. 1
  1076. #endif
  1077. ;
  1078. m_rectLimit.bottom -= cy;
  1079. }
  1080. else if( ht >= hSplitterBar1 && ht <= hSplitterBar15 )
  1081. {
  1082. cx =
  1083. m_cxSplitter - ( 2*m_cxBorder -
  1084. #if _MFC_VER < 0x700
  1085. afxData.bWin4
  1086. #else
  1087. 1
  1088. #endif
  1089. );
  1090. m_ptTrackOffset.x = -(cx / 2);
  1091. int col = 0;
  1092. for( ; col < ht - hSplitterBar1; col++ )
  1093. x += m_pColInfo[col].nCurSize + m_cxSplitterGap;
  1094. m_rectLimit.left = x;
  1095. x +=
  1096. m_pColInfo[col].nCurSize + m_cxBorderShare +
  1097. #if _MFC_VER < 0x700
  1098. afxData.bWin4
  1099. #else
  1100. 1
  1101. #endif
  1102. ;
  1103. m_rectLimit.right -= cx;
  1104. }
  1105. else
  1106. {
  1107. TRACE1("Error: GetHitRect(%d): Not Found!n", ht);
  1108. ASSERT(FALSE);
  1109. }
  1110. rectHit.right = (rectHit.left = x) + cx;
  1111. rectHit.bottom = (rectHit.top = y) + cy;
  1112. }
  1114. int CExtSplitterBaseWnd::HitTest( CPoint pt ) const
  1115. {
  1116. ASSERT_VALID( this );
  1117. CRect rectClient;
  1118. GetClientRect(&rectClient);
  1119. rectClient.InflateRect(-m_cxBorder, -m_cyBorder);
  1120. CRect rectInside;
  1121. GetInsideRect(rectInside);
  1122. if( m_bHasVScroll
  1123. && m_nRows < m_nMaxRows
  1124. && CRect(
  1125. rectInside.right,
  1126. rectClient.top,
  1127. rectClient.right,
  1128. rectClient.top + m_cySplitter -
  1129. #if _MFC_VER < 0x700
  1130. afxData.bWin4
  1131. #else
  1132. 1
  1133. #endif
  1134. ).PtInRect( pt )
  1135. )
  1136. return vSplitterBox;
  1138. if( m_bHasHScroll
  1139. && m_nCols < m_nMaxCols
  1140. && CRect(
  1141. rectClient.left,
  1142. rectInside.bottom,
  1143. rectClient.left + m_cxSplitter -
  1144. #if _MFC_VER < 0x700
  1145. afxData.bWin4
  1146. #else
  1147. 1
  1148. #endif
  1149. ,
  1150. rectClient.bottom
  1151. ).PtInRect( pt )
  1152. )
  1153. return hSplitterBox;
  1154. CRect rect;
  1155. rect = rectClient;
  1156. int col = 0;
  1157. for( ; col < m_nCols - 1; col++ )
  1158. {
  1159. rect.left += m_pColInfo[col].nCurSize;
  1160. rect.right = rect.left + m_cxSplitterGap;
  1161. if( rect.PtInRect(pt) )
  1162. break;
  1163. rect.left = rect.right;
  1164. }
  1165. rect = rectClient;
  1166. int row = 0;
  1167. for( ; row < m_nRows - 1; row++ )
  1168. {
  1169. rect.top += m_pRowInfo[row].nCurSize;
  1170. rect.bottom = rect.top + m_cySplitterGap;
  1171. if( rect.PtInRect(pt))
  1172. break;
  1173. rect.top = rect.bottom;
  1174. }
  1175. if( col != m_nCols - 1 )
  1176. {
  1177. if( row != m_nRows - 1 )
  1178. return splitterIntersection1 + row * 15 + col;
  1179. return hSplitterBar1 + col;
  1180. }
  1181. if( row != m_nRows - 1 )
  1182. return vSplitterBar1 + row;
  1183. return noHit;
  1184. }
  1186. void CExtSplitterBaseWnd::OnInvertTracker( const CRect & rect )
  1187. {
  1188. ASSERT_VALID( this );
  1189. ASSERT( ! rect.IsRectEmpty() );
  1190. //ASSERT( (GetStyle() & WS_CLIPCHILDREN ) == 0 );
  1191. CDC * pDC = GetDCEx( NULL, DCX_WINDOW|DCX_CACHE );
  1192. ASSERT( pDC != NULL );
  1193. CBrush * pBrush = CDC::GetHalftoneBrush();
  1194. HBRUSH hOldBrush = NULL;
  1195. if( pBrush != NULL)
  1196. hOldBrush = (HBRUSH)SelectObject( pDC->m_hDC, pBrush->m_hObject );
  1197. pDC->PatBlt( rect.left, rect.top, rect.Width(), rect.Height(), PATINVERT );
  1198. if( hOldBrush != NULL )
  1199. SelectObject( pDC->m_hDC, hOldBrush );
  1200. ReleaseDC(pDC);
  1201. }
  1203. BOOL CExtSplitterBaseWnd::DoKeyboardSplit()
  1204. {
  1205. ASSERT_VALID( this );
  1206. int ht;
  1207. if( m_nRows > 1 && m_nCols > 1 )
  1208. ht = splitterIntersection1;
  1209. else if( m_nRows > 1 )
  1210. ht = vSplitterBar1;
  1211. else if( m_nCols > 1 )
  1212. ht = hSplitterBar1;
  1213. else if( m_nMaxRows > 1 && m_nMaxCols > 1 )
  1214. ht = bothSplitterBox;
  1215. else if( m_nMaxRows > 1 )
  1216. ht = vSplitterBox;
  1217. else if( m_nMaxCols > 1 )
  1218. ht = hSplitterBox;
  1219. else
  1220. return FALSE;
  1221. StartTracking( ht );
  1222. CRect rect;
  1223. rect.left = m_rectTracker.Width() / 2;
  1224. rect.top = m_rectTracker.Height() / 2;
  1225. if( m_ptTrackOffset.y != 0 )
  1226. rect.top = m_rectTracker.top;
  1227. if( m_ptTrackOffset.x != 0 )
  1228. rect.left = m_bTracking2 ? m_rectTracker2.left :m_rectTracker.left;
  1229. rect.OffsetRect( -m_ptTrackOffset.x, -m_ptTrackOffset.y );
  1230. ClientToScreen( &rect );
  1231. SetCursorPos( rect.left, rect.top );
  1232. return TRUE;
  1233. }
  1235. void CExtSplitterBaseWnd::OnDisplayChange()
  1236. {
  1237. ASSERT_VALID( this );
  1238. if( !IsIconic() && IsWindowVisible() )
  1239. RecalcLayout();
  1240. }
  1242. LRESULT CExtSplitterBaseWnd::OnNextDlgCtrl( WPARAM wParam, LPARAM lParam )
  1243. {
  1244. ASSERT_VALID( this );
  1245. if( LOWORD(lParam) != 0 )
  1246. return 1;
  1247. HWND hWndParent = ::GetParent( m_hWnd );
  1248. if( hWndParent == NULL )
  1249. return 1;
  1250. HWND hWndControl = ::GetFocus();
  1251. if( hWndControl == NULL )
  1252. return 1;
  1253. BOOL bPrevious = ( wParam != 0 ) ? TRUE : FALSE;
  1254. HWND hWndNewFocus = CExtResizableDialog::stat_GetNextItemZ( hWndParent, hWndParent, hWndControl, bPrevious );
  1255. if( hWndNewFocus != NULL )
  1256. ::SetFocus( hWndNewFocus );
  1257. return 0;
  1258. }
  1260. void CExtSplitterBaseWnd::OnSize( UINT nType, int cx, int cy )
  1261. {
  1262. ASSERT_VALID( this );
  1264. if( nType != SIZE_MINIMIZED && cx > 0 && cy > 0 )
  1265. RecalcLayout();
  1266. CSplitterWnd::OnSize( nType, cx, cy );
  1267. }
  1269. CWnd * CExtSplitterBaseWnd::GetSizingParent()
  1270. {
  1271. ASSERT_VALID( this );
  1272. #if _MFC_VER < 0x700
  1273. if( ! afxData.bWin4 )
  1274. return NULL;
  1275. #endif //_MFC_VER < 0x700
  1276. CRect rectClient;
  1277. GetClientRect(rectClient);
  1278. CWnd * pParent = this;
  1279. if( ! ( pParent->GetStyle() & WS_THICKFRAME ) )
  1280. pParent = GetParent();
  1281. ASSERT_VALID( pParent );
  1282. if( ( pParent->GetStyle() & (WS_THICKFRAME|WS_MAXIMIZE) ) == WS_THICKFRAME )
  1283. {
  1284. CRect rect;
  1285. pParent->GetClientRect( &rect );
  1286. pParent->ClientToScreen( &rect );
  1287. ScreenToClient( &rect );
  1288. if( rectClient.BottomRight() == rect.BottomRight() )
  1289. return pParent;
  1290. }
  1291. return NULL;
  1292. }
  1294. void CExtSplitterBaseWnd::RecalcLayout()
  1295. {
  1296. ASSERT_VALID( this );
  1297. ASSERT( m_nRows > 0 && m_nCols > 0 );
  1298. CRect rectClient;
  1299. GetClientRect( rectClient );
  1300. rectClient.InflateRect( -m_cxBorder, -m_cyBorder );
  1301. CRect rectInside;
  1302. GetInsideRect( rectInside );
  1303. stat_LayoutRowCol( m_pColInfo, m_nCols, rectInside.Width(), m_cxSplitterGap );
  1304. stat_LayoutRowCol( m_pRowInfo, m_nRows, rectInside.Height(), m_cySplitterGap );
  1305. AFX_SIZEPARENTPARAMS layout;
  1306. layout.hDWP = ::BeginDeferWindowPos( (m_nCols + 1) * (m_nRows + 1) + 1 );
  1307. int cx = (rectClient.right - rectInside.right) -
  1308. #if _MFC_VER < 0x700
  1309. afxData.bNotWin4
  1310. #else
  1311. 0
  1312. #endif
  1313. ;
  1314. int cy = (rectClient.bottom - rectInside.bottom) -
  1315. #if _MFC_VER < 0x700
  1316. afxData.bNotWin4
  1317. #else
  1318. 0
  1319. #endif
  1320. ;
  1321. if( m_bHasHScroll && m_bHasVScroll )
  1322. {
  1323. CWnd* pScrollBar = GetDlgItem( AFX_IDW_SIZE_BOX );
  1324. ASSERT( pScrollBar != NULL );
  1325. BOOL bSizingParent = (GetSizingParent() != NULL);
  1326. if( pScrollBar->ModifyStyle(SBS_SIZEGRIP|SBS_SIZEBOX, bSizingParent ? SBS_SIZEGRIP : SBS_SIZEBOX ) )
  1327. pScrollBar->Invalidate();
  1328. pScrollBar->EnableWindow(bSizingParent);
  1329. stat_DeferClientPos(
  1330. &layout,
  1331. pScrollBar,
  1332. rectInside.right +
  1333. #if _MFC_VER < 0x700
  1334. afxData.bNotWin4
  1335. #else
  1336. 0
  1337. #endif
  1338. ,
  1339. rectInside.bottom +
  1340. #if _MFC_VER < 0x700
  1341. afxData.bNotWin4
  1342. #else
  1343. 0
  1344. #endif
  1345. ,
  1346. cx,
  1347. cy,
  1348. TRUE
  1349. );
  1350. }
  1351. if( m_bHasHScroll )
  1352. {
  1353. int cxSplitterBox =
  1354. m_cxSplitter +
  1355. #if _MFC_VER < 0x700
  1356. afxData.bNotWin4
  1357. #else
  1358. 0
  1359. #endif
  1360. ;
  1361. int x = rectClient.left;
  1362. int y =
  1363. rectInside.bottom +
  1364. #if _MFC_VER < 0x700
  1365. afxData.bNotWin4
  1366. #else
  1367. 0
  1368. #endif
  1369. ;
  1370. for( int col = 0; col < m_nCols; col++ )
  1371. {
  1372. CWnd* pScrollBar = GetDlgItem( AFX_IDW_HSCROLL_FIRST + col );
  1373. ASSERT( pScrollBar != NULL );
  1374. int cx = m_pColInfo[col].nCurSize;
  1375. if( col == 0 && m_nCols < m_nMaxCols )
  1376. x += cxSplitterBox, cx -= cxSplitterBox;
  1377. stat_DeferClientPos( &layout, pScrollBar, x, y, cx, cy, TRUE );
  1378. x += cx + m_cxSplitterGap;
  1379. }
  1380. }
  1381. if( m_bHasVScroll )
  1382. {
  1383. int cySplitterBox =
  1384. m_cySplitter +
  1385. #if _MFC_VER < 0x700
  1386. afxData.bNotWin4
  1387. #else
  1388. 0
  1389. #endif
  1390. ;
  1391. int x =
  1392. rectInside.right +
  1393. #if _MFC_VER < 0x700
  1394. afxData.bNotWin4
  1395. #else
  1396. 0
  1397. #endif
  1398. ;
  1399. int y = rectClient.top;
  1400. for( int row = 0; row < m_nRows; row++ )
  1401. {
  1402. CWnd* pScrollBar = GetDlgItem( AFX_IDW_VSCROLL_FIRST + row );
  1403. ASSERT(pScrollBar != NULL);
  1404. int cy = m_pRowInfo[row].nCurSize;
  1405. if( row == 0 && m_nRows < m_nMaxRows )
  1406. y += cySplitterBox, cy -= cySplitterBox;
  1407. stat_DeferClientPos( &layout, pScrollBar, x, y, cx, cy, TRUE );
  1408. y += cy + m_cySplitterGap;
  1409. }
  1410. }
  1412. {
  1413. int x = rectClient.left;
  1414. for( int col = 0; col < m_nCols; col++ )
  1415. {
  1416. int cx = m_pColInfo[col].nCurSize;
  1417. int y = rectClient.top;
  1418. for( int row = 0; row < m_nRows; row++)
  1419. {
  1420. int cy = m_pRowInfo[row].nCurSize;
  1421. CWnd* pWnd = GetPane(row, col);
  1422. stat_DeferClientPos( &layout, pWnd, x, y, cx, cy, FALSE );
  1423. y += cy + m_cySplitterGap;
  1424. }
  1425. x += cx + m_cxSplitterGap;
  1426. }
  1427. }
  1429. if( layout.hDWP == NULL || !::EndDeferWindowPos( layout.hDWP ) )
  1430. TRACE0("Warning: DeferWindowPos failed - low system resources.n");
  1432. DrawAllSplitBars( NULL, rectInside.right, rectInside.bottom );
  1433. }
  1435. void CExtSplitterBaseWnd::DrawAllSplitBars( CDC* pDC, int cxInside, int cyInside )
  1436. {
  1437. ASSERT_VALID( this );
  1438. CRect rect;
  1439. GetClientRect(rect);
  1440. rect.left += m_cxBorder;
  1441. int col = 0;
  1442. for( ; col < m_nCols - 1; col++ )
  1443. {
  1444. rect.left += m_pColInfo[col].nCurSize + m_cxBorderShare;
  1445. rect.right = rect.left + m_cxSplitter;
  1446. if( rect.left > cxInside)
  1447. break;
  1448. OnDrawSplitter(pDC, splitBar, rect);
  1449. rect.left = rect.right + m_cxBorderShare;
  1450. }
  1452. GetClientRect(rect);
  1453. rect.top += m_cyBorder;
  1454. int row = 0;
  1455. for( ; row < m_nRows - 1; row++ )
  1456. {
  1457. rect.top += m_pRowInfo[row].nCurSize + m_cyBorderShare;
  1458. rect.bottom = rect.top + m_cySplitter;
  1459. if( rect.top > cyInside)
  1460. break;
  1461. OnDrawSplitter( pDC, splitBar, rect );
  1462. rect.top = rect.bottom + m_cyBorderShare;
  1463. }
  1465. #if _MFC_VER < 0x700
  1466. if( afxData.bWin4 )
  1467. #endif //_MFC_VER < 0x700
  1468. {
  1469. GetClientRect( rect );
  1470. int x = rect.left;
  1471. for( col = 0; col < m_nCols; col++)
  1472. {
  1473. int cx = m_pColInfo[col].nCurSize + 2*m_cxBorder;
  1474. if( col == m_nCols-1 && m_bHasVScroll)
  1475. cx += afxData.cxVScroll - __EXT_MFC_CX_BORDER;
  1476. int y = rect.top;
  1477. for( int row = 0; row < m_nRows; row++)
  1478. {
  1479. int cy = m_pRowInfo[row].nCurSize + 2*m_cyBorder;
  1480. if( row == m_nRows-1 && m_bHasHScroll)
  1481. cy += afxData.cyHScroll - __EXT_MFC_CY_BORDER;
  1482. OnDrawSplitter( pDC, splitBorder, CRect( x, y, x+cx, y+cy ) );
  1483. y += cy + m_cySplitterGap - 2*m_cyBorder;
  1484. }
  1485. x += cx + m_cxSplitterGap - 2*m_cxBorder;
  1486. }
  1487. }
  1488. }
  1490. void CExtSplitterBaseWnd::OnPaint()
  1491. {
  1492. ASSERT_VALID( this );
  1493. CRect rectClient;
  1494. GetClientRect( &rectClient );
  1495. CPaintDC dcPaint( this );
  1496. CExtMemoryDC dc( &dcPaint, &rectClient );
  1497. CExtPaintManager::stat_ExcludeChildAreas(
  1498. dc,
  1499. GetSafeHwnd(),
  1500. CExtPaintManager::stat_DefExcludeChildAreaCallback
  1501. );
  1502. if( ! PmBridge_GetPM()->PaintDockerBkgnd( true, dc, this ) )
  1503. {
  1504. COLORREF clrBackground = OnQueryBackgroundColor();
  1505. dc.FillSolidRect( 
  1506. &rectClient, 
  1507. ( clrBackground != COLORREF(-1L) ) 
  1508. ? clrBackground 
  1509. : PmBridge_GetPM()->GetColor( CExtPaintManager::CLR_3DFACE_OUT, this ) 
  1510. );
  1511. }
  1513. rectClient.InflateRect( -m_cxBorder, -m_cyBorder );
  1514. CRect rectInside;
  1515. GetInsideRect(rectInside);
  1516. if( m_bHasVScroll && m_nRows < m_nMaxRows )
  1517. {
  1518. OnDrawSplitter(
  1519. &dc,
  1520. splitBox,
  1521. CRect(
  1522. rectInside.right +
  1523. #if _MFC_VER < 0x700
  1524. afxData.bNotWin4
  1525. #else
  1526. 0
  1527. #endif
  1528. ,
  1529. rectClient.top, rectClient.right,
  1530. rectClient.top + m_cySplitter
  1531. )
  1532. );
  1533. }
  1535. if( m_bHasHScroll && m_nCols < m_nMaxCols )
  1536. {
  1537. OnDrawSplitter(
  1538. &dc,
  1539. splitBox,
  1540. CRect(
  1541. rectClient.left,
  1542. rectInside.bottom +
  1543. #if _MFC_VER < 0x700
  1544. afxData.bNotWin4
  1545. #else
  1546. 0
  1547. #endif
  1548. ,
  1549. rectClient.left + m_cxSplitter,
  1550. rectClient.bottom
  1551. )
  1552. );
  1553. }
  1555. DrawAllSplitBars( &dc, rectInside.right, rectInside.bottom );
  1557. #if _MFC_VER < 0x700
  1558. if( ! afxData.bWin4 )
  1559. {
  1560. GetInsideRect( rectInside );
  1561. dc.IntersectClipRect( rectInside );
  1562. CRect rect;
  1563. rect.top = rectInside.top;
  1564. for( int row = 0; row < m_nRows - 1; row++ )
  1565. {
  1566. rect.top += m_pRowInfo[row].nCurSize + m_cyBorderShare;
  1567. rect.bottom = rect.top + m_cySplitter;
  1568. rect.left = rectInside.left;
  1569. for( int col = 0; col < m_nCols - 1; col++ )
  1570. {
  1571. rect.left += m_pColInfo[col].nCurSize + m_cxBorderShare;
  1572. rect.right = rect.left + m_cxSplitter;
  1573. OnDrawSplitter(&dc, splitIntersection, rect);
  1574. rect.left = rect.right + m_cxBorderShare;
  1575. }
  1576. rect.top = rect.bottom + m_cxBorderShare;
  1577. }
  1578. }
  1579. #endif //_MFC_VER < 0x700
  1580. }
  1582. BOOL CExtSplitterBaseWnd::OnSetCursor( CWnd * pWnd, UINT nHitTest, UINT message )
  1583. {
  1584. if( nHitTest == HTCLIENT && pWnd == this && ! m_bTracking )
  1585. return TRUE;
  1586. return CSplitterWnd::OnSetCursor(pWnd, nHitTest, message);
  1587. }
  1589. void CExtSplitterBaseWnd::SetSplitCursor( int ht )
  1590. {
  1591. UINT idcPrimary;
  1592. LPCTSTR idcSecondary;
  1593. AfxLockGlobals( CRIT_SPLITTERWND );
  1594. if( ht == vSplitterBox
  1595. || ht >= vSplitterBar1
  1596. && ht <= vSplitterBar15
  1597. )
  1598. {
  1599. idcPrimary = AFX_IDC_VSPLITBAR;
  1600. idcSecondary = IDC_SIZENS;
  1601. }
  1602. else if(
  1603. ht == hSplitterBox
  1604. || ht >= hSplitterBar1
  1605. && ht <= hSplitterBar15
  1606. )
  1607. {
  1608. idcPrimary = AFX_IDC_HSPLITBAR;
  1609. idcSecondary = IDC_SIZEWE;
  1610. }
  1611. else if(
  1612. ht == bothSplitterBox
  1613. || ( ht >= splitterIntersection1 && ht <= splitterIntersection225 )
  1614. )
  1615. {
  1616. idcPrimary = AFX_IDC_SMALLARROWS;
  1617. idcSecondary = IDC_SIZEALL;
  1618. }
  1619. else
  1620. {
  1621. SetCursor( afxData.hcurArrow );
  1622. idcPrimary = 0;
  1623. idcSecondary = 0;
  1624. }
  1626. if( idcPrimary != 0 )
  1627. {
  1628. HCURSOR hcurToDestroy = NULL;
  1629. if( idcPrimary != g_split_idcPrimaryLast )
  1630. {
  1631. HINSTANCE hInst = AfxFindResourceHandle( MAKEINTRESOURCE(idcPrimary), RT_GROUP_CURSOR );
  1632. hcurToDestroy = g_split_hcurDestroy;
  1633. if( ( g_split_hcurDestroy = g_split_hcurLast = ::LoadCursor(hInst, MAKEINTRESOURCE(idcPrimary) ) ) == NULL )
  1634. {
  1635. TRACE0("Warning: Could not find splitter cursor - using system provided alternative.n");
  1636. ASSERT( g_split_hcurDestroy == NULL );
  1637. g_split_hcurLast = ::LoadCursor( NULL, idcSecondary );
  1638. ASSERT(g_split_hcurLast != NULL);
  1639. }
  1640. g_split_idcPrimaryLast = idcPrimary;
  1641. }
  1642. ASSERT(g_split_hcurLast != NULL);
  1643. ::SetCursor(g_split_hcurLast);
  1644. ASSERT(g_split_hcurLast != hcurToDestroy);
  1645. if( hcurToDestroy != NULL)
  1646. ::DestroyCursor( hcurToDestroy );
  1647. }
  1648. AfxUnlockGlobals( CRIT_SPLITTERWND );
  1649. }
  1651. void CExtSplitterBaseWnd::OnMouseMove( UINT /*nFlags*/, CPoint pt )
  1652. {
  1653. if( GetCapture() != this )
  1654. StopTracking( FALSE );
  1655. if( m_bTracking )
  1656. {
  1657. pt.Offset( m_ptTrackOffset );
  1658. if( pt.y < m_rectLimit.top )
  1659. pt.y = m_rectLimit.top;
  1660. else if( pt.y > m_rectLimit.bottom)
  1661. pt.y = m_rectLimit.bottom;
  1662. if( pt.x < m_rectLimit.left )
  1663. pt.x = m_rectLimit.left;
  1664. else if( pt.x > m_rectLimit.right )
  1665. pt.x = m_rectLimit.right;
  1666. if( m_htTrack == vSplitterBox
  1667. || m_htTrack >= vSplitterBar1 && m_htTrack <= vSplitterBar15
  1668. )
  1669. {
  1670. if( m_rectTracker.top != pt.y )
  1671. {
  1672. OnInvertTracker( m_rectTracker );
  1673. m_rectTracker.OffsetRect( 0, pt.y - m_rectTracker.top );
  1674. OnInvertTracker( m_rectTracker );
  1675. }
  1676. }
  1677. else if(
  1678. m_htTrack == hSplitterBox
  1679. || m_htTrack >= hSplitterBar1 && m_htTrack <= hSplitterBar15
  1680. )
  1681. {
  1682. if( m_rectTracker.left != pt.x)
  1683. {
  1684. OnInvertTracker(m_rectTracker);
  1685. m_rectTracker.OffsetRect(pt.x - m_rectTracker.left, 0);
  1686. OnInvertTracker(m_rectTracker);
  1687. }
  1688. }
  1689. else if(
  1690. m_htTrack == bothSplitterBox
  1691. || ( m_htTrack >= splitterIntersection1 && m_htTrack <= splitterIntersection225 )
  1692. )
  1693. {
  1694. if( m_rectTracker.top != pt.y )
  1695. {
  1696. OnInvertTracker( m_rectTracker );
  1697. m_rectTracker.OffsetRect( 0, pt.y - m_rectTracker.top );
  1698. OnInvertTracker( m_rectTracker );
  1699. }
  1700. if( m_rectTracker2.left != pt.x )
  1701. {
  1702. OnInvertTracker( m_rectTracker2 );
  1703. m_rectTracker2.OffsetRect( pt.x - m_rectTracker2.left, 0 );
  1704. OnInvertTracker( m_rectTracker2 );
  1705. }
  1706. }
  1707. }
  1708. else
  1709. {
  1710. int ht = HitTest( pt );
  1711. SetSplitCursor( ht );
  1712. }
  1713. }
  1715. void CExtSplitterBaseWnd::OnLButtonDown( UINT /*nFlags*/, CPoint pt )
  1716. {
  1717. if( m_bTracking )
  1718. return;
  1719. StartTracking( HitTest( pt ) );
  1720. }
  1722. void CExtSplitterBaseWnd::OnLButtonDblClk( UINT /*nFlags*/, CPoint pt )
  1723. {
  1724. int ht = HitTest( pt );
  1725. CRect rect;
  1726. StopTracking( FALSE );
  1727. if( ( GetStyle() & SPLS_DYNAMIC_SPLIT ) == 0 )
  1728. return;
  1729. if( ht == vSplitterBox )
  1730. SplitRow( m_pRowInfo[0].nCurSize / 2 );
  1731. else if( ht == hSplitterBox)
  1732. SplitColumn( m_pColInfo[0].nCurSize / 2 );
  1733. else if( ht >= vSplitterBar1 && ht <= vSplitterBar15 )
  1734. {
  1735. int rowDelete = ht - vSplitterBar1;
  1736. int row;
  1737. if( GetActivePane(&row, NULL) != NULL && rowDelete == row )
  1738. ++rowDelete;
  1739. DeleteRow(rowDelete);
  1740. }
  1741. else if( ht >= hSplitterBar1 && ht <= hSplitterBar15 )
  1742. {
  1743. int colDelete = ht - hSplitterBar1;
  1744. int col;
  1745. if( GetActivePane( NULL, &col ) != NULL && colDelete == col )
  1746. ++colDelete;
  1747. DeleteColumn( colDelete );
  1748. }
  1749. else if( ht >= splitterIntersection1 && ht <= splitterIntersection225 )
  1750. {
  1751. int rowDelete = (ht - splitterIntersection1) / 15;
  1752. int colDelete = (ht - splitterIntersection1) % 15;
  1753. int row, col;
  1754. if( GetActivePane(&row, &col) != NULL )
  1755. {
  1756. if( col == colDelete )
  1757. ++colDelete;
  1758. if( row == rowDelete )
  1759. ++rowDelete;
  1760. }
  1761. DeleteRow( rowDelete );
  1762. DeleteColumn( colDelete );
  1763. }
  1764. }
  1766. void CExtSplitterBaseWnd::OnLButtonUp( UINT /*nFlags*/, CPoint /*pt*/ )
  1767. {
  1768. StopTracking(TRUE);
  1769. }
  1771. void CExtSplitterBaseWnd::OnCancelMode()
  1772. {
  1773. StopTracking(FALSE);
  1774. }
  1776. void CExtSplitterBaseWnd::OnKeyDown( UINT nChar, UINT /*nRepCnt*/, UINT /*nFlags*/ )
  1777. {
  1778. CPoint pt;
  1779. GetCursorPos(&pt);
  1780. int cz = GetKeyState(VK_CONTROL) < 0 ? 1 : 16;
  1781. int dx = 0;
  1782. int dy = 0;
  1783. switch( nChar )
  1784. {
  1785. case VK_ESCAPE:
  1786. StopTracking( FALSE );
  1787. return;
  1788. case VK_RETURN:
  1789. StopTracking( TRUE );
  1790. return;
  1791. case VK_LEFT:
  1792. dx = -1;
  1793. break;
  1794. case VK_RIGHT:
  1795. dx = +1;
  1796. break;
  1797. case VK_UP:
  1798. dy = -1;
  1799. break;
  1800. case VK_DOWN:
  1801. dy = +1;
  1802. break;
  1803. default:
  1804. Default();
  1805. return;
  1806. }
  1807. if( m_htTrack == vSplitterBox
  1808. || m_htTrack >= vSplitterBar1 && m_htTrack <= vSplitterBar15
  1809. )
  1810. dx = 0;
  1811. if( m_htTrack == hSplitterBox
  1812. || m_htTrack >= hSplitterBar1 && m_htTrack <= hSplitterBar15
  1813. )
  1814. dy = 0;
  1815. pt.x += dx * cz;
  1816. pt.y += dy * cz;
  1817. ScreenToClient( &pt );
  1818. if( pt.y < m_rectLimit.top )
  1819. pt.y = m_rectLimit.top;
  1820. else if( pt.y > m_rectLimit.bottom )
  1821. pt.y = m_rectLimit.bottom;
  1822. if( pt.x < m_rectLimit.left )
  1823. pt.x = m_rectLimit.left;
  1824. else if( pt.x > m_rectLimit.right )
  1825. pt.x = m_rectLimit.right;
  1826. ClientToScreen( &pt );
  1827. SetCursorPos( pt.x, pt.y );
  1828. }
  1830. void CExtSplitterBaseWnd::OnSysCommand( UINT nID, LPARAM lParam )
  1831. {
  1832. if( ( nID & 0xFFF0 ) == SC_SIZE )
  1833. {
  1834. CWnd * pParent = GetSizingParent();
  1835. if( pParent != NULL )
  1836. {
  1837. pParent->SendMessage( WM_SYSCOMMAND, (WPARAM)nID, lParam );
  1838. return;
  1839. }
  1840. }
  1841. CSplitterWnd::OnSysCommand( nID, lParam );
  1842. }
  1844. BOOL CExtSplitterBaseWnd::OnCommand( WPARAM wParam, LPARAM lParam )
  1845. {
  1846. if( CSplitterWnd::OnCommand( wParam, lParam ) )
  1847. return TRUE;
  1848. CFrameWnd * pFrameWnd = GetParentFrame();
  1849. if( pFrameWnd != NULL )
  1850. {
  1851. ASSERT_VALID( pFrameWnd );
  1852. return ( pFrameWnd->SendMessage( WM_COMMAND, wParam, lParam ) != 0L ) ? TRUE : FALSE;
  1853. }
  1854. return FALSE;
  1855. }
  1857. BOOL CExtSplitterBaseWnd::OnNotify( WPARAM wParam, LPARAM lParam, LRESULT * pResult )
  1858. {
  1859. if( CSplitterWnd::OnNotify( wParam, lParam, pResult ) )
  1860. return TRUE;
  1861. CFrameWnd * pFrameWnd = GetParentFrame();
  1862. if( pFrameWnd != NULL )
  1863. {
  1864. ASSERT_VALID( pFrameWnd );
  1865. *pResult = pFrameWnd->SendMessage( WM_NOTIFY, wParam, lParam );
  1866. return TRUE;
  1867. }
  1868. return FALSE;
  1869. }
  1871. BOOL CExtSplitterBaseWnd::OnMouseWheel( UINT fFlags, short zDelta, CPoint point )
  1872. {
  1873. BOOL bRetVal = FALSE;
  1874. int row;
  1875. int col;
  1876. for( row = 0; row < m_nRows; row++ )
  1877. {
  1878. for( col = 0; col < m_nCols; col++ )
  1879. {
  1880. CWnd * pPane = GetPane(row, col );
  1881. CScrollView* pView = DYNAMIC_DOWNCAST( CScrollView, pPane);
  1882. if( pView != NULL)
  1883. {
  1884. CScrollBar * pBar = pView->GetScrollBarCtrl( SB_VERT );
  1885. if( pBar == NULL)
  1886. {
  1887. pBar = pView->GetScrollBarCtrl( SB_HORZ );
  1888. if( pBar == NULL)
  1889. continue;
  1890. }
  1891. int nOldPos = pBar->GetScrollPos();
  1892. if( pView->DoMouseWheel( fFlags, zDelta, point ) )
  1893. bRetVal = TRUE;
  1894. if( col < m_nCols -1 )
  1895. pBar->SetScrollPos( nOldPos, FALSE );
  1896. }
  1897. }
  1898. }
  1899. return TRUE;
  1900. }
  1902. void CExtSplitterBaseWnd::OnHScroll( UINT nSBCode, UINT nPos, CScrollBar * pScrollBar )
  1903. {
  1904. ASSERT(pScrollBar != NULL);
  1905. int col = _AfxGetDlgCtrlID( pScrollBar->m_hWnd ) - AFX_IDW_HSCROLL_FIRST;
  1906. ASSERT( col >= 0 && col < m_nMaxCols );
  1907. ASSERT( m_nRows > 0 );
  1908. int nOldPos = pScrollBar->GetScrollPos();
  1909. #ifdef _DEBUG
  1910. int nNewPos;
  1911. #endif
  1912. for( int row = 0; row < m_nRows; row++ )
  1913. {
  1914. GetPane(row, col)->SendMessage( WM_HSCROLL, MAKELONG(nSBCode, nPos), (LPARAM)pScrollBar->m_hWnd );
  1915. #ifdef _DEBUG
  1916. if( row == 0 )
  1917. {
  1918. nNewPos = pScrollBar->GetScrollPos();
  1919. if( pScrollBar->GetScrollPos() != nNewPos )
  1920. {
  1921. TRACE0("Warning: scroll panes setting different scroll positions.n");
  1922. }
  1923. }
  1924. #endif //_DEBUG
  1925. if( row < m_nRows - 1 )
  1926. pScrollBar->SetScrollPos( nOldPos, FALSE );
  1927. }
  1928. }
  1930. void CExtSplitterBaseWnd::OnVScroll( UINT nSBCode, UINT nPos, CScrollBar * pScrollBar )
  1931. {
  1932. ASSERT( pScrollBar != NULL );
  1933. int row = _AfxGetDlgCtrlID( pScrollBar->m_hWnd ) - AFX_IDW_VSCROLL_FIRST;
  1934. ASSERT( row >= 0 && row < m_nMaxRows );
  1935. ASSERT(m_nCols > 0);
  1936. int nOldPos = pScrollBar->GetScrollPos();
  1937. #ifdef _DEBUG
  1938. int nNewPos;
  1939. #endif
  1940. for( int col = 0; col < m_nCols; col++ )
  1941. {
  1942. GetPane( row, col )->SendMessage( WM_VSCROLL, MAKELONG(nSBCode, nPos), (LPARAM)pScrollBar->m_hWnd );
  1943. #ifdef _DEBUG
  1944. if( col == 0 )
  1945. {
  1946. nNewPos = pScrollBar->GetScrollPos();
  1947. if( pScrollBar->GetScrollPos() != nNewPos )
  1948. {
  1949. TRACE0("Warning: scroll panes setting different scroll positions.n");
  1950. }
  1951. }
  1952. #endif //_DEBUG
  1953. if( col < m_nCols - 1 )
  1954. pScrollBar->SetScrollPos( nOldPos, FALSE );
  1955. }
  1956. }
  1958. BOOL CExtSplitterBaseWnd::DoScroll( CView * pViewFrom, UINT nScrollCode, BOOL bDoScroll )
  1959. {
  1960. ASSERT_VALID( pViewFrom );
  1961. int rowFrom, colFrom;
  1962. if( ! IsChildPane( pViewFrom, &rowFrom, &colFrom ) )
  1963. return FALSE;
  1964. BOOL bResult = FALSE;
  1965. int nOldVert = 0;
  1966. CScrollBar * pScrollVert = pViewFrom->GetScrollBarCtrl( SB_VERT );
  1967. if( pScrollVert != NULL)
  1968. nOldVert = pScrollVert->GetScrollPos();
  1969. int nOldHorz = 0;
  1970. CScrollBar * pScrollHorz = pViewFrom->GetScrollBarCtrl( SB_HORZ );
  1971. if( pScrollHorz != NULL )
  1972. nOldHorz = pScrollHorz->GetScrollPos();
  1973. if( pViewFrom->OnScroll(nScrollCode, 0, bDoScroll ) )
  1974. bResult = TRUE;
  1975. if( pScrollVert != NULL )
  1976. {
  1977. #ifdef _DEBUG
  1978. int nNewVert = pScrollVert->GetScrollPos();
  1979. #endif
  1980. for( int col = 0; col < m_nCols; col++ )
  1981. {
  1982. if( col == colFrom )
  1983. continue;
  1984. pScrollVert->SetScrollPos( nOldVert, FALSE );
  1985. CView * pView = (CView*)GetPane( rowFrom, col );
  1986. ASSERT_KINDOF( CView, pView );
  1987. ASSERT( pView != pViewFrom );
  1988. if( pView->OnScroll( MAKEWORD( -1, HIBYTE( nScrollCode ) ), 0, bDoScroll ) )
  1989. {
  1990. bResult = TRUE;
  1991. }
  1992. #ifdef _DEBUG
  1993. if( pScrollVert->GetScrollPos() != nNewVert )
  1994. {
  1995. TRACE0("Warning: scroll panes setting different scroll positions.n");
  1996. }
  1997. #endif
  1998. }
  1999. }
  2000. if( pScrollHorz != NULL )
  2001. {
  2002. #ifdef _DEBUG
  2003. int nNewHorz = pScrollHorz->GetScrollPos();
  2004. #endif
  2005. for( int row = 0; row < m_nRows; row++ )
  2006. {
  2007. if( row == rowFrom)
  2008. continue;
  2009. pScrollHorz->SetScrollPos( nOldHorz, FALSE );
  2010. CView * pView = (CView*)GetPane( row, colFrom );
  2011. ASSERT_KINDOF( CView, pView );
  2012. ASSERT( pView != pViewFrom );
  2013. if( pView->OnScroll( MAKEWORD( LOBYTE( nScrollCode ), -1 ), 0, bDoScroll ) )
  2014. bResult = TRUE;
  2015. #ifdef _DEBUG
  2016. if( pScrollHorz->GetScrollPos() != nNewHorz )
  2017. {
  2018. TRACE0("Warning: scroll panes setting different scroll positions.n");
  2019. }
  2020. #endif
  2021. }
  2022. }
  2023. return bResult;
  2024. }
  2026. BOOL CExtSplitterBaseWnd::DoScrollBy( CView * pViewFrom, CSize sizeScroll, BOOL bDoScroll )
  2027. {
  2028. int rowFrom, colFrom;
  2029. if( ! IsChildPane( pViewFrom, &rowFrom, &colFrom ) )
  2030. return FALSE;
  2031. BOOL bResult = FALSE;
  2032. int nOldVert = 0;
  2033. CScrollBar * pScrollVert = pViewFrom->GetScrollBarCtrl( SB_VERT );
  2034. if( pScrollVert != NULL )
  2035. nOldVert = pScrollVert->GetScrollPos();
  2036. int nOldHorz = 0;
  2037. CScrollBar * pScrollHorz = pViewFrom->GetScrollBarCtrl( SB_HORZ );
  2038. if( pScrollHorz != NULL)
  2039. nOldHorz = pScrollHorz->GetScrollPos();
  2040. if( pViewFrom->OnScrollBy( sizeScroll, bDoScroll ) )
  2041. bResult = TRUE;
  2042. if( pScrollVert != NULL )
  2043. {
  2044. #ifdef _DEBUG
  2045. int nNewVert = pScrollVert->GetScrollPos();
  2046. #endif
  2047. for( int col = 0; col < m_nCols; col++ )
  2048. {
  2049. if( col == colFrom )
  2050. continue;
  2051. pScrollVert->SetScrollPos( nOldVert, FALSE );
  2052. CView * pView = (CView*)GetPane( rowFrom, col );
  2053. ASSERT_KINDOF( CView, pView );
  2054. ASSERT( pView != pViewFrom );
  2055. if( pView->OnScrollBy( CSize( 0, sizeScroll.cy ), bDoScroll ) )
  2056. bResult = TRUE;
  2057. #ifdef _DEBUG
  2058. if( pScrollVert->GetScrollPos() != nNewVert )
  2059. {
  2060. TRACE0("Warning: scroll panes setting different scroll positions.n");
  2061. }
  2062. #endif
  2063. }
  2064. }
  2065. if( pScrollHorz != NULL )
  2066. {
  2067. #ifdef _DEBUG
  2068. int nNewHorz = pScrollHorz->GetScrollPos();
  2069. #endif
  2070. for( int row = 0; row < m_nRows; row++ )
  2071. {
  2072. if( row == rowFrom)
  2073. continue;
  2074. pScrollHorz->SetScrollPos( nOldHorz, FALSE );
  2075. CView * pView = (CView*)GetPane( row, colFrom );
  2076. ASSERT_KINDOF( CView, pView );
  2077. ASSERT( pView != pViewFrom );
  2078. if( pView->OnScrollBy( CSize( sizeScroll.cx, 0 ), bDoScroll ) )
  2079. bResult = TRUE;
  2080. #ifdef _DEBUG
  2081. if( pScrollHorz->GetScrollPos() != nNewHorz )
  2082. {
  2083. TRACE0("Warning: scroll panes setting different scroll positions.n");
  2084. }
  2085. #endif
  2086. }
  2087. }
  2088. return bResult;
  2089. }
  2091. BOOL CExtSplitterBaseWnd::CanActivateNext( BOOL )
  2092. {
  2093. ASSERT_VALID( this );
  2094. if( GetActivePane() == NULL )
  2095. {
  2096. TRACE0("Warning: Can't go to next pane - there is no current pane.n");
  2097. return FALSE;
  2098. }
  2099. ASSERT(m_nRows != 0);
  2100. ASSERT(m_nCols != 0);
  2101. return (m_nRows > 1) || (m_nCols > 1);
  2102. }
  2104. void CExtSplitterBaseWnd::ActivateNext( BOOL bPrev )
  2105. {
  2106. ASSERT_VALID( this );
  2107. int row, col;
  2108. if( GetActivePane( &row, &col ) == NULL )
  2109. {
  2110. TRACE0("Warning: Cannot go to next pane - there is no current view.n");
  2111. return;
  2112. }
  2113. ASSERT(row >= 0 && row < m_nRows);
  2114. ASSERT(col >= 0 && col < m_nCols);
  2115. if( bPrev )
  2116. {
  2117. if( --col < 0 )
  2118. {
  2119. col = m_nCols - 1;
  2120. if( --row < 0 )
  2121. row = m_nRows - 1;
  2122. }
  2123. }
  2124. else
  2125. {
  2126. if( ++col >= m_nCols )
  2127. {
  2128. col = 0;
  2129. if( ++row >= m_nRows )
  2130. row = 0;
  2131. }
  2132. }
  2133. SetActivePane( row, col );
  2134. }
  2136. void CExtSplitterBaseWnd::SetActivePane( int row, int col, CWnd * pWnd )
  2137. {
  2138. CWnd* pPane = pWnd == NULL ? GetPane(row, col) : pWnd;
  2139. if( pPane->IsKindOf( RUNTIME_CLASS( CView ) ) )
  2140. {
  2141. CFrameWnd * pFrameWnd = GetParentFrame();
  2142. if( pFrameWnd != NULL )
  2143. {
  2144. ASSERT_VALID( pFrameWnd );
  2145. pFrameWnd->SetActiveView( (CView*) pPane );
  2146. }
  2147. }
  2148. else
  2149. {
  2150. TRACE0("Warning: Next pane is not a view - calling SetFocus.n");
  2151. pPane->SetFocus();
  2152. }
  2153. }
  2155. CWnd * CExtSplitterBaseWnd::GetActivePane( int * pRow, int * pCol )
  2156. {
  2157. ASSERT_VALID( this );
  2158. CWnd * pView = NULL;
  2159. CFrameWnd * pFrameWnd = GetParentFrame();
  2160. if( pFrameWnd != NULL )
  2161. {
  2162. ASSERT_VALID( pFrameWnd );
  2163. pView = pFrameWnd->GetActiveView();
  2164. }
  2165. if( pView == NULL )
  2166. pView = GetFocus();
  2167. if( pView != NULL && (! IsChildPane( pView, pRow, pCol ) ) )
  2168. pView = NULL;
  2169. return pView;
  2170. }
  2172. /////////////////////////////////////////////////////////////////////////////
  2173. // CExtSplitterWnd
  2175. IMPLEMENT_DYNCREATE( CExtSplitterWnd, CExtSplitterBaseWnd );
  2177. CExtSplitterWnd::CExtSplitterWnd()
  2178. {
  2179. }
  2181. CExtSplitterWnd::~CExtSplitterWnd()
  2182. {
  2183. }
  2185. BEGIN_MESSAGE_MAP( CExtSplitterWnd, CExtSplitterBaseWnd )
  2186. //{{AFX_MSG_MAP(CExtSplitterWnd)
  2187. ON_WM_HSCROLL()
  2188. ON_WM_VSCROLL()
  2189. //}}AFX_MSG_MAP
  2190. END_MESSAGE_MAP()
  2192. void CExtSplitterWnd::DrawAllSplitBars(
  2193. CDC * pDC,
  2194. int cxInside,
  2195. int cyInside
  2196. )
  2197. {
  2198. if( pDC == NULL )
  2199. {
  2200. RedrawWindow( NULL, NULL, RDW_INVALIDATE|RDW_NOCHILDREN );
  2201. return;
  2202. }
  2203. ASSERT_VALID( pDC );
  2204. if( (GetStyle()&WS_CLIPCHILDREN) == 0 )
  2205. ModifyStyle( 0, WS_CLIPCHILDREN );
  2206. if( (GetStyle()&WS_CLIPSIBLINGS) == 0 )
  2207. ModifyStyle( 0, WS_CLIPSIBLINGS );
  2208. CRect rcClient;
  2209. GetClientRect( &rcClient );
  2210. CWnd * pMainFrame = NULL, * pInnerFrame = GetParentFrame();
  2211. if( pInnerFrame != NULL )
  2212. {
  2213. ASSERT_VALID( pInnerFrame );
  2214. pMainFrame = pInnerFrame->GetParentFrame();
  2215. if( pMainFrame == NULL )
  2216. pMainFrame = pInnerFrame;
  2217. }
  2218. if( pMainFrame == NULL )
  2219. {
  2220. pMainFrame = GetParent();
  2221. for( ; pMainFrame != NULL; pMainFrame = pMainFrame->GetParent() )
  2222. {
  2223. if( ( pMainFrame->GetStyle() & WS_CHILD ) == 0 )
  2224. break;
  2225. }
  2226. }
  2227. #if (!defined __EXT_MFC_NO_TAB_ONENOTE_CTRL)
  2228. bool bDrawDefault = true;
  2229. CExtTabMdiOneNoteWnd * pOneNoteTabs = NULL;
  2230. CWnd * pWnd = ( pMainFrame != NULL ) ? pMainFrame->GetWindow( GW_CHILD ) : NULL;
  2231. for( ; pWnd != NULL; pWnd = pWnd->GetWindow( GW_HWNDNEXT ) )
  2232. {
  2233. pOneNoteTabs =
  2234. DYNAMIC_DOWNCAST(
  2235. CExtTabMdiOneNoteWnd,
  2236. pWnd
  2237. );
  2238. if( pOneNoteTabs != NULL )
  2239. break;
  2240. } // for( ; pWnd != NULL; pWnd = pWnd->GetWindow( GW_HWNDNEXT ) )
  2241. if( pOneNoteTabs != NULL )
  2242. {
  2243. bDrawDefault = false;
  2244. LONG nIndex = ( pInnerFrame != NULL ) ? pOneNoteTabs->ItemFindByHWND( pInnerFrame->m_hWnd ) : -1L;
  2245. // ASSERT( nIndex >= 0 );
  2246. if( nIndex >= 0 )
  2247. {
  2248. CExtTabOneNoteWnd::TAB_ITEM_INFO_ONENOTE * pTII =
  2249. pOneNoteTabs->ItemGet( nIndex );
  2250. COLORREF clrFill = pTII->GetColorBkDark();
  2251. pDC->FillSolidRect( rcClient, clrFill );
  2252. }
  2253. } // if( pOneNoteTabs != NULL )
  2254. if( bDrawDefault )
  2255. #endif
  2256. if( pMainFrame != NULL )
  2257. { // block
  2258. CExtPaintManager * pPM = PmBridge_GetPM();
  2259. ASSERT_VALID( pPM );
  2260. CRect rcWnd;
  2261. pMainFrame->GetWindowRect( &rcWnd );
  2262. ScreenToClient( &rcWnd );
  2263. if( pPM->m_clrForceSplitterBk != COLORREF(-1L) )
  2264. {
  2265. pDC->FillSolidRect( rcClient, pPM->m_clrForceSplitterBk );
  2266. return;
  2267. }
  2268. else if( (! pPM->GetCb2DbTransparentMode(this) )
  2269. || (! pPM->PaintDockerBkgnd(
  2270. true,
  2271. *pDC,
  2272. rcClient,
  2273. rcWnd
  2274. )
  2275. )
  2276. )
  2277. {
  2278. COLORREF clrFill =
  2279. pPM->GetColor( CExtPaintManager::CLR_3DFACE_OUT );
  2280. pDC->FillSolidRect( rcClient, clrFill );
  2281. }
  2282. //  else
  2283. //  return;
  2284. } // block
  2285. CExtSplitterBaseWnd::DrawAllSplitBars(
  2286. pDC,
  2287. cxInside,
  2288. cyInside
  2289. );
  2290. }
  2292. void CExtSplitterWnd::OnDrawSplitter(
  2293. CDC* pDC,
  2294. ESplitType nType,
  2295. const CRect & rectArg
  2296. )
  2297. {
  2298. if( pDC == NULL )
  2299. {
  2300. RedrawWindow( rectArg, NULL, RDW_INVALIDATE|RDW_NOCHILDREN );
  2301. return;
  2302. }
  2303. ASSERT_VALID( pDC );
  2304. CRect rect = rectArg;
  2305. switch( nType )
  2306. {
  2307. case splitBorder:
  2308. {
  2309. CExtPaintManager * pPM = PmBridge_GetPM();
  2310. ASSERT_VALID( pPM );
  2311. if( pPM->m_clrForceSplitterBk != COLORREF(-1L) )
  2312. pDC->FillSolidRect( rect, pPM->m_clrForceSplitterBk );
  2314. rect.InflateRect( -__EXT_MFC_CX_BORDER, -__EXT_MFC_CY_BORDER );
  2315. PmBridge_GetPM()->PaintResizableBarChildNcAreaRect(
  2316. *pDC,
  2317. rect,
  2318. this
  2319. );
  2320. }
  2321. return;
  2322. case splitIntersection:
  2323. case splitBox:
  2324. case splitBar:
  2325. {
  2326. CExtPaintManager * pPM = PmBridge_GetPM();
  2327. ASSERT_VALID( pPM );
  2328. if( pPM->m_clrForceSplitterBk != COLORREF(-1L) )
  2329. pDC->FillSolidRect( rect, pPM->m_clrForceSplitterBk );
  2330. }
  2331. return;
  2332. default:
  2333. ASSERT(FALSE);  // unknown splitter type
  2334. break;
  2335. } // switch( nType )
  2336. }
  2338. void CExtSplitterWnd::OnInvertTracker(
  2339. const CRect & rect
  2340. )
  2341. {
  2342. ASSERT_VALID( this );
  2343. ASSERT( ! rect.IsRectEmpty() );
  2344. CRect rc = rect;
  2345. CWnd * pWndParent = GetParent();
  2346. ClientToScreen( &rc );
  2347. pWndParent->ScreenToClient( &rc );
  2348. //CDC * pDC = pWndParent->GetDC();
  2349. CDC * pDC = pWndParent->GetDCEx( NULL, DCX_CACHE | DCX_LOCKWINDOWUPDATE | DCX_CLIPSIBLINGS );
  2350. CBrush * pBrush = CDC::GetHalftoneBrush();
  2351. HBRUSH hOldBrush = NULL;
  2352. if( pBrush != NULL )
  2353. hOldBrush = (HBRUSH)SelectObject( pDC->m_hDC, pBrush->m_hObject );
  2354. pDC->PatBlt( rc.left, rc.top, rc.Width(), rc.Height(), PATINVERT );
  2355. if( hOldBrush != NULL )
  2356. SelectObject( pDC->m_hDC, hOldBrush );
  2357. ReleaseDC( pDC );
  2358. }
  2360. BOOL CExtSplitterWnd::CreateScrollBarCtrl( DWORD dwStyle, UINT nID )
  2361. {
  2362. ASSERT_VALID( this );
  2363. ASSERT( m_hWnd != NULL );
  2364. if( (dwStyle&SBS_SIZEBOX) != 0 )
  2365. return CExtSplitterBaseWnd::CreateScrollBarCtrl( dwStyle, nID );
  2366. CExtScrollBar * pExtScrollBar = new CExtScrollBar;
  2367. pExtScrollBar->m_bAutoDeleteOnPostNcDestroy = true;
  2368. pExtScrollBar->m_bReflectParentSizing = false;
  2369. pExtScrollBar->m_bHelperLightAccent = false;
  2370. if( ! pExtScrollBar->Create(
  2371. dwStyle|WS_VISIBLE|WS_CHILD,
  2372. CRect(0,0,1,1),
  2373. this,
  2374. nID
  2375. )
  2376. )
  2377. return FALSE;
  2378. HWND hWnd = pExtScrollBar->GetSafeHwnd();
  2379. //HWND hWnd =
  2380. // ::CreateWindow(
  2381. // _T("SCROLLBAR"), NULL,
  2382. // dwStyle|WS_VISIBLE|WS_CHILD,
  2383. // 0,
  2384. // 0,
  2385. // 1,
  2386. // 1,
  2387. // m_hWnd, 
  2388. // (HMENU)nID,
  2389. // AfxGetInstanceHandle(),
  2390. // NULL
  2391. // );
  2392. #ifdef _DEBUG
  2393. if( hWnd == NULL )
  2394. TRACE1(
  2395. "Warning: Window creation failed: GetLastError returns 0x%8.8Xn",
  2396. GetLastError()
  2397. );
  2398. #endif
  2399. return ( hWnd != NULL ) ? TRUE : FALSE;
  2400. }
  2402. void CExtSplitterWnd::OnHScroll( UINT nSBCode, UINT nPos, CScrollBar* pScrollBar )
  2403. {
  2404. ASSERT( pScrollBar != NULL );
  2405. if( ! pScrollBar->IsKindOf( RUNTIME_CLASS(CExtScrollBar) ) )
  2406. {
  2407. CExtSplitterBaseWnd::OnHScroll( nSBCode, nPos, pScrollBar );
  2408. return;
  2409. }
  2410. int col = _AfxGetDlgCtrlID( pScrollBar->m_hWnd ) - AFX_IDW_HSCROLL_FIRST;
  2411. ASSERT( col >= 0 && col < m_nMaxCols );
  2412. ASSERT( m_nRows > 0 );
  2413. int nOldPos = pScrollBar->GetScrollPos();
  2414. #ifdef _DEBUG
  2415. int nNewPos;
  2416. #endif
  2417. for( int row = 0; row < m_nRows; row++ )
  2418. {
  2419. GetPane( row, col ) ->
  2420. SendMessage(
  2421. WM_HSCROLL,
  2422. MAKELONG( nSBCode, nPos ),
  2423. (LPARAM)pScrollBar->m_hWnd
  2424. );
  2425. #ifdef _DEBUG
  2426. if( row == 0 )
  2427. {
  2428. nNewPos = pScrollBar->GetScrollPos();
  2429. if( pScrollBar->GetScrollPos() != nNewPos )
  2430. {
  2431. TRACE0( "Warning: scroll panes setting different scroll positions.n" );
  2432. } // if( pScrollBar->GetScrollPos() != nNewPos )
  2433. } // if( row == 0 )
  2434. #endif //_DEBUG
  2435. if( row < ( m_nRows - 1 ) )
  2436. pScrollBar->SetScrollPos( nOldPos, FALSE );
  2437. //((CExtScrollBar*)pScrollBar)->_SetScrollPos( nOldPos, false, false );
  2438. } // for( int row = 0; row < m_nRows; row++ )
  2439. }
  2441. void CExtSplitterWnd::OnVScroll( UINT nSBCode, UINT nPos, CScrollBar* pScrollBar )
  2442. {
  2443. ASSERT( pScrollBar != NULL );
  2444. if( ! pScrollBar->IsKindOf( RUNTIME_CLASS(CExtScrollBar) ) )
  2445. {
  2446. CExtSplitterBaseWnd::OnHScroll( nSBCode, nPos, pScrollBar );
  2447. return;
  2448. }
  2449. int row = _AfxGetDlgCtrlID( pScrollBar->m_hWnd ) - AFX_IDW_VSCROLL_FIRST;
  2450. ASSERT( row >= 0 && row < m_nMaxRows );
  2451. ASSERT( m_nCols > 0 );
  2452. int nOldPos = pScrollBar->GetScrollPos();
  2453. #ifdef _DEBUG
  2454. int nNewPos;
  2455. #endif
  2456. for( int col = 0; col < m_nCols; col++ )
  2457. {
  2458. GetPane( row, col ) ->
  2459. SendMessage(
  2460. WM_VSCROLL,
  2461. MAKELONG( nSBCode, nPos ),
  2462. (LPARAM)pScrollBar->m_hWnd
  2463. );
  2464. #ifdef _DEBUG
  2465. if( col == 0 )
  2466. {
  2467. nNewPos = pScrollBar->GetScrollPos();
  2468. if( pScrollBar->GetScrollPos() != nNewPos )
  2469. {
  2470. TRACE0("Warning: scroll panes setting different scroll positions.n");
  2471. } // if( pScrollBar->GetScrollPos() != nNewPos )
  2472. } // if( col == 0 )
  2473. #endif //_DEBUG
  2474. if( col < ( m_nCols - 1 ) )
  2475. pScrollBar->SetScrollPos( nOldPos, FALSE );
  2476. //((CExtScrollBar*)pScrollBar)->_SetScrollPos( nOldPos, false, false );
  2477. } // for( int col = 0; col < m_nCols; col++ )
  2478. }
  2480. #endif // (!defined __EXT_MFC_NO_SPLITTER_WND)