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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > P2P编程 > 查看源码
ToolBarEx.cpp
资源名称：GGBT.rar　[点击查看]
上传用户：lds876
上传日期：2013-05-25
资源大小：567k
文件大小：31k
源码类别：

P2P编程

开发平台：

Visual C++

ToolBarEx.cpp：源码内容
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Copyright (C) 1997 by Joerg Koenig
  3. // All rights reserved
  4. //
  5. // Distribute freely, except: don't remove my name from the source or
  6. // documentation (don't take credit for my work), mark your changes (don't
  7. // get me blamed for your possible bugs), don't alter or remove this
  8. // notice.
  9. // No warrantee of any kind, express or implied, is included with this
  10. // software; use at your own risk, responsibility for damages (if any) to
  11. // anyone resulting from the use of this software rests entirely with the
  12. // user.
  13. //
  14. // Send bug reports, bug fixes, enhancements, requests, flames, etc., and
  15. // I'll try to keep a version up to date.  I can be reached as follows:
  16. //    J.Koenig@adg.de                 (company site)
  17. //    Joerg.Koenig@rhein-neckar.de    (private site)
  18. /////////////////////////////////////////////////////////////////////////////
  21. // ToolBarEx.cpp : implementation file
  22. //
  23. // Description:
  24. // CToolBarEx provides additional features to the standard toolbar
  25. // "CToolBar". The main addition is the flat mode (last seen in
  26. // Developer Studio 5.0).
  27. // There are no special requirements for having the flat mode in your
  28. // application (no special comctl32.dll or what ever)!
  29. // If you need custom draw abilities, then you have to use VC++ >= 4.2
  30. // However, the flat mode should work with older versions of VC++ too (let
  31. // me know of your experiences!)
  32. //
  33. // Usage:
  34. // The only task you have to perform, is to
  35. // #include "ToolBarEx.h"
  36. // in either StdAfx.h or MainFrm.h and to change the type of
  37. // CMainFrame::m_wndToolBar from CToolBar to CToolBarEx.
  38. // Don't forget to recompile :-)
  39. //
  40. // Acknowledgements:
  41. // o The main idea of how to draw a separator and the gripper is stolen
  42. // from Roger Onslow's MSIE flat toolbar.
  43. // Thanks for saving my time, Roger ;-)
  44. // o The embossed drawing of a disabled image came from
  45. // Victor M. Vogelpoel (victorv@telic.nl)
  46. // o Some hints for buttons with text came from
  47. // David Bates (bates@econ.ubc.ca)
  48. // (I'm still thinking, text on toolbar-buttons is broken.
  49. // That has to be tooltip's work. However, texts on buttons
  50. // now work)
  51. // o Thanks to Patrick Liechty (patrickl@code3.code3.com) for
  52. // the reports of his experiences with VC++ 4.0/4.1
  53. // o Thanks to Jeng-Yuan Sheu (m8501511@chu.edu.tw) for the
  54. // enhanced checked button.
  55. // o Thanks to Todd C. Wilson (todd@mediatec.com) for his
  56. // bug report and code-enhancement for users of VC++ 4.2b
  57. //
  58. //
  59. // (known) bugs and limitations:
  60. // o the CDRF_NEWFONT notification is still untested ...
  61. // o Assigning texts to buttons may cause the buttons to
  62. // resize horizontally without notified by CToolBar. This
  63. // leads to a wrong calculation inside CalcDynamicLayout()
  64. // and CalcFixedLayout(). One could override both these
  65. // functions in derived classes to avoid that problem,
  66. // but that would be a greater pain ...
  67. // o some features of the toolbars seen in Office97/DevStudio
  68. // are not implemented (for instance text-only buttons or
  69. // the way how image+text buttons are displayed. The Alt-drag
  70. // feature too is unimplemented)
  71. //
  72. // if you find others (and have a solution for them ?!), please let me know:
  73. // Joerg.Koenig@rhein-neckar.de (private site) or
  74. // J.Koenig@adg.de (company site)
  75. //
  76. // Changes:
  77. // 11/25/97
  78. // o Some minor modifications to compile with VC++ 4.0/4.1 and 4.2b
  79. // o checked buttons now look hilighted (as in Office97/DevStudio)
  80. //
  81. // 11/07/97
  82. // (2 minor bugs have been occured as a result of the last update :)
  83. // o The WRAP state of a separator will be ignored now, if
  84. // the bar is docked vertically
  85. // o Draw an image transparently. This is needed only if one
  86. // uses 256 color images.
  87. //
  88. // 10/30/97
  89. // o texts on buttons now work
  90. // o gripper improved for a closer look like Office97
  91. // o disabled images now look embossed
  92. // o a separator is drawn only if it has no WRAP state set
  96. #include "stdafx.h"
  97. #include "ToolBarEx.h"
  98. #include "testBT.h"
  100. #ifdef _DEBUG
  101. #define new DEBUG_NEW
  102. #undef THIS_FILE
  103. static char THIS_FILE[] = __FILE__;
  104. #endif
  107. /////////////////////////////////////////////////////////////////////////////
  108. // local helper class CCustomDrawInfo
  109. //
  110. // The helper class CCustomDrawInfo handles the messaging to the docking
  111. // frame of the toolbar in flat mode only. If flat-mode is disabled, then
  112. // MFC's own messanger will be used.
  113. //
  114. // A few words about custom draw on toolbars:
  115. // o custom draw is possible for MFC >= 4.2 only (older versions don't know
  116. //   anything about certain structures ...)
  117. // o MFC does not set the "rc" member of NMCUSTOMDRAW to the rectangle of the
  118. //  button that will be drawn. However, we do, so watch out, wether the
  119. //  toolbar is flat or not (or ignore the "rc" member in both cases).
  120. //  If the current mode is not "flat", then MFC's art of message arrives ...
  121. // o MFC does not send a message for separators, so we too don't do it.
  122. // o It seems that MFC toolbars never send *ERASE notifications; instead they
  123. //   send TBN_QUERYDELETE for instance.
  124. // o The CDRF_NEWFONT notification result is ignored (in flat mode. Never
  125. //   tried with original MFC, because it is broken on toolbars).
  126. /////////////////////////////////////////////////////////////////////////////
  130. class CCustomDrawInfo {
  132. #if _MFC_VER >= 0x0420
  133. NMCUSTOMDRAW m_CDRW; // custom draw information holder
  134. LRESULT m_PrePaint; // result from prepaint notification
  135. LRESULT m_ItemPrePaint; // dito for specific item
  136. CToolBarEx * m_pToolBar; // the real sender of the notification
  137. CWnd * m_pReceiver; // the receiver of the notification
  139. LRESULT NotifyParent();
  140. #endif // _MFC_VER
  142. public: // construction
  143. CCustomDrawInfo( CDC & dc, CToolBarEx * pToolBar );
  145. public:
  146. // NotifyItemPrePaint() returns TRUE,
  147. // if the user wants to do the default
  148. // (CDRF_DODEFAULT) or FALSE, if the
  149. // user wants to skip (CDRF_SKIPDEFAULT)
  150. // Note that CDRF_SKIPDEFAULT is not
  151. // allowed for CDDS_PREPAINT, CDDS_POSTPAINT !
  152. // and CDDS_ITEMPOSTPAINT
  153. void NotifyPrePaint();
  154. BOOL NotifyItemPrePaint(int item);
  155. void NotifyItemPostPaint(int item);
  156. void NotifyPostPaint();
  157. };
  160. #if _MFC_VER >= 0x420
  162. LRESULT CCustomDrawInfo :: NotifyParent() {
  163. LRESULT lRes = CDRF_DODEFAULT;
  165. if( m_pReceiver )
  166. lRes = m_pReceiver->SendMessage(WM_NOTIFY,
  167. WPARAM(m_CDRW.hdr.idFrom),
  168. LPARAM(&m_CDRW));
  169. return lRes;
  170. }
  173. CCustomDrawInfo :: CCustomDrawInfo( CDC & dc, CToolBarEx * pBar )
  174. : m_PrePaint(0)
  175. , m_ItemPrePaint(0)
  176. {
  177. VERIFY((m_pToolBar = pBar) != 0);
  178. VERIFY((m_CDRW.hdc = dc.GetSafeHdc()) != 0);
  180. HWND hwnd = pBar->GetSafeHwnd();
  181. VERIFY(::IsWindow(hwnd));
  183. // initialise the NMHDR member of the customdraw structure
  184. m_CDRW.hdr.hwndFrom = hwnd;
  185. m_CDRW.hdr.idFrom = UINT(::GetWindowLong(hwnd, GWL_ID));
  186. m_CDRW.hdr.code = NM_CUSTOMDRAW;
  188. // Do not use CControlBar::GetDockingFrame() to receive
  189. // the parent. CWnd::GetParent() is inacceptable too.
  190. // Both these functions don't work, if the toolbar is
  191. // floating in the air!
  192. m_pReceiver = pBar->GetParentFrame();
  193. if( m_pReceiver )
  194. VERIFY(::IsWindow(m_pReceiver->GetSafeHwnd()));
  195. }
  197. void CCustomDrawInfo :: NotifyPrePaint() {
  198. // fill the customdraw structure with values for CDDS_PREPAINT
  199. m_CDRW.dwDrawStage = CDDS_PREPAINT;
  200. // the rest of the structure stays undefined in this stage
  201. // of drawing.
  202. m_PrePaint = NotifyParent();
  203. }
  205. BOOL CCustomDrawInfo :: NotifyItemPrePaint( int nItem ) {
  206. BOOL bRet = TRUE; // we assume to do the default
  207. if( m_PrePaint & CDRF_NOTIFYITEMDRAW ) {
  208. m_CDRW.dwDrawStage = CDDS_ITEMPREPAINT;
  209. m_pToolBar->GetItemRect(nItem, &m_CDRW.rc);
  210. m_CDRW.dwItemSpec = DWORD(m_pToolBar->GetItemID(nItem));
  211. UINT uStyle = m_pToolBar->GetButtonStyle(nItem);
  212. BOOL bEnable = m_pToolBar->GetToolBarCtrl()
  213. .IsButtonEnabled(m_CDRW.dwItemSpec);
  214. m_CDRW.uItemState = (bEnable ? 0 : CDIS_DISABLED) |
  215. (((uStyle & TBBS_PRESSED) || (uStyle & TBBS_CHECKED)) ?
  216. CDIS_CHECKED : 0);
  217. m_CDRW.lItemlParam = 0;
  218. m_ItemPrePaint = NotifyParent();
  219. if( m_ItemPrePaint & CDRF_SKIPDEFAULT )
  220. bRet = FALSE;
  221. }
  222. return bRet;
  223. }
  225. void CCustomDrawInfo :: NotifyItemPostPaint( int nItem ) {
  226. if( m_ItemPrePaint & CDRF_NOTIFYPOSTPAINT ) {
  227. m_CDRW.dwDrawStage = CDDS_ITEMPOSTPAINT;
  228. // the rest of the data has not been changed since ITEMPREPAINT
  229. // make sure it is so:
  230. ASSERT(m_pToolBar->GetItemID(nItem) == m_CDRW.dwItemSpec);
  231. NotifyParent();
  232. }
  233. }
  235. void CCustomDrawInfo :: NotifyPostPaint() {
  236. if( m_PrePaint & CDRF_NOTIFYPOSTPAINT ) {
  237. m_CDRW.dwDrawStage = CDDS_POSTPAINT;
  238. NotifyParent();
  239. }
  240. }
  242. #else // _MFC_VER < 4.2
  244. CCustomDrawInfo :: CCustomDrawInfo( CDC & dc, CToolBarEx * pParent ) {
  245. }
  247. void CCustomDrawInfo :: NotifyPrePaint() {
  248. }
  250. void CCustomDrawInfo :: NotifyPostPaint() {
  251. }
  253. BOOL CCustomDrawInfo :: NotifyItemPrePaint( int ) {
  254. return TRUE; // we always make the drawing by ourself
  255. }
  257. void CCustomDrawInfo :: NotifyItemPostPaint( int ) {
  258. }
  260. #endif // _MFC_VER
  264. /////////////////////////////////////////////////////////////////////////////
  265. // CToolBarEx
  267. CToolBarEx::CToolBarEx()
  268. : m_bFlatLook(TRUE)
  269. , m_clrBtnFace(::GetSysColor(COLOR_BTNFACE))
  270. , m_clrBtnHilight(::GetSysColor(COLOR_BTNHILIGHT))
  271. , m_clrBtnShadow(::GetSysColor(COLOR_BTNSHADOW))
  272. , m_clrBtnLight(::GetSysColor(COLOR_3DLIGHT))
  273. , m_nLastBtn(-1)
  274. , m_uTimerEvent(0)
  275. {
  276. // the systems I've tested, made no difference between
  277. // COLOR_BTNFACE and COLOR_3DLIGHT ...
  278. if( m_clrBtnFace == m_clrBtnLight )
  279. m_clrBtnLight = m_clrBtnHilight;
  281. CalculateOffset();
  283. // create the default font, used for buttons with text
  284. CFont Font;
  285. BOOL bOldSys = FALSE;
  286. if( ! Font.CreateStockObject( DEFAULT_GUI_FONT ) ) {
  287. // older versions of Windows* (NT 3.51 for instance)
  288. // fail with DEFAULT_GUI_FONT
  289. VERIFY( Font.CreateStockObject( SYSTEM_FONT ) );
  290. bOldSys = TRUE;
  291. }
  292. LOGFONT logfont ;
  293. Font.GetLogFont( &logfont ) ;
  294. if( bOldSys ) {
  295. logfont.lfWeight = 400;
  296. strcpy(logfont.lfFaceName,"MS Sans Serif");
  297. }
  298. logfont.lfHeight = 6 ;
  299. logfont.lfWidth = 0 ; // let windows compute this.
  300. VERIFY( m_GuiFont.CreateFontIndirect( &logfont ) ) ;
  302. m_bTracking = false;
  303. m_bMouseLeave = false;
  304. }
  306. CToolBarEx::~CToolBarEx()
  307. {
  308. }
  311. IMPLEMENT_DYNAMIC(CToolBarEx, CToolBar)
  314. BEGIN_MESSAGE_MAP(CToolBarEx, CDkToolBar)
  315. //{{AFX_MSG_MAP(CToolBarEx)
  316. ON_WM_PAINT()
  317. ON_WM_SYSCOLORCHANGE()
  318. ON_WM_NCCALCSIZE()
  319. ON_WM_MOUSEMOVE()
  320. ON_WM_NCPAINT()
  321. ON_WM_CREATE()
  322. ON_WM_ERASEBKGND()
  323. //}}AFX_MSG_MAP
  324. ON_WM_RBUTTONDOWN()
  325. ON_MESSAGE(TB_SETBUTTONSIZE, OnSetButtonSize)
  326. ON_MESSAGE(TB_SETBITMAPSIZE, OnSetBitmapSize)
  327. ON_MESSAGE(WM_MOUSELEAVE, OnMouseLeave)
  328. END_MESSAGE_MAP()
  330. /////////////////////////////////////////////////////////////////////////////
  331. // CToolBarEx message handlers
  333. void CToolBarEx::OnRButtonDown(UINT nFlags, CPoint point) 
  334. {
  335. // CToolBar::OnRButtonDown(nFlags, point);
  336. }
  338. LRESULT CToolBarEx :: OnSetButtonSize(WPARAM wParam, LPARAM lParam) 
  339. {
  340. LRESULT lResult = CDkToolBar::OnSetButtonSize(wParam, lParam);
  341. if( lResult )
  342. CalculateOffset();
  343. return lResult;
  344. }
  346. LRESULT CToolBarEx :: OnSetBitmapSize(WPARAM wParam, LPARAM lParam) 
  347. {
  348. LRESULT lResult = CDkToolBar::OnSetBitmapSize(wParam, lParam);
  349. if( lResult )
  350. CalculateOffset();
  351. return lResult;
  352. }
  355. void CToolBarEx::OnPaint() 
  356. {
  357. // DbgGuiLeak dbgGui;
  359. // HIMAGELIST hImg = GetImageList(TB_GETIMAGELIST);
  361. /*
  362. #ifdef _DEBUG
  363. if( hImg == 0 ) {
  364. TRACE0("CToolBarEx::OnPaint(): could not get image listn");
  365. }
  366. #endif
  367. //*/
  369. if( m_bFlatLook) 
  370. {
  371. CRect rcUpdate;
  372. if( ! GetUpdateRect(rcUpdate) )
  373. return;
  375. if( HasButtonText() )
  376. CalculateOffset(); // strings may have been added
  378. // attach image-list for even more MFC feeling :)
  379. CImageList& imglist = *GetToolBarCtrl().GetImageList();
  380. CImageList& imglistHot = *GetToolBarCtrl().GetHotImageList();
  381. CImageList& imglistDisable = *GetToolBarCtrl().GetDisabledImageList();
  383. POINT cursor;
  384. ::GetCursorPos(&cursor);
  385. ScreenToClient(&cursor);
  387. CPaintDC dc(this); // device context for painting
  388. CFont * pOldFont = dc.SelectObject(&m_GuiFont);
  390. // Now it's time for the first custom-draw-notification...
  391. CCustomDrawInfo cdrw(dc, this);
  392. cdrw.NotifyPrePaint();
  395. bool bMouseLeavePaint = false;
  396. register const int nBtn = GetToolBarCtrl().GetButtonCount();
  398. for( register int i = 0; i < nBtn; ++i ) 
  399. {
  400. CRect rc;
  401. GetItemRect(i, rc);
  404. int nBitmap; UINT uID, uStyleState;
  405. GetButtonInfo(i, uID, uStyleState, nBitmap);
  406. WORD wStyle = LOWORD(uStyleState);
  407. WORD wState = HIWORD(uStyleState);
  409. if( wState & TBSTATE_HIDDEN )
  410. continue;
  412. if( wStyle == TBSTYLE_SEP ) 
  413. {
  414. if( !(wState & TBSTATE_WRAP) || ! IsFloating() )
  415. {
  416. DrawSeparator(dc, rc);
  417. }
  418. }
  419. else 
  420. {
  421. if( ! CRect().IntersectRect(rcUpdate, rc) )
  422. continue; // this button needs no repaint
  425. BOOL bBtnDown = (wState & TBSTATE_CHECKED) || (wState & TBSTATE_PRESSED);
  426. BOOL bBtnEnabled = GetToolBarCtrl().IsButtonEnabled(int(uID));
  427. BOOL bHasCursor = rc.PtInRect(cursor);
  428. COLORREF clrRect = (bBtnDown && !bHasCursor) ? m_clrBtnLight : m_clrBtnFace;
  430. // maybe the button has text
  431. dc.SetTextColor(RGB(0,0,0));
  432. dc.SetBkColor(clrRect);
  434. // There is a bug in CToolBar: If there are texts assigned
  435. // to buttons, then the button-widths may change transparently
  436. // (without notified by CToolBar), so we recalculate the
  437. // horizontal offset here:
  438. m_sizeOffset.cx = (rc.Width() - m_sizeImage.cx) / 2;
  440. if( ! cdrw.NotifyItemPrePaint(i) )
  441. continue; // parent has already drawn the button
  443. bMouseLeavePaint = true;
  444. // dc.FillSolidRect(rc, clrRect);
  445. //CBrush brush(clrRect);
  446. //dc.FillRect(rc, &brush);
  448. // it seems, that CDC::Draw3dRect() changes the background color
  449. COLORREF clrBk = dc.GetBkColor();
  451. if( bBtnDown ) 
  452. {
  453. // draw a pressed button
  454. /*
  455. dc.Draw3dRect(rc, m_clrBtnShadow, m_clrBtnHilight);
  456. if( ! bHasCursor ) 
  457. {
  458. // draw an invisible frame around the hilighted area
  459. CRect rcCheck = rc;
  460. rcCheck.DeflateRect(1,1);
  461. dc.Draw3dRect(rcCheck, m_clrBtnFace, m_clrBtnFace);
  462. }
  463. //*/
  464. }
  465. else if( bHasCursor && ! bBtnDown && bBtnEnabled )
  466. {
  467. // draw a normal button
  468. // dc.Draw3dRect(rc, RGB(0, 255, 0), RGB(0, 255, 0));
  469. // dc.Draw3dRect(rc, m_clrBtnHilight, m_clrBtnShadow);
  470. }
  471. else if( ! bBtnDown && bBtnEnabled )
  472. // Draw an invisible rect around the button.
  473. // This prevents us from erasing the background
  474. // if the button was formed before
  475. // (that would cause the button to flicker ...)
  476. {
  477. // dc.Draw3dRect(rc, m_clrBtnFace, m_clrBtnFace);
  478. /*
  479. CBrush brush;
  480. brush.CreatePatternBrush(&m_bkBmp);
  481. dc.FillRect(rc, &brush);
  482. //*/
  483. }
  485. dc.SetBkColor(clrBk);
  487. // the point where to start with the image
  488. //CPoint pt(rc.left + m_sizeOffset.cx + bBtnDown,
  489. //   rc.top + m_sizeOffset.cy + bBtnDown);
  491. CPoint pt(rc.left + bBtnDown, rc.top + bBtnDown);
  492. pt.Offset(4, 4);
  494. if(!bBtnEnabled)
  495. {
  496. if (&imglistDisable)
  497. imglistDisable.Draw(&dc, nBitmap, pt, ILD_TRANSPARENT);
  498. else
  499. {
  500. imglist.Draw(&dc, nBitmap, pt, ILD_TRANSPARENT);
  501. // DrawDisabledButton(dc, rc);
  502. }
  503. }
  504. else if (bHasCursor && !m_bMouseLeave)
  505. {
  506. if (&imglistHot)
  507. {
  508. CRect rcItem = rc;
  510. DrawFace(RGB(255, 212, 139), RGB(255, 174, 86), rcItem, rcItem, &dc);
  511. DrawFrame(RGB(100, 100, 100), RGB(100, 100, 100), RGB(100, 100, 100), rcItem , &dc);
  513. imglistHot.Draw(&dc, nBitmap, pt, ILD_TRANSPARENT);
  514. }
  515. }
  516. else
  517. {
  518. if (&imglist)
  519. imglist.Draw(&dc, nBitmap, pt, ILD_TRANSPARENT);
  520. }
  523. CString strText = GetButtonText(i);
  524. if( strText.GetLength() ) 
  525. {
  526. CRect rectText(
  527. rc.left+3+bBtnDown,
  528. rc.top+m_sizeOffset.cy+m_sizeImage.cy+1+bBtnDown,
  529. rc.right-3+bBtnDown,
  530. rc.bottom-3+bBtnDown
  531. );
  532. dc.DrawText(strText, rectText, DT_CENTER|DT_VCENTER|DT_NOCLIP);
  533. }
  535. /*
  536. if( ! bBtnEnabled )
  537. // gray out that button
  538. DrawDisabledButton(dc, rc);
  539. //*/
  541. cdrw.NotifyItemPostPaint(i);
  542. }
  543. }
  545. dc.SelectObject(pOldFont);
  547. if( ! m_bDeleteImgList )
  548. {
  549. imglist.Detach();
  550. imglistHot.Detach();
  551. imglistDisable.Detach();
  552. }
  554. // last but not least: inform the parent for end of painting
  555. cdrw.NotifyPostPaint();
  557. if (m_bMouseLeave)
  558. TRACE("rb****on paint(%d, %d, %d)rn", cursor.x, cursor.y, bMouseLeavePaint);
  559. } 
  560. else
  561. {
  562. // classic mode (or couldn't receive imagelist)
  563. CDkToolBar::OnPaint();
  564. }
  566. if (m_bMouseLeave)
  567. m_bMouseLeave = false;
  568. }
  571. void CToolBarEx :: DrawDisabledButton( CDC & dc, const CRect & rc ) const {
  572. // create a monochrome memory DC
  573. CDC ddc;
  574. ddc.CreateCompatibleDC(0);
  575. CBitmap bmp;
  576. bmp.CreateCompatibleBitmap(&ddc, rc.Width(), rc.Height());
  577. CBitmap * pOldBmp = ddc.SelectObject(&bmp);
  579. // build a mask
  580. ddc.PatBlt(0, 0, rc.Width(), rc.Height(), WHITENESS);
  581. dc.SetBkColor(m_clrBtnFace);
  582. ddc.BitBlt(0, 0, rc.Width(), rc.Height(), &dc, rc.left, rc.top, SRCCOPY);
  583. dc.SetBkColor(m_clrBtnHilight);
  584. ddc.BitBlt(0, 0, rc.Width(), rc.Height(), &dc, rc.left, rc.top, SRCPAINT);
  586. // Copy the image from the toolbar into the memory DC
  587. // and draw it (grayed) back into the toolbar.
  588. dc.FillSolidRect(rc.left, rc.top, rc.Width(), rc.Height(), m_clrBtnFace);
  589. dc.SetBkColor(RGB(0, 0, 0));
  590. dc.SetTextColor(RGB(255, 255, 255));
  591. CBrush brShadow, brHilight;
  592. brHilight.CreateSolidBrush(m_clrBtnHilight);
  593. brShadow.CreateSolidBrush(m_clrBtnShadow);
  594. CBrush * pOldBrush = dc.SelectObject(&brHilight);
  595. dc.BitBlt(rc.left+1, rc.top+1, rc.Width(), rc.Height(), &ddc, 0, 0, 0x00E20746L);
  596. dc.SelectObject(&brShadow);
  597. dc.BitBlt(rc.left, rc.top, rc.Width(), rc.Height(), &ddc, 0, 0, 0x00E20746L);
  599. // reset DCs
  600. dc.SelectObject(pOldBrush);
  601. ddc.SelectObject(pOldBmp);
  602. ddc.DeleteDC();
  604. bmp.DeleteObject();
  605. }
  608. void CToolBarEx :: DrawSeparator( CDC & dc, CRect & rc ) const 
  609. {
  610.     BOOL bHorz = ((m_dwStyle & CBRS_ORIENT_HORZ) != 0) ? TRUE : FALSE;
  611. // make sure, this separator is not a placeholder for
  612. // another control.
  613. if( rc.Width() <= 8 ) 
  614. {
  615. {
  616. /*
  617. CDC memdc;
  618. memdc.CreateCompatibleDC(&dc);
  620. CBitmap* pold = memdc.SelectObject((CBitmap*)&m_bmpBack);
  622. BOOL bRet = dc.BitBlt(rc.left, rc.top, rc.Width(), rc.Height(), &memdc, 0, 0, SRCCOPY);
  623. ASSERT(bRet);
  624. memdc.SelectObject(pold);
  625. //*/
  626. }
  628. if( bHorz ) 
  629. {
  630. // draw the separator bar in the middle
  631. int x = (rc.left + rc.right) / 2;
  632. rc.left = x-1; rc.right = x+1;
  635. dc.Draw3dRect(
  636. rc,
  637. m_clrBtnShadow,
  638. m_clrBtnHilight
  639. );
  640. }
  641. else 
  642. {
  643. // draw the separator bar in the middle
  644. rc.left = rc.left - m_sizeButton.cx;
  645. rc.right = rc.left + m_sizeButton.cx;
  646. rc.top = rc.bottom+1;
  647. rc.bottom = rc.top+3;
  648. int y = (rc.top+rc.bottom)/2;
  649. rc.top = y-1; rc.bottom = y+1;
  651. dc.Draw3dRect(
  652. rc,
  653. m_clrBtnShadow,
  654. m_clrBtnHilight
  655. );
  656. }
  657. }
  658. }
  661. void CToolBarEx :: DrawGripper( CDC & dc ) const 
  662. { 
  663.     if( m_dwStyle & CBRS_FLOATING )
  664. return; // no gripper if floating
  666. CRect gripper;
  667. GetWindowRect(gripper);
  668. ScreenToClient(gripper);
  669. gripper.OffsetRect(-gripper.left, -gripper.top);
  671. if( m_dwStyle & CBRS_ORIENT_HORZ ) {
  672. // gripper at left
  673. gripper.DeflateRect(4, 4);
  674. gripper.right = gripper.left+3;
  675.         dc.Draw3dRect(
  676. gripper,
  677. m_clrBtnHilight,
  678.             m_clrBtnShadow
  679. );
  680. gripper.OffsetRect(3, 0);
  681.         dc.Draw3dRect(
  682. gripper,
  683. m_clrBtnHilight,
  684.             m_clrBtnShadow
  685. );
  686. } else {
  687. // gripper at top
  688. gripper.DeflateRect(4, 4);
  689. gripper.bottom = gripper.top+3;
  690. dc.Draw3dRect(
  691. gripper,
  692. m_clrBtnHilight,
  693.             m_clrBtnShadow
  694. );
  695. gripper.OffsetRect(0, 3);
  696.         dc.Draw3dRect(
  697. gripper,
  698. m_clrBtnHilight,
  699.             m_clrBtnShadow
  700. );
  701. }
  702. }
  704. void CToolBarEx :: OnUpdateCmdUI( CFrameWnd* pTarget, BOOL bDisableIfNoHndler ) {
  705. if( m_bFlatLook ) {
  706. // save current styles
  707. register const int nBtn = GetToolBarCtrl().GetButtonCount();
  708. register int nIdx;
  709. for( nIdx = 0; nIdx < nBtn; ++nIdx )
  710. m_Styles.SetAtGrow(nIdx, GetButtonStyle(nIdx));
  712. // do base class processing
  713. CDkToolBar::OnUpdateCmdUI(pTarget,bDisableIfNoHndler);
  715. //check wether styles have been changed
  716. for( nIdx = 0; nIdx < nBtn; ++nIdx ) {
  717. if( m_Styles[nIdx] != GetButtonStyle(nIdx) ) {
  718. // invalidate that button
  719. CRect rc;
  720. GetItemRect(nIdx, rc);
  721. InvalidateRect(rc);
  722. }
  723. }
  724. } else
  725. // simply delegate
  726. CDkToolBar::OnUpdateCmdUI(pTarget,bDisableIfNoHndler);
  727. }
  729. void CToolBarEx::OnSysColorChange() 
  730. {
  731. CDkToolBar::OnSysColorChange();
  733. m_clrBtnFace    = ::GetSysColor(COLOR_BTNFACE);
  734. m_clrBtnHilight = ::GetSysColor(COLOR_BTNHILIGHT);
  735. m_clrBtnShadow  = ::GetSysColor(COLOR_BTNSHADOW);
  736. m_clrBtnLight   = ::GetSysColor(COLOR_3DLIGHT);
  738. if( m_clrBtnFace == m_clrBtnLight )
  739. m_clrBtnLight = m_clrBtnHilight;
  740. }
  743. void CToolBarEx::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp) 
  744. {
  745. CDkToolBar::OnNcCalcSize(bCalcValidRects, lpncsp);
  746. return;
  747. // adjust non-client area for gripper at left or top
  748. if( m_dwStyle & CBRS_ORIENT_HORZ ) 
  749. {
  750. lpncsp->rgrc[0].left += 4;
  751. lpncsp->rgrc[0].right += 4;
  752. } else {
  753. lpncsp->rgrc[0].top += 6;
  754. lpncsp->rgrc[0].bottom += 6;
  755. }
  756. }
  759. void CToolBarEx::OnMouseMove(UINT nFlags, CPoint point) 
  760. {
  761. if (!m_bTracking)
  762. {
  763. TRACKMOUSEEVENT tme;
  764. tme.cbSize = sizeof(tme);
  765. tme.hwndTrack = GetSafeHwnd();
  766. tme.dwFlags = TME_LEAVE;
  767. tme.dwHoverTime = HOVER_DEFAULT;
  768. m_bTracking = _TrackMouseEvent(&tme);
  769. }
  772. if( m_bFlatLook ) 
  773. {
  774. register const int nBtn = GetToolBarCtrl().GetButtonCount();
  775. const int nLastBtn = m_nLastBtn;
  776. m_nLastBtn = -1;
  778. for( register int i = 0 ; i < nBtn ; ++i ) 
  779. {
  780. CRect rc;
  781. GetItemRect(i, rc);
  783. const BOOL bBtnEnabled = GetToolBarCtrl().IsButtonEnabled(int(GetItemID(i)));
  784. const BOOL bSep = GetButtonStyle(i) & TBBS_SEPARATOR;
  786. if( bSep || ! bBtnEnabled )
  787. continue;
  789. const BOOL bHasCursor = rc.PtInRect(point);
  791. if( bHasCursor && bBtnEnabled ) 
  792. {
  793. if( nLastBtn != i ) 
  794. {
  795. // force a repaint of the button with the cursor on it
  796. InvalidateRect(rc, FALSE);
  797. }
  798. m_nLastBtn = i;
  799. }
  800. else if( !bHasCursor && i == nLastBtn ) 
  801. {
  802. // force a repaint of the last formed button
  803. InvalidateRect(rc, FALSE);
  804. }
  805. }
  807. // One problem occures with WM_MOUSEMOVE: we cannot detect
  808. // that the mouse leaves the window. If the mouse moves quick
  809. // enough, then the last formed button stays visible. To
  810. // resolve this problem, we set a timer and check, wether
  811. // the mouse is outside the window ...
  812. // KillTimer(m_uTimerEvent);
  813. // m_uTimerEvent = SetTimer(1, 250, 0);
  814. }
  815. CDkToolBar::OnMouseMove(nFlags, point);
  816. }
  818. LRESULT CToolBarEx::OnMouseLeave(WPARAM wParam, LPARAM lParam)
  819. {
  820. m_bTracking = false;
  822. if (m_nLastBtn >= 0)
  823. {
  824. m_bMouseLeave = true;
  825. CRect rc;
  826. GetItemRect(m_nLastBtn, rc);
  827. InvalidateRect(rc, TRUE);
  828. m_nLastBtn = -1;
  830. /*
  831. POINT pt;
  832. ::GetCursorPos(&pt);
  833. ScreenToClient(&pt);
  834. TRACE("rb****mouse leave(%d, %d)rn", pt.x, pt.y);
  835. //*/
  836. }
  837. else
  838. {
  839. /*
  840. CRect rc;
  841. GetClientRect(rc);
  842. // InvalidateRect(rc, TRUE);
  843. TRACE("rb****mouse leave(%d, %d)rn", 12, 12);
  844. //*/
  845. }
  846. return 0;
  847. }
  850. void CToolBarEx::OnNcPaint() 
  851. {
  852. // DbgGuiLeak dbgGui;
  854. if( m_bFlatLook ) 
  855. {
  856. CDkToolBar::EraseNonClient();
  857. CWindowDC dc(this);
  858. // DrawGripper(dc);
  860. /*
  861. CRect rc;
  862. GetWindowRect(rc);
  863. ScreenToClient(rc);
  864. rc.OffsetRect(-rc.left, -rc.top);
  866. CDC memdc;
  867. memdc.CreateCompatibleDC(&dc);
  868. CBitmap bmptemp;
  869. bmptemp.CreateCompatibleBitmap(&memdc, rc.right - rc.left, rc.bottom - rc.top);
  870. CBitmap* pold = memdc.SelectObject(&bmptemp);
  872. CRect temprc = rc;
  873. temprc.OffsetRect(-temprc.left, -temprc.top);
  875. DrawFace(RGB(255, 255, 255), RGB(0, 0, 0), temprc, temprc, &memdc);
  876. memdc.FillRect(temprc, &CBrush(RGB(233, 233, 233)));
  878. BOOL bRet = dc.BitBlt(rc.left, rc.top, rc.Width(), rc.Height(), &memdc, 0, 0, SRCCOPY);
  879. ASSERT(bRet);
  881. memdc.SelectObject(pold);
  882. //*/
  885. /*
  886. CDC memdc;
  887. memdc.CreateCompatibleDC(&dc);
  888. CBitmap* pold = memdc.SelectObject(&m_bmpBack);
  889. BOOL bRet = dc.BitBlt(rc.left, rc.top, rc.Width(), rc.Height(), &memdc, 0, 0, SRCCOPY);
  890. ASSERT(bRet);
  891. memdc.SelectObject(pold);
  892. //*/
  894. } 
  895. else
  896. CDkToolBar::OnNcPaint();
  897. }
  899. /*
  900. void CToolBarEx::OnTimer(UINT nIDEvent) 
  901. {
  902. if( nIDEvent == m_uTimerEvent && m_nLastBtn >= 0 ) {
  903. POINT pt;
  904. ::GetCursorPos(&pt);
  905. CRect rc;
  906. GetWindowRect(rc);
  907. if( ! rc.PtInRect(pt) ) {
  908. GetItemRect(m_nLastBtn, rc);
  909. InvalidateRect(rc, FALSE);
  910. m_nLastBtn = -1;
  911. KillTimer(nIDEvent);
  912. }
  913. } else
  914. CDkToolBar::OnTimer(nIDEvent);
  915. }
  916. //*/
  917. int CToolBarEx::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  918. {
  919. if (CDkToolBar::OnCreate(lpCreateStruct) == -1)
  920. return -1;
  922. // Save the parent at creation time. It may change, if
  923. // the toolbar is floating; but we want to know of the
  924. // "real" parent (for notification messages)!
  925. m_hwndParent = lpCreateStruct->hwndParent;
  927. int iRet = m_bmpBack.LoadBitmap(IDB_BITMAP_REBAR_BK);
  928. ASSERT(iRet);
  929. // LoadBitmap(::AfxGetInstanceHandle(), MAKEINTRESOURCE(IDB_BITMAP_REBAR_BK));
  931. return 0;
  932. }
  934. #define PADWIDTH(x) (((x)*8+31)&~31)/8
  937. HIMAGELIST CToolBarEx :: GetImageList(UINT nImageType) 
  938. {
  939. m_bDeleteImgList = FALSE;
  941. HIMAGELIST hImg = 0;
  943. #ifdef TB_GETIMAGELIST
  944. // Some older versions of VC++ do not know of
  945. // the TB_GETIMAGELIST macro (defined in commctrl.h).
  947. hImg = HIMAGELIST(SendMessage(nImageType));
  949. #ifdef _DEBUG
  950. if( hImg == 0 ) {
  951. TRACE0("CToolBarEx::OnPaint(): could not get image listn");
  952. }
  953. #endif
  954. #endif // TB_GETIMAGELIST
  956. if( ! hImg ) 
  957. {
  958. // comctl32.dll version prior to 4.70 doesn't know
  959. // anything of the TB_GETIMAGELIST message
  960. if( m_hbmImageWell != 0 ) 
  961. {
  962. // Yup - we have a valid image.
  963. // But beware: Do not use this bitmap directly.
  964. // We make the copy by ourself. CopyImage() (for
  965. // instace) produces inacceptable copies under
  966. // some circumstances ...
  967. CImageList imglist;
  968. CBitmap bmp;
  970. // retrieve the size of the bitmap
  971. BITMAP bmHdr;
  972. ::GetObject(m_hbmImageWell, sizeof(BITMAP), &bmHdr);
  974. DWORD dwWidth, dwHeight = bmHdr.bmHeight;
  976. if (bmHdr.bmBitsPixel > 8)
  977. dwWidth = PADWIDTH(bmHdr.bmWidth * 3);
  978. else
  979. dwWidth = PADWIDTH(bmHdr.bmWidth);
  981. // copy the bitmap
  982. CClientDC cdc(this);
  983. CDC dc1, dc2;
  984. dc1.CreateCompatibleDC(&cdc);
  985. dc2.CreateCompatibleDC(&cdc);
  986. bmp.CreateCompatibleBitmap(&cdc, dwWidth, dwHeight);
  987. CBitmap * pOBmp = dc1.SelectObject(&bmp);
  988. HGDIOBJ hOObj = ::SelectObject(dc2.GetSafeHdc(), m_hbmImageWell);
  989. dc1.BitBlt(0,0,dwWidth,dwHeight,&dc2,0,0,SRCCOPY);
  990. ::SelectObject(dc2.GetSafeHdc(), hOObj);
  991. dc1.SelectObject(pOBmp);
  992. dc1.DeleteDC();
  993. dc2.DeleteDC();
  995. imglist.Create(m_sizeImage.cx, m_sizeImage.cy,TRUE,dwWidth/m_sizeImage.cx,1);
  996. imglist.SetBkColor(m_clrBtnFace);
  997. imglist.Add(&bmp,m_clrBtnFace);
  998. hImg = imglist.Detach();
  999. bmp.DeleteObject();
  1000. m_bDeleteImgList = TRUE;
  1001. }
  1002. }
  1004. return hImg;
  1005. }
  1007. void CToolBarEx::DrawFace(COLORREF Top, COLORREF Bottom, CRect& rc, CRect CalRc, CDC* pDC)
  1008. {
  1009. if (!CalRc.Height())
  1010. return;
  1013. int R, G, B;
  1014. R = (GetRValue(Top) - GetRValue(Bottom)) / CalRc.Height();
  1015. G = (GetGValue(Top) - GetGValue(Bottom)) / CalRc.Height();
  1016. B = (GetBValue(Top) - GetBValue(Bottom)) / CalRc.Height();
  1019. int ColR = GetRValue(Top), ColG = GetGValue(Top), ColB = GetBValue(Top);
  1020. COLORREF ColMax = Top > Bottom ? Top : Bottom;
  1021. COLORREF ColMin = Top > Bottom ? Bottom: Top;
  1023. for(int i=0; i<rc.Height(); i++)
  1024. {
  1025. ColR -= R;
  1026. ColG -= G;
  1027. ColB -= B;
  1029. CPen Pen;
  1030. Pen.CreatePen(PS_SOLID, 1, RGB(ColR, ColG, ColB));
  1031. CPen* pOldPen = pDC->SelectObject(&Pen);
  1033. // pDC->SelectObject(&Pen);
  1035. pDC->MoveTo(rc.left, rc.top+i);
  1036. pDC->LineTo(rc.right, rc.top+i);
  1038. pDC->SelectObject(pOldPen);
  1039. Pen.DeleteObject();
  1040. }
  1042. }
  1045. void CToolBarEx::DrawFrame(COLORREF HeightLight, COLORREF ShadowLight, COLORREF FrameColor, CRect& rc, CDC* pDC)
  1046. {
  1047. CBrush NullBrush;
  1048. NullBrush.CreateStockObject(NULL_BRUSH);
  1049. CBrush* pOldBrush = pDC->SelectObject(&NullBrush);
  1051. CPen Pen;
  1052. Pen.CreatePen(PS_SOLID, 1, FrameColor);
  1053. CPen* pOldPen = pDC->SelectObject(&Pen);
  1055. pDC->RoundRect(rc, CPoint(3, 3));
  1056. // rc.DeflateRect(1, 1, 1, 1); 
  1057. // pDC->Draw3dRect(rc, HeightLight, ShadowLight);
  1059. pDC->SelectObject(pOldPen);
  1060. pDC->SelectObject(pOldBrush);
  1061. }
  1063. BOOL CToolBarEx::OnEraseBkgnd(CDC* pDC) 
  1064. {
  1065. // DbgGuiLeak dbgGui;
  1067. CRect rc;
  1068. pDC->GetClipBox(rc);
  1069. if (rc.right < 0 || rc.bottom < 0)
  1070. {
  1071. ASSERT(FALSE);
  1072. return FALSE;
  1073. }
  1075. CDC memdc, memdcbmp;
  1076. BOOL bRet = memdc.CreateCompatibleDC(pDC);
  1077. if (!bRet)
  1078. {
  1079. DWORD dwErr = GetLastError();
  1080. ASSERT(false);
  1081. return FALSE;
  1082. }
  1084. CBitmap bmptemp;
  1085. bRet = bmptemp.CreateCompatibleBitmap(pDC, rc.right, rc.bottom);
  1086. if (!bRet)
  1087. {
  1088. DWORD dwErr = GetLastError();
  1089. ASSERT(false);
  1090. return FALSE;
  1091. }
  1093. CBitmap* pold = memdc.SelectObject(&bmptemp);
  1095. bRet = memdcbmp.CreateCompatibleDC(&memdc);
  1096. if (!bRet)
  1097. {
  1098. DWORD dwErr = GetLastError();
  1099. ASSERT(false);
  1100. return FALSE;
  1101. }
  1103. CBitmap* pOldBmp = memdcbmp.SelectObject(&m_bmpBack);
  1107. // CRect rctemp = rc;
  1108. // rctemp.left = rctemp.top = 0;
  1109. // DrawFace(RGB(243, 243, 241), RGB(217, 214, 217), rctemp, rctemp, &memdc);
  1110. // memdc.FillRect(temprc, &CBrush(RGB(255, 0, 0)));
  1112. for (int i=0; i<(rc.Width()/50 + 1); i++)
  1113. {
  1114. memdc.BitBlt(rc.left + i*50, rc.top, 100, rc.Height(), &memdcbmp, 0, rc.top, SRCCOPY);
  1115. }
  1117. memdcbmp.SelectObject(pOldBmp);
  1118. bRet = memdcbmp.DeleteDC();
  1119. ASSERT(bRet);
  1122. bRet = pDC->BitBlt(rc.left, rc.top, rc.Width(), rc.Height(), &memdc, rc.left, rc.top, SRCCOPY);
  1123. ASSERT(bRet);
  1125. bRet = bmptemp.DeleteObject();
  1126. ASSERT(bRet);
  1128. memdc.SelectObject(pold);
  1129. bRet = memdc.DeleteDC();
  1130. ASSERT(bRet);
  1135. #ifdef _DEBUG
  1136. CString strText;
  1137. strText.Format("rnerase rect = %d, %d, %d, %d rn", rc.left, rc.top, rc.right, rc.bottom);
  1138. TRACE(strText);
  1139. #endif
  1140. return TRUE;
  1142. return CDkToolBar::OnEraseBkgnd(pDC);
  1143. }