Category

Development Platform
Home > SourceCode/Document > Graph program > View Code
EGDockingPane.cpp
Package: solidgraph_sources.zip　[view]
Upload User: kairuinn
Upload Date: 2009-02-07
Package Size: 2922k
Code Size: 65k
Category:

Graph program

Development Platform:

Visual C++

EGDockingPane.cpp：Code Content
  1. #include "stdafx.h"
  2. #include "EGDocking.h"
  3. #include "NewTheme.h"
  4. #include "EGMenu.h"
  6. #include <algorithm>
  7. #include <functional>
  9. #define SPLITTER_SIZE 4
  10. #define TABS_BKGND RGB(247,243,233)
  11. #define DM_PANESTATE_CHANGED WM_USER + 1
  12. #define _AfxGetDlgCtrlID(hWnd)          ((UINT)(WORD)::GetDlgCtrlID(hWnd))
  14. /////////////////////////////////////////////////////////////////////////
  15. // functors
  17. class HotPaneButton {
  18. int m_nX;
  19. public:
  20. HotPaneButton( int x ) {
  21. m_nX = x;
  22. }
  23. bool operator() ( CEGDockingTabBtn btn ) { 
  24. return ( btn.m_nLeft <= m_nX && m_nX <= btn.m_nLeft + btn.m_nWidth );
  25. }
  26. };
  28. class MatchPaneButton {
  29. CEGDockingPane * m_pPane;
  30. public:
  31. MatchPaneButton( CEGDockingPane * pPane ) {
  32. m_pPane = pPane;
  33. }
  34. bool operator() ( CEGDockingTabBtn btn ) { 
  35. return btn.m_pPane == m_pPane; 
  36. }
  37. };
  39. // stub
  40. int CALLBACK EnumFontFamProc(ENUMLOGFONT FAR *lpelf,
  41.  NEWTEXTMETRIC FAR *lpntm,
  42.  int FontType,
  43.  LPARAM lParam)
  44. {
  45. UNUSED_ALWAYS(lpelf);
  46. UNUSED_ALWAYS(lpntm);
  47. UNUSED_ALWAYS(FontType);
  48. UNUSED_ALWAYS(lParam);
  50. return 0;
  51. }
  53. /////////////////////////////////////////////////////////////////////////
  54. // CEGDockingPane
  56. CEGDockingPane::CEGDockingPane() {
  57. m_pDockingBar = NULL;
  58. m_pszTitle = NULL;
  59. m_bHidden = FALSE;
  60. m_clrColor = themeData.GetNewColor();
  62. // Caption height
  63. m_cyCaption = ::GetSystemMetrics(SM_CYSMCAPTION);
  64. m_pRemovedFromBar = NULL;
  65. }
  67. CEGDockingPane::~CEGDockingPane() {
  68. if ( m_pDockingBar != NULL ) {
  69. m_pDockingBar->RemovePane( this );
  70. if ( m_pDockingBar->IsEmpty() ) 
  71. delete m_pDockingBar;
  72. m_pDockingBar = NULL;
  73. }
  74. if( m_pszTitle != NULL )
  75. free( m_pszTitle );
  76. }
  78. BEGIN_MESSAGE_MAP(CEGDockingPane, CStatic)
  79. ON_NOTIFY( NM_KILLFOCUS, 0, OnKillFocus )
  80. ON_NOTIFY( NM_SETFOCUS, 0, OnSetFocus )
  81. END_MESSAGE_MAP()
  83. BOOL CEGDockingPane::baseCreate( TCHAR* lpszTitle, CSize size, CFrameWnd* pFrame ) {
  84. m_pszTitle = _tcsdup( lpszTitle );
  86. if( !Create( NULL, WS_CHILD /*| WS_BORDER */| WS_CLIPCHILDREN | WS_CLIPSIBLINGS , CRect( CPoint(0,0), size ), pFrame, 0 /* nID */ ) )
  87. return FALSE;
  89. return TRUE;
  90. }
  92. void CEGDockingPane::CreateBar( TCHAR* lpszTitle, CSize size, CFrameWnd* pFrame ) {
  93. m_pDockingBar = new CEGDockingBar( size );
  94. ::SendMessage( pFrame->m_hWnd, DM_DOCKING_BAR, (WPARAM) m_pDockingBar, 0 );
  95. m_pDockingBar->Create( lpszTitle, 0, pFrame, 0 /*nID*/);
  96. m_pDockingBar->AddPane( this );
  97. }
  100. BOOL CEGDockingPane::CreatePane( TCHAR* lpszTitle, CSize size, CFrameWnd* pFrame, CEGDockingPane *pPane, DockType nDockType, CPoint ptFloat ) {
  102. // Create pane
  103. if( !baseCreate( lpszTitle, size, pFrame ) ) {
  104. TRACE1("FAILED to CEGDockingPane::baseCreate("%s",...)", lpszTitle );
  105. return FALSE;
  106. }
  108. if ( !pPane ) {
  109. // dock to client area side
  111. CreateBar( lpszTitle, size, pFrame );
  113. int nSide = 0; 
  114. switch( nDockType ) {
  115. case dctBottom:
  116. nSide = AFX_IDW_DOCKBAR_BOTTOM;
  117. break;
  118. case dctLeft:
  119. nSide = AFX_IDW_DOCKBAR_LEFT;
  120. break;
  121. case dctRight:
  122. nSide = AFX_IDW_DOCKBAR_RIGHT;
  123. break;
  124. case dctTop:
  125. nSide = AFX_IDW_DOCKBAR_TOP;
  126. break;
  127. };
  128. if ( 0 == nSide  ) {
  129. pFrame->FloatControlBar( (CControlBar*)m_pDockingBar, ptFloat );
  130. } else {
  131. pFrame->DockControlBar( (CControlBar*)m_pDockingBar, nSide );
  132. m_pDockingBar->m_pDockContext->m_uMRUDockID = nSide;
  133. }
  134. pFrame->RecalcLayout();
  136. } else if ( pPane && dctTab == nDockType ) {
  137. // append tab to another pane
  139. pPane->AppendTab( this );
  140. m_pDockingBar = pPane->m_pDockingBar;
  142. } else {
  143. // dock to border of another pane
  145. CreateBar( lpszTitle, size, pFrame );
  147. CRect rc;
  148. pPane->m_pDockingBar->GetWindowRect( &rc );
  149. switch( nDockType ) {
  150. case dctBottom:
  151. rc.OffsetRect( 0, 20 );
  152. break;
  153. case dctLeft:
  154. rc.OffsetRect( -20, 0 );
  155. break;
  156. case dctRight:
  157. rc.OffsetRect( 20, 0 );
  158. break;
  159. case dctTop:
  160. rc.OffsetRect( 0, -20 );
  161. break;
  162. };
  164. CDockBar * pDockBar = (CDockBar*)pFrame->GetControlBar(pPane->m_pDockingBar->GetDockBarID());
  165. pDockBar->DockControlBar( m_pDockingBar, &rc);
  166. pFrame->RecalcLayout();
  167. m_pDockingBar->m_pDockContext->m_uMRUDockID = _AfxGetDlgCtrlID(pDockBar->m_hWnd);
  169. }
  171. return TRUE;
  172. }
  174. DockType GetDropTarget( CPoint pt, CRect rcClient ) {
  176. CRect rcArea;
  178. // trying dock on top
  179. rcArea = rcClient;
  180. rcArea.bottom = rcArea.top + min( rcClient.Height(), DROP_AREA_SIZE );
  181. if ( rcArea.PtInRect( pt ) )
  182. return dctTop; // can dock on top
  184. // trying dock on bottom
  185. rcArea = rcClient;
  186. rcArea.top = rcArea.bottom - min( rcClient.Height(), DROP_AREA_SIZE );
  187. if ( rcArea.PtInRect( pt ) )
  188. return dctBottom; // can dock on bottom
  190. // trying dock on left
  191. rcArea = rcClient;
  192. rcArea.right = rcArea.left + min( rcClient.Width(), DROP_AREA_SIZE );
  193. if ( rcArea.PtInRect( pt ) )
  194. return dctLeft; // can dock on bottom
  196. // trying dock on right
  197. rcArea = rcClient;
  198. rcArea.left = rcArea.right - min( rcClient.Width(), DROP_AREA_SIZE );
  199. if ( rcArea.PtInRect( pt ) )
  200. return dctRight; // can dock on bottom
  202. return dctFloat;
  203. }
  205. CRect GetDropRect( DockType dt, CRect rcWindow, int nSize ) {
  207. CRect rcResult = rcWindow; // default for dctTab;
  209. switch( dt ) {
  210. case dctBottom:
  211. rcResult.top = rcResult.bottom - min( rcWindow.Height(), nSize );
  212. break;
  213. case dctLeft:
  214. rcResult.right = rcResult.left + min( rcWindow.Width(), nSize );
  215. break;
  216. case dctRight:
  217. rcResult.left = rcResult.right - min( rcWindow.Width(), nSize );
  218. break;
  219. case dctTop:
  220. rcResult.bottom = rcResult.top + min( rcWindow.Height(), nSize );
  221. break;
  222. };
  224. return rcResult;
  225. }
  227. DockType CEGDockingPane::GetDropTarget( CPoint pt /* client coordinates */ ) {
  229. CRect rcClient;
  230. GetWindowRect( &rcClient );
  231. rcClient.OffsetRect( -rcClient.TopLeft() );
  233. return ::GetDropTarget( pt, rcClient );
  235. }
  237. CRect CEGDockingPane::GetDropRect( DockType dt ) {
  239. CRect rcWindow;
  240. GetParent()->GetWindowRect( &rcWindow );
  242. return ::GetDropRect( dt, rcWindow, DOCK_AREA_SIZE );
  244. }
  246. void CEGDockingPane::CreateDragBar( CPoint pt, CSize size, double xScale ) {
  248. CFrameWnd * pFrame = GetTopLevelFrame();
  250. CreateBar( GetTitle(), size, pFrame );
  252. pFrame->FloatControlBar( m_pDockingBar, pt );
  253. m_pDockingBar->ShowBar( FALSE );
  255. reinterpret_cast<CEGDockingContext*>( m_pDockingBar->m_pDockContext )->StartDrag( pt, xScale, 0 );
  257. }
  259. void CEGDockingPane::AppendTab( CEGDockingPane* pPane ) {
  261. ASSERT( m_pDockingBar != NULL );
  263. m_pDockingBar->AddPane( pPane );
  264. }
  266. int CEGDockingPane::Width() {
  267. return m_pDockingBar->Width();
  268. }
  270. int CEGDockingPane::Height() { 
  271. return m_pDockingBar->Height();
  272. }
  274. void CEGDockingPane::RestoreParent() {
  275. SetParent( m_pDockingBar );
  276. }
  278. void CEGDockingPane::RemoveFromBorder( CEGDockBorder * pBorder, BOOL bShow ) {
  279. ASSERT( pBorder != NULL );
  281. SetParent( m_pDockingBar );
  282. m_pDockingBar->ActivatePane( this );
  283. m_pDockingBar->RemoveFromBorder( pBorder, bShow );
  284. }
  286. void CEGDockingPane::OnKillFocus( NMHDR* pNMHDR, LRESULT* pResult ) {
  288. HWND hFocus = ::GetFocus();
  289. if ( hFocus && !::IsChild( hFocus, GetSafeHwnd() ) )
  290. GetParent()->PostMessage( WM_KILLFOCUS, (WPARAM)hFocus, 0 );
  291. }
  293. void CEGDockingPane::OnSetFocus( NMHDR* pNMHDR, LRESULT* pResult ) {
  294. GetParent()->PostMessage( WM_FOCUS_CHANGED, 0, 0 );
  295. }
  297. void CEGDockingPane::Show() {
  299. if ( m_pDockingBar->IsFlyOutMode() && m_bHidden ) {
  301. m_pDockingBar->m_pBorder->AddButton( DRAWBTNSTYLE_GROUP, this );
  302. m_bHidden = FALSE;
  303. //m_pDockingBar->m_pBorder->FlyOutPane( this );
  305. m_pDockingBar->GetTopLevelFrame()->RecalcLayout();
  307. } else if ( m_bHidden ) {
  308. m_bHidden = FALSE;
  309. m_pDockingBar->PostMessage( DM_PANESTATE_CHANGED, (WPARAM)this, 1 );
  310. }
  312. }
  314. void CEGDockingPane::Hide( BOOL bNotifyContainer ) {
  316. if ( m_pDockingBar->IsFlyOutMode() && !m_bHidden ) {
  318. m_pDockingBar->m_pBorder->FlyDownPane( this );
  319. m_pDockingBar->m_pBorder->RemoveButton( this );
  320. m_bHidden = TRUE;
  322. m_pDockingBar->GetTopLevelFrame()->DelayRecalcLayout();
  325. } else if ( !m_bHidden ) {
  326. m_bHidden = TRUE;
  327. if ( bNotifyContainer )
  328. m_pDockingBar->PostMessage( DM_PANESTATE_CHANGED, (WPARAM)this, 0 );
  329. }
  330. }
  332. void CEGDockingPane::ToggleVisible() {
  333. if ( !m_bHidden ) {
  334. Hide();
  335. } else {
  336. Show();
  337. }
  338. }
  340. BOOL CEGDockingPane::SetIcon( UINT nIDResource, HINSTANCE hInst ) {
  341. return m_bmpIcon.LoadBitmap( nIDResource, hInst );
  342. }
  344. BOOL CEGDockingPane::SetIcon( LPCTSTR lpszResourceName, HINSTANCE hInst ) {
  345. return m_bmpIcon.LoadBitmap( lpszResourceName, hInst );
  346. }
  348. /////////////////////////////////////////////////////////////////////////
  349. // CEGDockingControlPane
  351. CEGDockingControlPane::CEGDockingControlPane(void)
  352. {
  353. m_hWndControl = NULL;
  354. m_nID = 0;
  355. }
  357. CEGDockingControlPane::~CEGDockingControlPane(void)
  358. {
  359. }
  361. HWND CEGDockingControlPane::CreateControl() {
  362. return NULL;
  363. }
  365. BOOL CEGDockingControlPane::InitControl() {
  366. return TRUE;
  367. }
  369. BEGIN_MESSAGE_MAP(CEGDockingControlPane, CEGDockingPane)
  370. ON_WM_CREATE()
  371. ON_WM_SIZE()
  372. // ON_MESSAGE(WM_USER,OnKickIdle)
  373. END_MESSAGE_MAP()
  375. int CEGDockingControlPane::OnCreate( LPCREATESTRUCT lpCreateStruct ) {
  377. if( CEGDockingPane::OnCreate( lpCreateStruct) ) {
  378. TRACE0("Cannot create docking pane");
  379. return -1;
  380. }
  382. m_hWndControl = CreateControl();
  384. if ( !m_hWndControl ) {
  385. TRACE0("Cannot create docking control");
  386. return -1;
  387. }
  389. if ( !InitControl() ) {
  390. TRACE0("Cannot initialize docking control");
  391. return -1;
  392. }
  394. if ( 0 == m_nID ) 
  395. return 0;
  397.   if (!m_wndToolBar.CreateEx(this, TBSTYLE_AUTOSIZE|TBSTYLE_FLAT|TBSTYLE_LIST, WS_CHILD | WS_VISIBLE | CBRS_TOP
  398.     |CBRS_TOOLTIPS | CBRS_SIZE_DYNAMIC,CRect(1,1,1,1),AFX_IDW_TOOLBAR) ||
  399.     !m_wndToolBar.LoadToolBar(m_nID))
  400.   {
  401.     TRACE0("Failed to create toolbarn");
  402.     return -1;      // fail to create
  403.   }
  405.   // Prevent the toolbarbutton to be too big after resizing TaskBar!
  406.   for (int n=0;n<m_wndToolBar.GetCount();n++)
  407.   {
  408.     DWORD dwStyle = m_wndToolBar.GetButtonStyle(n);
  409.     if( !(dwStyle&TBBS_SEPARATOR) )
  410.     {
  411.        m_wndToolBar.SetButtonStyle(n,dwStyle|TBBS_AUTOSIZE);
  412.     }
  413.   }
  415.   // adjust border
  416.   switch (CEGMenu::GetMenuDrawMode())
  417.   {
  418.   case CEGMenu::STYLE_COLORFUL_NOBORDER:
  419.   case CEGMenu::STYLE_COLORFUL:
  420.   case CEGMenu::STYLE_XP_2003_NOBORDER:
  421.   case CEGMenu::STYLE_XP_2003:
  422.   case CEGMenu::STYLE_ICY:
  423.   case CEGMenu::STYLE_ICY_NOBORDER:
  424.     m_wndToolBar.SetBorders(0,0,0,4);
  425.     break;
  426.   default:
  427.     m_wndToolBar.SetBorders(0,0,0,0);
  428.     break;
  429.   }
  431.   CRect rcClientStart;
  432. CRect rcClientNow;
  433. GetClientRect(rcClientStart);
  434. RepositionBars(AFX_IDW_CONTROLBAR_FIRST,AFX_IDW_CONTROLBAR_LAST,0,reposQuery,rcClientNow);
  436. // Set the icon for this dialog.  The framework does this automatically
  437. CPoint ptoffset(rcClientNow.left - rcClientStart.left, rcClientNow.top - rcClientStart.top); 
  438. CRect  rcchild;
  439. CWnd* pwndchild = GetWindow(GW_CHILD);
  440. while (pwndchild)
  441. {      
  442. pwndchild->GetWindowRect(rcchild);
  443. ScreenToClient(rcchild);
  444. rcchild.OffsetRect(ptoffset);
  445. pwndchild->MoveWindow(rcchild, FALSE);
  446. pwndchild = pwndchild->GetNextWindow();
  447. }
  448. // adjust the dialog window dimensions
  449. CRect rcwindow;
  450. GetWindowRect(rcwindow);
  451. rcwindow.right += rcClientStart.Width() - rcClientNow.Width();
  452. rcwindow.bottom += rcClientStart.Height() - rcClientNow.Height();
  453. MoveWindow(rcwindow, FALSE); // and position the control bars
  454. RepositionBars(AFX_IDW_CONTROLBAR_FIRST, AFX_IDW_CONTROLBAR_LAST, 0);
  456. return 0;
  457. }
  459. void CEGDockingControlPane::OnSize( UINT nType, int cx, int cy ) {
  461. CEGDockingPane::OnSize( nType, cx, cy );
  464. if ( 0 != m_nID ) 
  465. RepositionBars(AFX_IDW_CONTROLBAR_FIRST, AFX_IDW_CONTROLBAR_LAST, 0);
  467. if ( m_hWndControl ) {
  468. int nDelta = 0;
  469. if ( 0 != m_nID ) {
  470. CRect rc;
  471. m_wndToolBar.GetWindowRect( &rc );
  472. nDelta = rc.Height();
  473. }
  474. ::MoveWindow( m_hWndControl, 0, 0 + nDelta  , cx, cy - nDelta, TRUE );
  475. }
  476. }
  478. void CEGDockingControlPane::SetResourceID( int nID ) {
  479. m_nID = nID;
  480. }
  482. class CToolCmdUI : public CCmdUI 
  483. {    
  484.   virtual void Enable(BOOL bEnable) 
  485.   {
  486.     ::SendMessage(m_pOther->GetSafeHwnd(), TB_ENABLEBUTTON, m_nID , MAKELPARAM(bEnable, 0));
  487.   }
  488.   virtual void SetCheck(int nCheck = 1)
  489.   { 
  490.     ::SendMessage(m_pOther->GetSafeHwnd(), TB_CHECKBUTTON, m_nID, MAKELPARAM(nCheck, 0)); 
  491.   }
  492. };
  494. /*LRESULT CEGDockingControlPane::OnKickIdle(WPARAM wp, LPARAM lp)
  495. {
  496.   UNREFERENCED_PARAMETER(wp);
  497.   UNREFERENCED_PARAMETER(lp);
  499. if ( 0 == m_nID ) return false;
  501.   CToolCmdUI cmdUI;
  502.   cmdUI.m_pOther = &m_wndToolBar;
  503.   UINT indexMax = m_wndToolBar.GetToolBarCtrl().GetButtonCount();
  504.   cmdUI.m_nIndexMax = indexMax;
  505.   for (UINT i = 0; i < indexMax; i++) 
  506.   {
  507.     if (m_wndToolBar.GetButtonStyle(i) & TBSTYLE_SEP)
  508.       continue;
  509.     cmdUI.m_nIndex = i;
  510.     cmdUI.m_nID = m_wndToolBar.GetItemID(i);
  511.     cmdUI.m_pMenu = NULL;
  512.     cmdUI.DoUpdate(this,FALSE);
  513.   }
  514. return false;
  515.   //UpdateDialogControls(this,FALSE);
  516.   //AfxCallWndProc(this, m_hWnd,WM_IDLEUPDATECMDUI, (WPARAM)TRUE, 0);
  517.   //SendMessageToDescendants(WM_IDLEUPDATECMDUI,(WPARAM)TRUE, 0, TRUE, TRUE);
  518.   //return 0;
  519. } 
  520. */
  522. /////////////////////////////////////////////////////////////////////////
  523. // CEGToolBaredPane
  524. /*
  525. BEGIN_MESSAGE_MAP(CEGToolBaredPane, CEGDockingPane)
  526. ON_WM_CREATE()
  527. ON_WM_SIZE()
  528. ON_MESSAGE(WM_USER,OnKickIdle)
  529. END_MESSAGE_MAP()
  531. int CEGToolBaredPane::OnCreate( LPCREATESTRUCT lpCreateStruct ) {
  533. if( CEGDockingPane::OnCreate( lpCreateStruct) ) {
  534. TRACE0("Cannot create docking pane");
  535. return -1;
  536. }
  538. if ( 0 == m_nID ) 
  539. return 0;
  541.   if (!m_wndToolBar.CreateEx(this, TBSTYLE_AUTOSIZE|TBSTYLE_FLAT|TBSTYLE_LIST, WS_CHILD | WS_VISIBLE | CBRS_TOP
  542.     |CBRS_TOOLTIPS | CBRS_SIZE_DYNAMIC,CRect(1,1,1,1),AFX_IDW_TOOLBAR) ||
  543.     !m_wndToolBar.LoadToolBar(m_nID))
  544.   {
  545.     TRACE0("Failed to create toolbarn");
  546.     return -1;      // fail to create
  547.   }
  549.   // Prevent the toolbarbutton to be too big after resizing TaskBar!
  550.   for (int n=0;n<m_wndToolBar.GetCount();n++)
  551.   {
  552.     DWORD dwStyle = m_wndToolBar.GetButtonStyle(n);
  553.     if( !(dwStyle&TBBS_SEPARATOR) )
  554.     {
  555.        m_wndToolBar.SetButtonStyle(n,dwStyle|TBBS_AUTOSIZE);
  556.     }
  557.   }
  559.   // adjust border
  560.   switch (CEGMenu::GetMenuDrawMode())
  561.   {
  562.   case CEGMenu::STYLE_COLORFUL_NOBORDER:
  563.   case CEGMenu::STYLE_COLORFUL:
  564.   case CEGMenu::STYLE_XP_2003_NOBORDER:
  565.   case CEGMenu::STYLE_XP_2003:
  566.   case CEGMenu::STYLE_ICY:
  567.   case CEGMenu::STYLE_ICY_NOBORDER:
  568.     m_wndToolBar.SetBorders(0,0,0,4);
  569.     break;
  570.   default:
  571.     m_wndToolBar.SetBorders(0,0,0,0);
  572.     break;
  573.   }
  575.   CRect rcClientStart;
  576. CRect rcClientNow;
  577. GetClientRect(rcClientStart);
  578. RepositionBars(AFX_IDW_CONTROLBAR_FIRST,AFX_IDW_CONTROLBAR_LAST,0,reposQuery,rcClientNow);
  580. // Set the icon for this dialog.  The framework does this automatically
  581. CPoint ptoffset(rcClientNow.left - rcClientStart.left, rcClientNow.top - rcClientStart.top); 
  582. CRect  rcchild;
  583. CWnd* pwndchild = GetWindow(GW_CHILD);
  584. while (pwndchild)
  585. {      
  586. pwndchild->GetWindowRect(rcchild);
  587. ScreenToClient(rcchild);
  588. rcchild.OffsetRect(ptoffset);
  589. pwndchild->MoveWindow(rcchild, FALSE);
  590. pwndchild = pwndchild->GetNextWindow();
  591. }
  592. // adjust the dialog window dimensions
  593. CRect rcwindow;
  594. GetWindowRect(rcwindow);
  595. rcwindow.right += rcClientStart.Width() - rcClientNow.Width();
  596. rcwindow.bottom += rcClientStart.Height() - rcClientNow.Height();
  597. MoveWindow(rcwindow, FALSE); // and position the control bars
  598. RepositionBars(AFX_IDW_CONTROLBAR_FIRST, AFX_IDW_CONTROLBAR_LAST, 0);
  600. return 0;
  601. }
  604. void CEGToolBaredPane::OnSize( UINT nType, int cx, int cy ) {
  606. CEGDockingPane::OnSize( nType, cx, cy );
  608. if ( 0 != m_nID ) 
  609. RepositionBars(AFX_IDW_CONTROLBAR_FIRST, AFX_IDW_CONTROLBAR_LAST, 0);
  610. }
  612. void CEGToolBaredPane::SetResourceID( int nID ) {
  613. m_nID = nID;
  614. }
  616. LRESULT CEGToolBaredPane::OnKickIdle(WPARAM wp, LPARAM lp)
  617. {
  618.   UNREFERENCED_PARAMETER(wp);
  619.   UNREFERENCED_PARAMETER(lp);
  621. if ( 0 == m_nID ) return false;
  623.   CToolCmdUI cmdUI;
  624.   cmdUI.m_pOther = &m_wndToolBar;
  625.   UINT indexMax = m_wndToolBar.GetToolBarCtrl().GetButtonCount();
  626.   cmdUI.m_nIndexMax = indexMax;
  627.   for (UINT i = 0; i < indexMax; i++) 
  628.   {
  629.     if (m_wndToolBar.GetButtonStyle(i) & TBSTYLE_SEP)
  630.       continue;
  631.     cmdUI.m_nIndex = i;
  632.     cmdUI.m_nID = m_wndToolBar.GetItemID(i);
  633.     cmdUI.m_pMenu = NULL;
  634.     cmdUI.DoUpdate(this,FALSE);
  635.   }
  636. return false;
  637.   //UpdateDialogControls(this,FALSE);
  638.   //AfxCallWndProc(this, m_hWnd,WM_IDLEUPDATECMDUI, (WPARAM)TRUE, 0);
  639.   //SendMessageToDescendants(WM_IDLEUPDATECMDUI,(WPARAM)TRUE, 0, TRUE, TRUE);
  640.   //return 0;
  641. } 
  642. */
  643. /////////////////////////////////////////////////////////////////////////
  644. // CEGDockingBar
  646. IMPLEMENT_DYNAMIC(CEGDockingBar, CControlBar);
  648. CEGDockingBar::CEGDockingBar( CSize size )
  649. {
  650. m_szMinHorz = CSize(33, 32);
  651. m_szMinVert = CSize(33, 32);
  652. m_szMinFloat = CSize(37, 32);
  653. m_szHorz = size;
  654. m_szVert = size;
  655. m_szFloat = CSize( size.cx, size.cx );
  656. m_bTracking = FALSE;
  657. m_bKeepSize = FALSE;
  658. m_bParentSizing = FALSE;
  659. m_cxEdge = 4;
  660. m_bDragShowContent = FALSE;
  661. m_nDockBarID = 0;
  662. m_dwPaneStyle = 0;
  663. m_cyCaption = 16;
  664. m_cyTabs = 25;
  665. m_bActive = FALSE;
  666. m_bAutoHidePinned = FALSE;
  668. m_bClosePressed = FALSE;
  669. m_bCloseHover = FALSE;
  671. m_bPinPressed = FALSE;
  672. m_bPinHover = FALSE;
  675. m_pActivePane = NULL;
  676. m_bFlyOutMode = FALSE;
  677. m_pFrameWnd = NULL;
  678. m_bTabDrag = FALSE;
  679. m_pBorder = NULL;
  680. }
  682. CEGDockingBar::~CEGDockingBar()
  683. {
  684. }
  686. BEGIN_MESSAGE_MAP(CEGDockingBar, CControlBar)
  687. ON_WM_CREATE()
  688. ON_WM_DESTROY()
  689. ON_WM_TIMER()
  690. //ON_WM_PAINT()
  691. ON_WM_NCPAINT()
  692. ON_WM_NCCALCSIZE()
  693. ON_WM_WINDOWPOSCHANGING()
  694. ON_WM_CAPTURECHANGED()
  695. ON_WM_CANCELMODE()
  696. ON_WM_SETTINGCHANGE()
  697. ON_WM_LBUTTONUP()
  698. ON_WM_MOUSEMOVE()
  699. ON_WM_NCLBUTTONDOWN()
  700. ON_WM_NCLBUTTONUP()
  701. ON_WM_NCMOUSEMOVE()
  702. ON_WM_LBUTTONDOWN()
  703. ON_WM_LBUTTONDBLCLK()
  704. ON_WM_RBUTTONDOWN()
  705. ON_WM_NCHITTEST()
  706. ON_WM_CLOSE()
  707. ON_WM_SIZE()
  709. ON_MESSAGE( WM_SETTEXT, OnSetText )
  710. ON_MESSAGE( WM_NCMOUSELEAVE, OnNcMouseLeave )
  711. ON_MESSAGE( DM_PANESTATE_CHANGED, OnPaneStateChanged )
  712. END_MESSAGE_MAP()
  714. BOOL CEGDockingBar::Create(LPCTSTR lpszWindowName, UINT nIconID,
  715.  CWnd* pParentWnd, UINT nID,
  716.  DWORD dwStyle)
  717. {
  718. m_nIconID = nIconID;
  720. // must have a parent
  721. ASSERT_VALID(pParentWnd);
  722. // cannot be both fixed and dynamic
  723. // (CBRS_SIZE_DYNAMIC is used for resizng when floating)
  724. ASSERT (!((dwStyle & CBRS_SIZE_FIXED) &&
  725. (dwStyle & CBRS_SIZE_DYNAMIC)));
  727. m_dwStyle = dwStyle & CBRS_ALL; // save the control bar styles
  729. // register and create the window - skip CControlBar::Create()
  730. CString wndclass = ::AfxRegisterWndClass(CS_DBLCLKS,
  731. ::LoadCursor(NULL, IDC_ARROW),
  732. ::GetSysColorBrush(COLOR_BTNFACE), 0);
  734. dwStyle &= ~CBRS_ALL; // keep only the generic window styles
  735. dwStyle |= WS_CLIPCHILDREN; // prevents flashing
  736. if (!CWnd::Create(wndclass, lpszWindowName, dwStyle,
  737. CRect(0, 0, 0, 0), pParentWnd, nID))
  738. return FALSE;
  740. EnableDocking(CBRS_ALIGN_ANY);
  742. return TRUE;
  743. }
  745. /////////////////////////////////////////////////////////////////////////
  746. // CEGDockingBar attributes
  748. DockType CEGDockingBar::GetDropTarget( CPoint ptScreen, CEGDockingPane ** ppPane ) {
  750. *ppPane = NULL;
  752. CRect rcWindow;
  753. GetWindowRect( &rcWindow );
  754. if ( !rcWindow.PtInRect( ptScreen ) )
  755. return dctOutOfBorders;
  757. if ( IsFloating() ) {
  758. *ppPane = m_pActivePane;
  759. return dctTab;
  760. }
  762. CPoint pt = ptScreen;
  763. ScreenToClient( &pt );
  765. CRect rcActivePane;
  766. m_pActivePane->GetWindowRect( &rcActivePane );
  767. ScreenToClient( rcActivePane );
  769. *ppPane = m_pActivePane;
  770. if ( !rcActivePane.PtInRect( pt ) )
  771. return dctTab;
  773. return (*ppPane)->GetDropTarget( pt );
  774. }
  776. CRect CEGDockingBar::GetDropRect( DockType nDockType ) {
  778. CRect rc;
  779. GetWindowRect( &rc ); // default for dctTab
  781. switch ( nDockType ) {
  782. case dctTop:
  783. rc.bottom = rc.top + min( rc.Height(), m_cyCaption * 2 );
  784. break;
  785. case dctBottom:
  786. rc.top = rc.bottom - min( rc.Height(), m_cyCaption * 2 );
  787. break;
  788. case dctLeft:
  789. rc.right = rc.left + min( rc.Width(), m_cyCaption * 2 );
  790. break;
  791. case dctRight:
  792. rc.left = rc.right - min( rc.Width(), m_cyCaption * 2 );
  793. break;
  794. }
  796. return rc;
  797. }
  799. /////////////////////////////////////////////////////////////////////////
  800. // CEGDockingBar operations
  802. void CEGDockingBar::EnableDocking(DWORD dwDockStyle)
  803. {
  804. // must be CBRS_ALIGN_XXX or CBRS_FLOAT_MULTI only
  805. ASSERT((dwDockStyle & ~(CBRS_ALIGN_ANY|CBRS_FLOAT_MULTI)) == 0);
  806. // cannot have the CBRS_FLOAT_MULTI style
  807. ASSERT((dwDockStyle & CBRS_FLOAT_MULTI) == 0);
  808. // the bar must have CBRS_SIZE_DYNAMIC style
  809. ASSERT((m_dwStyle & CBRS_SIZE_DYNAMIC) != 0);
  811. m_dwDockStyle = dwDockStyle;
  812. if (m_pDockContext == NULL)
  813. m_pDockContext = new CEGDockingContext(this);
  815. // permanently wire the bar's owner to its current parent
  816. if (m_hWndOwner == NULL)
  817. m_hWndOwner = ::GetParent(m_hWnd);
  818. }
  820. /////////////////////////////////////////////////////////////////////////
  821. // CEGDockingBar message handlers
  823. int CEGDockingBar::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  824. {
  825. if (CControlBar::OnCreate(lpCreateStruct) == -1)
  826. return -1;
  828. // query SPI_GETDRAGFULLWINDOWS system parameter
  829. // OnSettingChange() will update m_bDragShowContent
  830. m_bDragShowContent = FALSE;
  831. ::SystemParametersInfo(SPI_GETDRAGFULLWINDOWS, 0,
  832. &m_bDragShowContent, 0);
  834. // Caption height
  835. m_cyCaption = ::GetSystemMetrics(SM_CYSMCAPTION);
  838. // uncomment this line if you want raised borders
  839. //m_dwPaneStyle |= DPS_SHOWEDGES;
  841. SetPaneStyle(m_dwPaneStyle|DPS_SIZECHILD);
  843. // m_tabs.Create( NULL, NULL, WS_CHILD | FTS_ALIGN_BOTTOM, CRect(0,0,0,0), this, 0, NULL ); 
  845. m_nTimer = (UINT)SetTimer( 1, 250, NULL );
  847. return 0;
  848. }
  850. void CEGDockingBar::OnDestroy() {
  851. KillTimer( m_nTimer );
  852. }
  854. LRESULT CEGDockingBar::OnSetText(WPARAM wParam, LPARAM lParam)
  855. {
  856. UNUSED_ALWAYS(wParam);
  858. LRESULT lResult = CWnd::Default();
  859. CFrameWnd * pFrame = GetParentFrame();
  861. if (IsFloating() && pFrame && pFrame->IsKindOf(RUNTIME_CLASS(CMiniDockFrameWnd)))
  862. {
  863. pFrame->SetWindowText( (LPCTSTR) lParam); // update dockbar
  864. pFrame->DelayRecalcLayout(); // refresh miniframe
  865. }
  867. return lResult;
  868. }
  870. const BOOL CEGDockingBar::IsFloating() const
  871. {
  872. return !IsHorzDocked() && !IsVertDocked();
  873. }
  875. const BOOL CEGDockingBar::IsHorzDocked() const
  876. {
  877. return (m_nDockBarID == AFX_IDW_DOCKBAR_TOP ||
  878. m_nDockBarID == AFX_IDW_DOCKBAR_BOTTOM);
  879. }
  881. const BOOL CEGDockingBar::IsVertDocked() const
  882. {
  883. return (m_nDockBarID == AFX_IDW_DOCKBAR_LEFT ||
  884. m_nDockBarID == AFX_IDW_DOCKBAR_RIGHT);
  885. }
  887. const BOOL CEGDockingBar::IsSideTracking() const
  888. {
  889. // don't call this when not tracking
  890. ASSERT(m_bTracking && !IsFloating());
  892. return (m_htEdge == HTLEFT || m_htEdge == HTRIGHT) ?
  893. IsHorzDocked() : IsVertDocked();
  894. }
  896. CSize CEGDockingBar::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  897. {
  898. if (bStretch) // the bar is stretched (is not the child of a dockbar)
  899. if (bHorz)
  900. return CSize(32767, m_szHorz.cy);
  901. else
  902. return CSize(m_szVert.cx, 32767);
  904. // dirty cast - we need access to protected CDockBar members
  905. CEGDockSite* pDockBar = reinterpret_cast<CEGDockSite*>( m_pDockBar );
  907. // force imediate RecalcDelayShow() for all sizing bars on the row
  908. // with delayShow/delayHide flags set to avoid IsVisible() problems
  909. CDPArray arrSCBars;
  910. GetRowSizingBars(arrSCBars);
  911. AFX_SIZEPARENTPARAMS layout;
  912. layout.hDWP = pDockBar->m_bLayoutQuery ?
  913. NULL : ::BeginDeferWindowPos(int(arrSCBars.GetSize()));
  914. for (INT_PTR i = 0; i < arrSCBars.GetSize(); i++)
  915. if (arrSCBars[i]->m_nStateFlags & (delayHide|delayShow))
  916. arrSCBars[i]->RecalcDelayShow(&layout);
  917. if (layout.hDWP != NULL)
  918. ::EndDeferWindowPos(layout.hDWP);
  920. // get available length
  921. CRect rc = pDockBar->m_rectLayout;
  922. if (rc.IsRectEmpty())
  923. m_pDockSite->GetClientRect(&rc);
  924. int nLengthTotal = bHorz ? rc.Width() + 2 : rc.Height() - 2;
  926. if (IsVisible() && !IsFloating() &&
  927. m_bParentSizing && arrSCBars[0] == this)
  928. if (NegotiateSpace(nLengthTotal, (bHorz != FALSE)))
  929. AlignControlBars();
  931. m_bParentSizing = FALSE;
  933. if (bHorz)
  934. return CSize(max(m_szMinHorz.cx, m_szHorz.cx),
  935. max(m_szMinHorz.cy, m_szHorz.cy));
  937. return CSize(max(m_szMinVert.cx, m_szVert.cx),
  938. max(m_szMinVert.cy, m_szVert.cy));
  939. }
  941. CSize CEGDockingBar::CalcDynamicLayout(int nLength, DWORD dwMode)
  942. {
  943. if (dwMode & (LM_HORZDOCK | LM_VERTDOCK)) // docked ?
  944. {
  945. if (nLength == -1)
  946. m_bParentSizing = TRUE;
  948. return CControlBar::CalcDynamicLayout(nLength, dwMode);
  949. }
  951. if (dwMode & LM_MRUWIDTH) return m_szFloat;
  952. if (dwMode & LM_COMMIT) return m_szFloat; // already committed
  954. // check for dialgonal resizing hit test
  955. int nHitTest = m_pDockContext->m_nHitTest;
  956. if (IsFloating() &&
  957. (nHitTest == HTTOPLEFT || nHitTest == HTBOTTOMLEFT ||
  958. nHitTest == HTTOPRIGHT || nHitTest == HTBOTTOMRIGHT))
  959. {
  960. CPoint ptCursor;
  961. ::GetCursorPos(&ptCursor);
  963. CRect rFrame, rBar;
  964. GetParentFrame()->GetWindowRect(&rFrame);
  965. GetWindowRect(&rBar);
  967. if (nHitTest == HTTOPLEFT || nHitTest == HTBOTTOMLEFT)
  968. {
  969. m_szFloat.cx = rFrame.left + rBar.Width() - ptCursor.x;
  970. m_pDockContext->m_rectFrameDragHorz.left = 
  971. min(ptCursor.x, rFrame.left + rBar.Width() - m_szMinFloat.cx);
  972. }
  974. if (nHitTest == HTTOPLEFT || nHitTest == HTTOPRIGHT)
  975. {
  976. m_szFloat.cy = rFrame.top + rBar.Height() - ptCursor.y;
  977. m_pDockContext->m_rectFrameDragHorz.top =
  978. min(ptCursor.y, rFrame.top + rBar.Height() - m_szMinFloat.cy);
  979. }
  981. if (nHitTest == HTTOPRIGHT || nHitTest == HTBOTTOMRIGHT)
  982. m_szFloat.cx = rBar.Width() + ptCursor.x - rFrame.right;
  984. if (nHitTest == HTBOTTOMLEFT || nHitTest == HTBOTTOMRIGHT)
  985. m_szFloat.cy = rBar.Height() + ptCursor.y - rFrame.bottom;
  986. }
  987. else
  988. ((dwMode & LM_LENGTHY) ? m_szFloat.cy : m_szFloat.cx) = nLength;
  990. m_szFloat.cx = max(m_szFloat.cx, m_szMinFloat.cx);
  991. m_szFloat.cy = max(m_szFloat.cy, m_szMinFloat.cy);
  993. return m_szFloat;
  994. }
  996. void CEGDockingBar::OnWindowPosChanging(WINDOWPOS FAR* lpwndpos)
  997. {
  998. // force non-client recalc if moved or resized
  999. lpwndpos->flags |= SWP_FRAMECHANGED;
  1001. CControlBar::OnWindowPosChanging(lpwndpos);
  1003. // find on which side are we docked
  1004. m_nDockBarID = GetParent()->GetDlgCtrlID();
  1006. if (!IsFloating())
  1007. if (lpwndpos->flags & SWP_SHOWWINDOW)
  1008. m_bKeepSize = TRUE;
  1009. }
  1011. /////////////////////////////////////////////////////////////////////////
  1012. // Mouse Handling
  1013. //
  1014. void CEGDockingBar::OnLButtonDown(UINT nFlags, CPoint point)
  1015. {
  1016. HWND hActiveWnd = ::GetFocus();
  1017. if ( hActiveWnd && hActiveWnd !=  m_hWnd && !::IsChild( m_hWnd, hActiveWnd ) ) {
  1018. if ( !m_pActivePane ) {
  1019. ::SetFocus( m_hWnd );
  1020. } else {
  1021. HWND hChild = ::GetWindow( m_pActivePane->GetSafeHwnd(), GW_CHILD );
  1022. ::SetFocus( hChild != NULL ? hChild : m_hWnd );
  1023. }
  1024. }
  1026. if ( point.y < 0 && -point.y < m_cyCaption ) {
  1027. if ( m_rcClose.PtInRect( point ) ) {
  1028. SetCapture();
  1029. m_bClosePressed = TRUE;
  1030. RePaint();
  1031. } else if ( m_rcPin.PtInRect( point ) ) {
  1032. SetCapture();
  1033. m_bPinPressed = TRUE;
  1034. RePaint();
  1035. }
  1036. }
  1037. CWnd::OnLButtonDown(nFlags, point);
  1038. }
  1040. void CEGDockingBar::OnLButtonDblClk(UINT nFlags, CPoint point)
  1041. {
  1042. if (m_pDockBar != NULL)
  1043. {
  1045. // not a buttons?
  1046. if ( !m_rcClose.PtInRect( point ) && !m_rcPin.PtInRect( point ) ) {
  1047. // toggle docking
  1048. ASSERT(m_pDockContext != NULL);
  1049. m_pDockContext->ToggleDocking();
  1050. TRACE0("CEGDockingBar::OnLButtonDblClkrn");
  1051. }
  1052. }
  1053. else {
  1054. TRACE0("CEGDockingBar::OnLButtonDblClk - CWnd::OnLButtonDblClkrn");
  1055. CWnd::OnLButtonDblClk(nFlags, point);
  1056. }
  1057. }
  1059. void CEGDockingBar::OnNcLButtonDown(UINT nHitTest, CPoint point) 
  1060. {
  1061. UNUSED_ALWAYS(point);
  1063. if (m_bTracking /* || IsFloating() */ )
  1064. return;
  1066. CPoint ptScreen( point );
  1067. ScreenToClient( &point );
  1068. point.y -= m_cxEdge;
  1070. if ((nHitTest >= HTSIZEFIRST) && (nHitTest <= HTSIZELAST)) {
  1071. StartTracking(nHitTest, ptScreen); // sizing edge hit
  1072. } else if ( point.y >= m_rcClient.Height() && point.y <= m_rcClient.Height() + m_cyTabs ) {
  1073. CEGDockingTabBtnsIt it = find_if( m_lstTabButtons.begin(), m_lstTabButtons.end(), HotPaneButton( point.x ) );
  1074. if ( it != m_lstTabButtons.end() && !it->m_pPane->IsHidden() ) {
  1076. ActivatePane( it->m_pPane );
  1078. m_bTabDrag = TRUE;
  1079. m_nTabDragStart = point.x;
  1081. // 狸蜩忤痼屐 蝠