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

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

界面编程

开发平台：

Visual C++

ExtStatusControlBar.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. #ifndef __EXT_MFC_NO_STATUSBAR
  26. #if (!defined __EXT_STATUSCONTROLBAR_H)
  27. #include <ExtStatusControlBar.h>
  28. #endif
  30. #if (!defined __EXTDOCKBAR_H)
  31. #include "ExtDockBar.h"
  32. #endif
  34. #if (!defined __EXT_PAINT_MANAGER_H)
  35. #include <ExtPaintManager.h>
  36. #endif
  38. #if _MFC_VER < 0x700
  39. #include <../src/AfxImpl.h>
  40. #else
  41. #include <../src/mfc/AfxImpl.h>
  42. #endif
  44. #if (!defined __EXT_MFC_NO_CUSTOMIZE)
  45. #if (!defined __EXTCUSTOMIZE_H)
  46. #include <ExtCustomize.h>
  47. #endif
  48. #endif // (!defined __EXT_MFC_NO_CUSTOMIZE)
  50. #if (!defined __EXT_MEMORY_DC_H)
  51. #include <../src/ExtMemoryDC.h>
  52. #endif
  54. #if (!defined __EXT_POPUP_MENU_WND_H)
  55. #include <ExtPopupMenuWnd.h>
  56. #endif
  58. #ifdef _DEBUG
  59. #define new DEBUG_NEW
  60. #undef THIS_FILE
  61. static char THIS_FILE[] = __FILE__;
  62. #endif
  64. #if (!defined SBPF_UPDATE)
  65. #define SBPF_UPDATE 0x0001  // pending update of text
  66. #endif // _DEBUG
  68. /////////////////////////////////////////////////////////////////////////////
  69. // CExtStatusControlBar
  71. IMPLEMENT_DYNCREATE( CExtStatusControlBar, CStatusBar )
  72. IMPLEMENT_CExtPmBridge_MEMBERS( CExtStatusControlBar );
  74. CExtStatusControlBar::CExtStatusControlBar()
  75. : m_bOuterRectInFirstBand( false )
  76. , m_bCompleteRepaint( true )
  77. , m_bDrawPaneSeparatorsInsteadOfBorders( false ) // default status bar control behavior
  78. , m_bHideTextOnDisabledPanes( true ) // default status bar control behavior
  79. , m_bDoNotPaintIcons( false )
  80. , m_nDrawPaneTextFlags( DT_SINGLELINE|DT_LEFT|DT_VCENTER ) // default status bar control behavior
  81. , m_bLockPainting( false )
  82. , m_nAdvancedTipStyle( INT(CExtPopupMenuTipWnd::__ETS_RECTANGLE_NO_ICON) )
  83. {
  84. m_clrStatusBk = (COLORREF)(-1);
  85. PmBridge_Install();
  86. }
  88. CExtStatusControlBar::~CExtStatusControlBar()
  89. {
  90. PmBridge_Uninstall();
  91. _RemovePanesImpl();
  92. }
  94. void CExtStatusControlBar::PostNcDestroy()
  95. {
  96. _RemovePanesImpl();
  97. CStatusBar::PostNcDestroy();
  98. }
  100. void CExtStatusControlBar::_RemovePanesImpl()
  101. {
  102. INT nCount = INT( m_arrPaneControls.GetSize() );
  103. if( nCount == 0 )
  104. return;
  105. CList < UINT, UINT > _listCtrlIDs( nCount );
  106.   for( INT i = 0; i < nCount; i++ )
  107.   _listCtrlIDs.AddTail( UINT( m_arrPaneControls[i]->nID ) );
  108. for( POSITION pos = _listCtrlIDs.GetHeadPosition(); pos != NULL; )
  109. {
  110. UINT nID = _listCtrlIDs.GetNext( pos );
  111. RemovePaneControl( nID );
  112. }
  113. }
  115. bool CExtStatusControlBar::OnQueryDrawPaneSeparatorsInsteadOfBorders() const
  116. {
  117. ASSERT_VALID( this );
  118. if( m_bCompleteRepaint
  119. && PmBridge_GetPM()->StatusBar_QuerySkinSupport(this)
  120. )
  121. return true;
  122. return m_bDrawPaneSeparatorsInsteadOfBorders;
  123. }
  125. BEGIN_MESSAGE_MAP(CExtStatusControlBar, CStatusBar)
  126. //{{AFX_MSG_MAP(CExtStatusControlBar)
  127. ON_WM_PAINT()
  128. ON_WM_NCPAINT()
  129. ON_WM_CREATE()
  130. ON_WM_CONTEXTMENU()
  131. ON_WM_ERASEBKGND()
  132. ON_WM_SIZE()
  133. ON_WM_MOUSEMOVE()
  134. ON_WM_CANCELMODE()
  135. //}}AFX_MSG_MAP
  136. ON_MESSAGE( WM_SIZEPARENT, OnSizeParent )
  137. ON_WM_SYSCOLORCHANGE()
  138. __EXT_MFC_SAFE_ON_WM_SETTINGCHANGE()
  139. ON_MESSAGE(WM_DISPLAYCHANGE, OnDisplayChange)
  140. ON_MESSAGE(__ExtMfc_WM_THEMECHANGED, OnThemeChanged)
  141. __EXT_MFC_ON_WM_NCHITTEST()
  142. END_MESSAGE_MAP()
  145. /////////////////////////////////////////////////////////////////////////////
  146. // CExtStatusControlBar message handlers
  148. void CExtStatusControlBar::OnPaint() 
  149. {
  150. ASSERT_VALID( this );
  152. if( m_bLockPainting ) 
  153. return;
  155. if( !m_bCompleteRepaint )
  156. {
  157. Default();
  158. return;
  159. }
  161. CPaintDC dcPaint( this );
  162. DoPaint( &dcPaint );
  163. }
  165. void CExtStatusControlBar::DoPaint( CDC * pDC )
  166. {
  167. ASSERT_VALID( this );
  168. ASSERT_VALID( pDC );
  170. // XP painting & last pane size fixed by Dmitry Yakovlev
  171. _SyncStatusBarColors();
  173. CRect rcClient;
  174. GetClientRect( &rcClient );
  175. CExtPaintManager::stat_ExcludeChildAreas(
  176. *pDC,
  177. GetSafeHwnd(),
  178. CExtPaintManager::stat_DefExcludeChildAreaCallback
  179. );
  180. CExtMemoryDC dc(
  181. pDC,
  182. &rcClient
  183. );
  184. UpdateAllPanes( FALSE, TRUE );
  186. // erase client area with the current color/gradient
  187. CRect rcFill( rcClient );
  188. rcFill.left = rcFill.top = 0;
  189. rcFill.right  -= rcClient.left;
  190. rcFill.bottom -= rcClient.top;
  191. OnPaintEntireBackground( dc, rcFill );
  193. // pre-compute gripper rect, exclude it's area
  194. CRect rcGrip( 0, 0, 0, 0 );
  195. CWnd * pWndParentStatus = GetParent(); // GetTopLevelParent();
  196. if( pWndParentStatus != NULL )
  197. {
  198. WINDOWPLACEMENT _wp;
  199. ::memset( (void*)&_wp, 0, sizeof(WINDOWPLACEMENT) );
  200. _wp.length = sizeof(WINDOWPLACEMENT);
  201. pWndParentStatus->GetWindowPlacement( &_wp );
  202. if( _wp.showCmd != SW_SHOWMAXIMIZED
  203. //&& (pWndParentStatus->GetStyle()&WS_BORDER) != 0
  204. )
  205. {
  206. MINMAXINFO _mmi;
  207. ::memset( &_mmi, 0, sizeof(MINMAXINFO) );
  208. CExtPaintManager::monitor_parms_t _mp;
  209. CExtPaintManager::stat_GetMonitorParms( _mp, (CWnd*)pWndParentStatus );
  210. _mmi.ptMaxPosition.x = _mp.m_rcWorkArea.left;
  211. _mmi.ptMaxPosition.y = _mp.m_rcWorkArea.top;
  212. _mmi.ptMaxTrackSize.x = _mp.m_rcWorkArea.Width(); // ::GetSystemMetrics( SM_CXMAXTRACK );
  213. _mmi.ptMaxTrackSize.y = _mp.m_rcWorkArea.Height(); // ::GetSystemMetrics( SM_CYMAXTRACK );
  214. _mmi.ptMinTrackSize.x = ::GetSystemMetrics( SM_CXMINTRACK );
  215. _mmi.ptMinTrackSize.y = ::GetSystemMetrics( SM_CYMINTRACK );
  216. _mmi.ptMaxSize.x = _mmi.ptMaxTrackSize.x;
  217. _mmi.ptMaxSize.y = _mmi.ptMaxTrackSize.y;
  218. if( ((CWnd*)pWndParentStatus)->SendMessage( WM_GETMINMAXINFO, 0, LPARAM(&_mmi) ) == 0 )
  219. {
  220. if( _mmi.ptMinTrackSize.x < _mmi.ptMaxTrackSize.x
  221. || _mmi.ptMinTrackSize.y < _mmi.ptMaxTrackSize.y
  222. )
  223. {
  224. GetClientRect( &rcGrip );
  225. rcGrip.left = rcGrip.right - ::GetSystemMetrics( SM_CXVSCROLL );
  226. dc.ExcludeClipRect( &rcGrip );
  227. }
  228. } // if( ((CWnd*)pWndParentStatus)->SendMessage( WM_GETMINMAXINFO, 0, LPARAM(&_mmi) ) == 0 )
  229. } // if( _wp.showCmd != SW_SHOWMAXIMIZED ...
  230. } // if( pWndParentStatus != NULL )
  232. CFont * pOldFont = NULL;
  233. int nOldBkMode = 0;
  234. COLORREF nOldTextColor = 0;
  235. if( m_bCompleteRepaint )
  236. {
  237. pOldFont = dc.SelectObject( &PmBridge_GetPM()->m_FontNormal );
  238. nOldBkMode = dc.SetBkMode( TRANSPARENT );
  239. nOldTextColor = dc.SetTextColor( m_clrPaneTextNormal );
  240. } // if( m_bCompleteRepaint )
  241. // re-paint borders/text/icons
  242. CRect rcPanePrev( 0, 0, 0, 0 );
  243. for( INT nPaneIdx = 0; nPaneIdx < m_nCount; nPaneIdx++ )
  244. {
  245. CRect rcPane;
  246. GetItemRect( nPaneIdx, &rcPane );
  247. // CStatusBar::GetItemRect() sometimes returns invalid size 
  248. // of the last pane - we will re-compute it
  249.         DWORD dwPaneStyle = GetPaneStyle( nPaneIdx );
  250. if( nPaneIdx == (m_nCount-1) )
  251. {
  252. int cx = ::GetSystemMetrics( SM_CXEDGE );
  253. if( (dwPaneStyle & SBPS_STRETCH ) == 0 )
  254. {
  255. UINT nID, nStyle;
  256. int  cxWidth;
  257. GetPaneInfo( nPaneIdx, nID, nStyle, cxWidth );
  258. rcPane.right = rcPane.left + cxWidth + cx*3;
  259. } // if( (dwPaneStyle & SBPS_STRETCH ) == 0 )
  260. else
  261. {
  262. CRect rcClient;
  263. GetClientRect( &rcClient );
  264. rcPane.right = rcClient.right;
  265. if( (GetStyle() & SBARS_SIZEGRIP) == SBARS_SIZEGRIP )
  266. {
  267. int cxSmIcon = ::GetSystemMetrics( SM_CXSMICON );
  268. rcPane.right -= cxSmIcon + cx;
  269. } // if( (GetStyle() & SBARS_SIZEGRIP) == SBARS_SIZEGRIP )
  270. } // else from if( (dwPaneStyle & SBPS_STRETCH ) == 0 )
  271. } // if( nPaneIdx == (m_nCount-1) )
  272. HICON hIcon = NULL;
  273. if( ! m_bDoNotPaintIcons )
  274. hIcon = (HICON)
  275. CStatusBar::GetStatusBarCtrl().
  276. SendMessage( SB_GETICON, nPaneIdx );
  277. CString sPaneText = GetPaneText( nPaneIdx );
  278. OnErasePaneBackground(
  279. dc,
  280. nPaneIdx,
  281. rcPane
  282. );
  283. OnPaintPane(
  284. dc,
  285. nPaneIdx,
  286. rcPane,
  287. dwPaneStyle,
  288. hIcon,
  289. sPaneText.IsEmpty()
  290. ? __EXT_MFC_SAFE_LPCTSTR( NULL )
  291. : __EXT_MFC_SAFE_LPCTSTR( LPCTSTR(sPaneText) )
  292. ,
  293. GetPaneDrawTextFlags(nPaneIdx) // m_nDrawPaneTextFlags
  294. );
  295. if( m_bCompleteRepaint
  296. && OnQueryDrawPaneSeparatorsInsteadOfBorders()
  297. && nPaneIdx > 0
  298. )
  299. OnPaintSeparator(
  300. dc,
  301. nPaneIdx,
  302. rcPanePrev,
  303. rcPane
  304. );
  305. rcPanePrev = rcPane;
  306. } // for( INT nPaneIdx = m_bOuterRectInFirstBand ? 0 : 1; nPaneIdx < m_nCount; nPaneIdx++ )
  307. if( m_bCompleteRepaint )
  308. {
  309. dc.SetTextColor( nOldTextColor );
  310. dc.SetBkMode( nOldBkMode );
  311. dc.SelectObject( pOldFont );
  312. } // if( m_bCompleteRepaint )
  314. // paint resizing gripper after all pane borders - this will allow gripper
  315. // to be on the top of all panes when window size is near its minimal size 
  316. if( !rcGrip.IsRectEmpty() )
  317. {
  318. dc.SelectClipRgn( NULL );
  319. OnPaintGripper( dc, rcGrip );
  320. } // if( !rcGrip.IsRectEmpty() )
  321. }
  323. bool CExtStatusControlBar::OnQueryGripperEnabledState() const
  324. {
  325. ASSERT_VALID( this );
  326. if( CExtPopupMenuWnd::g_bFullScreenMode )
  327. return false;
  328. CWnd * pWndParent = GetParent();
  329. if( pWndParent != NULL )
  330. {
  331. DWORD dwWndStyle = pWndParent->GetStyle();
  332. if( (dwWndStyle&WS_THICKFRAME) == 0 )
  333. return false;
  334. }
  335. return true;
  336. }
  338. //////////////////////////////////////////////////////////////////////////
  340. void CExtStatusControlBar::OnPaintGripper(
  341. CDC & dc,
  342. const CRect & rcGrip
  343. )
  344. {
  345. ASSERT_VALID( this );
  346. if( ! m_bCompleteRepaint )
  347. dc.FillSolidRect( &rcGrip, m_clrStatusBk );
  348. if( ! OnQueryGripperEnabledState() )
  349. return;
  350. CRect rcPaintGrip( rcGrip );
  351. rcPaintGrip.OffsetRect( -1, -1 );
  352. PmBridge_GetPM()->PaintResizingGripper(
  353. dc,
  354. rcPaintGrip,
  355. this
  356. );
  357. }
  359. //////////////////////////////////////////////////////////////////////////
  361. void CExtStatusControlBar::OnPaintSeparator(
  362. CDC & dc,
  363. int nPaneIdxAfterSep,
  364. const CRect & rcPaneBefore,
  365. const CRect & rcPaneAfter
  366. )
  367. {
  368. ASSERT_VALID( this );
  369. if( PmBridge_GetPM()->StatusBar_PaintSeparator(
  370. dc,
  371. nPaneIdxAfterSep,
  372. rcPaneBefore,
  373. rcPaneAfter,
  374. this
  375. )
  376. )
  377. return;
  378. CRect rcSeparator(
  379. rcPaneBefore.right,
  380. rcPaneAfter.top,
  381. rcPaneAfter.left,
  382. rcPaneAfter.bottom
  383. );
  384. rcSeparator.DeflateRect( 0, 1 );
  385. PmBridge_GetPM()->PaintSeparator(
  386. dc,
  387. rcSeparator,
  388. true,
  389. true,
  390. this,
  391. nPaneIdxAfterSep
  392. );
  393. }
  395. //////////////////////////////////////////////////////////////////////////
  397. void CExtStatusControlBar::OnPaintEntireBackground(
  398. CDC & dc,
  399. const CRect & rcBk
  400. )
  401. {
  402. ASSERT_VALID( this );
  403. if( m_bCompleteRepaint
  404. && PmBridge_GetPM()->StatusBar_EraseBackground(
  405. dc,
  406. rcBk,
  407. this
  408. )
  409. )
  410. return;
  412. bool bTransparent = false;
  413. if( m_bCompleteRepaint
  414. && PmBridge_GetPM()->GetCb2DbTransparentMode(this)
  415. )
  416. {
  417. if( PmBridge_GetPM()->PaintDockerBkgnd( true, dc, this ) )
  418. bTransparent = true;
  419. }
  420. if( ! bTransparent )
  421. dc.FillSolidRect( &rcBk, m_clrStatusBk );
  423. // invoke default handler
  424. if( ! m_bCompleteRepaint )
  425. CStatusBar::DefWindowProc( WM_PAINT, (WPARAM)dc.GetSafeHdc(), 0 );
  426. }
  428. //////////////////////////////////////////////////////////////////////////
  430. void CExtStatusControlBar::OnErasePaneBackground(
  431. CDC & dc,
  432. int nPaneIdx,
  433. const CRect & rcPane
  434. )
  435. {
  436. ASSERT_VALID( this );
  437. COLORREF clrBack = OnQueryPaneBkColor( nPaneIdx );
  438. if( clrBack != COLORREF(-1L) )
  439. {
  440. dc.FillSolidRect( rcPane, clrBack );
  441. return;
  442. }
  443. PmBridge_GetPM()->StatusBar_ErasePaneBackground(
  444. dc,
  445. nPaneIdx,
  446. rcPane,
  447. this
  448. );
  449. }
  451. //////////////////////////////////////////////////////////////////////////
  453. void CExtStatusControlBar::OnPaintPane(
  454. CDC & dc,
  455. int nPaneIdx,
  456. const CRect & rcPane,
  457. DWORD dwPaneStyle,
  458. HICON hIcon,
  459. __EXT_MFC_SAFE_LPCTSTR sPaneText, // by default it's text from the status bar control
  460. UINT nDrawTextFlags // by default m_nDrawPaneTextFlags is used
  461. )
  462. {
  463. ASSERT_VALID( this );
  464. if( m_bCompleteRepaint )
  465. {
  466. bool bDisabled = 
  467. ((dwPaneStyle & SBPS_DISABLED) != 0) ? true : false;
  468. COLORREF clrText = 
  469. OnQueryPaneTextColor( nPaneIdx, !bDisabled );
  470. if( PmBridge_GetPM()->StatusBar_PaintPane(
  471. dc,
  472. nPaneIdx,
  473. rcPane,
  474. dwPaneStyle,
  475. hIcon,
  476. sPaneText,
  477. nDrawTextFlags,
  478. clrText,
  479. this
  480. )
  481. )
  482. return;
  483. CRect rcText( rcPane );
  484. if( hIcon != NULL )
  485. {
  486. CExtCmdIcon _icon;
  487. _icon.AssignFromHICON( hIcon, true );
  488. CSize sizeIcon = _icon.GetSize();
  489. ASSERT( sizeIcon.cx > 0 && sizeIcon.cy > 0 );
  490. rcText.left += sizeIcon.cx + 1;
  491. _icon.Paint(
  492. PmBridge_GetPM(),
  493. dc,
  494. rcPane.left + 1,
  495. rcPane.top + ( rcPane.Height() - sizeIcon.cy ) / 2,
  496. -1,
  497. -1
  498. );
  499. } // if( hIcon != NULL )
  500. int nPaneTextLen =
  501. (sPaneText == NULL)
  502. ? int(0)
  503. : int(_tcslen(sPaneText))
  504. ;
  505. if( (!bDisabled)
  506. || (bDisabled && (!m_bHideTextOnDisabledPanes))
  507. && nPaneTextLen > 0
  508. )
  509. { // if text painting is allowed
  510. rcText.DeflateRect( 2, 0 );
  511. if( rcText.right > rcText.left )
  512. {
  513. COLORREF clrTextRestore = COLORREF(-1L);
  514. COLORREF clrTextCustom = OnQueryPaneTextColor( nPaneIdx, !bDisabled );
  515. if( clrTextCustom != COLORREF(-1L) )
  516. clrTextRestore = dc.SetTextColor( clrTextCustom );
  517. else if( bDisabled )
  518. clrTextRestore = dc.SetTextColor( m_clrPaneTextDisabled );
  519. dc.DrawText(
  520. LPCTSTR(sPaneText),
  521. nPaneTextLen,
  522. &rcText,
  523. nDrawTextFlags
  524. );
  525. if( clrTextRestore != COLORREF(-1L) )
  526. dc.SetTextColor( clrTextRestore );
  527. } // if( rcText.right > rcText.left )
  528. } // if text painting is allowed
  529. } // if( m_bCompleteRepaint )
  530. if( (!m_bCompleteRepaint)
  531. || ( m_bCompleteRepaint
  532. && (! OnQueryDrawPaneSeparatorsInsteadOfBorders() )
  533. )
  534. )
  535. { // if paint pane borders
  536. bool bDrawPaneBorder = false;
  537. if( nPaneIdx == 0 )
  538. {
  539. bDrawPaneBorder = m_bOuterRectInFirstBand;
  540. } // if( nPaneIdx == 0 )
  541. else
  542. {
  543. if( (dwPaneStyle&SBPS_NOBORDERS) == 0 )
  544. bDrawPaneBorder = true;
  545. } // else from if( nPaneIdx == 0 )
  546. if( bDrawPaneBorder )
  547. {
  548. // if( m_bCompleteRepaint )
  549. // {
  550. // dc.Draw3dRect( &rcPane, m_clrPaneRect, m_clrPaneRect );
  551. // } // if( m_bCompleteRepaint )
  552. // else
  553. {
  554. CExtPaintManager::PAINTCONTROLBARBORDERSDATA _pcbbd(
  555. this,
  556. CExtPaintManager::__CB_INNER_STATUSBAR_ITEM,
  557. 0,
  558. rcPane
  559. );
  560. PmBridge_GetPM()->PaintControlBarBorders( dc, _pcbbd );
  561. } // else from if( m_bCompleteRepaint )
  562. } // if( bDrawPaneBorder )
  563. } // if paint pane borders
  564. if( (!m_bCompleteRepaint) && g_PaintManager.m_UxTheme.IsAppThemed() )
  565. {
  566. CRect rcPaneInner( rcPane );
  567. rcPaneInner.DeflateRect( 1, 1 );
  568. dc.Draw3dRect( &rcPaneInner, m_clrStatusBk, m_clrStatusBk );
  569. } // if( (!m_bCompleteRepaint) && g_PaintManager.m_UxTheme.IsAppThemed() )
  570. }
  572. //////////////////////////////////////////////////////////////////////////
  574. COLORREF CExtStatusControlBar::OnQueryPaneTextColor(
  575. int nPaneIdx,
  576. bool bEnabled
  577. ) const
  578. {
  579. ASSERT_VALID( this );
  580. ASSERT( 0 <= nPaneIdx && nPaneIdx < GetPaneCount() );
  581. _ED_ _data;
  582. UINT nID = GetItemID( nPaneIdx );
  583. if( ! m_mapIdToExtData.Lookup( nID, _data ) )
  584. return COLORREF(-1L);
  585. return 
  586. bEnabled 
  587. ? _data.m_clrTextNormal 
  588. : _data.m_clrTextDisabled;
  589. }
  591. COLORREF CExtStatusControlBar::OnQueryPaneBkColor(
  592. int nPaneIdx
  593. ) const
  594. {
  595. ASSERT_VALID( this );
  596. ASSERT( 0 <= nPaneIdx && nPaneIdx < GetPaneCount() );
  597. _ED_ _data;
  598. UINT nID = GetItemID( nPaneIdx );
  599. if( ! m_mapIdToExtData.Lookup( nID, _data ) )
  600. return COLORREF(-1L);
  601. return _data.m_clrBack;
  602. }
  604. //////////////////////////////////////////////////////////////////////////
  606. void CExtStatusControlBar::OnNcPaint() 
  607. {
  608. ASSERT_VALID( this );
  609. if( !m_bCompleteRepaint )
  610. {
  611. Default();
  612. return;
  613. }
  614. _SyncStatusBarColors();
  615. CRect rcClient, rcWnd;
  616. GetClientRect( rcClient );
  617. ClientToScreen( rcClient );
  618. GetWindowRect( rcWnd );
  619. rcClient.OffsetRect( -rcWnd.TopLeft() );
  620. rcWnd.OffsetRect( -rcWnd.TopLeft() );
  621. CWindowDC dc( this );
  622. dc.ExcludeClipRect( &rcClient );
  623. CExtPaintManager::PAINTCONTROLBARBORDERSDATA _pcbbd(
  624. this,
  625. CExtPaintManager::__CB_OUTER_STATUSBAR,
  626. m_dwStyle,
  627. rcWnd
  628. );
  629. PmBridge_GetPM()->PaintControlBarBorders( dc, _pcbbd );
  630. }
  632. //////////////////////////////////////////////////////////////////////////
  634. void CExtStatusControlBar::DrawBorders( CDC * pDC, CRect& rc )
  635. {
  636. ASSERT_VALID( this );
  637. ASSERT_VALID( pDC );
  638. CExtPaintManager::PAINTCONTROLBARBORDERSDATA _pcbbd(
  639. this,
  640. CExtPaintManager::__CB_OUTER_STATUSBAR,
  641. m_dwStyle,
  642. rc
  643. );
  644. PmBridge_GetPM()->PaintControlBarBorders( *pDC, _pcbbd );
  645. }
  647. //////////////////////////////////////////////////////////////////////////
  649. void CExtStatusControlBar::_SyncStatusBarColors()
  650. {
  651. ASSERT_VALID( this );
  652. COLORREF clrStatusBkNeeded =
  653. PmBridge_GetPM()->GetColor(
  654. CExtPaintManager::CLR_3DFACE_OUT, this
  655. );
  656. if( m_clrStatusBk != clrStatusBkNeeded )
  657. {
  658. m_clrStatusBk = clrStatusBkNeeded;
  659. GetStatusBarCtrl().SetBkColor( m_clrStatusBk );
  660. } // if( m_clrStatusBk != clrStatusBkNeeded )
  661. m_clrGripper = PmBridge_GetPM()->GetColor( CExtPaintManager::CLR_TEXT_OUT, this );
  662. m_clrPaneTextNormal = PmBridge_GetPM()->GetColor( COLOR_BTNTEXT, this );
  663. m_clrPaneTextDisabled = PmBridge_GetPM()->GetColor( CExtPaintManager::CLR_TEXT_DISABLED, this );
  664. m_clrPaneRect = m_clrStatusBk;
  665. if( m_bCompleteRepaint )
  666. m_clrPaneRect = PmBridge_GetPM()->GetColor( COLOR_3DSHADOW, this );
  667. }
  669. //////////////////////////////////////////////////////////////////////////
  671. void CExtStatusControlBar::OnSysColorChange() 
  672. {
  673. ASSERT_VALID( this );
  674. CStatusBar::OnSysColorChange();
  675. CExtPaintManager * pPM = PmBridge_GetPM();
  676. g_PaintManager.OnSysColorChange( this );
  677. g_CmdManager.OnSysColorChange( pPM, this );
  678. _SyncStatusBarColors();
  679. }
  681. //////////////////////////////////////////////////////////////////////////
  683. void CExtStatusControlBar::OnSettingChange(UINT uFlags, __EXT_MFC_SAFE_LPCTSTR lpszSection) 
  684. {
  685. ASSERT_VALID( this );
  686. //USES_CONVERSION;
  687. //TRACE2("  ==> CExtStatusControlBar::OnSettingChange(0x%08X,"%S")n", uFlags, (lpszSection == NULL) ? "NULL" : T2CA(lpszSection) );
  688. CStatusBar::OnSettingChange( uFlags, lpszSection );
  689. CExtPaintManager * pPM = PmBridge_GetPM();
  690. g_PaintManager.OnSettingChange( this, uFlags, lpszSection );
  691. g_CmdManager.OnSettingChange( pPM, this, uFlags, lpszSection );
  692. _SyncStatusBarColors();
  693. }
  695. //////////////////////////////////////////////////////////////////////////
  697. LRESULT CExtStatusControlBar::OnDisplayChange( WPARAM wParam, LPARAM lParam )
  698. {
  699. ASSERT_VALID( this );
  700. LRESULT lResult = CStatusBar::OnDisplayChange( wParam, lParam );
  701. CExtPaintManager * pPM = PmBridge_GetPM();
  702. g_PaintManager.OnDisplayChange( this, (INT)wParam, CPoint(lParam) );
  703. g_CmdManager.OnDisplayChange( pPM, this, (INT)wParam, CPoint(lParam) );
  704. return lResult;
  705. }
  707. //////////////////////////////////////////////////////////////////////////
  709. LRESULT CExtStatusControlBar::OnThemeChanged( WPARAM wParam, LPARAM lParam )
  710. {
  711. ASSERT_VALID( this );
  712. LRESULT lResult = Default();
  713. CExtPaintManager * pPM = PmBridge_GetPM();
  714. g_PaintManager.OnThemeChanged( this, wParam, lParam );
  715. g_CmdManager.OnThemeChanged( pPM, this, wParam, lParam );
  716. return lResult;
  717. }
  719. //////////////////////////////////////////////////////////////////////////
  721. int CExtStatusControlBar::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  722. {
  723. ASSERT_VALID( this );
  724. if( CStatusBar::OnCreate(lpCreateStruct) == -1 )
  725. return -1;
  727. CWnd::EnableToolTips( TRUE );
  728. CWnd::ModifyStyle( 0, WS_CLIPCHILDREN );
  730. ASSERT( GetSafeHwnd() != NULL );
  731. ASSERT( ::IsWindow(GetSafeHwnd()) );
  732. HWND hWndParent = ::GetParent( GetSafeHwnd() );
  733. ASSERT( hWndParent != NULL );
  734. ASSERT( ::IsWindow(hWndParent) );
  735. VERIFY(
  736. ::SetWindowPos(
  737. GetSafeHwnd(),
  738. HWND_TOP,
  739. 0, 0, 0, 0,
  740. SWP_NOSIZE|SWP_NOMOVE
  741. |SWP_NOREDRAW|SWP_NOACTIVATE|SWP_NOCOPYBITS
  742. |SWP_NOSENDCHANGING
  743. )
  744. );
  746. _SyncStatusBarColors();
  748. return 0;
  749. }
  751. //////////////////////////////////////////////////////////////////////////
  753. void CExtStatusControlBar::OnContextMenu(CWnd* pWnd, CPoint point) 
  754. {
  755. ASSERT_VALID( this );
  756. #if (!defined __EXT_MFC_NO_CUSTOMIZE)
  757. CExtCustomizeSite * pSite =
  758. CExtCustomizeSite::GetCustomizeSite( m_hWnd );
  759. if( pSite != NULL
  760. && pSite->IsCustomizeMode()
  761. )
  762. return;
  763. #endif // (!defined __EXT_MFC_NO_CUSTOMIZE)
  765. if( CExtControlBar::FindHelpMode(this) )
  766. return;
  768. CFrameWnd * pFrame = _GetDockingFrameImpl();
  769. if( pFrame == NULL )
  770. {
  771. CStatusBar::OnContextMenu( pWnd, point );
  772. return;
  773. }
  775. ASSERT_VALID( pFrame );
  776. HWND hWndTrack = GetOwner()->GetSafeHwnd();
  777. ASSERT( hWndTrack != NULL && ::IsWindow(hWndTrack) );
  778. CExtPopupMenuWnd * pPopup =
  779. CExtPopupMenuWnd::InstantiatePopupMenu(
  780. GetSafeHwnd(),
  781. RUNTIME_CLASS(CExtPopupMenuWnd),
  782. this
  783. );
  784. VERIFY( pPopup->CreatePopupMenu(hWndTrack) );
  786. if( ! CExtDockBar::_ConstructDockSiteControlBarPopupMenu(
  787. pFrame,
  788. pPopup,
  789. CExtControlBar::POPUP_MENU_EVENT_DATA::__PMED_STATUSBAR_CTX,
  790. this,
  791. WM_CONTEXTMENU,
  792. NULL
  793. )
  794. )
  795. {
  796. delete pPopup;
  797. return;
  798. }
  799. if( pPopup->ItemGetCount() == 0 )
  800. {
  801. delete pPopup;
  802. return;
  803. }
  804. ::SetFocus( hWndTrack );
  805. if( ! pPopup->TrackPopupMenu(
  806. TPMX_OWNERDRAW_FIXED,
  807. point.x,
  808. point.y,
  809. NULL,
  810. this,
  811. NULL,
  812. NULL,
  813. true
  814. )
  815. )
  816. {
  817. //delete pPopup;
  818. }
  819. }
  821. //////////////////////////////////////////////////////////////////////////
  823. CFrameWnd * CExtStatusControlBar::_GetDockingFrameImpl()
  824. {
  825. ASSERT_VALID( this );
  827. CFrameWnd * pFrame = GetParentFrame();
  828. if( pFrame == NULL )
  829. return NULL;
  831. ASSERT_VALID( pFrame );
  832. if( pFrame->IsKindOf(RUNTIME_CLASS(CMiniDockFrameWnd)) )
  833. {
  834. pFrame = pFrame->GetParentFrame();
  835. //ASSERT_VALID( pFrame );
  836. ASSERT( pFrame != NULL );
  837. ASSERT( !pFrame->IsKindOf(RUNTIME_CLASS(CMiniDockFrameWnd)) );
  838. }
  840. return pFrame;
  841. }
  843. //////////////////////////////////////////////////////////////////////////
  845. BOOL CExtStatusControlBar::OnEraseBkgnd(CDC* pDC) 
  846. {
  847. ASSERT_VALID( this );
  848. pDC;
  849. if( ! m_bCompleteRepaint )
  850. return Default() ? TRUE : FALSE;
  851. return TRUE;
  852. }
  854. //////////////////////////////////////////////////////////////////////////
  856. UINT CExtStatusControlBar::OnNcHitTest(CPoint point) 
  857. {
  858. ASSERT_VALID( this );
  859. if ( OnQueryGripperEnabledState() ) // fixed by Thomas Fuchs
  860. {
  861. CRect rcGrip( 0, 0, 0, 0 );
  862. CWnd * pWndParentStatus = GetParent();
  863. if( pWndParentStatus != NULL )
  864. {
  865. WINDOWPLACEMENT _wp;
  866. ::memset( (void*)&_wp, 0, sizeof(WINDOWPLACEMENT) );
  867. _wp.length = sizeof(WINDOWPLACEMENT);
  868. pWndParentStatus->GetWindowPlacement( &_wp );
  869. if( _wp.showCmd != SW_SHOWMAXIMIZED
  870. //&& (pWndParentStatus->GetStyle()&WS_BORDER) != 0
  871. )
  872. {
  873. MINMAXINFO _mmi;
  874. ::memset( &_mmi, 0, sizeof(MINMAXINFO) );
  875. CExtPaintManager::monitor_parms_t _mp;
  876. CExtPaintManager::stat_GetMonitorParms( _mp, (CWnd*)pWndParentStatus );
  877. _mmi.ptMaxPosition.x = _mp.m_rcWorkArea.left;
  878. _mmi.ptMaxPosition.y = _mp.m_rcWorkArea.top;
  879. _mmi.ptMaxTrackSize.x = _mp.m_rcWorkArea.Width(); // ::GetSystemMetrics( SM_CXMAXTRACK );
  880. _mmi.ptMaxTrackSize.y = _mp.m_rcWorkArea.Height(); // ::GetSystemMetrics( SM_CYMAXTRACK );
  881. _mmi.ptMinTrackSize.x = ::GetSystemMetrics( SM_CXMINTRACK );
  882. _mmi.ptMinTrackSize.y = ::GetSystemMetrics( SM_CYMINTRACK );
  883. _mmi.ptMaxSize.x = _mmi.ptMaxTrackSize.x;
  884. _mmi.ptMaxSize.y = _mmi.ptMaxTrackSize.y;
  885. if( ((CWnd*)pWndParentStatus)->SendMessage( WM_GETMINMAXINFO, 0, LPARAM(&_mmi) ) == 0 )
  886. {
  887. if( _mmi.ptMinTrackSize.x < _mmi.ptMaxTrackSize.x
  888. || _mmi.ptMinTrackSize.y < _mmi.ptMaxTrackSize.y
  889. )
  890. {
  891. GetClientRect( &rcGrip );
  892. rcGrip.top = rcGrip.bottom - ::GetSystemMetrics( SM_CYVSCROLL );
  893. rcGrip.left = rcGrip.right - ::GetSystemMetrics( SM_CXVSCROLL );
  894. CPoint ptClient( point );
  895. ScreenToClient( &ptClient );
  896. if( rcGrip.PtInRect(ptClient) )
  897. {
  898. __EXT_MFC_LONG_PTR dwExStyle = ::__EXT_MFC_GetWindowLong( GetSafeHwnd(), GWL_EXSTYLE );
  899. bool bRTL = ( (dwExStyle & WS_EX_LAYOUTRTL) != 0 ) ? true : false;
  900. return bRTL 
  901. ? HTBOTTOMLEFT 
  902. : HTBOTTOMRIGHT;
  903. }
  904. }
  905. } // if( ((CWnd*)pWndParentStatus)->SendMessage( WM_GETMINMAXINFO, 0, LPARAM(&_mmi) ) == 0 )
  906. } // if( _wp.showCmd != SW_SHOWMAXIMIZED ...
  907. } // if( pWndParentStatus != NULL )
  908. } // if ( OnQueryGripperEnabledState() )
  909. UINT nHT = (UINT)CStatusBar::OnNcHitTest(point);
  910. if( nHT != HTCLIENT
  911. && ( ! OnQueryGripperEnabledState() )
  912. )
  913. nHT = HTCLIENT;
  914. return nHT;
  915. }
  917. void CExtStatusControlBar::OnSize(UINT nType, int cx, int cy) 
  918. {
  919. CStatusBar::OnSize(nType, cx, cy);
  920. RepositionControls();
  921. }
  923. void CExtStatusControlBar::RepositionControls(
  924. bool bUpdate // = true
  925. )
  926. {
  927. ASSERT_VALID( this );
  928. int nPaneIndex, nPaneCount = (int)m_arrPaneControls.GetSize();
  929. HDWP _hDWP = ::BeginDeferWindowPos( nPaneCount );
  930. CRect rcClient;
  931. GetClientRect( &rcClient );
  932. for( nPaneIndex = 0; nPaneIndex < nPaneCount; nPaneIndex++ )
  933. {
  934. int iIndex =
  935. CommandToIndex(
  936. m_arrPaneControls[ nPaneIndex ] -> nID
  937. );
  938. HWND hWnd =
  939. m_arrPaneControls[ nPaneIndex ] -> hWnd;
  940. CRect rcPane;
  941. GetItemRect( iIndex, &rcPane );
  942. // CStatusBar::GetItemRect() sometimes returns invalid size 
  943. // of the last pane - we will re-compute it
  944. int cx = ::GetSystemMetrics( SM_CXEDGE );
  945. DWORD dwPaneStyle = GetPaneStyle( iIndex );
  946. if( iIndex == (m_nCount-1) )
  947. {
  948. if( (dwPaneStyle & SBPS_STRETCH ) == 0 )
  949. {
  950. UINT nID, nStyle;
  951. int  cxWidth;
  952. GetPaneInfo( iIndex, nID, nStyle, cxWidth );
  953. rcPane.right = rcPane.left + cxWidth + cx*3;
  954. } // if( (dwPaneStyle & SBPS_STRETCH ) == 0 )
  955. else
  956. {
  957. CRect rcClient;
  958. GetClientRect( &rcClient );
  959. rcPane.right = rcClient.right;
  960. if( (GetStyle() & SBARS_SIZEGRIP) == SBARS_SIZEGRIP )
  961. {
  962. int cxSmIcon = ::GetSystemMetrics( SM_CXSMICON );
  963. rcPane.right -= cxSmIcon + cx;
  964. } // if( (GetStyle() & SBARS_SIZEGRIP) == SBARS_SIZEGRIP )
  965. } // else from if( (dwPaneStyle & SBPS_STRETCH ) == 0 )
  966. } // if( iIndex == (m_nCount-1) )
  967. if( ( GetPaneStyle(iIndex)&SBPS_NOBORDERS ) == 0
  968. && (! OnQueryDrawPaneSeparatorsInsteadOfBorders() )
  969. )
  970. {
  971. rcPane.DeflateRect( cx, cx );
  972. }
  973. else
  974. {
  975. rcPane.DeflateRect( cx, 1, cx, 1 );
  976. }
  977. if( hWnd != NULL && ::IsWindow( hWnd ) )
  978. {
  979. _hDWP =
  980. ::DeferWindowPos(
  981. _hDWP, 
  982. hWnd, 
  983. NULL, 
  984. rcPane.left,
  985. rcPane.top, 
  986. rcPane.Width(), 
  987. rcPane.Height(),
  988. SWP_NOZORDER|SWP_NOOWNERZORDER
  989. |SWP_NOACTIVATE //|SWP_SHOWWINDOW
  990. |SWP_FRAMECHANGED
  991. |SWP_NOCOPYBITS
  992. );
  993. } // if( hWnd != NULL && ::IsWindow( hWnd ) )
  994. } // for( nPaneIndex = 0; nPaneIndex < nPaneCount; nPaneIndex++ )
  995. VERIFY( ::EndDeferWindowPos( _hDWP ) );
  996. if( bUpdate )
  997. {
  998. Invalidate();
  999. UpdateWindow();
  1000. }
  1001. };
  1003. //////////////////////////////////////////////////////////////////////////
  1005. bool CExtStatusControlBar::AddPane(
  1006.  UINT nID, // ID of the  pane
  1007.  int nIndex // index of the pane
  1008.  )
  1009. {
  1010. ASSERT_VALID( this );
  1011. if( nIndex < 0 || nIndex > m_nCount )
  1012. {
  1013. //ASSERT( FALSE );
  1014. return false;
  1015. }
  1016. if( CommandToIndex(nID) != -1)
  1017. {
  1018. //ASSERT( FALSE );
  1019. return false;
  1020. }
  1022. // disable painting
  1023. m_bLockPainting = true;
  1025. CArray <_STATUSBAR_PANE_* , _STATUSBAR_PANE_* > arrPanesTmp;
  1026. CArray < HICON, HICON > arrPaneIcons;
  1027. CStatusBarCtrl & _ctrl = GetStatusBarCtrl();
  1028. int iIndex;
  1029. for( iIndex = 0; iIndex < (m_nCount+1); iIndex++ )
  1030. {
  1031. _STATUSBAR_PANE_ * pNewPane = new _STATUSBAR_PANE_;
  1032. if( iIndex == nIndex )
  1033. {
  1034. pNewPane->nID    = nID;
  1035. pNewPane->nStyle = SBPS_NORMAL;
  1036. arrPaneIcons.Add( NULL );
  1037. } // if( iIndex == nIndex )
  1038. else
  1039. {
  1040. int idx = iIndex;
  1041. if( iIndex > nIndex )
  1042. idx--;
  1043. _STATUSBAR_PANE_ * pOldPane = GetPanePtr(idx);
  1044. pNewPane->cxText  = pOldPane->cxText;
  1045. pNewPane->nFlags  = pOldPane->nFlags;
  1046. pNewPane->nID     = pOldPane->nID;
  1047. pNewPane->nStyle  = pOldPane->nStyle;
  1048. pNewPane->strText = pOldPane->strText;
  1049. HICON hIcon = (HICON)
  1050. _ctrl.SendMessage(
  1051. SB_GETICON,
  1052. WPARAM(idx)
  1053. );
  1054. if( hIcon != NULL )
  1055. {
  1056. CExtCmdIcon _iconClone;
  1057. _iconClone.AssignFromHICON( hIcon, true );
  1058. hIcon = _iconClone.ExtractHICON();
  1059. ASSERT( hIcon != NULL );
  1060. } // if( hIcon != NULL )
  1061. arrPaneIcons.Add( hIcon );
  1062. } // else from if( iIndex == nIndex )
  1063. arrPanesTmp.Add( pNewPane );
  1064. } // for( iIndex = 0; iIndex < (m_nCount+1); iIndex++ )
  1065. int nPaneCount = (int)arrPanesTmp.GetSize();
  1066. UINT * lpIDArray = new UINT[ nPaneCount ];
  1067. for( iIndex = 0; iIndex < nPaneCount; iIndex++ )
  1068. lpIDArray[iIndex] = arrPanesTmp[iIndex]->nID;
  1069. // set the indicators 
  1070. SetIndicators( lpIDArray, nPaneCount );
  1071. // free memory, reset icons
  1072. for( iIndex = 0; iIndex < nPaneCount; iIndex++ )
  1073. {
  1074. _STATUSBAR_PANE_* pPane = arrPanesTmp[iIndex];
  1075. if( iIndex != nIndex )
  1076. PaneInfoSet(iIndex, pPane);
  1077. if( pPane ) 
  1078. delete pPane;
  1079. HICON hIcon = arrPaneIcons[iIndex];
  1080. _ctrl.SetIcon( iIndex, hIcon );
  1081. } // for( iIndex = 0; iIndex < nPaneCount; iIndex++ )
  1082. arrPanesTmp.RemoveAll();
  1083. arrPaneIcons.RemoveAll();
  1084. if( lpIDArray ) 
  1085. delete [] lpIDArray;
  1087. // enable painting
  1088. m_bLockPainting = false;
  1090. RepositionControls();
  1091. return true;
  1092. }
  1094. //////////////////////////////////////////////////////////////////////////
  1096. bool CExtStatusControlBar::_RemovePaneImpl(
  1097. UINT nID, // ID of the pane
  1098. bool bRefresh
  1099. )
  1100. {
  1101. ASSERT_VALID( this );
  1102. if( CommandToIndex(nID) == -1
  1103. //|| m_nCount == 1
  1104. )
  1105. {
  1106. ASSERT( FALSE );
  1107. return false;
  1108. }
  1110. // disable painting
  1111. m_bLockPainting = true;
  1113. m_mapIdToExtData.RemoveKey( nID );
  1115. CArray < _STATUSBAR_PANE_* , _STATUSBAR_PANE_ * > arrPanesTmp;
  1116. CArray < HICON, HICON > arrPaneIcons;
  1117. CStatusBarCtrl & _ctrl = GetStatusBarCtrl();
  1118. int nIndex;
  1119. for( nIndex = 0; nIndex < m_nCount; nIndex++ )
  1120. {
  1121. _STATUSBAR_PANE_ * pOldPane = GetPanePtr(nIndex);
  1122. HICON hIcon = (HICON)
  1123. _ctrl.SendMessage(
  1124. SB_GETICON,
  1125. WPARAM(nIndex)
  1126. );
  1127. if( pOldPane->nID == nID )
  1128. {
  1129. if( hIcon != NULL )
  1130. _ctrl.SetIcon( nIndex, (HICON)NULL );
  1131. continue;
  1132. } // if( pOldPane->nID == nID )
  1133. _STATUSBAR_PANE_ * pNewPane = new _STATUSBAR_PANE_;
  1134. pNewPane->cxText  = pOldPane->cxText;
  1135. pNewPane->nFlags  = pOldPane->nFlags;
  1136. pNewPane->nID     = pOldPane->nID;
  1137. pNewPane->nStyle  = pOldPane->nStyle;
  1138. pNewPane->strText = pOldPane->strText;
  1139. arrPanesTmp.Add( pNewPane );
  1140. if( hIcon != NULL )
  1141. {
  1142. CExtCmdIcon _iconClone;
  1143. _iconClone.AssignFromHICON( hIcon, true );
  1144. hIcon = _iconClone.ExtractHICON();
  1145. ASSERT( hIcon != NULL );
  1146. } // if( hIcon != NULL )
  1147. arrPaneIcons.Add( hIcon );
  1148. } // for( nIndex = 0; nIndex < m_nCount; nIndex++ )
  1149. UINT * lpIDArray = NULL;
  1150. if( arrPanesTmp.GetSize() > 0 )
  1151. {
  1152. lpIDArray = new UINT[ arrPanesTmp.GetSize() ];
  1153. for( nIndex = 0; nIndex < arrPanesTmp.GetSize(); nIndex++ )
  1154. lpIDArray[nIndex] = arrPanesTmp[nIndex]->nID;
  1155. } // if( arrPanesTmp.GetSize() > 0 )
  1156. // set the indicators
  1157. SetIndicators( lpIDArray, (int)arrPanesTmp.GetSize() );
  1158. // free memory, reset icons
  1159. for( nIndex = 0; nIndex < arrPanesTmp.GetSize(); nIndex++ )
  1160. {
  1161. _STATUSBAR_PANE_* pPane = arrPanesTmp[nIndex];
  1162. PaneInfoSet(nIndex, pPane);
  1163. if( pPane ) 
  1164. delete pPane;
  1165. HICON hIcon = arrPaneIcons[nIndex];
  1166. _ctrl.SetIcon( nIndex, hIcon );
  1167. } // for( nIndex = 0; nIndex < arrPanesTmp.GetSize(); nIndex++ )
  1168. RemovePaneControl( nID );
  1169. arrPanesTmp.RemoveAll();
  1170. arrPaneIcons.RemoveAll();
  1171. if( lpIDArray != NULL ) 
  1172. delete [] lpIDArray;
  1173. if( bRefresh )
  1174. RepositionControls();
  1176. // enable painting
  1177. m_bLockPainting = false;
  1179. return true;
  1180. }
  1182. //////////////////////////////////////////////////////////////////////////
  1184. bool CExtStatusControlBar::RemovePane(
  1185. UINT nID // ID of the pane
  1186. )
  1187. {
  1188. return _RemovePaneImpl( nID, true );
  1189. }
  1191. //////////////////////////////////////////////////////////////////////////
  1193. int CExtStatusControlBar::_RemovePanesImpl(
  1194. int nIndexToRemove,
  1195. int nCountToRemove,
  1196. bool bRefresh
  1197. )
  1198. {
  1199. ASSERT_VALID( this );
  1200. if( nIndexToRemove < 0
  1201. || nCountToRemove <= 0
  1202. )
  1203. return 0;
  1204. int nPaneCount = GetPaneCount();
  1205. ASSERT( nPaneCount >= 0 );
  1206. if( nIndexToRemove >= nPaneCount )
  1207. return 0;
  1208. if( (nIndexToRemove + nCountToRemove) > nPaneCount )
  1209. {
  1210. nCountToRemove = nPaneCount - nIndexToRemove;
  1211. ASSERT( nCountToRemove > 0 );
  1212. }
  1213. int nCountRemoved = 0;
  1214. for( int i = 0; i < nCountToRemove; i++ )
  1215. {
  1216. UINT nID = GetItemID( nIndexToRemove );
  1217. if( !_RemovePaneImpl( nID, false ) )
  1218. break;
  1219. nCountRemoved ++;
  1220. } // for( int i = 0; i < nCountToRemove; i++ )
  1221. if( bRefresh && nCountRemoved > 0 )
  1222. RepositionControls();
  1223. return nCountRemoved;
  1224. }
  1226. //////////////////////////////////////////////////////////////////////////
  1228. int CExtStatusControlBar::RemovePanes(
  1229. int nIndexToRemove,
  1230. int nCountToRemove
  1231. )
  1232. {
  1233. return _RemovePanesImpl( nIndexToRemove, nCountToRemove, true );
  1234. }
  1236. //////////////////////////////////////////////////////////////////////////
  1238. bool CExtStatusControlBar::RemovePaneControl( UINT nID )
  1239. {
  1240. ASSERT_VALID( this );
  1241. for( INT i = 0; i < m_arrPaneControls.GetSize(); i++ )
  1242. {
  1243. if( m_arrPaneControls[i]->nID == nID )
  1244. {
  1245. if( m_arrPaneControls[i]->hWnd != NULL
  1246. && ::IsWindow(m_arrPaneControls[i]->hWnd) 
  1247. ) 
  1248. {
  1249. ::ShowWindow( m_arrPaneControls[i]->hWnd, SW_HIDE ); 
  1250. if( m_arrPaneControls[i]->bAutoDestroy ) 
  1251. ::DestroyWindow( m_arrPaneControls[i]->hWnd );
  1252. }
  1253. _STATUSBAR_PANE_CTRL_ *pPaneCtrl = m_arrPaneControls[i];
  1254. if( pPaneCtrl )
  1255. delete pPaneCtrl;
  1256. m_arrPaneControls.RemoveAt(i);
  1257. return true;
  1258. }
  1259. }
  1260. return false;
  1261. }
  1263. //////////////////////////////////////////////////////////////////////////
  1265. bool CExtStatusControlBar::SetPaneControl(CWnd* pWnd, UINT nID, bool bAutoDestroy)
  1266. {
  1267. ASSERT_VALID( this );
  1268. return SetPaneControl( pWnd->GetSafeHwnd(), nID, bAutoDestroy);
  1269. }
  1271. bool CExtStatusControlBar::SetPaneControl(HWND hWnd, UINT nID, bool bAutoDestroy)
  1272. {
  1273. ASSERT_VALID( this );
  1275. if (CommandToIndex (nID) == -1)
  1276. {
  1277. return false; // pane doesn't exists
  1278. }
  1280. RemovePaneControl( nID ); // remove previous control if it exists
  1282. _STATUSBAR_PANE_CTRL_* pPaneCtrl = new _STATUSBAR_PANE_CTRL_;
  1283. pPaneCtrl->nID         = nID;
  1284. pPaneCtrl->hWnd        = hWnd;
  1285. pPaneCtrl->bAutoDestroy = bAutoDestroy;
  1287. m_arrPaneControls.Add(pPaneCtrl);
  1288. RepositionControls();
  1289. return true;
  1290. }
  1292. //////////////////////////////////////////////////////////////////////////
  1294. bool CExtStatusControlBar::PaneInfoGet(int nIndex, _STATUSBAR_PANE_* pPane) const
  1295. {
  1296. ASSERT_VALID( this );
  1297. ASSERT( pPane != NULL );
  1298. if( nIndex < m_nCount  && nIndex >= 0 )
  1299. {
  1300. GetPaneInfo( nIndex,  pPane->nID, pPane->nStyle, pPane->cxText );
  1301. CString strPaneText;
  1302. GetPaneText( nIndex , strPaneText );
  1303. pPane->strText = LPCTSTR(strPaneText);
  1304. return true;
  1305. }
  1306. return false;
  1307. }
  1309. //////////////////////////////////////////////////////////////////////////
  1311. bool CExtStatusControlBar::PaneInfoSet(int nIndex, _STATUSBAR_PANE_* pPane)
  1312. {
  1313. ASSERT_VALID( this );
  1314. ASSERT( pPane != NULL );
  1315. if( nIndex < m_nCount  && nIndex >= 0 )
  1316. {
  1317. SetPaneInfo( nIndex, pPane->nID, pPane->nStyle, pPane->cxText );
  1318. SetPaneText( nIndex, LPCTSTR( pPane->strText) );
  1319. return true;
  1320. }
  1321. return false;
  1322. }
  1324. //////////////////////////////////////////////////////////////////////////
  1326. UINT CExtStatusControlBar::GetPaneDrawTextFlags(
  1327. int nIndex
  1328. ) const
  1329. {
  1330. ASSERT_VALID( this );
  1331. if( GetSafeHwnd() == NULL )
  1332. return m_nDrawPaneTextFlags;
  1333. ASSERT( 0 <= nIndex && nIndex < GetPaneCount() );
  1334. _ED_ _data;
  1335. UINT nID = GetItemID( nIndex );
  1336. if( ! m_mapIdToExtData.Lookup( nID, _data ) )
  1337. return m_nDrawPaneTextFlags;
  1338. return _data.m_nDTF;
  1339. }
  1341. //////////////////////////////////////////////////////////////////////////
  1343. void CExtStatusControlBar::SetPaneDrawTextFlags(
  1344. int nIndex,
  1345. UINT _nDTF
  1346. )
  1347. {
  1348. ASSERT_VALID( this );
  1349. if( GetSafeHwnd() == NULL )
  1350. return;
  1351. ASSERT( 0 <= nIndex && nIndex < GetPaneCount() );
  1352. UINT nID = GetItemID( nIndex );
  1353. _ED_ _data;
  1354. if( m_mapIdToExtData.Lookup( nID, _data ) )
  1355. {
  1356. if( _nDTF == _data.m_nDTF )
  1357. return;
  1358. } // if( m_mapIdToExtData.Lookup( nID, nDTF ) )
  1359. _data.m_nDTF = _nDTF;
  1360. m_mapIdToExtData.SetAt( nID, _data );
  1361. Invalidate();
  1362. }
  1364. //////////////////////////////////////////////////////////////////////////
  1366. CExtStatusControlBar::e_StatusPaneBackgroundAccent_t CExtStatusControlBar::OnQueryPaneBackgroundAccent(
  1367. int nIndex
  1368. ) const
  1369. {
  1370. ASSERT_VALID( this );
  1371. if( GetSafeHwnd() == NULL )
  1372. return __ESPBA_DARK;
  1373. if( !( 0 <= nIndex && nIndex < GetPaneCount() ) )
  1374. return __ESPBA_DARK;
  1375. e_StatusPaneBackgroundAccent_t eSPBA = GetPaneBackgroundAccent( nIndex );
  1376. if( eSPBA == __ESPBA_AUTOMATIC )
  1377. {
  1378. eSPBA = __ESPBA_DARK;
  1379. UINT nID, nStyle;
  1380. int  cxWidth;
  1381. GetPaneInfo( nIndex, nID, nStyle, cxWidth );
  1382. if( nID == 0 )
  1383. eSPBA = __ESPBA_LIGHT;
  1384. }
  1385. return eSPBA;
  1386. }
  1388. //////////////////////////////////////////////////////////////////////////
  1390. CExtStatusControlBar::e_StatusPaneBackgroundAccent_t CExtStatusControlBar::GetPaneBackgroundAccent(
  1391. int nIndex
  1392. ) const
  1393. {
  1394. ASSERT_VALID( this );
  1395. if( GetSafeHwnd() == NULL )
  1396. return __ESPBA_AUTOMATIC;
  1397. ASSERT( 0 <= nIndex && nIndex < GetPaneCount() );
  1398. _ED_ _data;
  1399. UINT nID = GetItemID( nIndex );
  1400. if( ! m_mapIdToExtData.Lookup( nID, _data ) )
  1401. return __ESPBA_AUTOMATIC;
  1402. return _data.m_eSPBA;
  1403. }
  1405. //////////////////////////////////////////////////////////////////////////
  1407. void CExtStatusControlBar::SetPaneBackgroundAccent(
  1408. int nIndex,
  1409. CExtStatusControlBar::e_StatusPaneBackgroundAccent_t eSPBA
  1410. )
  1411. {
  1412. ASSERT_VALID( this );
  1413. if( GetSafeHwnd() == NULL )
  1414. return;
  1415. ASSERT( __ESPBA_MIN_VALUE <= eSPBA && eSPBA <= __ESPBA_MAX_VALUE );
  1416. UINT nID = GetItemID( nIndex );
  1417. _ED_ _data;
  1418. if( m_mapIdToExtData.Lookup( nID, _data ) )
  1419. {
  1420. if( eSPBA == _data.m_eSPBA )
  1421. return;
  1422. } // if( m_mapIdToExtData.Lookup( nID, nDTF ) )
  1423. _data.m_eSPBA = eSPBA;
  1424. m_mapIdToExtData.SetAt( nID, _data );
  1425. Invalidate();
  1426. }
  1428. //////////////////////////////////////////////////////////////////////////
  1430. UINT CExtStatusControlBar::GetItemID( int nIndex ) const
  1431. {
  1432. ASSERT_VALID( this );
  1433. if( GetSafeHwnd() == NULL )
  1434. return 0;
  1435. ASSERT( 0 <= nIndex && nIndex < GetPaneCount() );
  1436. _STATUSBAR_PANE_ pane;
  1437. PaneInfoGet( nIndex, &pane );
  1438. return pane.nID;
  1439. }
  1441. //////////////////////////////////////////////////////////////////////////
  1443. CExtStatusControlBar::_STATUSBAR_PANE_* CExtStatusControlBar::GetPanePtr(int nIndex) const
  1444. {
  1445. ASSERT_VALID( this );
  1446. ASSERT((nIndex >= 0 && nIndex < m_nCount) || m_nCount == 0);
  1447. return ((_STATUSBAR_PANE_*)m_pData) + nIndex;
  1448. }
  1450. CExtStatusControlBar::_STATUSBAR_PANE_ * CExtStatusControlBar::_GetPanePtr( int nIndex ) const
  1451. {
  1452. ASSERT((nIndex >= 0 && nIndex < m_nCount) || m_nCount == 0);
  1453. return ((_STATUSBAR_PANE_*)m_pData) + nIndex;
  1454. }
  1456. //////////////////////////////////////////////////////////////////////////
  1458. BOOL CExtStatusControlBar::SetIndicators(
  1459. const UINT * lpIDArray,
  1460. int nIDCount
  1461. )
  1462. {
  1463. ASSERT_VALID( this );
  1464. ASSERT( nIDCount >= 0 );
  1465. ASSERT(
  1466. lpIDArray == NULL
  1467. || ::AfxIsValidAddress(
  1468. lpIDArray,
  1469. sizeof(UINT) * nIDCount,
  1470. FALSE
  1471. )
  1472. );
  1473. ASSERT( ::IsWindow(m_hWnd) );
  1474. if( ! AllocElements(
  1475. nIDCount,
  1476. sizeof(_STATUSBAR_PANE_)
  1477. )
  1478. )
  1479. return FALSE;
  1480. ASSERT( nIDCount == m_nCount );
  1481. BOOL bResult = TRUE;
  1482. if( lpIDArray != NULL )
  1483. {
  1484. HFONT hFont = (HFONT)SendMessage( WM_GETFONT );
  1485. CClientDC dcScreen( NULL );
  1486. HGDIOBJ hOldFont = NULL;
  1487. if( hFont != NULL )
  1488. hOldFont = dcScreen.SelectObject( hFont );
  1489. _STATUSBAR_PANE_ * pPane = _GetPanePtr( 0 );
  1490. for( int nPaneIndex = 0; nPaneIndex < nIDCount; nPaneIndex++ )
  1491. {
  1492. pPane->nID = * lpIDArray++;
  1493. pPane->nFlags |= SBPF_UPDATE;
  1494. if( pPane->nID != 0 )
  1495. {
  1496. if( ! g_ResourceManager->LoadString( pPane->strText, pPane->nID ) )
  1497. {
  1498. // bResult = FALSE;
  1499. // break;
  1500. pPane->strText = _T("");
  1501. }
  1502. pPane->cxText =
  1503. dcScreen.GetTextExtent(
  1504. pPane->strText,
  1505. pPane->strText.GetLength()
  1506. ).cx;
  1507. //ASSERT( pPane->cxText >= 0 );
  1508. if( ! SetPaneText( nPaneIndex, pPane->strText, FALSE ) )
  1509. {
  1510. bResult = FALSE;
  1511. break;
  1512. } // if( ! SetPaneText( nPaneIndex, pPane->strText, FALSE ) )
  1513. } // if( pPane->nID != 0 )
  1514. else
  1515. {
  1516. pPane->cxText =
  1517. ::GetSystemMetrics(SM_CXSCREEN) / 4;
  1518. if( nPaneIndex == 0 )
  1519. pPane->nStyle |=
  1520. SBPS_STRETCH|SBPS_NOBORDERS;
  1521. } // else from if( pPane->nID != 0 )
  1522. pPane ++;
  1523. } // for( int nPaneIndex = 0; nPaneIndex < nIDCount; nPaneIndex++ )
  1524. if( hOldFont != NULL )
  1525. dcScreen.SelectObject( hOldFont );
  1526. } // if( lpIDArray != NULL )
  1527. UpdateAllPanes( TRUE, TRUE );
  1528. return bResult;
  1529. }
  1531. //////////////////////////////////////////////////////////////////////////
  1533. CExtSafeString CExtStatusControlBar::GetTipText( int nPane ) const
  1534. {
  1535. ASSERT_VALID( this );
  1536. if( GetSafeHwnd() == NULL )
  1537. return CExtSafeString( _T("") );
  1538. ASSERT( 0 <= nPane && nPane < GetPaneCount() );
  1539. _ED_ _data;
  1540. UINT nID = GetItemID( nPane );
  1541. if( ! m_mapIdToExtData.Lookup( nID, _data ) )
  1542. return CExtSafeString( _T("") );
  1543. return _data.m_strTipText;
  1544. }
  1546. //////////////////////////////////////////////////////////////////////////
  1548. void CExtStatusControlBar::SetTipText( int nPane, __EXT_MFC_SAFE_LPCTSTR pszTipText )
  1549. {
  1550. ASSERT_VALID( this );
  1551. if( GetSafeHwnd() == NULL )
  1552. return;
  1553. CWnd::CancelToolTips();
  1554. if( pszTipText == NULL )
  1555. pszTipText = _T("");
  1556. ASSERT( 0 <= nPane && nPane < GetPaneCount() );
  1557. UINT nID = GetItemID( nPane );
  1558. _ED_ _data;
  1559. if( m_mapIdToExtData.Lookup( nID, _data ) )
  1560. {
  1561. if( _tcscmp(
  1562. pszTipText,
  1563. ( _data.m_strTipText.IsEmpty() ? _T("") : LPCTSTR(_data.m_strTipText) )
  1564. ) == 0
  1565. )
  1566. return;
  1567. } // if( m_mapIdToExtData.Lookup( nID, nDTF ) )
  1568. _data.m_strTipText = pszTipText;
  1569. m_mapIdToExtData.SetAt( nID, _data );
  1570. Invalidate();
  1571. }
  1573. //////////////////////////////////////////////////////////////////////////
  1575. void CExtStatusControlBar::SetPaneBkColor( 
  1576. int nPane, 
  1577. COLORREF clrBk // = COLORREF(-1L)
  1578. )
  1579. {
  1580. ASSERT_VALID( this );
  1581. ASSERT( 0 <= nPane && nPane < GetPaneCount() );
  1582. UINT nID = GetItemID( nPane );
  1583. _ED_ _data;
  1584. if( m_mapIdToExtData.Lookup( nID, _data ) 
  1585. && _data.m_clrBack == clrBk
  1586. )
  1587. return;
  1588. _data.m_clrBack = clrBk;
  1589. m_mapIdToExtData.SetAt( nID, _data );
  1590. Invalidate();
  1591. }
  1593. void CExtStatusControlBar::SetPaneTextColor(
  1594. int nPane, 
  1595. bool bEnabled,
  1596. COLORREF clrText // = COLORREF(-1L)
  1597. )
  1598. {
  1599. ASSERT_VALID( this );
  1600. ASSERT( 0 <= nPane && nPane < GetPaneCount() );
  1601. UINT nID = GetItemID( nPane );
  1602. _ED_ _data;
  1603. if( m_mapIdToExtData.Lookup( nID, _data ) 
  1604. && ( (bEnabled && _data.m_clrTextNormal == clrText)
  1605. || ((!bEnabled) && _data.m_clrTextDisabled == clrText)
  1606. )
  1607. )
  1608. return;
  1609. if( bEnabled )
  1610. _data.m_clrTextNormal = clrText;
  1611. else
  1612. _data.m_clrTextDisabled = clrText;
  1613. m_mapIdToExtData.SetAt( nID, _data );
  1614. Invalidate();
  1615. }
  1617. COLORREF CExtStatusControlBar::GetPaneBkColor( 
  1618. int nPane
  1619. ) const
  1620. {
  1621. ASSERT_VALID( this );
  1622. ASSERT( 0 <= nPane && nPane < GetPaneCount() );
  1623. return OnQueryPaneBkColor( nPane );
  1624. }
  1626. COLORREF CExtStatusControlBar::GetPaneTextColor(
  1627. int nPane,
  1628. bool bEnabled
  1629. ) const
  1630. {
  1631. ASSERT_VALID( this );
  1632. ASSERT( 0 <= nPane && nPane < GetPaneCount() );
  1633. return OnQueryPaneTextColor( nPane, bEnabled );
  1634. }
  1636. //////////////////////////////////////////////////////////////////////////
  1638. int CExtStatusControlBar::HitTestStatusPane(
  1639. CPoint ptClient
  1640. ) const
  1641. {
  1642. ASSERT_VALID( this );
  1643. if( GetSafeHwnd() == NULL
  1644. || (! ::IsWindow( GetSafeHwnd() ) )
  1645. )
  1646. return -1;
  1647. int nPaneCount = GetPaneCount();
  1648. if( nPaneCount == 0 )
  1649. return -1;
  1650. CPoint ptScreen( ptClient );
  1651. ClientToScreen( &ptScreen );
  1652. HWND hWndFromPoint = ::WindowFromPoint( ptScreen );
  1653. if( hWndFromPoint != m_hWnd
  1654. && (! ::IsChild(m_hWnd, hWndFromPoint) )
  1655. )
  1656. return -1;
  1657. for( int nPaneIndex = 0; nPaneIndex < nPaneCount; nPaneIndex++ )
  1658. {
  1659. CRect rcPane;
  1660. GetItemRect( nPaneIndex, &rcPane );
  1661. if( rcPane.PtInRect(ptClient) )
  1662. return nPaneIndex;
  1663. } // for( int nPaneIndex = 0; nPaneIndex < nPaneCount; nPaneIndex++ )
  1664. return -1;
  1665. }
  1667. //////////////////////////////////////////////////////////////////////////
  1669. __EXT_MFC_INT_PTR CExtStatusControlBar::OnToolHitTest(
  1670. CPoint point,
  1671. TOOLINFO * pTI
  1672. ) const
  1673. {
  1674. ASSERT_VALID( this );
  1675. if( CExtToolControlBar::g_bMenuTracking
  1676. || CExtPopupMenuWnd::IsMenuTracking()
  1677. || GetSafeHwnd() == NULL
  1678. || (! ::IsWindow( GetSafeHwnd() ) )
  1679. )
  1680. return -1;
  1682. if( m_nAdvancedTipStyle != INT(CExtPopupMenuTipWnd::__ETS_NONE) )
  1683. return -1;
  1685. int nPaneIndex = HitTestStatusPane( point );
  1686. if( nPaneIndex < 0 )
  1687. return -1;
  1688. __EXT_MFC_INT_PTR nHit = (__EXT_MFC_INT_PTR)GetItemID( nPaneIndex );
  1689. if( pTI != NULL )
  1690. {
  1691. GetItemRect( nPaneIndex, &(pTI->rect) );
  1692. pTI->uId = nHit;
  1693. pTI->hwnd = m_hWnd;
  1694. CString strToolTipText = GetTipText( nPaneIndex );
  1695. if( ! strToolTipText.IsEmpty() )
  1696. pTI->lpszText = _tcsdup( strToolTipText );
  1697. if( pTI->lpszText == NULL )
  1698. pTI->lpszText = LPSTR_TEXTCALLBACK;
  1699. } // if( pTI != NULL )
  1700. return nHit;
  1701. }
  1703. void CExtStatusControlBar::DrawPaneSeparatorsSet( 
  1704. bool bSet // = true 
  1705. )
  1706. {
  1707. ASSERT_VALID( this );
  1708. m_bDrawPaneSeparatorsInsteadOfBorders = bSet;
  1709. RepositionControls();
  1710. }
  1711. bool CExtStatusControlBar::DrawPaneSeparatorsGet() const
  1712. {
  1713. ASSERT_VALID( this );
  1714. return m_bDrawPaneSeparatorsInsteadOfBorders;
  1715. }
  1717. void CExtStatusControlBar::OuterRectInFirstBandSet( 
  1718. bool bSet // = true 
  1719. )
  1720. {
  1721. ASSERT_VALID( this );
  1722. m_bOuterRectInFirstBand = bSet;
  1723. Invalidate();
  1724. UpdateWindow();
  1725. }
  1726. bool CExtStatusControlBar::OuterRectInFirstBandGet() const
  1727. {
  1728. ASSERT_VALID( this );
  1729. return m_bOuterRectInFirstBand;
  1730. }
  1732. void CExtStatusControlBar::HideTextOnDisabledPanesSet( 
  1733. bool bSet // = true
  1734. )
  1735. {
  1736. ASSERT_VALID( this );
  1737. m_bHideTextOnDisabledPanes = bSet;
  1738. Invalidate();
  1739. UpdateWindow();
  1740. }
  1741. bool CExtStatusControlBar::HideTextOnDisabledPanesGet() const
  1742. {
  1743. ASSERT_VALID( this );
  1744. return m_bHideTextOnDisabledPanes;
  1745. }
  1747. void CExtStatusControlBar::EnableControl( 
  1748. int nIndex, 
  1749. bool bEnable // = true 
  1750. )
  1751. {
  1752. ASSERT_VALID( this );
  1753. UINT uItemID = GetItemID(nIndex);
  1755. for ( int i = 0; i < m_arrPaneControls.GetSize(); i++ )
  1756. {
  1757. if( uItemID == m_arrPaneControls[i]->nID )
  1758. {
  1759. if( m_arrPaneControls[i]->hWnd && ::IsWindow(m_arrPaneControls[i]->hWnd) ) 
  1760. {
  1761. ::EnableWindow(m_arrPaneControls[i]->hWnd, bEnable); 
  1762. Invalidate();
  1763. UpdateWindow();
  1764. }
  1765. }
  1766. }
  1767. }
  1769. void CExtStatusControlBar::SetPaneInfo(
  1770. int nIndex, 
  1771. UINT nID, 
  1772. UINT nStyle, 
  1773. int cxWidth
  1774. )
  1775. {
  1776. ASSERT_VALID( this );
  1777. CStatusBar::SetPaneInfo(nIndex, nID, nStyle, cxWidth);
  1778. bool bEnabled = ((nStyle&SBPS_DISABLED) == 0);
  1779. EnableControl(nIndex, bEnabled);
  1780. }
  1782. void CExtStatusControlBar::SetPaneStyle(
  1783. int nIndex, 
  1784. UINT nStyle
  1785. )
  1786. {
  1787. ASSERT_VALID( this );
  1788. CStatusBar::SetPaneStyle(nIndex, nStyle);
  1789. bool bEnabled = ((nStyle&SBPS_DISABLED) == 0);
  1790. EnableControl(nIndex, bEnabled);
  1791. }
  1793. int CExtStatusControlBar::GetPaneCount() const
  1794. {
  1795. ASSERT_VALID( this );
  1796. return m_nCount;
  1797. }
  1799. void CExtStatusControlBar::SetPaneWidth(int nIndex, int nWidth)
  1800. {
  1801. ASSERT_VALID( this );
  1802. _STATUSBAR_PANE_ pane;
  1803. PaneInfoGet(nIndex, &pane);
  1804. pane.cxText = nWidth;
  1805. PaneInfoSet(nIndex, &pane);
  1806. }
  1808. void CExtStatusControlBar::WidthFromContent( int nIndex )
  1809. {
  1810. ASSERT_VALID( this );
  1811. ASSERT((nIndex >= 0 && nIndex < m_nCount) || m_nCount == 0);
  1812. _STATUSBAR_PANE_ * pPane = GetPanePtr( nIndex );
  1813. ASSERT( pPane != NULL );
  1814. if( pPane == NULL )
  1815. return;
  1816. CRect rcText(0,0,0,0);
  1817. if( !pPane->strText.IsEmpty() )
  1818. {
  1819. HFONT hFont = (HFONT)SendMessage( WM_GETFONT );
  1820. CClientDC dcScreen( NULL );
  1821. HGDIOBJ hOldFont = NULL;
  1822. if( hFont != NULL )
  1823. hOldFont = dcScreen.SelectObject( hFont );
  1824. dcScreen.DrawText(
  1825. pPane->strText,
  1826. pPane->strText.GetLength(),
  1827. &rcText,
  1828. GetPaneDrawTextFlags( nIndex ) | DT_CALCRECT
  1829. );
  1830. if( hOldFont != NULL )
  1831. dcScreen.SelectObject( hOldFont );
  1832. } // if( !pPane->strText.IsEmpty() )
  1833. CStatusBarCtrl & _ctrl = GetStatusBarCtrl();
  1834. HICON hIcon = (HICON)
  1835. _ctrl.SendMessage(
  1836. SB_GETICON,
  1837. WPARAM(nIndex)
  1838. );
  1839. // ICON 2.53
  1840. CSize szIcon = CSize(0,0);
  1841. //  if( hIcon != NULL )
  1842. //  szIcon = CExtCmdIcon::stat_GetIconSize( hIcon );
  1843. if( hIcon != NULL )
  1844. {
  1845. CExtCmdIcon _icon;
  1846. _icon.AssignFromHICON( hIcon, false );
  1847. szIcon = _icon.GetSize();
  1848. }
  1849. SetPaneWidth( 
  1850. nIndex,
  1851. szIcon.cx + rcText.Width() + 2
  1852. );
  1853. RepositionControls();
  1854. }
  1856. void CExtStatusControlBar::OnCancelMode() 
  1857. {
  1858. CExtPopupMenuWnd::CancelMenuTracking();
  1859. CWnd::CancelToolTips();
  1861. CStatusBar::OnCancelMode();
  1862. }
  1864. CExtPopupMenuTipWnd * CExtStatusControlBar::OnAdvancedPopupMenuTipWndGet() const
  1865. {
  1866. if( m_nAdvancedTipStyle == INT(CExtPopupMenuTipWnd::__ETS_NONE) )
  1867. return NULL;
  1868. return (&( CExtPopupMenuSite::g_DefPopupMenuSite.GetTip() ));
  1869. }
  1871. void CExtStatusControlBar::OnAdvancedPopupMenuTipWndDisplay(
  1872. CExtPopupMenuTipWnd & _ATTW,
  1873. const RECT & rcExcludeArea,
  1874. __EXT_MFC_SAFE_LPCTSTR strTipText
  1875. ) const
  1876. {
  1877. ASSERT_VALID( this );
  1878. if( strTipText == NULL
  1879. || _tcscmp( strTipText, _T("") ) == 0 
  1880. )
  1881. return;
  1882. _ATTW.SetText( LPCTSTR(strTipText) );
  1883. _ATTW.SetTipStyle( (CExtPopupMenuTipWnd::e_tip_style_t) m_nAdvancedTipStyle );
  1884. _ATTW.Show( (CWnd*) this, rcExcludeArea );
  1885. }
  1887. void CExtStatusControlBar::OnMouseMove( UINT nFlags, CPoint point )
  1888. {
  1889. CStatusBar::OnMouseMove( nFlags, point );
  1891. if( (! CExtPopupMenuWnd::IsMenuTracking() ) )
  1892. {
  1893. CExtPopupMenuTipWnd * pATTW =
  1894. OnAdvancedPopupMenuTipWndGet();
  1895. if( pATTW != NULL )
  1896. {
  1897. int nPaneIndex = HitTestStatusPane( point );
  1898. if( nPaneIndex < 0 )
  1899. return;
  1900. CRect rcPane;
  1901. GetItemRect( nPaneIndex, &rcPane );
  1902. CString strToolTipText = GetTipText( nPaneIndex );
  1903. if( ! strToolTipText.IsEmpty() )
  1904. {
  1905. CRect rcArea = rcPane;
  1906. ClientToScreen( &rcArea );
  1907. OnAdvancedPopupMenuTipWndDisplay(
  1908. *pATTW,
  1909. rcArea,
  1910. LPCTSTR( strToolTipText )
  1911. );
  1912. }
  1913. } // if( pATTW != NULL )
  1914. }
  1915. }
  1917. LRESULT CExtStatusControlBar::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
  1918. {
  1919. if( ( message == WM_PRINT
  1920. || message == WM_PRINTCLIENT 
  1921. )
  1922. && m_bCompleteRepaint
  1923. )
  1924. {
  1925. CDC * pDC = CDC::FromHandle( (HDC) wParam );
  1927. CRect rcWnd, rcClient;
  1928. GetWindowRect( &rcWnd );
  1929. GetClientRect( &rcClient );
  1930. ClientToScreen( rcClient );
  1931. rcClient.OffsetRect( -rcWnd.TopLeft() );
  1932. rcWnd.OffsetRect( -rcWnd.TopLeft() );
  1934. if( (lParam&PRF_NONCLIENT) != 0 )
  1935. {
  1936. pDC->ExcludeClipRect(rcClient);
  1937. CExtPaintManager::PAINTCONTROLBARBORDERSDATA _pcbbd(
  1938. this,
  1939. CExtPaintManager::__CB_OUTER_STATUSBAR,
  1940. m_dwStyle,
  1941. rcWnd
  1942. );
  1943. PmBridge_GetPM()->PaintControlBarBorders( *pDC, _pcbbd );
  1944. pDC->SelectClipRgn( NULL );
  1945. }
  1947. if( (lParam&(PRF_CLIENT|PRF_ERASEBKGND)) != 0 )
  1948. {
  1949. CPoint ptVpOffset( 0, 0 );
  1950. if( (lParam&PRF_NONCLIENT) != 0 )
  1951. {
  1952. ptVpOffset.x = rcWnd.left - rcClient.left;
  1953. ptVpOffset.y = rcWnd.top - rcClient.top;
  1954. }
  1955. if( ptVpOffset.x != 0
  1956. || ptVpOffset.y != 0
  1957. )
  1958. pDC->OffsetViewportOrg(
  1959. -ptVpOffset.x,
  1960. -ptVpOffset.y
  1961. );
  1962. DoPaint( pDC );
  1963. if( ptVpOffset.x != 0
  1964. || ptVpOffset.y != 0
  1965. )
  1966. pDC->OffsetViewportOrg(
  1967. ptVpOffset.x,
  1968. ptVpOffset.y
  1969. );
  1970. } // if( (lParam&(PRF_CLIENT|PRF_ERASEBKGND)) != 0 )
  1972. if( (lParam&PRF_CHILDREN) != 0 )
  1973. CExtPaintManager::stat_PrintChildren(
  1974. m_hWnd,
  1975. message,
  1976. pDC->GetSafeHdc(),
  1977. lParam,
  1978. false
  1979. );
  1980. return (!0);
  1981. }
  1982. return CStatusBar::WindowProc(message, wParam, lParam);
  1983. }
  1985. LRESULT CExtStatusControlBar::OnSizeParent( WPARAM wParam, LPARAM lParam )
  1986. {
  1987. ASSERT_VALID( this );
  1988. LRESULT lResult = CStatusBar::OnSizeParent( wParam, lParam );
  1989. HWND hWndOwn = GetSafeHwnd();
  1990. if( hWndOwn == NULL )
  1991. return lResult;
  1992. ::RedrawWindow(
  1993. hWndOwn,
  1994. NULL,
  1995. NULL,
  1996. RDW_INVALIDATE|RDW_ERASE|RDW_ALLCHILDREN
  1997. );
  1998. return lResult;
  1999. }
  2001. #endif // __EXT_MFC_NO_STATUSBAR