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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 菜单 > 查看源码
ToolBarEx.cpp
资源名称：bcmenu24.zip　[点击查看]
上传用户：aphuaqiang
上传日期：2007-01-02
资源大小：62k
文件大小：69k
源码类别：

菜单

开发平台：

Visual C++

ToolBarEx.cpp：源码内容
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Copyright (C) 1997,'98 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. /////////////////////////////////////////////////////////////////////////////
  20. // last revised: $Date: 10.05.98 17:45 $ $Revision: 2 $
  22. // ToolBarEx.cpp : implementation file
  23. //
  24. // Description:
  25. // CToolBarEx provides additional features to the standard toolbar
  26. // "CToolBar". The main addition is the flat mode (last seen in
  27. // Developer Studio 5.0).
  28. // There are no special requirements for having the flat mode in your
  29. // application (no special comctl32.dll or what ever)!
  30. // If you need custom draw abilities, then you have to use VC++ >= 4.2
  31. // However, the flat mode should work with older versions of VC++ too (let
  32. // me know of your experiences!)
  33. //
  34. // Usage:
  35. // The only task you have to perform, is to
  36. // #include "ToolBarEx.h"
  37. // in either StdAfx.h or MainFrm.h and to change the type of
  38. // CMainFrame::m_wndToolBar from CToolBar to CToolBarEx.
  39. // Don't forget to recompile :-)
  40. // if you want to reduce flickering, then you have to include
  41. // the header of Keith Rule's CMemDC class in your <stdafx.h>.
  42. // CToolBarEx will use it automagically then.
  43. // If you want a "real cool" 3D look, then you have to exchange the call
  44. // to "EnableDocking()" in your CMainFrame::OnCreate() method to
  45. // "FrameEnableDocking()". This will ensure, that the toolbar has the
  46. // same outfit as in Office or DevStudio.
  47. //
  48. // Acknowledgements:
  49. // o The main idea of how to draw a separator and the gripper is stolen
  50. // from Roger Onslow's MSIE flat toolbar.
  51. // Thanks for saving my time, Roger ;-)
  52. // o The embossed drawing of a disabled image came from
  53. // Victor M. Vogelpoel (victorv@telic.nl)
  54. // o Some hints for buttons with text came from
  55. // David Bates (bates@econ.ubc.ca)
  56. // (I'm still thinking, text on toolbar-buttons is broken.
  57. // That has to be tooltip's work. However, texts on buttons
  58. // now work)
  59. // o Thanks to Patrick Liechty (patrickl@code3.code3.com) for
  60. // the reports of his experiences with VC++ 4.0/4.1
  61. // o Thanks to Jeng-Yuan Sheu (m8501511@chu.edu.tw) for the
  62. // enhanced checked button.
  63. // o Thanks to Todd C. Wilson (todd@mediatec.com) for his
  64. // bug report and code-enhancement for users of VC++ 4.2b
  65. // o Matthias Drigalla <matthias.drigalla@bluewin.ch> has pointed
  66. // me out, that the timer is not released in all circumstances.
  67. // o thanks to Jonathan Chin <jonathan.chin@scitec.com.au> for his
  68. // experiences with UNICODE and for his enhancement to conform to
  69. // the standard interface (the flat toolbar should not perform any
  70. // hit test (and hence displaying the raised button state) if the
  71. // parent window (application) does not have the focus or is disabled.)
  72. // o thanks to Wang Ruopeng (ripple@thinker.ep.tsinghua.edu.cn) for
  73. // the enhanced outfit of checked buttons
  74. //
  75. // o Many thanks to Victor Vogelpoel, Jonathan Chin and Patrick Liechty
  76. // for their help to test and correct some bugs in the enhanced version.
  77. // Their work made this class much cleaner. Thanks.
  78. //
  79. // o Wolfgang Loch (W.Loch@intershop.de) sent in a fix for undockable bars
  80. // o Thanks to John Armstrong (jarmstrong@runge.com.au) for his fix to
  81. // the adjustment of gripperspace in "classic" mode
  82. // o Thanks to Anatoly Ivasyuk (aivasyuk@clark.net) for a much cooler method
  83. // to draw checked buttons that does not have the cursor on it.
  84. //
  85. //
  86. // (known) bugs and limitations:
  87. // o the CDRF_NEWFONT notification is still untested ...
  88. // o Assigning texts to buttons may cause the buttons to
  89. // resize horizontally without notified by CToolBar. This
  90. // leads to a wrong calculation inside CalcDynamicLayout()
  91. // and CalcFixedLayout(). One could override both these
  92. // functions in derived classes to avoid that problem,
  93. // but that would be a greater pain ...
  94. // o some features of the toolbars seen in Office97/DevStudio
  95. // are not implemented (for instance text-only buttons or
  96. // the way how image+text buttons are displayed.
  97. //
  98. // if you find others (and have a solution for them ?!), please let me know:
  99. // Joerg.Koenig@rhein-neckar.de (private site) or
  100. // J.Koenig@adg.de (company site)
  101. //
  102. // Changes:
  103. // 05/10/98
  104. // o buttons that are checked *and* disabled are now looking ok.
  105. // o don't draw a gripper if the bar is not dockable
  106. // o do not adjust space for gripper in "classic" mode
  107. //
  108. // 01/17/98
  109. // o If you have Keith Rule's "MemDC.h" included via
  110. // "stdafx.h", then CToolBarEx uses it to reduce
  111. // flickering.
  112. // o release the timer in all circumstances
  113. // o made the class compile even if UNICODE is #define'ed
  114. // o do not make any hit test (and display a raised button state)
  115. // if the application does not have the focus.
  116. // o Changed the outfit of a checked button that does not have
  117. // the cursor on it.
  118. // Major enhancements:
  119. // o added easy way to add controls to a toolbar
  120. // (both: replacing a button with a control and
  121. // inserting/appending new controls)
  122. // o Added many functions especially for the often
  123. // requested need for additional controls
  124. // o ALT-Drag feature implemented. You just can move buttons
  125. // (and controls!) from one CToolBarEx-object to another
  126. // in the style of the Developer Studio. There is no additional
  127. // requirement for having this feature in your application.
  128. // Just follow the online-help for how to enable customizable
  129. // toolbars. CToolBarEx uses the same technique.
  130. //
  131. // 11/25/97
  132. // o Some minor modifications to compile with VC++ 4.0/4.1 and 4.2b
  133. // o checked buttons now look hilighted (as in Office97/DevStudio)
  134. //
  135. // 11/07/97
  136. // (2 minor bugs have been occured as a result of the last update :)
  137. // o The WRAP state of a separator will be ignored now, if
  138. // the bar is docked vertically
  139. // o Draw an image transparently. This is needed only if one
  140. // uses 256 color images.
  141. //
  142. // 10/30/97
  143. // o texts on buttons now work
  144. // o gripper improved for a closer look like Office97
  145. // o disabled images now look embossed
  146. // o a separator is drawn only if it has no WRAP state set
  150. #include "stdafx.h"
  151. #include "ToolBarEx.h"
  153. #ifndef __AFXPRIV_H__
  154. #include <afxpriv.h> // one of the most interesting headers ;-)
  155. // if you plan to change CToolBarEx, then you
  156. // should better insert it in your "stdafx.h"
  157. // to speed up compilation
  158. #endif
  161. #ifdef _MEMDC_H_
  162. //#undef _MEMDC_H_ // this is for testing purposes
  163. #endif
  167. #ifdef _DEBUG
  168. #define new DEBUG_NEW
  169. #undef THIS_FILE
  170. static char THIS_FILE[] = __FILE__;
  171. #endif
  174. /////////////////////////////////////////////////////////////////////////////
  175. // local helper class CCustomDrawInfo
  176. //
  177. // The helper class CCustomDrawInfo handles the messaging to the docking
  178. // frame of the toolbar in flat mode only. If flat-mode is disabled, then
  179. // MFC's own messanger will be used.
  180. //
  181. // A few words about custom draw on toolbars:
  182. // o custom draw is possible for MFC >= 4.2 only (older versions don't know
  183. //   anything about certain structures ...)
  184. // o MFC does not set the "rc" member of NMCUSTOMDRAW to the rectangle of the
  185. //  button that will be drawn. However, we do, so watch out, whether the
  186. //  toolbar is flat or not (or ignore the "rc" member in both cases).
  187. //  If the current mode is not "flat", then MFC's art of message arrives ...
  188. // o MFC does not send a message for separators, so we too don't do it.
  189. // o It seems that MFC toolbars never send *ERASE notifications; instead they
  190. //   send TBN_QUERYDELETE for instance.
  191. // o The CDRF_NEWFONT notification result is ignored (in flat mode. Never
  192. //   tried with original MFC, because it is broken on toolbars).
  193. /////////////////////////////////////////////////////////////////////////////
  197. class CCustomDrawInfo {
  199. #if _MFC_VER >= 0x0420
  200. NMCUSTOMDRAW m_CDRW; // custom draw information holder
  201. LRESULT m_PrePaint; // result from prepaint notification
  202. LRESULT m_ItemPrePaint; // dito for specific item
  203. CToolBarEx * m_pToolBar; // the real sender of the notification
  204. CWnd * m_pReceiver; // the receiver of the notification
  206. LRESULT NotifyParent();
  207. #endif // _MFC_VER
  209. public: // construction
  210. CCustomDrawInfo( CDC & dc, CToolBarEx * pToolBar );
  212. public:
  213. // NotifyItemPrePaint() returns TRUE,
  214. // if the user wants to do the default
  215. // (CDRF_DODEFAULT) or FALSE, if the
  216. // user wants to skip (CDRF_SKIPDEFAULT)
  217. // Note that CDRF_SKIPDEFAULT is not
  218. // allowed for CDDS_PREPAINT, CDDS_POSTPAINT !
  219. // and CDDS_ITEMPOSTPAINT
  220. void NotifyPrePaint();
  221. BOOL NotifyItemPrePaint(int item);
  222. void NotifyItemPostPaint(int item);
  223. void NotifyPostPaint();
  224. };
  227. #if _MFC_VER >= 0x420
  229. LRESULT CCustomDrawInfo :: NotifyParent() {
  230. LRESULT lRes = CDRF_DODEFAULT;
  232. if( m_pReceiver )
  233. lRes = m_pReceiver->SendMessage(WM_NOTIFY,
  234. WPARAM(m_CDRW.hdr.idFrom),
  235. LPARAM(&m_CDRW));
  236. return lRes;
  237. }
  240. CCustomDrawInfo :: CCustomDrawInfo( CDC & dc, CToolBarEx * pBar )
  241. : m_PrePaint(0)
  242. , m_ItemPrePaint(0)
  243. {
  244. VERIFY((m_pToolBar = pBar) != 0);
  245. VERIFY((m_CDRW.hdc = dc.GetSafeHdc()) != 0);
  247. HWND hwnd = pBar->GetSafeHwnd();
  248. VERIFY(::IsWindow(hwnd));
  250. // initialise the NMHDR member of the customdraw structure
  251. m_CDRW.hdr.hwndFrom = hwnd;
  252. m_CDRW.hdr.idFrom = UINT(::GetWindowLong(hwnd, GWL_ID));
  253. m_CDRW.hdr.code = NM_CUSTOMDRAW;
  255. // Do not use CControlBar::GetDockingFrame() to receive
  256. // the parent. CWnd::GetParent() is inacceptable too.
  257. // Both these functions don't work, if the toolbar is
  258. // floating in the air!
  259. m_pReceiver = pBar->GetParentFrame();
  260. if( m_pReceiver )
  261. VERIFY(::IsWindow(m_pReceiver->GetSafeHwnd()));
  262. }
  264. void CCustomDrawInfo :: NotifyPrePaint() {
  265. // fill the customdraw structure with values for CDDS_PREPAINT
  266. m_CDRW.dwDrawStage = CDDS_PREPAINT;
  267. // the rest of the structure stays undefined in this stage
  268. // of drawing.
  269. m_PrePaint = NotifyParent();
  270. }
  272. BOOL CCustomDrawInfo :: NotifyItemPrePaint( int nItem ) {
  273. BOOL bRet = TRUE; // we assume to do the default
  274. if( m_PrePaint & CDRF_NOTIFYITEMDRAW ) {
  275. m_CDRW.dwDrawStage = CDDS_ITEMPREPAINT;
  276. m_pToolBar->GetItemRect(nItem, &m_CDRW.rc);
  277. m_CDRW.dwItemSpec = DWORD(m_pToolBar->GetItemID(nItem));
  278. UINT uStyle = m_pToolBar->GetButtonStyle(nItem);
  279. BOOL bEnable = m_pToolBar->GetToolBarCtrl()
  280. .IsButtonEnabled(m_CDRW.dwItemSpec);
  281. m_CDRW.uItemState = (bEnable ? 0 : CDIS_DISABLED) |
  282. (((uStyle & TBBS_PRESSED) || (uStyle & TBBS_CHECKED)) ?
  283. CDIS_CHECKED : 0);
  284. m_CDRW.lItemlParam = 0;
  285. m_ItemPrePaint = NotifyParent();
  286. if( m_ItemPrePaint & CDRF_SKIPDEFAULT )
  287. bRet = FALSE;
  288. }
  289. return bRet;
  290. }
  292. void CCustomDrawInfo :: NotifyItemPostPaint( int nItem ) {
  293. if( m_ItemPrePaint & CDRF_NOTIFYPOSTPAINT ) {
  294. m_CDRW.dwDrawStage = CDDS_ITEMPOSTPAINT;
  295. // the rest of the data has not been changed since ITEMPREPAINT
  296. // make sure it is so:
  297. ASSERT(m_pToolBar->GetItemID(nItem) == m_CDRW.dwItemSpec);
  298. NotifyParent();
  299. }
  300. }
  302. void CCustomDrawInfo :: NotifyPostPaint() {
  303. if( m_PrePaint & CDRF_NOTIFYPOSTPAINT ) {
  304. m_CDRW.dwDrawStage = CDDS_POSTPAINT;
  305. NotifyParent();
  306. }
  307. }
  309. #else // _MFC_VER < 4.2
  311. CCustomDrawInfo :: CCustomDrawInfo( CDC & dc, CToolBarEx * pParent ) {
  312. }
  314. void CCustomDrawInfo :: NotifyPrePaint() {
  315. }
  317. void CCustomDrawInfo :: NotifyPostPaint() {
  318. }
  320. BOOL CCustomDrawInfo :: NotifyItemPrePaint( int ) {
  321. return TRUE; // we always make the drawing by ourself
  322. }
  324. void CCustomDrawInfo :: NotifyItemPostPaint( int ) {
  325. }
  327. #endif // _MFC_VER
  330. /////////////////////////////////////////////////////////////////////////////
  331. // CToolBarEx  --  class static data
  333. HCURSOR CToolBarEx :: m_hOrigCursor = 0;
  334. HCURSOR CToolBarEx :: m_hDragCursor = 0;
  335. HCURSOR CToolBarEx :: m_hNoDragCursor = 0;
  336. BOOL CToolBarEx :: m_bDragging = FALSE;
  337. BOOL CToolBarEx :: m_bDragCursor = FALSE;
  338. int CToolBarEx :: m_nDragButton = -1;
  339. CToolBarEx * CToolBarEx :: m_pDropBar = 0;
  340. CPoint CToolBarEx :: m_ptDrop(0,0);
  342. /////////////////////////////////////////////////////////////////////////////
  343. // CToolBarEx
  345. CToolBarEx::CToolBarEx()
  346. : m_bFlatLook(TRUE)
  347. , m_clrBtnFace(::GetSysColor(COLOR_BTNFACE))
  348. , m_clrBtnHilight(::GetSysColor(COLOR_BTNHILIGHT))
  349. , m_clrBtnShadow(::GetSysColor(COLOR_BTNSHADOW))
  350. , m_clrBtnLight(::GetSysColor(COLOR_3DLIGHT))
  351. , m_nLastBtn(-1)
  352. , m_uTimerEvent(0)
  353. , m_pControls(0)
  354. , m_bReal3DBorder(FALSE) // set to TRUE, if you're using FrameEnableDocking()
  355. , m_bDragChild(FALSE)
  356. {
  357. CalculateOffset();
  359. // create the default font, used for buttons with text
  360. CFont Font;
  361. BOOL bOldSys = FALSE;
  362. if( ! Font.CreateStockObject( DEFAULT_GUI_FONT ) ) {
  363. // older versions of Windows* (NT 3.51 for instance)
  364. // fail with DEFAULT_GUI_FONT
  365. VERIFY( Font.CreateStockObject( SYSTEM_FONT ) );
  366. bOldSys = TRUE;
  367. }
  368. LOGFONT logfont ;
  369. Font.GetLogFont( &logfont ) ;
  370. if( bOldSys ) {
  371. logfont.lfWeight = 400;
  372. _tcscpy(logfont.lfFaceName,_T("MS Sans Serif"));
  374. }
  375. logfont.lfHeight = 6 ;
  376. logfont.lfWidth = 0 ; // let windows compute this.
  377. VERIFY( m_GuiFont.CreateFontIndirect( &logfont ) ) ;
  378. }
  380. CToolBarEx::~CToolBarEx()
  381. {
  382. if( m_pControls ) {
  383. for( POSITION pos = m_pControls->GetHeadPosition() ; pos ; )
  384. delete m_pControls->GetNext(pos);
  385. delete m_pControls;
  386. }
  387. }
  390. IMPLEMENT_DYNAMIC(CToolBarEx, CToolBar)
  393. BEGIN_MESSAGE_MAP(CToolBarEx, CToolBar)
  394. //{{AFX_MSG_MAP(CToolBarEx)
  395. ON_WM_PAINT()
  396. ON_WM_SYSCOLORCHANGE()
  397. ON_WM_NCCALCSIZE()
  398. ON_WM_MOUSEMOVE()
  399. ON_WM_NCPAINT()
  400. ON_WM_TIMER()
  401. ON_WM_CREATE()
  402. ON_WM_LBUTTONDOWN()
  403. ON_WM_LBUTTONUP()
  404. ON_WM_WINDOWPOSCHANGING()
  405. ON_WM_CAPTURECHANGED()
  406. ON_WM_PARENTNOTIFY()
  407. ON_WM_KILLFOCUS()
  408. //}}AFX_MSG_MAP
  409. ON_MESSAGE(TB_SETBUTTONSIZE, OnSetButtonSize)
  410. ON_MESSAGE(TB_SETBITMAPSIZE, OnSetBitmapSize)
  411. ON_MESSAGE(TB_ADDBITMAP, OnAddBitmap)
  412. ON_MESSAGE(TB_DELETEBUTTON, OnDeleteButton)
  413. #ifdef _MEMDC_H_
  414. ON_WM_ERASEBKGND()
  415. #endif
  416. END_MESSAGE_MAP()
  418. /////////////////////////////////////////////////////////////////////////////
  419. // CToolBarEx message handlers
  421. LRESULT CToolBarEx :: OnSetButtonSize(WPARAM wParam, LPARAM lParam) {
  422. LRESULT lResult = CToolBar::OnSetButtonSize(wParam, lParam);
  423. if( lResult )
  424. CalculateOffset();
  425. return lResult;
  426. }
  428. LRESULT CToolBarEx :: OnSetBitmapSize(WPARAM wParam, LPARAM lParam) {
  429. LRESULT lResult = CToolBar::OnSetBitmapSize(wParam, lParam);
  430. if( lResult )
  431. CalculateOffset();
  432. return lResult;
  433. }
  436. void CToolBarEx :: SetFlatLook( BOOL bFlat ) {
  437. if( bFlat != m_bFlatLook ) {
  438. m_bFlatLook = bFlat;
  439. if( ::IsWindow(GetSafeHwnd()) ) {
  440.             //flat tool bars have gripper space at the left, cause non-client to resize
  441.             SetWindowPos(0, 0,0,0,0,SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER);
  442. // force a repaint of all buttons
  443. Invalidate();
  444. // erase/draw the gripper
  445. OnNcPaint();
  446. // if the "FrameEnableDocking()" function is used, we have to adjust
  447. // the bars inside the parent.
  448. VERIFY(::IsWindow(m_hwndParent));
  449. ((CFrameWnd*)(CWnd::FromHandle(m_hwndParent)))->RecalcLayout();
  450. }
  451. }
  452. }
  455. void CToolBarEx::OnPaint() 
  456. {
  457. HIMAGELIST hImg = GetImageList();
  459. #ifdef _DEBUG
  460. if( hImg == 0 ) {
  461. TRACE0("CToolBarEx::OnPaint(): could not get image listn");
  462. }
  463. #endif
  465. if( m_bFlatLook && hImg ) {
  466. CRect rcUpdate;
  467. if( ! GetUpdateRect(rcUpdate) )
  468. return;
  470. if( HasButtonText() )
  471. CalculateOffset(); // strings may have been added
  473. // attach image-list for even more MFC feeling :)
  474. CImageList imglist;
  475. imglist.Attach(hImg);
  477. POINT cursor;
  478. ::GetCursorPos(&cursor);
  479. ScreenToClient(&cursor);
  481. #ifdef _MEMDC_H_
  482. // if you have Keith Rule's CMemDC class inserted
  483. // in "stdafx.h", then we use it here ...
  484. CPaintDC dcp(this);
  485. CMemDC dc(&dcp);
  486. dc.FillSolidRect(rcUpdate, m_clrBtnFace);
  487. #else // _MEMDC_H_
  488. CPaintDC dc(this); // device context for painting
  489. #endif // _MEMDC_H_
  491. CFont * pOldFont = dc.SelectObject(&m_GuiFont);
  493. // Now it's time for the first custom-draw-notification...
  494. CCustomDrawInfo cdrw(dc, this);
  495. cdrw.NotifyPrePaint();
  497. register const int nBtn = GetToolBarCtrl().GetButtonCount();
  499. for( register int i = 0; i < nBtn; ++i ) {
  500. CRect rc;
  501. GetItemRect(i, rc);
  503. int nBitmap; UINT uID, uStyleState;
  504. GetButtonInfo(i, uID, uStyleState, nBitmap);
  505. WORD wStyle = LOWORD(uStyleState);
  506. WORD wState = HIWORD(uStyleState);
  508. if( wState & TBSTATE_HIDDEN )
  509. continue;
  511. if( wStyle == TBSTYLE_SEP ) {
  512. if( !(wState & TBSTATE_WRAP) || ! IsFloating() )
  513. DrawSeparator(dc, rc);
  514. } else {
  515. if( ! CRect().IntersectRect(rcUpdate, rc) )
  516. continue; // this button needs no repaint
  518. BOOL bBtnDown = (wState & TBSTATE_CHECKED) || (wState & TBSTATE_PRESSED);
  519. BOOL bBtnEnabled = GetToolBarCtrl().IsButtonEnabled(int(uID));
  520. BOOL bHasCursor = rc.PtInRect(cursor);
  521. COLORREF clrRect = (bBtnDown && !bHasCursor) ? m_clrBtnLight : m_clrBtnFace;
  523. // maybe the button has text
  524. dc.SetTextColor(RGB(0,0,0));
  525. dc.SetBkColor(clrRect);
  527. if( HasButtonText() )
  528. // There is a bug in CToolBar: If there are texts assigned
  529. // to buttons, then the button-widths may change transparently
  530. // (without notified by CToolBar), so we recalculate the
  531. // horizontal offset here:
  532. m_sizeOffset.cx = (rc.Width() - m_sizeImage.cx) / 2;
  534. if( ! cdrw.NotifyItemPrePaint(i) )
  535. continue; // parent has already drawn the button
  537. dc.FillSolidRect(rc, clrRect);
  539. // it seems, that CDC::Draw3dRect() changes the background color
  540. COLORREF clrBk = dc.GetBkColor();
  542. if( bBtnDown ) {
  543. // draw a pressed button
  544. dc.Draw3dRect(rc, m_clrBtnShadow, m_clrBtnHilight);
  545. if( ! bHasCursor ) {
  546. // if the button does not have the cursor on it,
  547. // then the pressed button is somewhat lighter
  548. // then the other buttons.
  549. CRect rcCheck = rc;
  550. rcCheck.DeflateRect(1,1);
  552. // draw an invisible frame around the hilighted area
  553. dc.Draw3dRect(rcCheck, m_clrBtnFace, m_clrBtnFace);
  555. rcCheck.DeflateRect(1,1);
  556. CBrush *pBrush = CDC::GetHalftoneBrush();
  557. dc.SetTextColor(m_clrBtnHilight);
  558. dc.SetBkColor(m_clrBtnFace);
  559. dc.FillRect(rcCheck, pBrush);
  560. dc.SetTextColor(RGB(0,0,0));
  561. dc.SetBkColor(clrRect);
  562. }
  563. } else if( bHasCursor && ! bBtnDown && bBtnEnabled )
  564. // draw a normal button
  565. dc.Draw3dRect(rc, m_clrBtnHilight, m_clrBtnShadow);
  566. else if( ! bBtnDown && bBtnEnabled )
  567. // Draw an invisible rect around the button.
  568. // This prevents us from erasing the background
  569. // if the button was formed before
  570. // (that would cause the button to flicker ...)
  571. dc.Draw3dRect(rc, m_clrBtnFace, m_clrBtnFace);
  573. dc.SetBkColor(clrBk);
  575. // the point where to start with the image
  576. CPoint pt(rc.left + m_sizeOffset.cx + bBtnDown,
  577.   rc.top + m_sizeOffset.cy + bBtnDown);
  579. imglist.Draw(&dc, nBitmap, pt, ILD_TRANSPARENT);
  581. CString strText = GetButtonText(i);
  582. if( strText.GetLength() ) {
  583. CRect rectText(
  584. rc.left+3+bBtnDown,
  585. rc.top+m_sizeOffset.cy+m_sizeImage.cy+1+bBtnDown,
  586. rc.right-3+bBtnDown,
  587. rc.bottom-3+bBtnDown
  588. );
  589. int nBkMode = dc.SetBkMode(TRANSPARENT) ;
  590. dc.DrawText(strText, rectText, DT_CENTER|DT_VCENTER|DT_NOCLIP);
  591. dc.SetBkMode(nBkMode) ;
  592. }
  594. if( ! bBtnEnabled ) {
  595. // gray out that button
  596. rc.DeflateRect(bBtnDown,bBtnDown);
  597. DrawDisabledButton(dc, rc);
  598. }
  600. cdrw.NotifyItemPostPaint(i);
  601. }
  602. }
  604. dc.SelectObject(pOldFont);
  606. if( ! m_bDeleteImgList )
  607. imglist.Detach();
  609. // last but not least: inform the parent for end of painting
  610. cdrw.NotifyPostPaint();
  611. } else
  612. // classic mode (or couldn't receive imagelist)
  613. CToolBar::OnPaint();
  614. }
  617. void CToolBarEx :: DrawDisabledButton( CDC & dc, const CRect & rc ) const {
  618. // create a monochrome memory DC
  619. CDC ddc;
  620. ddc.CreateCompatibleDC(0);
  621. CBitmap bmp;
  622. bmp.CreateCompatibleBitmap(&ddc, rc.Width(), rc.Height());
  623. CBitmap * pOldBmp = ddc.SelectObject(&bmp);
  625. // build a mask
  626. ddc.PatBlt(0, 0, rc.Width(), rc.Height(), WHITENESS);
  627. dc.SetBkColor(m_clrBtnFace);
  628. ddc.BitBlt(0, 0, rc.Width(), rc.Height(), &dc, rc.left, rc.top, SRCCOPY);
  629. dc.SetBkColor(m_clrBtnHilight);
  630. ddc.BitBlt(0, 0, rc.Width(), rc.Height(), &dc, rc.left, rc.top, SRCPAINT);
  632. // Copy the image from the toolbar into the memory DC
  633. // and draw it (grayed) back into the toolbar.
  634. dc.FillSolidRect(rc.left, rc.top, rc.Width(), rc.Height(), m_clrBtnFace);
  635. dc.SetBkColor(RGB(0, 0, 0));
  636. dc.SetTextColor(RGB(255, 255, 255));
  637. CBrush brShadow, brHilight;
  638. brHilight.CreateSolidBrush(m_clrBtnHilight);
  639. brShadow.CreateSolidBrush(m_clrBtnShadow);
  640. CBrush * pOldBrush = dc.SelectObject(&brHilight);
  641. dc.BitBlt(rc.left+1, rc.top+1, rc.Width(), rc.Height(), &ddc, 0, 0, 0x00E20746L);
  642. dc.SelectObject(&brShadow);
  643. dc.BitBlt(rc.left, rc.top, rc.Width(), rc.Height(), &ddc, 0, 0, 0x00E20746L);
  645. // reset DCs
  646. dc.SelectObject(pOldBrush);
  647. ddc.SelectObject(pOldBmp);
  648. ddc.DeleteDC();
  650. bmp.DeleteObject();
  651. }
  654. void CToolBarEx :: DrawSeparator( CDC & dc, CRect & rc ) const {
  655.     BOOL bHorz = ((m_dwStyle & CBRS_ORIENT_HORZ) != 0) ? TRUE : FALSE;
  656. // make sure, this separator is not a placeholder for
  657. // another control.
  658. if( rc.Width() <= 8 ) {
  659. if( bHorz ) {
  660. // draw the separator bar in the middle
  661. int x = (rc.left + rc.right) / 2;
  662. rc.left = x-1; rc.right = x+1;
  663. dc.Draw3dRect(
  664. rc,
  665. m_clrBtnShadow,
  666. m_clrBtnHilight
  667. );
  668. } else {
  669. // draw the separator bar in the middle
  670. rc.left = rc.left - m_sizeButton.cx;
  671. rc.right = rc.left + m_sizeButton.cx;
  672. rc.top = rc.bottom+1;
  673. rc.bottom = rc.top+3;
  674. int y = (rc.top+rc.bottom)/2;
  675. rc.top = y-1; rc.bottom = y+1;
  676. dc.Draw3dRect(
  677. rc,
  678. m_clrBtnShadow,
  679. m_clrBtnHilight
  680. );
  681. }
  682. }
  683. }
  686. void CToolBarEx :: DrawGripper( CDC & dc ) const { 
  687.     // Do not draw a gripper if the bar is floating or not
  688. // dockable.
  689. if( (m_dwStyle & CBRS_FLOATING) || m_dwDockStyle == 0 )
  690. return;
  692. CRect gripper;
  693. GetWindowRect(gripper);
  694. ScreenToClient(gripper);
  695. gripper.OffsetRect(-gripper.left, -gripper.top);
  697. if( m_dwStyle & CBRS_ORIENT_HORZ ) {
  698. // gripper at left
  699. gripper.DeflateRect(4, 4);
  700. gripper.right = gripper.left+3;
  701.         dc.Draw3dRect(
  702. gripper,
  703. m_clrBtnHilight,
  704.             m_clrBtnShadow
  705. );
  706. gripper.OffsetRect(3, 0);
  707.         dc.Draw3dRect(
  708. gripper,
  709. m_clrBtnHilight,
  710.             m_clrBtnShadow
  711. );
  712. } else {
  713. // gripper at top
  714. gripper.DeflateRect(4, 4);
  715. gripper.bottom = gripper.top+3;
  716. dc.Draw3dRect(
  717. gripper,
  718. m_clrBtnHilight,
  719.             m_clrBtnShadow
  720. );
  721. gripper.OffsetRect(0, 3);
  722.         dc.Draw3dRect(
  723. gripper,
  724. m_clrBtnHilight,
  725.             m_clrBtnShadow
  726. );
  727. }
  728. }
  730. void CToolBarEx :: OnUpdateCmdUI( CFrameWnd* pTarget, BOOL bDisableIfNoHndler ) {
  731. if( m_bFlatLook ) {
  732. // save current styles
  733. register const int nBtn = GetToolBarCtrl().GetButtonCount();
  734. register int nIdx;
  735. for( nIdx = 0; nIdx < nBtn; ++nIdx )
  736. m_Styles.SetAtGrow(nIdx, GetButtonStyle(nIdx));
  738. // do base class processing
  739. CToolBar::OnUpdateCmdUI(pTarget,bDisableIfNoHndler);
  741. //check whether styles have been changed
  742. for( nIdx = 0; nIdx < nBtn; ++nIdx ) {
  743. if( m_Styles[nIdx] != GetButtonStyle(nIdx) )
  744. // invalidate that button
  745. InvalidateButton(nIdx);
  746. }
  747. } else
  748. // simply delegate
  749. CToolBar::OnUpdateCmdUI(pTarget,bDisableIfNoHndler);
  750. }
  752. void CToolBarEx::OnSysColorChange() 
  753. {
  754. CToolBar::OnSysColorChange();
  756. m_clrBtnFace    = ::GetSysColor(COLOR_BTNFACE);
  757. m_clrBtnHilight = ::GetSysColor(COLOR_BTNHILIGHT);
  758. m_clrBtnShadow  = ::GetSysColor(COLOR_BTNSHADOW);
  759. m_clrBtnLight   = ::GetSysColor(COLOR_3DLIGHT);
  760. }
  763. void CToolBarEx::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp) 
  764. {
  765. CToolBar::OnNcCalcSize(bCalcValidRects, lpncsp);
  766. if( m_bFlatLook ) {
  767. // adjust non-client area for gripper at left or top
  768. if( m_dwStyle & CBRS_ORIENT_HORZ ) {
  769. lpncsp->rgrc[0].left += 4;
  770. lpncsp->rgrc[0].right += 4;
  771. } else {
  772. lpncsp->rgrc[0].top += 6;
  773. lpncsp->rgrc[0].bottom += 6;
  774. }
  775. }
  776. }
  779. void CToolBarEx::OnMouseMove(UINT nFlags, CPoint point) 
  780. {
  781. if( m_bDragging ) {
  782. DragMove();
  783. return;
  784. }
  786. if( m_bFlatLook && IsTopParentActive() && GetTopLevelParent()->IsWindowEnabled()) {
  787. register const int nBtn = GetToolBarCtrl().GetButtonCount();
  788. const int nLastBtn = m_nLastBtn;
  789. m_nLastBtn = -1;
  791. for( register int i = 0 ; i < nBtn ; ++i ) {
  792. CRect rc;
  793. GetItemRect(i, rc);
  795. const BOOL bBtnEnabled = GetToolBarCtrl().IsButtonEnabled(int(GetItemID(i)));
  796. const BOOL bSep = GetButtonStyle(i) & TBBS_SEPARATOR;
  798. if( bSep || ! bBtnEnabled )
  799. continue;
  801. const BOOL bHasCursor = rc.PtInRect(point);
  803. if( bHasCursor && bBtnEnabled ) {
  804. if( nLastBtn != i ) {
  805. // force a repaint of the button with the cursor on it
  806. InvalidateRect(rc, FALSE);
  807. }
  808. m_nLastBtn = i;
  809. } else if( !bHasCursor && i == nLastBtn ) {
  810. // force a repaint of the last formed button
  811. InvalidateRect(rc, FALSE);
  812. }
  813. }
  814. // One problem occures with WM_MOUSEMOVE: we cannot detect
  815. // that the mouse leaves the window. If the mouse moves quick
  816. // enough, then the last formed button stays visible. To
  817. // resolve this problem, we set a timer and check, whether
  818. // the mouse is outside the window ...
  819. KillTimer(m_uTimerEvent);
  820. m_uTimerEvent = SetTimer(1, 250, 0);
  821. }
  822. CToolBar::OnMouseMove(nFlags, point);
  823. }
  826. void CToolBarEx::OnNcPaint() 
  827. {
  828. if( m_bFlatLook ) {
  829. // get window DC that is clipped to the non-client area
  830. CWindowDC dc(this);
  831. CRect rectClient;
  832. GetClientRect(rectClient);
  833. CRect rectWindow;
  834. GetWindowRect(rectWindow);
  835. ScreenToClient(rectWindow);
  836. rectClient.OffsetRect(-rectWindow.left, -rectWindow.top);
  837. dc.ExcludeClipRect(rectClient);
  839. // draw borders in non-client area
  840. rectWindow.OffsetRect(-rectWindow.left, -rectWindow.top);
  842. Draw3DBorders(&dc, rectWindow);
  844. dc.IntersectClipRect(rectWindow);
  846. #ifdef _MEMDC_H_
  847. // You're using Keith Rule's CMemDC. In this case
  848. // we have to make sure that WM_ERASEBKGND
  849. // will not be sent.
  850. dc.FillSolidRect(rectWindow, m_clrBtnFace);
  851. #else
  852. // erase parts not drawn
  853. SendMessage(WM_ERASEBKGND, (WPARAM)dc.m_hDC);
  854. #endif
  856. DrawGripper(dc);
  857. } else
  858. CToolBar::OnNcPaint();
  859. }
  862. void CToolBarEx :: Draw3DBorders(CDC * pDC, CRect & rect) {
  863. ASSERT_VALID(this);
  864. ASSERT_VALID(pDC);
  866. if( m_bReal3DBorder ) {
  867. DWORD dwStyle = m_dwStyle;
  868. if (!(dwStyle & CBRS_BORDER_ANY))
  869. return;
  871. COLORREF clr = (m_dwStyle & CBRS_BORDER_3D) ? m_clrBtnHilight : m_clrBtnShadow;
  872. if(m_dwStyle & CBRS_BORDER_LEFT)
  873. pDC->FillSolidRect(0, 0, 1, rect.Height() - 1, clr);
  874. if(m_dwStyle & CBRS_BORDER_TOP)
  875. pDC->FillSolidRect(0, 0, rect.Width()-1 , 1, clr);
  876. if(m_dwStyle & CBRS_BORDER_RIGHT)
  877. pDC->FillSolidRect(rect.right, 1, -1, rect.Height() - 1, m_clrBtnShadow);
  878. if(m_dwStyle & CBRS_BORDER_BOTTOM)
  879. pDC->FillSolidRect(0, rect.bottom, rect.Width()-1, -1, m_clrBtnShadow);
  881. // if undockable toolbar at top of frame, apply special formatting to mesh
  882. // properly with frame menu
  883. if(!m_pDockContext) {
  884. pDC->FillSolidRect(0,0,rect.Width(),1,m_clrBtnShadow);
  885. pDC->FillSolidRect(0,1,rect.Width(),1,m_clrBtnHilight);
  886. }
  888. if (dwStyle & CBRS_BORDER_LEFT)
  889. ++rect.left;
  890. if (dwStyle & CBRS_BORDER_TOP)
  891. ++rect.top;
  892. if (dwStyle & CBRS_BORDER_RIGHT)
  893. --rect.right;
  894. if (dwStyle & CBRS_BORDER_BOTTOM)
  895. --rect.bottom;
  896. } else
  897. DrawBorders(pDC, rect);
  898. }
  900. void CToolBarEx::OnTimer(UINT nIDEvent) 
  901. {
  902. if( nIDEvent == m_uTimerEvent ) {
  903. if( m_nLastBtn >= 0 ) {
  904. POINT pt;
  905. ::GetCursorPos(&pt);
  906. CRect rc;
  907. GetWindowRect(rc);
  908. if( ! rc.PtInRect(pt) ) {
  909. InvalidateButton(m_nLastBtn);
  910. m_nLastBtn = -1;
  911. }
  912. }
  913. if( m_nLastBtn < 0 )
  914. KillTimer(nIDEvent);
  915. } else
  916. CToolBar::OnTimer(nIDEvent);
  917. }
  919. int CToolBarEx::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  920. {
  921. if (CToolBar::OnCreate(lpCreateStruct) == -1)
  922. return -1;
  924. // Save the parent at creation time. It may change, if
  925. // the toolbar is floating; but we want to know of the
  926. // "real" parent (for notification messages)!
  927. m_hwndParent = lpCreateStruct->hwndParent;
  929. return 0;
  930. }
  932. void CToolBarEx::OnWindowPosChanging(WINDOWPOS FAR* lpwndpos) 
  933. {
  934. CToolBar::OnWindowPosChanging(lpwndpos);
  936. // If moved just force a redraw. This stops the partial redraw bug.
  937. if( !(lpwndpos->flags & SWP_NOMOVE) )
  938. Invalidate(FALSE);
  940. }
  942. #define PADWIDTH(x) (((x)*8+31)&~31)/8
  945. HIMAGELIST CToolBarEx :: GetImageList() {
  946. m_bDeleteImgList = FALSE;
  948. HIMAGELIST hImg = 0;
  950. #ifdef TB_GETIMAGELIST
  951. // Some older versions of VC++ do not know of
  952. // the TB_GETIMAGELIST macro (defined in commctrl.h).
  954. hImg = HIMAGELIST(SendMessage(TB_GETIMAGELIST));
  956. #ifdef _DEBUG
  957. if( hImg == 0 ) {
  958. TRACE0("CToolBarEx::GetImageList(): could not get image listn");
  959. }
  960. #endif
  961. #endif // TB_GETIMAGELIST
  963. if( ! hImg ) {
  964. // comctl32.dll version prior to 4.70 doesn't know
  965. // anything of the TB_GETIMAGELIST message
  966. if( m_hbmImageWell != 0 ) {
  967. // Yep - we have a valid image.
  968. // But beware: Do not use this bitmap directly.
  969. // We make the copy by ourself. CopyImage() (for
  970. // instace) produces inacceptable copies under
  971. // some circumstances ...
  972. CImageList imglist;
  973. CBitmap bmp;
  975. // retrieve the size of the bitmap
  976. BITMAP bmHdr;
  977. ::GetObject(m_hbmImageWell, sizeof(BITMAP), &bmHdr);
  979. DWORD dwWidth, dwHeight = bmHdr.bmHeight;
  981. if (bmHdr.bmBitsPixel > 8)
  982. dwWidth = PADWIDTH(bmHdr.bmWidth * 3);
  983. else
  984. dwWidth = PADWIDTH(bmHdr.bmWidth);
  986. // copy the bitmap
  987. CClientDC cdc(this);
  988. CDC dc1, dc2;
  989. dc1.CreateCompatibleDC(&cdc);
  990. dc2.CreateCompatibleDC(&cdc);
  991. bmp.CreateCompatibleBitmap(&cdc, dwWidth, dwHeight);
  992. CBitmap * pOBmp = dc1.SelectObject(&bmp);
  993. HGDIOBJ hOObj = ::SelectObject(dc2.GetSafeHdc(), m_hbmImageWell);
  994. dc1.BitBlt(0,0,dwWidth,dwHeight,&dc2,0,0,SRCCOPY);
  995. ::SelectObject(dc2.GetSafeHdc(), hOObj);
  996. dc1.SelectObject(pOBmp);
  997. dc1.DeleteDC();
  998. dc2.DeleteDC();
  1000. imglist.Create(m_sizeImage.cx, m_sizeImage.cy,TRUE,dwWidth/m_sizeImage.cx,1);
  1001. imglist.SetBkColor(m_clrBtnFace);
  1002. imglist.Add(&bmp,m_clrBtnFace);
  1003. hImg = imglist.Detach();
  1004. bmp.DeleteObject();
  1005. m_bDeleteImgList = TRUE;
  1006. }
  1007. }
  1009. return hImg;
  1010. }
  1012. void CToolBarEx::InvalidateButton(int nIndex) {
  1013. if( nIndex < 0 || nIndex >= GetToolBarCtrl().GetButtonCount() )
  1014. return;
  1015. CRect rc;
  1016. GetItemRect(nIndex, rc);
  1017. InvalidateRect(rc, FALSE);
  1018. }
  1020. BOOL CToolBarEx :: IsSeparator(int nIndex) const {
  1021. if( nIndex >= 0 && nIndex < GetToolBarCtrl().GetButtonCount() )
  1022. if( GetButtonStyle(nIndex) == TBBS_SEPARATOR ) {
  1023. // make sure this is a "real" separator
  1024. CRect rc;
  1025. GetItemRect(nIndex, rc);
  1026. if( rc.Width() <= 8 )
  1027. return TRUE;
  1028. }
  1030. return FALSE;
  1031. }
  1033. BOOL CToolBarEx :: IsControl(int nIndex) const {
  1034. if( nIndex >= 0 && nIndex < GetToolBarCtrl().GetButtonCount() )
  1035. if( GetButtonStyle(nIndex) == TBBS_SEPARATOR ) {
  1036. // make sure this is a placeholder for a control
  1037. CRect rc;
  1038. GetItemRect(nIndex, rc);
  1039. if( rc.Width() > 8 )
  1040. return TRUE;
  1041. }
  1043. return FALSE;
  1044. }
  1047. CWnd * CToolBarEx :: GetControl(int idx, BOOL bIdxIsID) const {
  1048. UINT uID = bIdxIsID ? UINT(idx) : GetItemID(idx);
  1049. for( CWnd * pWnd = GetWindow(GW_CHILD); pWnd; pWnd = pWnd->GetNextWindow() )
  1050. if( UINT(::GetWindowLong(pWnd->GetSafeHwnd(), GWL_ID)) == uID )
  1051. return pWnd;
  1052. return 0;
  1053. }
  1056. CWnd * CToolBarEx :: CtrlReplace(
  1057. CRuntimeClass * pClass,
  1058. CRect & rc,
  1059. UINT ID,
  1060. DWORD dwStyle ) {
  1061. int nIndex = CommandToIndex(ID);
  1062. if(nIndex < 0) {
  1063. TRACE1("CToolBarEx::CtrlReplace(): 0x%x is not a valid ID for this toolbar.n,", ID);
  1064. return 0;
  1065. }
  1067. int nWidth = rc.Width();
  1068. if( nWidth < 0 )
  1069. nWidth = -nWidth;
  1070. SetButtonInfo(nIndex, ID, TBBS_SEPARATOR, nWidth);
  1073. CWnd * pCtrl = CreateControl(pClass, rc, ID, dwStyle);
  1075. return pCtrl;
  1076. }
  1078. CWnd * CToolBarEx :: CtrlInsert(
  1079. CRuntimeClass * pClass,
  1080. CRect & rc,
  1081. UINT ID,
  1082. int nBefore,
  1083. DWORD dwStyle) {
  1084. BOOL bAppend = FALSE;
  1085. CToolBarCtrl & wndToolBarCtrl = GetToolBarCtrl();
  1086. if( nBefore < 0 || nBefore > wndToolBarCtrl.GetButtonCount() )
  1087. bAppend = TRUE;
  1089. int nWidth = rc.Width();
  1090. if( nWidth < 0 )
  1091. nWidth = -nWidth;
  1093. TBBUTTON tbButton;
  1094. tbButton.iBitmap = nWidth;
  1095. tbButton.idCommand = ID;
  1096. tbButton.fsState = TBSTATE_ENABLED;
  1097. tbButton.fsStyle = TBSTYLE_SEP;
  1098. tbButton.dwData = 0;
  1099. tbButton.iString = 0;
  1100. if( bAppend )
  1101. wndToolBarCtrl.AddButtons(1, &tbButton);
  1102. else
  1103. wndToolBarCtrl.InsertButton(nBefore, &tbButton);
  1105. CWnd * pCtrl = CreateControl(pClass, rc, ID, dwStyle);
  1107. return pCtrl;
  1108. }
  1110. CWnd * CToolBarEx :: CreateControl(
  1111. CRuntimeClass * pClass,
  1112. CRect & rc,
  1113. UINT ID,
  1114. DWORD dwStyle) {
  1115. if( ! pClass || ! pClass->IsDerivedFrom(RUNTIME_CLASS(CWnd)) ) {
  1116. TRACE0("CToolBarEx::CreateControl(): given class is NULL or not derived from CWnd.n");
  1117. return 0;
  1118. }
  1120. CWnd * pCtrl = 0;
  1122. BOOL bSelfDeleting = TRUE;
  1124. CString strClass = pClass->m_lpszClassName;
  1126. if( strClass == TEXT("CComboBox") ) {
  1127. pCtrl = new CComboBox();
  1128. bSelfDeleting = FALSE;
  1129. } else if( strClass == TEXT("CEdit") ) {
  1130. pCtrl = new CEdit();
  1131. bSelfDeleting = FALSE;
  1132. } else {
  1133. pCtrl = (CWnd *)pClass->CreateObject();
  1134. if( pCtrl == 0 ) {
  1135. TRACE1("CToolBarEx::CreateControl(): dynamic create of control %hs failed.n",
  1136. pClass->m_lpszClassName);
  1137. return 0;
  1138. }
  1139. }
  1141. // create the control itself
  1142. CRect rect = rc;
  1143. BOOL bCreate = FALSE;
  1145. if( pCtrl->IsKindOf(RUNTIME_CLASS(CComboBox)) )
  1146. bCreate = ((CComboBox*)pCtrl)->Create(WS_CHILD|WS_VISIBLE|dwStyle, rect, this, ID);
  1147. else if( pCtrl->IsKindOf(RUNTIME_CLASS(CEdit)) )
  1148. bCreate = ((CEdit*)pCtrl)->Create(WS_CHILD|WS_VISIBLE|dwStyle, rect, this, ID);
  1149. else
  1150. bCreate = pCtrl->Create(0, 0, WS_CHILD|WS_VISIBLE|dwStyle, rect, this, ID);
  1152. if( ! bCreate ) {
  1153. TRACE1("CToolBarEx::CreateControl(): could not Create() control.n,", ID);
  1154. if( ! bSelfDeleting )
  1155. delete pCtrl;
  1156. return 0;
  1157. }
  1159. if( ! bSelfDeleting ) {
  1160. // we have to remember this control, so we can delete it later
  1161. if( ! m_pControls )
  1162. m_pControls = new CObList();
  1163. m_pControls->AddTail(pCtrl);
  1164. }
  1166. RepositionControls();
  1168. return pCtrl;
  1169. }
  1171. void CToolBarEx :: RepositionControls() {
  1172. // Walk all descendents.
  1173. for( CWnd * pWnd = GetWindow(GW_CHILD); pWnd; pWnd = pWnd->GetNextWindow() ) {
  1174. // If that window is a child of this
  1175. // toolbar, then reposition this control.
  1176. if( pWnd->GetParent() == this ) {
  1177. DWORD dwID = ::GetWindowLong(pWnd->GetSafeHwnd(), GWL_ID);
  1178. int idx = CommandToIndex(dwID);
  1179. ASSERT(idx >= 0);
  1180. CRect rc;
  1181. GetItemRect(idx, rc);
  1182. pWnd->SetWindowPos(0, rc.left, rc.top, 0, 0, SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOCOPYBITS);
  1183. pWnd->ShowWindow(SW_SHOW);
  1184. }
  1185. }
  1186. }
  1188. void CToolBarEx :: RecalcLayout() {
  1189. // Recalculate the size of the bar.
  1190. BOOL bHorz = (m_dwStyle & CBRS_ORIENT_HORZ) != 0;
  1191. if ((m_dwStyle & CBRS_FLOATING) && (m_dwStyle & CBRS_SIZE_DYNAMIC))
  1192. CalcDynamicLayout(0, LM_HORZ | LM_MRUWIDTH | LM_COMMIT);
  1193. else if (bHorz)
  1194. CalcDynamicLayout(0, LM_HORZ | LM_HORZDOCK | LM_COMMIT);
  1195. else
  1196. CalcDynamicLayout(0, LM_VERTDOCK | LM_COMMIT);
  1198. RepositionControls();
  1200. // recalculate the parent frame
  1201. if( m_dwStyle & CBRS_FLOATING ) {
  1202. ASSERT(m_pDockBar != 0);
  1203. ((CMiniDockFrameWnd *)m_pDockBar->GetParent())->RecalcLayout();
  1204. } else {
  1205. ((CFrameWnd*)GetParentFrame())->RecalcLayout();
  1206. }
  1207. }
  1209. HBITMAP CToolBarEx :: GetBitmap(int nBtnID) {
  1210. int nBitmap = SendMessage(TB_GETBITMAP, WPARAM(nBtnID));
  1211. return GetBitmap(nBitmap, m_sizeImage);
  1212. }
  1214. HBITMAP CToolBarEx :: GetBitmap(int nIndex, const CSize & sizeBitmap) {
  1215. HIMAGELIST hImgList = GetImageList();
  1216. if( ! hImgList )
  1217. return 0;
  1219. CImageList imglist;
  1220. imglist.Attach(hImgList);
  1222. HICON hIcon = imglist.ExtractIcon(nIndex);
  1223. CBitmap bmp;
  1225. if( hIcon ) {
  1226. CClientDC cdc(this) ;
  1227. CDC dc;
  1228. dc.CreateCompatibleDC(&cdc);
  1229. VERIFY(bmp.CreateCompatibleBitmap(&cdc, sizeBitmap.cx, sizeBitmap.cy));
  1230. CBitmap* pOldBmp = dc.SelectObject(&bmp);
  1231. CBrush brush ;
  1232. VERIFY(brush.CreateSolidBrush(m_clrBtnFace));
  1233. ::DrawIconEx(
  1234. dc.GetSafeHdc(),
  1235. 0,
  1236. 0,
  1237. hIcon,
  1238. sizeBitmap.cx,
  1239. sizeBitmap.cy,
  1240. 0,
  1241. (HBRUSH)brush,
  1242. DI_NORMAL
  1243. );
  1244. dc.SelectObject( pOldBmp );
  1245. dc.DeleteDC();
  1247. // the icon is not longer needed
  1248. DestroyIcon(hIcon);
  1249. } else
  1250. TRACE1("CToolBarEx::GetBitmap(): unable to extract bitmap with index %dn", nIndex);
  1252. if( ! m_bDeleteImgList )
  1253. imglist.Detach();
  1255. return hIcon ? HBITMAP(bmp.Detach()) : 0;
  1256. }
  1259. LRESULT CToolBarEx::OnAddBitmap(WPARAM wParam, LPARAM lParam) {
  1260. // work around a bug in CToolBar:
  1261. // if one calls CToolBar::GetToolBarCtrl().AddBitmap(...),
  1262. // then CToolBar does not realize this. This can lead to
  1263. // confusing button images ...
  1265. int nButtons = int(wParam);
  1266. LPTBADDBITMAP pAddBmp = LPTBADDBITMAP(lParam);
  1268. if( pAddBmp->hInst != HINST_COMMCTRL ) {
  1269. // This workaround does not work, if one
  1270. // specifies "HINST_COMMCTRL" to the "hInst"
  1271. // member of pAddBmp, because we cannot access
  1272. // the internals of commctl32.dll ...
  1274. TRACE0("Adding a bitmapn");
  1276. HBITMAP hBitmap;
  1277. if( pAddBmp->hInst != 0 )
  1278. // Have to load the bitmap "pAddBmp->nID"
  1279. // contains the resource-ID of the bitmap.
  1280. hBitmap = ::LoadBitmap(pAddBmp->hInst, MAKEINTRESOURCE(pAddBmp->nID));
  1281. else
  1282. // "pAddBmp->nID" is the handle of the bitmap.
  1283. hBitmap = HBITMAP(pAddBmp->nID);
  1285. if(hBitmap == 0)
  1286. return HRESULT(-1);
  1288. // You really should use CToolBarEx as a replacement for
  1289. // CToolBar. So make sure you have set up a toolbar
  1290. // properly before you begin to customize it.
  1291. ASSERT(m_hbmImageWell);
  1293. // retrieve number of images currently stored in CToolBar
  1294. BITMAP bitmap;
  1295. VERIFY(::GetObject(m_hbmImageWell, sizeof(BITMAP), &bitmap));
  1296. int nImageCount = bitmap.bmWidth / m_sizeImage.cx;
  1298. CClientDC cdc(this);
  1299. CDC dcOld, dcNew;
  1300. dcOld.CreateCompatibleDC(&cdc);
  1301. dcNew.CreateCompatibleDC(&cdc);
  1303. HGDIOBJ hOldBmp = ::SelectObject(dcOld.GetSafeHdc(), m_hbmImageWell);
  1305. // create the new bitmap and make it big enough to
  1306. // hold all images (old+new)
  1307. CBitmap bmpNew;
  1308. bmpNew.CreateCompatibleBitmap(
  1309. &cdc,
  1310. bitmap.bmWidth + nButtons * m_sizeImage.cx,
  1311. m_sizeImage.cy);
  1312. CBitmap * pbmpNew = dcNew.SelectObject(&bmpNew);
  1314. dcNew.BitBlt(0,0,bitmap.bmWidth,bitmap.bmHeight,&dcOld,0,0,SRCCOPY);
  1316. ::SelectObject(dcOld.GetSafeHdc(), hBitmap);
  1317. dcNew.BitBlt(bitmap.bmWidth,0,m_sizeImage.cx*nButtons,bitmap.bmHeight,&dcOld,0,0,SRCCOPY);
  1319. ::SelectObject(dcOld.GetSafeHdc(), hOldBmp);
  1320. dcNew.SelectObject(pbmpNew);
  1321. dcOld.DeleteDC();
  1322. dcNew.DeleteDC();
  1324. VERIFY(bmpNew.GetObject(sizeof(BITMAP), &bitmap));
  1326. HRESULT hRes = DefWindowProc(TB_ADDBITMAP, wParam, lParam);
  1328. // syncronize toolbarcontrol's bitmap with our's
  1329. AddReplaceBitmap(HBITMAP(bmpNew.Detach()));
  1331. return HRESULT(nImageCount);
  1332. }
  1334. return DefWindowProc(TB_ADDBITMAP, wParam, lParam);
  1335. }
  1338. // intercept TB_DELETEBUTTON, so we can delete controls too.
  1339. LRESULT CToolBarEx::OnDeleteButton(WPARAM wParam, LPARAM lParam) {
  1340. CWnd * pControl = GetControl(int(wParam));
  1341. if( pControl ) {
  1342. // this is the control associated with the button to delete
  1343. BOOL bMustDelete = FALSE;
  1344. if( m_pControls ) {
  1345. // It is really a good idea to add a control via the
  1346. // CToolBarEx own members. This will guarantee that
  1347. // all resources are freed.
  1348. POSITION pos = m_pControls->Find(pControl);
  1349. if( pos ) {
  1350. m_pControls->RemoveAt(pos);
  1351. bMustDelete = TRUE;
  1352. }
  1353. }
  1354. pControl->DestroyWindow();
  1355. if( bMustDelete )
  1356. delete pControl;
  1357. }
  1359. return DefWindowProc(TB_DELETEBUTTON, wParam, lParam);
  1360. }
  1363. #ifdef _MEMDC_H_
  1364. BOOL CToolBarEx::OnEraseBkgnd(CDC* pDC) 
  1365. {
  1366. return IsFlatLook() ? FALSE : CToolBar::OnEraseBkgnd(pDC);
  1367. }
  1368. #endif
  1370. /////////////////////////////////////////////////////////////////////////////
  1371. // ALT-drag
  1373. // To keep the users of CToolBarEx from inserting cursor-resources, we
  1374. // create the cursors on the fly. This makes usage of CToolBarEx as easy as
  1375. // possible:
  1377. static const BYTE ANDmaskDrop[] = { 
  1378.     0xFF, 0xFF, 0xFF, 0xFF,   // line 1
  1379.     0xFF, 0xFF, 0xFF, 0xFF,   // line 2
  1380.     0xF3, 0xFF, 0xFF, 0xFF,   // line 3
  1381.     0xF1, 0xFF, 0xFF, 0xFF,   // line 4
  1382.  
  1383.     0xF0, 0xFF, 0xFF, 0xFF,   // line 5
  1384.     0xF0, 0x7F, 0xFF, 0xFF,   // line 6
  1385.     0xF0, 0x3F, 0xFF, 0xFF,   // line 7
  1386.     0xF0, 0x1F, 0xFF, 0xFF,   // line 8
  1387.  
  1388.     0xF0, 0x0F, 0xFF, 0xFF,   // line 9
  1389.     0xF0, 0x07, 0xFF, 0xFF,   // line 10
  1390.     0xF0, 0x03, 0xFF, 0xFF,   // line 11
  1391.     0xF0, 0x01, 0xFF, 0xFF,   // line 12
  1392.  
  1393.     0xF0, 0x00, 0xFF, 0xFF,   // line 13
  1394.     0xF0, 0x0F, 0xFF, 0xFF,   // line 14
  1395.     0xF0, 0x0F, 0xFF, 0xFF,   // line 15
  1396.     0xF1, 0x07, 0xFF, 0xFF,   // line 16
  1397.  
  1398.     0xF3, 0x07, 0xFF, 0xFF,   // line 17
  1399.     0xF6, 0x00, 0x00, 0x3F,   // line 18
  1400.     0xFE, 0x00, 0x00, 0x3F,   // line 19
  1401.     0xFE, 0x00, 0x00, 0x3F,   // line 20
  1402.  
  1403.     0xFE, 0x00, 0x00, 0x3F,   // line 21
  1404.     0xFE, 0x00, 0x00, 0x3F,   // line 22
  1405.     0xFE, 0x00, 0x00, 0x3F,   // line 23
  1406.     0xFE, 0x00, 0x00, 0x3F,   // line 24
  1407.  
  1408.     0xFE, 0x00, 0x00, 0x3F,   // line 25
  1409.     0xFE, 0x00, 0x00, 0x3F,   // line 26
  1410.     0xFF, 0xFF, 0xFF, 0xFF,   // line 27
  1411.     0xFF, 0xFF, 0xFF, 0xFF,   // line 28
  1412.  
  1413.     0xFF, 0xFF, 0xFF, 0xFF,   // line 29
  1414.     0xFF, 0xFF, 0xFF, 0xFF,   // line 30
  1415.     0xFF, 0xFF, 0xFF, 0xFF,   // line 31
  1416.     0xFF, 0xFF, 0xFF, 0xFF    // line 32
  1417. };
  1418.  
  1419. static const BYTE XORmaskDrop[] = { 
  1420.     0x00, 0x00, 0x00, 0x00,   // line 1
  1421.     0x00, 0x00, 0x00, 0x00,   // line 2
  1422.     0x00, 0x00, 0x00, 0x00,   // line 3
  1423.     0x04, 0x00, 0x00, 0x00,   // line 4
  1424.  
  1425.     0x06, 0x00, 0x00, 0x00,   // line 5
  1426.     0x07, 0x00, 0x00, 0x00,   // line 6
  1427.     0x07, 0x80, 0x00, 0x00,   // line 7
  1428.     0x07, 0xC0, 0x00, 0x00,   // line 8
  1429.  
  1430.     0x07, 0xE0, 0x00, 0x00,   // line 9
  1431.     0x07, 0xF0, 0x00, 0x00,   // line 10
  1432.     0x07, 0xF8, 0x00, 0x00,   // line 11
  1433.     0x07, 0xFC, 0x00, 0x00,   // line 12
  1434.  
  1435.     0x07, 0xE0, 0x00, 0x00,   // line 13
  1436.     0x07, 0x60, 0x00, 0x00,   // line 14
  1437.     0x06, 0x60, 0x00, 0x00,   // line 15
  1438.     0x04, 0x30, 0x00, 0x00,   // line 16
  1439.  
  1440.     0x00, 0x30, 0x00, 0x00,   // line 17
  1441.     0x00, 0x18, 0x00, 0x00,   // line 18
  1442.     0x00, 0xDD, 0xFF, 0x00,   // line 19
  1443.     0x00, 0xAC, 0xAA, 0x00,   // line 20
  1444.  
  1445.     0x00, 0xCD, 0x55, 0x00,   // line 21
  1446.     0x00, 0xA0, 0xAA, 0x00,   // line 22
  1447.     0x00, 0xD5, 0x55, 0x00,   // line 23
  1448.     0x00, 0xAA, 0xAA, 0x00,   // line 24
  1449.  
  1450.     0x00, 0x00, 0x00, 0x00,   // line 25
  1451.     0x00, 0x00, 0x00, 0x00,   // line 26
  1452.     0x00, 0x00, 0x00, 0x00,   // line 27
  1453.     0x00, 0x00, 0x00, 0x00,   // line 28
  1454.  
  1455.     0x00, 0x00, 0x00, 0x00,   // line 29
  1456.     0x00, 0x00, 0x00, 0x00,   // line 30
  1457.     0x00, 0x00, 0x00, 0x00,   // line 31
  1458.     0x00, 0x00, 0x00, 0x00    // line 32
  1459. };
  1461. static const BYTE ANDmaskNoDrop[] = { 
  1462.     0xFF, 0xFF, 0xFF, 0xFF,   // line 1
  1463.     0xFF, 0xFF, 0xFF, 0xFF,   // line 2
  1464.     0xF3, 0xFF, 0xFF, 0xFF,   // line 3
  1465.     0xF1, 0xFF, 0xFF, 0xFF,   // line 4
  1466.  
  1467.     0xF0, 0xFF, 0xFF, 0xFF,   // line 5
  1468.     0xF0, 0x7F, 0xFF, 0xFF,   // line 6
  1469.     0xF0, 0x3F, 0xFF, 0xFF,   // line 7
  1470.     0xF0, 0x1F, 0xFF, 0xFF,   // line 8
  1471.  
  1472.     0xF0, 0x0F, 0xFF, 0xFF,   // line 9
  1473.     0xF0, 0x07, 0xFF, 0xFF,   // line 10
  1474.     0xF0, 0x03, 0xFF, 0xFF,   // line 11
  1475.     0xF0, 0x01, 0xFF, 0xFF,   // line 12
  1476.  
  1477.     0xF0, 0x00, 0xFF, 0xFF,   // line 13
  1478.     0xF0, 0x0F, 0xFF, 0xFF,   // line 14
  1479.     0xF0, 0x0F, 0xFF, 0xFF,   // line 15
  1480.     0xF1, 0x07, 0xFF, 0xFF,   // line 16
  1481.  
  1482.     0xF3, 0x07, 0xFF, 0xFF,   // line 17
  1483.     0xF6, 0x00, 0x00, 0x3F,   // line 18
  1484.     0xFE, 0x00, 0x00, 0x3F,   // line 19
  1485.     0xFE, 0x00, 0x00, 0x3F,   // line 20
  1486.  
  1487.     0xFE, 0x00, 0x00, 0x3F,   // line 21
  1488.     0xFE, 0x00, 0x00, 0x0F,   // line 22
  1489.     0xFE, 0x00, 0x00, 0x0F,   // line 23
  1490.     0xFE, 0x00, 0x00, 0x0F,   // line 24
  1491.  
  1492.     0xFE, 0x00, 0x00, 0x0F,   // line 25
  1493.     0xFE, 0x00, 0x00, 0x0F,   // line 26
  1494.     0xFF, 0xFF, 0x80, 0x0F,   // line 27
  1495.     0xFF, 0xFF, 0x80, 0x0F,   // line 28
  1496.  
  1497.     0xFF, 0xFF, 0x80, 0x0F,   // line 29
  1498.     0xFF, 0xFF, 0x80, 0x0F,   // line 30
  1499.     0xFF, 0xFF, 0x80, 0x0F,   // line 31
  1500.     0xFF, 0xFF, 0x80, 0x0F    // line 32
  1501. };
  1502.  
  1503. static const BYTE XORmaskNoDrop[] = {
  1504.     0x00, 0x00, 0x00, 0x00,   // line 1
  1505.     0x00, 0x00, 0x00, 0x00,   // line 2
  1506.     0x00, 0x00, 0x00, 0x00,   // line 3
  1507.     0x04, 0x00, 0x00, 0x00,   // line 4
  1508.  
  1509.     0x06, 0x00, 0x00, 0x00,   // line 5
  1510.     0x07, 0x00, 0x00, 0x00,   // line 6
  1511.     0x07, 0x80, 0x00, 0x00,   // line 7
  1512.     0x07, 0xC0, 0x00, 0x00,   // line 8
  1513.  
  1514.     0x07, 0xE0, 0x00, 0x00,   // line 9
  1515.     0x07, 0xF0, 0x00, 0x00,   // line 10
  1516.     0x07, 0xF8, 0x00, 0x00,   // line 11
  1517.     0x07, 0xFC, 0x00, 0x00,   // line 12
  1518.  
  1519.     0x07, 0xE0, 0x00, 0x00,   // line 13
  1520.     0x07, 0x60, 0x00, 0x00,   // line 14
  1521.     0x06, 0x60, 0x00, 0x00,   // line 15
  1522.     0x04, 0x30, 0x00, 0x00,   // line 16
  1523.  
  1524.     0x00, 0x30, 0x00, 0x00,   // line 17
  1525.     0x00, 0x18, 0x00, 0x00,   // line 18
  1526.     0x00, 0xDD, 0xFF, 0x00,   // line 19
  1527.     0x00, 0xAC, 0xAA, 0x00,   // line 20
  1528.  
  1529.     0x00, 0xCD, 0x55, 0x00,   // line 21
  1530.     0x00, 0xA0, 0x80, 0x00,   // line 22
  1531.     0x00, 0xD5, 0x3F, 0xE0,   // line 23
  1532.     0x00, 0xAA, 0xA7, 0x20,   // line 24
  1533.  
  1534.     0x00, 0x00, 0x22, 0x20,   // line 25
  1535.     0x00, 0x00, 0x30, 0x60,   // line 26
  1536.     0x00, 0x00, 0x38, 0xE0,   // line 27
  1537.     0x00, 0x00, 0x30, 0x60,   // line 28
  1538.  
  1539.     0x00, 0x00, 0x22, 0x20,   // line 29
  1540.     0x00, 0x00, 0x27, 0x20,   // line 30
  1541.     0x00, 0x00, 0x3F, 0xE0,   // line 31
  1542.     0x00, 0x00, 0x00, 0x00    // line 32
  1543. };
  1545. void CToolBarEx::OnLButtonDown(UINT nFlags, CPoint point) 
  1546. {
  1547. if( ::GetAsyncKeyState(VK_MENU) & (1<<15) )
  1548. // one of the ALT keys is pressed too - begin drag operation
  1549. if( BeginDrag() )
  1550. return;
  1552. if( ::GetAsyncKeyState(VK_SHIFT) & (1<<15) )
  1553. // disable the old-style drag
  1554. return;
  1556. CToolBar::OnLButtonDown(nFlags, point);
  1557. }
  1559. void CToolBarEx::OnLButtonUp(UINT nFlags, CPoint point) 
  1560. {
  1561. if( m_bDragging )
  1562. EndDrag();
  1563. else
  1564. CToolBar::OnLButtonUp(nFlags, point);
  1565. }
  1567. BOOL CToolBarEx :: BeginDrag() {
  1568. TRACE0("beginning drag operationn");
  1570. VERIFY(!m_hDragCursor);
  1571. VERIFY(!m_hNoDragCursor);
  1573. if( !(::GetWindowLong(GetToolBarCtrl().GetSafeHwnd(),GWL_STYLE) & CCS_ADJUSTABLE) )
  1574. return FALSE; // Bar is not adjustable
  1576. register const int nBtn = GetToolBarCtrl().GetButtonCount();
  1577. const int nLastBtn = m_nLastBtn;
  1578. m_nLastBtn = -1;
  1579. CPoint pt;
  1580. ::GetCursorPos(&pt);
  1581. ScreenToClient(&pt);
  1583. m_nDragButton = -1;
  1585. // have a look for whether the button is valid and
  1586. // - if so - draw a dragging border around it.
  1587. for( register int i = 0 ; i < nBtn ; ++i ) {
  1588. if( IsSeparator(i) )
  1589. continue; // real separators are not draggable
  1591. CRect rc;
  1592. GetItemRect(i, rc);
  1594. const BOOL bHasCursor = rc.PtInRect(pt);
  1596. if( bHasCursor ) {
  1597. // OK we've found the button. Now ask for deletion:
  1598. if( ! DoQueryDelete(i) )
  1599. // the app does not allow the removal ...
  1600. return FALSE;
  1602. m_nDragButton = i;
  1603. CClientDC cdc(this);
  1604. cdc.DrawDragRect(rc, CSize(2,2),0,CSize(0,0));
  1605. break;
  1606. }
  1607. }
  1609. if( m_nDragButton < 0 )
  1610. return FALSE; // nothing to drag ...
  1612. VERIFY(m_hDragCursor = ::CreateCursor(0, 4, 2, 32, 32, ANDmaskDrop, XORmaskDrop));
  1613. VERIFY(m_hNoDragCursor = ::CreateCursor(0, 4, 2, 32, 32, ANDmaskNoDrop, XORmaskNoDrop));
  1615. // capture the mouse during the drag operation
  1616. SetCapture();
  1618. // make sure we receive keyboard-input
  1619. SetFocus();
  1621. m_hOrigCursor = ::SetCursor(m_hDragCursor);
  1622. m_bDragCursor = TRUE;
  1624. m_bDragging = TRUE;
  1626. ::GetCursorPos(&pt);
  1627. SetMarker(m_pDropBar=this, m_ptDrop=pt);
  1629. return m_bDragging;
  1630. }
  1634. BOOL CToolBarEx :: IsValidDropTarget(const CWnd * pWnd) const {
  1635. return (pWnd &&
  1636. pWnd->IsKindOf(RUNTIME_CLASS(CToolBarEx)) &&
  1637. (::GetWindowLong(((CToolBarEx*)pWnd)->GetToolBarCtrl()
  1638. .GetSafeHwnd(),GWL_STYLE) & CCS_ADJUSTABLE) &&
  1639. ((const CToolBarEx*)pWnd)->GetParentFrame() == GetParentFrame())
  1640. ? TRUE : FALSE;
  1641. }
  1644. void CToolBarEx :: DragMove() {
  1645. //TRACE0("dragmove in progressn");
  1647. CPoint pt;
  1648. ::GetCursorPos(&pt);
  1649. const CWnd * pWnd = WindowFromPoint(pt);
  1651. // is the cursor moving over an adjustable toolbar ?
  1652. BOOL bToolBar = IsValidDropTarget(pWnd);
  1654. // If the window under the cursor is not a toolbar, then
  1655. // check whether this window is a child of a toolbar.
  1656. while( ! bToolBar && (pWnd = pWnd->GetParent()) != 0 )
  1657. bToolBar = IsValidDropTarget(pWnd);
  1659. // check whether we have to switch the cursor
  1660. if( bToolBar && ! m_bDragCursor ) {
  1661. ::SetCursor(m_hDragCursor);
  1662. m_bDragCursor = TRUE;
  1663. } else if( ! bToolBar && m_bDragCursor ) {
  1664. ::SetCursor(m_hNoDragCursor);
  1665. m_bDragCursor = FALSE;
  1666. }
  1668. SetMarker(m_pDropBar = (bToolBar ? (CToolBarEx*)pWnd : 0), m_ptDrop = pt);
  1669. }
  1671. void CToolBarEx :: EndDrag(BOOL bDoMove) {
  1672. TRACE0("ending drag operationn");
  1674. // remove the marker
  1675. SetMarker(0, CPoint(0,0));
  1677. VERIFY(::SetCursor(m_hOrigCursor));
  1678. ::DestroyCursor(m_hDragCursor);
  1679. ::DestroyCursor(m_hNoDragCursor);
  1680. m_hDragCursor = 0;
  1681. m_hNoDragCursor = 0;
  1683. if( m_nDragButton >= 0 ) {
  1684. CToolBarCtrl & wndTBCtrl = GetToolBarCtrl();
  1685. register const int nBtn = wndTBCtrl.GetButtonCount();
  1687. if( m_bDragCursor && bDoMove ) {
  1688. // move the button to a different location
  1690. // make sure the last "DragMove()" has done its work correctly:
  1691. ASSERT(m_pDropBar != 0);
  1692. ASSERT_KINDOF(CToolBarEx, m_pDropBar);
  1693. ASSERT(::GetWindowLong(m_pDropBar->GetToolBarCtrl()
  1694. .GetSafeHwnd(),GWL_STYLE) & CCS_ADJUSTABLE);
  1696. // have a look for where to drop the button
  1697. int nDropBtn = m_pDropBar->FindDropButton(m_ptDrop);
  1698. TBBUTTON tbButton;
  1699. memset(&tbButton, 0, sizeof(TBBUTTON)); // not the safest, but the easiest way
  1700. // to zero out all members ;-)
  1702. if( m_pDropBar == this ) {
  1703. // move the button around, but stay on *this* toolbar
  1704. if( nDropBtn == m_nDragButton+1 || (nDropBtn < 0 && m_nDragButton == nBtn-1) ) {
  1705. // simply insert a separator before the dragged button,
  1706. // if there is still none
  1707. if( m_nDragButton > 0 && !IsSeparator(m_nDragButton-1) ) {
  1708. tbButton.iBitmap = 8;
  1709. tbButton.fsState = TBSTATE_ENABLED;
  1710. tbButton.fsStyle = TBSTYLE_SEP;
  1711. if( DoQueryInsert(tbButton, m_nDragButton) )
  1712. wndTBCtrl.InsertButton(m_nDragButton, &tbButton);
  1713. }
  1714. } else if( nDropBtn == m_nDragButton && m_nDragButton > 0 ) {
  1715. // Remove the separator immediately before the dragged button.
  1716. // if there is no such separator, then do nothing
  1717. if( IsSeparator(nDropBtn-1) )
  1718. if( DoQueryDelete(nDropBtn-1) )
  1719. wndTBCtrl.DeleteButton(nDropBtn-1);
  1720. } else {
  1721. wndTBCtrl.GetButton(m_nDragButton, &tbButton);
  1722. if( DoQueryInsert(tbButton, (nDropBtn>=0) ? nDropBtn : nBtn) ) {
  1723. CWnd * pControl = 0;
  1724. if( IsControl(m_nDragButton) ) {
  1725. // Beware: The TB_DELETEBUTTON message causes the toolbar
  1726. // to destroy the associated control.
  1727. // To avoid this we temporary set the parent of the
  1728. // control to NULL.
  1729. pControl = GetControl(m_nDragButton);
  1730. VERIFY(pControl != 0);
  1731. pControl->SetParent(0);
  1732. }
  1734. if( nDropBtn >= 0 )
  1735. // have to insert
  1736. wndTBCtrl.InsertButton(nDropBtn, &tbButton);
  1737. else
  1738. // append the button
  1739. wndTBCtrl.AddButtons(1, &tbButton);
  1741. // delete the button at its original location
  1742. // we do not need to ask the owner, because this
  1743. // was already done in "BeginDrag()"
  1744. wndTBCtrl.DeleteButton(
  1745. (m_nDragButton < nDropBtn || nDropBtn < 0)
  1746. ? m_nDragButton
  1747. : m_nDragButton+1
  1748. );
  1750. // Reconnect the control (if any)
  1751. if( pControl )
  1752. pControl->SetParent(this);
  1754. if( m_nDragButton == wndTBCtrl.GetButtonCount()-1 )
  1755. // remove trailing separators too
  1756. RemoveTrailingSeparators();
  1757. }
  1758. }
  1759. } else {
  1760. // move the button to a different toolbar
  1762. wndTBCtrl.GetButton(m_nDragButton, &tbButton);
  1763. CToolBarCtrl & wndDropTBCtrl = m_pDropBar->GetToolBarCtrl();
  1765. if( m_pDropBar->DoQueryInsert(tbButton, (nDropBtn>=0) ? nDropBtn : wndDropTBCtrl.GetButtonCount()) ) {
  1766. // Get the bitmap of the dragged button and resize it to
  1767. // the image-size of the destination-bar.
  1768. int nDestBitmap = 0;
  1769. if( IsControl(m_nDragButton) ) {
  1770. CRect rc;
  1771. GetItemRect(m_nDragButton, rc);
  1772. nDestBitmap = rc.Width();
  1773. } else {
  1774. HBITMAP hBmp = GetBitmap(tbButton.iBitmap, m_pDropBar->m_sizeImage);
  1775. CBitmap bmp;
  1776. if( hBmp ) {
  1777. bmp.Attach(hBmp);
  1778. nDestBitmap = wndDropTBCtrl.AddBitmap(1, &bmp);
  1779. }
  1780. }
  1781. tbButton.iBitmap = nDestBitmap;
  1782. //tbButton.iString = nDestString;
  1783. tbButton.iString = -1;
  1784. BOOL bInsertOK;
  1785. if( nDropBtn >= 0 )
  1786. bInsertOK = wndDropTBCtrl.InsertButton(nDropBtn, &tbButton);
  1787. else
  1788. bInsertOK = wndDropTBCtrl.AddButtons(1, &tbButton);
  1790. if( bInsertOK ) {
  1791. // transfer the string too, if any (check target first)
  1792. if( m_pDropBar->HasButtonText() && HasButtonText() )
  1793. {
  1794. // let the CToolBar class do all the leg work
  1795. m_pDropBar->SetButtonText(
  1796. m_pDropBar->CommandToIndex(tbButton.idCommand),
  1797. GetButtonText(m_nDragButton)
  1798. );
  1799. }
  1800. // check whether the dragged button was a control in real life and
  1801. // - if so - move that control to its new parent.
  1802. CheckMoveControl(m_pDropBar, tbButton);
  1804. wndTBCtrl.DeleteButton(m_nDragButton);
  1806. if( m_nDragButton == wndTBCtrl.GetButtonCount()-1 )
  1807. // remove trailing separators too
  1808. RemoveTrailingSeparators();
  1810. m_pDropBar->RecalcLayout();
  1811. }
  1812. }
  1813. }
  1814. } else {
  1815. // remove the button from the toolbar
  1816. if( bDoMove ) {
  1817. wndTBCtrl.DeleteButton(m_nDragButton);
  1819. if( m_nDragButton == wndTBCtrl.GetButtonCount() )
  1820. // remove trailing separators too
  1821. RemoveTrailingSeparators();
  1822. } else
  1823. // User has aborted the drag-operation.
  1824. // Remove the drag-border from the button
  1825. InvalidateButton(m_nDragButton);
  1826. }
  1828. // Recalculate the size of the bar.and the parent
  1829. RecalcLayout();
  1830. }
  1832. m_bDragging = FALSE;
  1834. // mouse capture is not longer needed
  1835. ReleaseCapture();
  1836. }
  1839. void CToolBarEx :: CheckMoveControl( CToolBarEx * pToolBar, const TBBUTTON & tbButton ) {
  1840. ASSERT_VALID(pToolBar);
  1841. CWnd * pControl = GetControl(tbButton.idCommand, TRUE);
  1842. if( pControl ) {
  1843. // now change the parent of the control, so that it jumps to the
  1844. // other toolbar
  1845. pControl->SetParent(pToolBar);
  1847. // remove the control from our list (if it's present there) and
  1848. // add it to the target's list
  1849. if( m_pControls ) {
  1850. POSITION pos = m_pControls->Find(pControl);
  1851. if(pos) {
  1852. m_pControls->RemoveAt(pos);
  1853. if( ! pToolBar->m_pControls )
  1854. pToolBar->m_pControls = new CObList();
  1855. pToolBar->m_pControls->AddTail(pControl);
  1856. }
  1857. }
  1858. }
  1859. }
  1862. void CToolBarEx :: RemoveTrailingSeparators() {
  1863. CToolBarCtrl & wndTBCtrl = GetToolBarCtrl();
  1864. register const int nBtn = wndTBCtrl.GetButtonCount();
  1865. register int i = nBtn;
  1866. while( i && IsSeparator(--i) )
  1867. if( DoQueryDelete(i) )
  1868. wndTBCtrl.DeleteButton(i);
  1869. }
  1871. int CToolBarEx :: FindDropButton( const CPoint & point ) {
  1872. CPoint pt = point;
  1873. ScreenToClient(&pt);
  1875. CRect rc;
  1876. // find the button which is closest to the cursor
  1877. register const int nBtn = GetToolBarCtrl().GetButtonCount();
  1878. for( register int i = 0 ; i < nBtn ; ++i ) {
  1879. GetItemRect(i, rc);
  1880. if( rc.PtInRect(pt) )
  1881. // insert the button to drop before this button:
  1882. return (pt.x - rc.left < rc.right - pt.x)
  1883. ? i
  1884. : ((i==nBtn-1)
  1885. ? -1
  1886. : i+1);
  1887. }
  1889. // have to append the button
  1890. return -1;
  1891. }
  1893. void CToolBarEx :: GetMarkerRect( int nButton, CRect & rc ) {
  1894. register const int nBtn = GetToolBarCtrl().GetButtonCount();
  1895. if( nButton < 0 || nButton > nBtn ) {
  1896. // set the marker behind the last button
  1897. GetItemRect(nBtn-1, rc);
  1898. rc.right += 3;
  1899. rc.left = rc.right-6;
  1900. } else {
  1901. // set the marker before the given button
  1902. GetItemRect(nButton, rc);
  1903. rc.left -= 3;
  1904. rc.right = rc.left+6;
  1905. }
  1906. rc.DeflateRect(0,1);
  1907. }
  1909. void CToolBarEx :: ShowMarker( const CRect & rcMarker, CBitmap & bmpArea ) {
  1910. ASSERT( bmpArea.GetSafeHandle() == 0 );
  1912. CClientDC  WinDC(this);
  1913. CDC MemDC; MemDC.CreateCompatibleDC(&WinDC);
  1915. bmpArea.CreateCompatibleBitmap(&WinDC, rcMarker.Width(), rcMarker.Height());
  1916. CBitmap * pOldBmp = MemDC.SelectObject(&bmpArea);
  1918. CPen pen(PS_SOLID, 1, RGB(0,0,0));
  1919. CPen * pOldPen = WinDC.SelectObject(&pen);
  1921. // save original area:
  1922. MemDC.BitBlt(0,0,rcMarker.Width(),rcMarker.Height(),
  1923. &WinDC, rcMarker.left, rcMarker.top, SRCCOPY);
  1925. WinDC.MoveTo(rcMarker.TopLeft());
  1926. WinDC.LineTo(rcMarker.right, rcMarker.top);
  1927. WinDC.MoveTo(rcMarker.left+1, rcMarker.top+1);
  1928. WinDC.LineTo(rcMarker.right-1, rcMarker.top+1);
  1930. WinDC.MoveTo(rcMarker.left+2, rcMarker.top+2);
  1931. WinDC.LineTo(rcMarker.left+2, rcMarker.bottom-2);
  1932. WinDC.MoveTo(rcMarker.left+3, rcMarker.top+2);
  1933. WinDC.LineTo(rcMarker.left+3, rcMarker.bottom-2);
  1935. WinDC.MoveTo(rcMarker.left, rcMarker.bottom-1);
  1936. WinDC.LineTo(rcMarker.right, rcMarker.bottom-1);
  1937. WinDC.MoveTo(rcMarker.left+1, rcMarker.bottom-2);
  1938. WinDC.LineTo(rcMarker.right-1, rcMarker.bottom-2);
  1940. MemDC.SelectObject(pOldBmp);
  1941. MemDC.DeleteDC();
  1942. WinDC.SelectObject(pOldPen);
  1943. }
  1945. void CToolBarEx :: RestoreMarker( const CRect & rcArea, CBitmap & bmpArea ) {
  1946. if( bmpArea.GetSafeHandle() == 0 )
  1947. return;
  1949. CClientDC  WinDC(this);
  1950. CDC MemDC; MemDC.CreateCompatibleDC(&WinDC);
  1952. CBitmap * pOldBmp = MemDC.SelectObject(&bmpArea);
  1953. WinDC.BitBlt(rcArea.left, rcArea.top, rcArea.Width(), rcArea.Height(),
  1954. &MemDC, 0, 0, SRCCOPY);
  1956. MemDC.SelectObject(pOldBmp);
  1957. MemDC.DeleteDC();
  1958. }
  1960. void CToolBarEx :: SetMarker( CToolBarEx * pBar, const CPoint & point ) {
  1961. static CToolBarEx * pLastToolBar = 0;
  1962. static CRect lastRect(0,0,0,0);
  1963. static CBitmap bmpLastSavedArea;
  1965. CRect rcMarker;
  1967. // retrieve proposed rectangle for the marker
  1968. if( pBar != 0 ) {
  1969. int nDropBtn = pBar->FindDropButton(point);
  1970. pBar->GetMarkerRect(nDropBtn, rcMarker);
  1972. if(rcMarker == lastRect)
  1973. return; // don't need to erase/draw
  1974. }
  1976. // restore the previously marked area:
  1977. if( pLastToolBar ) {
  1978. pLastToolBar->RestoreMarker(lastRect, bmpLastSavedArea);
  1979. bmpLastSavedArea.DeleteObject();
  1980. }
  1982. // draw the marker
  1983. if( pBar != 0 ) {
  1984. pBar->ShowMarker(rcMarker, bmpLastSavedArea);
  1985. lastRect = rcMarker;
  1986. }
  1987. pLastToolBar = pBar;
  1988. }
  1990. BOOL CToolBarEx :: DoQueryDelete(int nButton) {
  1991. ASSERT(nButton >= 0);
  1993. TBBUTTON tbButton;
  1994. if( ! GetToolBarCtrl().GetButton(nButton, &tbButton) ) {
  1995. TRACE1("CToolBarEx::DoQueryDelete(): could not retrieve button %dn", nButton);
  1996. return FALSE;
  1997. }
  1999. return QueryDeleteInsert(tbButton, TRUE, nButton);
  2000. }
  2002. BOOL CToolBarEx :: QueryDeleteInsert(TBBUTTON & tbButton, BOOL bDelete, int nIndex) {
  2003. TBNOTIFY tbn;
  2004. memset(&tbn, 0, sizeof(TBNOTIFY));
  2005. tbn.hdr.hwndFrom = GetSafeHwnd();
  2006. tbn.hdr.idFrom = UINT(::GetWindowLong(tbn.hdr.hwndFrom, GWL_ID));
  2007. tbn.hdr.code = bDelete ? TBN_QUERYDELETE : TBN_QUERYINSERT;
  2008. tbn.iItem = nIndex;
  2009. memcpy((void *)(&tbn.tbButton), (const void *)(&tbButton), sizeof(TBBUTTON));
  2011. CString strText;
  2012. if( bDelete ) {
  2013. strText = GetButtonText(nIndex);
  2014. tbn.cchText = strText.GetLength();
  2015. tbn.pszText = strText.GetBuffer(tbn.cchText);
  2016. }
  2018. ASSERT(GetParentFrame() != 0);
  2019. ASSERT(::IsWindow(GetParentFrame()->GetSafeHwnd()));
  2021. BOOL bRet = GetParentFrame()->SendMessage(
  2022. WM_NOTIFY,
  2023. WPARAM(tbn.hdr.idFrom),
  2024. LPARAM(&tbn)
  2025. );
  2027. if( bDelete )
  2028. strText.ReleaseBuffer();
  2030. return bRet;
  2031. }
  2033. void CToolBarEx::OnCaptureChanged(CWnd *pWnd) 
  2034. {
  2035. if( m_bDragging )
  2036. // without the mouse-capture we cannot complete the drag-operation
  2037. EndDrag(FALSE);
  2039. CToolBar::OnCaptureChanged(pWnd);
  2040. }
  2043. BOOL CToolBarEx :: PreTranslateMessage( MSG * pMsg ) {
  2044. if( m_bDragging &&
  2045. (pMsg->message == WM_KEYDOWN || pMsg->message == WM_KEYUP) && 
  2046. int(pMsg->wParam) == VK_ESCAPE ) {
  2048. // user pressed ESC to abort drag operation
  2049. EndDrag(FALSE);
  2050. return TRUE;
  2051. }
  2052. return CToolBar::PreTranslateMessage(pMsg);
  2053. }
  2055. void CToolBarEx::OnParentNotify(UINT message, LPARAM lParam) 
  2056. {
  2057. if( LOWORD(message) == WM_LBUTTONDOWN && (::GetAsyncKeyState(VK_MENU) & (1<<15)) ) {
  2058. // I see no chance to abort the child's message processing.
  2059. // That's why we set a flag here. If we lose the focus (a click
  2060. // in a child's area will activate that child window), then
  2061. // we start the real drag-operation (that would return the
  2062. // focus to the toolbar).
  2063. // This solution is somewhat obfuscated, so if you know of
  2064. // a better way -- let me know.
  2065. m_bDragChild = TRUE;
  2066. SetFocus();
  2067. }
  2069. CToolBar::OnParentNotify(message, lParam);
  2070. }
  2072. void CToolBarEx::OnKillFocus(CWnd* pNewWnd) 
  2073. {
  2074. CToolBar::OnKillFocus(pNewWnd);
  2076. if( m_bDragChild ) {
  2077. // See OnParentNotify() above ...
  2078. m_bDragChild = FALSE;
  2079. if( GetCapture() != this )
  2080. BeginDrag();
  2081. }
  2082. }
  2085. /////////////////////////////////////////////////////////////////////////////
  2086. // helpers for docking 
  2087. /////////////////////////////////////////////////////////////////////////////
  2090. // We need our own version of a dock bar, because the original
  2091. // MFC implementation overlapps toolbars. CToolBarEx don't want
  2092. // such a overlapping, because this makes it impossible to draw
  2093. // a real 3d border ...
  2094. class CToolDockBar : public CDockBar {
  2095. DECLARE_DYNAMIC(CToolDockBar)
  2097. public:
  2098. // this is the one and only method of interest
  2099. virtual CSize CalcFixedLayout(BOOL bStretch, BOOL bHorz);
  2100. };
  2102. IMPLEMENT_DYNAMIC(CToolDockBar, CDockBar);
  2104. CSize CToolDockBar::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  2105. {
  2106. ASSERT_VALID(this);
  2108. CSize sizeFixed = CControlBar::CalcFixedLayout(bStretch, bHorz);
  2110. // get max size
  2111. CSize sizeMax;
  2112. if (!m_rectLayout.IsRectEmpty())
  2113. sizeMax = m_rectLayout.Size();
  2114. else
  2115. {
  2116. CRect rectFrame;
  2117. CFrameWnd* pFrame = GetParentFrame();
  2118. pFrame->GetClientRect(&rectFrame);
  2119. sizeMax = rectFrame.Size();
  2120. }
  2122. // prepare for layout
  2123. AFX_SIZEPARENTPARAMS layout;
  2124. layout.hDWP = m_bLayoutQuery ?
  2125. NULL : ::BeginDeferWindowPos(m_arrBars.GetSize());
  2126. int cxBorder = 2, cyBorder = 2;
  2127. CPoint pt(-cxBorder, -cyBorder);
  2128. int nWidth = 0;
  2130. BOOL bWrapped = FALSE;
  2132. // layout all the control bars
  2133. for (int nPos = 0; nPos < m_arrBars.GetSize(); nPos++)
  2134. {
  2135. CControlBar* pBar = GetDockedControlBar(nPos);
  2136. void* pVoid = m_arrBars[nPos];
  2138. if (pBar != NULL)
  2139. {
  2140. if(pBar->IsKindOf(RUNTIME_CLASS(CToolBarEx)) && ((CToolBarEx*)pBar)->IsFlatLook())
  2141. ((CToolBarEx*)pBar)->m_bReal3DBorder = TRUE,
  2142. cxBorder = cyBorder = 0;
  2143. else if(pBar->IsKindOf(RUNTIME_CLASS(CToolBarEx)) && !((CToolBarEx*)pBar)->IsFlatLook())
  2144. ((CToolBarEx*)pBar)->m_bReal3DBorder = FALSE,
  2145. cxBorder = cyBorder = 2;
  2146. else
  2147. cxBorder = cyBorder = 2;
  2149. if (pBar->IsVisible())
  2150. {
  2151. // get ideal rect for bar
  2152. DWORD dwMode = 0;
  2153. if ((pBar->m_dwStyle & CBRS_SIZE_DYNAMIC) &&
  2154. (pBar->m_dwStyle & CBRS_FLOATING))
  2155. dwMode |= LM_HORZ | LM_MRUWIDTH;
  2156. else if (pBar->m_dwStyle & CBRS_ORIENT_HORZ)
  2157. dwMode |= LM_HORZ | LM_HORZDOCK;
  2158. else
  2159. dwMode |=  LM_VERTDOCK;
  2161. CSize sizeBar = pBar->CalcDynamicLayout(-1, dwMode);
  2163. CRect rect(pt, sizeBar);
  2165. // get current rect for bar
  2166. CRect rectBar;
  2167. pBar->GetWindowRect(&rectBar);
  2168. ScreenToClient(&rectBar);
  2170. if (bHorz)
  2171. {
  2172. // Offset Calculated Rect out to Actual
  2173. if (rectBar.left > rect.left && !m_bFloating)
  2174. rect.OffsetRect(rectBar.left - rect.left, 0);
  2176. // If ControlBar goes off the right, then right justify
  2177. if (rect.right > sizeMax.cx && !m_bFloating)
  2178. {
  2179. int x = rect.Width() - cxBorder;
  2180. x = max(sizeMax.cx - x, pt.x);
  2181. rect.OffsetRect(x - rect.left, 0);
  2182. }
  2184. // If ControlBar has been wrapped, then left justify
  2185. if (bWrapped)
  2186. {
  2187. bWrapped = FALSE;
  2188. rect.OffsetRect(-(rect.left + cxBorder), 0);
  2189. }
  2190. // If ControlBar is completely invisible, then wrap it
  2191. else if ((rect.left >= (sizeMax.cx - cxBorder)) &&
  2192. (nPos > 0) && (m_arrBars[nPos - 1] != NULL))
  2193. {
  2194. m_arrBars.InsertAt(nPos, (CObject*)NULL);
  2195. pBar = NULL; pVoid = NULL;
  2196. bWrapped = TRUE;
  2197. }
  2198. if (!bWrapped)
  2199. {
  2200. if (rect != rectBar)
  2201. {
  2202. if (!m_bLayoutQuery &&
  2203. !(pBar->m_dwStyle & CBRS_FLOATING))
  2204. {
  2205. pBar->m_pDockContext->m_rectMRUDockPos = rect;
  2206. }
  2207. AfxRepositionWindow(&layout, pBar->m_hWnd, &rect);
  2208. }
  2209. pt.x = rect.left + sizeBar.cx - cxBorder;
  2210. nWidth = max(nWidth, sizeBar.cy);
  2211. }
  2212. }
  2213. else
  2214. {
  2215. // Offset Calculated Rect out to Actual
  2216. if (rectBar.top > rect.top && !m_bFloating)
  2217. rect.OffsetRect(0, rectBar.top - rect.top);
  2219. // If ControlBar goes off the bottom, then bottom justify
  2220. if (rect.bottom > sizeMax.cy && !m_bFloating)
  2221. {
  2222. int y = rect.Height() - cyBorder;
  2223. y = max(sizeMax.cy - y, pt.y);
  2224. rect.OffsetRect(0, y - rect.top);
  2225. }
  2227. // If ControlBar has been wrapped, then top justify
  2228. if (bWrapped)
  2229. {
  2230. bWrapped = FALSE;
  2231. rect.OffsetRect(0, -(rect.top + cyBorder));
  2232. }
  2233. // If ControlBar is completely invisible, then wrap it
  2234. else if ((rect.top >= (sizeMax.cy - cyBorder)) &&
  2235. (nPos > 0) && (m_arrBars[nPos - 1] != NULL))
  2236. {
  2237. m_arrBars.InsertAt(nPos, (CObject*)NULL);
  2238. pBar = NULL; pVoid = NULL;
  2239. bWrapped = TRUE;
  2240. }
  2241. if (!bWrapped)
  2242. {
  2243. if (rect != rectBar)
  2244. {
  2245. if (!m_bLayoutQuery &&
  2246. !(pBar->m_dwStyle & CBRS_FLOATING))
  2247. {
  2248. pBar->m_pDockContext->m_rectMRUDockPos = rect;
  2249. }
  2250. AfxRepositionWindow(&layout, pBar->m_hWnd, &rect);
  2251. }
  2252. pt.y = rect.top + sizeBar.cy - cyBorder;
  2253. nWidth = max(nWidth, sizeBar.cx);
  2254. }
  2255. }
  2256. }
  2257. if (!bWrapped)
  2258. {
  2259. // handle any delay/show hide for the bar
  2260. pBar->RecalcDelayShow(&layout);
  2261. }
  2262. }
  2263. if (pBar == NULL && pVoid == NULL && nWidth != 0)
  2264. {
  2265. // end of row because pBar == NULL
  2266. if (bHorz)
  2267. {
  2268. pt.y += nWidth - cyBorder;
  2269. sizeFixed.cx = max(sizeFixed.cx, pt.x);
  2270. sizeFixed.cy = max(sizeFixed.cy, pt.y);
  2271. pt.x = -cxBorder;
  2272. }
  2273. else
  2274. {
  2275. pt.x += nWidth - cxBorder;
  2276. sizeFixed.cx = max(sizeFixed.cx, pt.x);
  2277. sizeFixed.cy = max(sizeFixed.cy, pt.y);
  2278. pt.y = -cyBorder;
  2279. }
  2280. nWidth = 0;
  2281. }
  2282. }
  2283. if (!m_bLayoutQuery)
  2284. {
  2285. // move and resize all the windows at once!
  2286. if (layout.hDWP == NULL || !::EndDeferWindowPos(layout.hDWP))
  2287. TRACE0("Warning: DeferWindowPos failed - low system resources.n");
  2288. }
  2290. // adjust size for borders on the dock bar itself
  2291. CRect rect;
  2292. rect.SetRectEmpty();
  2293. CalcInsideRect(rect, bHorz);
  2295. if ((!bStretch || !bHorz) && sizeFixed.cx != 0)
  2296. sizeFixed.cx += -rect.right + rect.left;
  2297. if ((!bStretch || bHorz) && sizeFixed.cy != 0)
  2298. sizeFixed.cy += -rect.bottom + rect.top;
  2300. return sizeFixed;
  2301. }
  2304. // dwDockBarMap
  2305. const DWORD dwDockBarMap[4][2] =
  2306. {
  2307. { AFX_IDW_DOCKBAR_TOP,      CBRS_TOP    },
  2308. { AFX_IDW_DOCKBAR_BOTTOM,   CBRS_BOTTOM },
  2309. { AFX_IDW_DOCKBAR_LEFT,     CBRS_LEFT   },
  2310. { AFX_IDW_DOCKBAR_RIGHT,    CBRS_RIGHT  },
  2311. };
  2314. // Unfortunataly a simple rewrite of CFrameWnd's EnableDocking() is not possible,
  2315. // because we have not enough permissions to access some data in this class.
  2316. // That's why we call CFrameWnd::EnableDocking() first and exchange all occurencies
  2317. // of CDockBar objects with our own version of a dock bar.
  2318. void FrameEnableDocking(CFrameWnd * pFrame, DWORD dwDockStyle) {
  2319. ASSERT_VALID(pFrame);
  2321. // must be CBRS_ALIGN_XXX or CBRS_FLOAT_MULTI only
  2322. ASSERT((dwDockStyle & ~(CBRS_ALIGN_ANY|CBRS_FLOAT_MULTI)) == 0);
  2324. pFrame->EnableDocking(dwDockStyle);
  2326. for (int i = 0; i < 4; i++) {
  2327. if (dwDockBarMap[i][1] & dwDockStyle & CBRS_ALIGN_ANY) {
  2328. CDockBar* pDock = (CDockBar*)pFrame->GetControlBar(dwDockBarMap[i][0]);
  2330. // make sure the dock bar is of correct type
  2331. if( pDock == 0 || ! pDock->IsKindOf(RUNTIME_CLASS(CToolDockBar)) ) {
  2332. BOOL bNeedDelete = ! pDock->m_bAutoDelete;
  2333. pDock->m_pDockSite->RemoveControlBar(pDock);
  2334. pDock->m_pDockSite = 0; // avoid problems in destroying the dockbar
  2335. pDock->DestroyWindow();
  2336. if( bNeedDelete )
  2337. delete pDock;
  2338. pDock = 0;
  2339. }
  2341. if( pDock == 0 ) {
  2342. pDock = new CToolDockBar;
  2343. if (!pDock->Create(pFrame,
  2344. WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_CHILD|WS_VISIBLE |
  2345. dwDockBarMap[i][1], dwDockBarMap[i][0])) {
  2346. AfxThrowResourceException();
  2347. }
  2348. }
  2349. }
  2350. }
  2351. }