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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 工具条 > 查看源码
Toolbarex.cpp
资源名称：ToolBarEx_demo.zip　[点击查看]
上传用户：shuini
上传日期：2007-02-05
资源大小：103k
文件大小：59k
源码类别：

工具条

开发平台：

Visual C++

Toolbarex.cpp：源码内容
  1. // ToolBarEx.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "ToolBarEx.h"
  7. #ifdef _DEBUG
  8. #define new DEBUG_NEW
  9. #undef THIS_FILE
  10. static char THIS_FILE[] = __FILE__;
  11. #endif
  13. /////////////////////////////////////////////////////////////////////////////
  14. // CToolBarEx
  16. IMPLEMENT_DYNCREATE( CToolBarEx,CToolBar);
  18. //Image sizes
  19. const CSize CToolBarEx::m_szImageSmall( 16, 15 );
  20. const CSize CToolBarEx::m_szImageLarge( 24, 24 );
  22. const TextOptions CToolBarEx:: m_eInitialTextOptions =  toNoTextLabels;
  23. const IconOptions CToolBarEx:: m_eInitialIconOptions =  ioSmallIcons;
  24.   
  27. int CToolBarEx::m_nBarNumber = 0;
  28. CCustomizeDialog*   CToolBarEx::m_pCustomizeDlg = NULL;
  29. HHOOK               CToolBarEx::m_hCBTHook      = NULL;
  32. #define STR_CUSTOMIZE  _T("&Customize...")
  35. // for determining version of COMCTL32.DLL
  36. #define VERSION_WIN4        MAKELONG(0, 4)
  37. #define VERSION_IE3         MAKELONG(70, 4)
  38. #define VERSION_IE4         MAKELONG(71, 4)
  39. #define VERSION_IE401       MAKELONG(72, 4)
  40. #define VERSION_IE5 MAKELONG(80, 5)
  41. #define VERSION_IE5_2000    MAKELONG(81, 5)
  43. struct AFX_DLLVERSIONINFO
  44. {
  45. DWORD cbSize;
  46. DWORD dwMajorVersion;                   // Major version
  47. DWORD dwMinorVersion;                   // Minor version
  48. DWORD dwBuildNumber;                    // Build number
  49. DWORD dwPlatformID;                     // DLLVER_PLATFORM_*
  50. };
  52. typedef HRESULT (CALLBACK* AFX_DLLGETVERSIONPROC)(AFX_DLLVERSIONINFO *);
  54. static int _ComCtlVersion = -1;
  56. static DWORD AFXAPI _GetComCtlVersion()
  57. {
  58. // return cached version if already determined...
  59. if (_ComCtlVersion != -1)
  60. return _ComCtlVersion;
  62. // otherwise determine comctl32.dll version via DllGetVersion
  63. HINSTANCE hInst = ::GetModuleHandleA("COMCTL32.DLL");
  64. ASSERT(hInst != NULL);
  65. AFX_DLLGETVERSIONPROC pfn;
  66. pfn = (AFX_DLLGETVERSIONPROC)GetProcAddress(hInst, "DllGetVersion");
  67. DWORD dwVersion = VERSION_WIN4;
  68. if (pfn != NULL)
  69. {
  70. AFX_DLLVERSIONINFO dvi;
  71. memset(&dvi, 0, sizeof(dvi));
  72. dvi.cbSize = sizeof(dvi);
  73. HRESULT hr = (*pfn)(&dvi);
  74. if (SUCCEEDED(hr))
  75. {
  76. ASSERT(dvi.dwMajorVersion <= 0xFFFF);
  77. ASSERT(dvi.dwMinorVersion <= 0xFFFF);
  78. dwVersion = MAKELONG(dvi.dwMinorVersion, dvi.dwMajorVersion);
  79. }
  81. TRACE(_T("Using CommCtl32.dll Ver:%d.%d.%dn"),dvi.dwMajorVersion,dvi.dwMinorVersion,dvi.dwBuildNumber);
  83. }
  84. _ComCtlVersion = dwVersion;
  85. return dwVersion;
  86. }
  89. CToolBarEx::CToolBarEx()
  90. {
  91. m_pControls  = NULL;
  92. m_pDropButtons  = NULL; // list of drop-down buttons
  93. // m_bShowDropdownArrowWhenVertical = FALSE;
  94. m_bHideChildWndOnVertical=TRUE;
  96. m_clrBtnHilight=::GetSysColor(COLOR_BTNHILIGHT);
  97. m_clrBtnShadow=::GetSysColor(COLOR_BTNSHADOW);
  98. m_clrBtnFace  = ::GetSysColor(COLOR_BTNFACE);
  100. ++m_nBarNumber; //Increase the Bar number
  102. CWinApp  *pApp = AfxGetApp();
  103. ASSERT_VALID(pApp);
  104. m_strValueName.Format( _T("ToolBarEx%d"), m_nBarNumber );
  105. m_strSubKey.Format( _T("Software\%s\%s\Settings"),
  106. pApp->m_pszRegistryKey, pApp->m_pszProfileName );
  108.     m_eTextOptions = toNone;    // no options selected yet
  109.     m_eIconOptions = ioNone;    // no options selected yet
  111. m_nResButtons=0;
  113. }
  115. CToolBarEx::~CToolBarEx()
  116. {
  117. while (m_pDropButtons)
  118. {
  119. CDropDownButtonInfo* pnext = m_pDropButtons->pNext;
  120. delete m_pDropButtons;
  121. m_pDropButtons = pnext;
  122. }
  124. if( m_pControls ) 
  125. {
  126. for( POSITION pos = m_pControls->GetHeadPosition() ; pos ; ) 
  127. {
  128. delete m_pControls->GetNext(pos);
  129. }
  131. delete m_pControls;
  132. }
  134. }
  137. BEGIN_MESSAGE_MAP(CToolBarEx, CToolBar)
  138. //{{AFX_MSG_MAP(CToolBarEx)
  139. ON_WM_CREATE()
  140. ON_WM_PAINT()
  141. ON_WM_SYSCOLORCHANGE()
  142. ON_WM_CONTEXTMENU()
  143. ON_WM_NCPAINT()
  144. //}}AFX_MSG_MAP
  145. ON_NOTIFY_REFLECT_EX(TBN_DROPDOWN,  OnToolBarBtnDropDown)
  146. ON_NOTIFY_REFLECT(TBN_BEGINADJUST,  OnToolBarBeginAdjust)
  147. ON_NOTIFY_REFLECT(TBN_CUSTHELP,  OnToolBarCustomHelp)
  148. ON_NOTIFY_REFLECT(TBN_ENDADJUST,  OnToolBarEndAdjust)
  149. ON_NOTIFY_REFLECT(TBN_GETBUTTONINFO, OnToolBarGetButtonInfo)
  150. ON_NOTIFY_REFLECT(TBN_QUERYDELETE,  OnToolBarQueryDelete)
  151. ON_NOTIFY_REFLECT(TBN_QUERYINSERT,  OnToolBarQueryInsert)
  152. ON_NOTIFY_REFLECT(TBN_RESET,  OnToolBarReset)
  153. ON_NOTIFY_REFLECT(TBN_TOOLBARCHANGE, OnToolBarChange)
  154. ON_MESSAGE(TB_CUSTOMIZE, OnCustomize)
  155.     ON_NOTIFY_REFLECT( TBN_INITCUSTOMIZE, OnInitCustomize )
  156.  //   ON_NOTIFY_REFLECT( NM_CUSTOMDRAW , OnCustomDraw)
  158.     // Saving and restoring toolbar
  159.     ON_NOTIFY_REFLECT( TBN_SAVE, OnSave )
  160.     ON_NOTIFY_REFLECT( TBN_RESTORE, OnRestore )
  161. END_MESSAGE_MAP()
  164. /////////////////////////////////////////////////////////////////////////////
  165. // CToolBarEx message handlers
  167. //////////////////////////////////////////////////////////////////////
  168. // 1999 Kirk Stowell - Inserts a control into the toolbar at the given button id.
  169. //
  170. CWnd* CToolBarEx::InsertControl( CRuntimeClass* pClass, LPCTSTR lpszWindowName, CRect& rect, UINT nID, DWORD dwStyle )
  171. {
  172. CWnd *pCtrl = NULL;
  174. if( pClass->IsDerivedFrom( RUNTIME_CLASS( CComboBox ))) // CComboBox control.
  175. {
  176. pCtrl = new CComboBox;
  178. ASSERT_VALID( pCtrl );
  180. if(((CComboBox*)pCtrl)->Create( WS_CHILD|WS_VISIBLE|dwStyle, rect, this, nID ) == FALSE )
  181. {
  182. delete pCtrl;
  183. return NULL;
  184. }
  185. }
  186. else if( pClass->IsDerivedFrom( RUNTIME_CLASS( CEdit ))) // CEdit control.
  187. {
  188. pCtrl = new CEdit;
  190. ASSERT_VALID( pCtrl );
  192. if(((CEdit*)pCtrl)->Create( WS_CHILD|WS_VISIBLE|dwStyle, rect, this, nID ) == FALSE )
  193. {
  194. delete pCtrl;
  195. return NULL;
  196. }
  197. }
  198. else if( pClass->IsDerivedFrom( RUNTIME_CLASS( CButton ))) // CButton control.
  199. {
  200. pCtrl = new CButton;
  202. ASSERT_VALID( pCtrl );
  204. if(((CButton*)pCtrl)->Create( lpszWindowName, WS_CHILD|WS_VISIBLE|dwStyle, rect, this, nID ) == FALSE )
  205. {
  206. delete pCtrl;
  207. return NULL;
  208. }
  209. }
  210. else if( pClass->IsDerivedFrom( RUNTIME_CLASS( CWnd ))) // CWnd object.
  211. {
  212. pCtrl = new CWnd;
  214. ASSERT_VALID( pCtrl );
  216. #ifdef _UNICODE
  217. TCHAR szClassName[ 256 ];
  219. MultiByteToWideChar( CP_ACP,
  220.  MB_PRECOMPOSED,
  221.  pClass->m_lpszClassName,
  222.  -1,
  223.  szClassName,
  224.  255 );
  226. if(((CWnd*)pCtrl)->Create( szClassName, lpszWindowName, WS_CHILD|WS_VISIBLE|dwStyle, rect, this, nID ) == FALSE )
  227. {
  228. delete pCtrl;
  229. return NULL;
  230. }
  231. #else
  232. if(((CWnd*)pCtrl)->Create( pClass->m_lpszClassName, lpszWindowName, WS_CHILD|WS_VISIBLE|dwStyle, rect, this, nID ) == FALSE )
  233. {
  234. delete pCtrl;
  235. return NULL;
  236. }
  237. #endif
  238. }
  239. else // An invalid object was passed in
  240. {
  241. ASSERT( FALSE );
  242. return NULL;
  243. }
  245. // if our object list has not been allocated, do it now...
  246. if( m_pControls == NULL )
  247. {
  248. m_pControls = new CObList();
  249. ASSERT( m_pControls );
  250. }
  252. // we have to remember this control, so we can delete it later
  253. m_pControls->AddTail( pCtrl );
  255. return InsertControl( pCtrl, rect, nID );
  256. }
  258. CWnd* CToolBarEx::InsertControl(CWnd* pCtrl, CRect & rect, UINT nID)
  259. {
  260. ASSERT_VALID( pCtrl );
  261. ASSERT(IsWindow(pCtrl->m_hWnd));
  263. // make sure the id is valid, and set the button 
  264. // style for a seperator.
  265. int nIndex = CommandToIndex( nID ) ;
  266. if (nIndex>-1)
  267. {
  268. ASSERT( nIndex >= 0 );
  269. SetButtonInfo( nIndex, nID, TBBS_SEPARATOR, rect.Width());
  270. // insert the control into the toolbar.
  271. GetItemRect( nIndex, &rect );
  272. CRect rt;
  273. pCtrl->GetWindowRect(&rt);
  274. rect.top+=max((rect.Height()-rt.Height())/2,0);  //move to middle
  275. pCtrl->SetWindowPos(0, rect.left, rect.top, 0, 0,
  276. SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOCOPYBITS );
  277. pCtrl->SetFont( GetFont( ));
  279. BOOL bVert =  IsVertDocked(); //(m_dwStyle & CBRS_ORIENT_VERT) != 0;
  281. if (bVert && m_bHideChildWndOnVertical)
  282. {
  283.     int nState=GetToolBarCtrl().GetState(nIndex);
  284.     GetToolBarCtrl().SetState(nID,(nState | TBSTATE_HIDDEN));
  285. pCtrl->ShowWindow( SW_HIDE );
  286. }
  287. else
  288. {
  289.     int nState=GetToolBarCtrl().GetState(nIndex);
  290.     GetToolBarCtrl().SetState(nIndex,(nState & ~TBSTATE_HIDDEN));
  291. pCtrl->ShowWindow( SW_SHOW );
  292. }
  294. }
  295. else
  296. {
  297. pCtrl->ShowWindow( SW_HIDE);
  298. }
  300. ModifyStyle(0,WS_CLIPCHILDREN);
  301. return pCtrl;
  302. }
  304. BOOL CToolBarEx::AddDropDownButton(UINT nIDButton, UINT nIDMenu,BOOL bArrow)
  305. {
  306. ASSERT_VALID(this);
  308. CDropDownButtonInfo* pb = FindDropDownButtonInfo(nIDButton);
  310. if (!pb) 
  311. {
  312. pb = new CDropDownButtonInfo;
  313. ASSERT(pb);
  314. pb->pNext = m_pDropButtons;
  315. m_pDropButtons = pb;
  316. }
  318. pb->idButton = nIDButton;
  319. pb->idMenu   = nIDMenu;
  321.    return SetDropDownButton(nIDButton,bArrow);
  322. }
  324. CToolBarEx::CDropDownButtonInfo* CToolBarEx::FindDropDownButtonInfo(UINT nID)
  325. {
  326. for (CDropDownButtonInfo* pb = m_pDropButtons; pb; pb = pb->pNext) 
  327. {
  328. if (pb->idButton == nID)
  329. return pb;
  330. }
  331. return NULL;
  332. }
  334. BOOL CToolBarEx::OnToolBarBtnDropDown(NMHDR* pNMHDR, LRESULT* pRes)
  335. {
  336. UNUSED_ALWAYS( pRes );
  338. const NMTOOLBAR& nmtb = *(NMTOOLBAR*)pNMHDR;
  339.   
  340. // get location of button
  341. CRect rc;
  342. GetToolBarCtrl().GetRect(nmtb.iItem, rc);
  343. ClientToScreen(&rc);
  345. // call virtual function to display dropdown menu
  346. return OnDropDownButtonInfo(nmtb, nmtb.iItem, rc);
  347. }
  349. BOOL CToolBarEx::OnDropDownButtonInfo(const NMTOOLBAR& nmtb, UINT nID, CRect rc)
  350. {
  351. UNUSED_ALWAYS( nID );
  353. CDropDownButtonInfo* pb = FindDropDownButtonInfo(nmtb.iItem);
  354. if (pb && pb->idMenu) 
  355. {
  357. // load and display popup menu
  358. CMenu menu;
  359. VERIFY(menu.LoadMenu(pb->idMenu));
  360. CMenu* pPopup = (CMenu*)menu.GetSubMenu(0);
  361. ASSERT(pPopup);
  362. pPopup->TrackPopupMenu(TPM_LEFTALIGN|TPM_LEFTBUTTON|TPM_VERTICAL,
  363. rc.left, rc.bottom, AfxGetMainWnd(), &rc);
  364. return TRUE;
  365. }
  367. return FALSE;
  368. }
  371. // This function saves the state (visible buttons, toolbar position, etc.)
  372. // of the toolbar, using the registry key provided to the Create(...) function.
  373. void CToolBarEx::SaveState()
  374. {
  375. // if there is an associated registry subkey
  376. if (m_strSubKey.GetLength())
  377. {
  378. // save the toolbar state to the registry
  379. GetToolBarCtrl().SaveState( HKEY_CURRENT_USER, m_strSubKey, m_strValueName );
  380. }
  381. }
  383. // This function restores the state (visible buttons, toolbar position, etc.)
  384. // of the toolbar, using the registry key provided to the Create(...) function.
  385. void CToolBarEx::RestoreState()
  386. {
  387. IconOptions eIconOptions=GetIconOptions();
  388. TextOptions eTextOptions=GetTextOptions();
  390. // if there is an associated registry subkey
  391. if (m_strSubKey.GetLength())
  392. {
  393. // restore the toolbar state from the registry
  394. GetToolBarCtrl().RestoreState( HKEY_CURRENT_USER, m_strSubKey, m_strValueName );
  395. }
  397. //Set Icon/Text options if changed
  398. if (eTextOptions!=GetTextOptions()) SetTextOptions(GetTextOptions(),TRUE);
  399. if (eIconOptions!=GetIconOptions()) SetIconOptions(GetIconOptions(),TRUE);
  401. }
  403. // This function is called when the user begins dragging a toolbar
  404. // button or when the customization dialog is being populated with
  405. // toolbar information.  Basically, *pResult should be populated with
  406. // your answer to the question, "is the user allowed to delete this
  407. // button?".
  408. void CToolBarEx::OnToolBarQueryDelete(NMHDR *pNMHDR, LRESULT *pResult)
  409. {
  410. UNUSED_ALWAYS( pNMHDR );
  412. NMTOOLBAR * tbStruct=(TBNOTIFY *)pNMHDR;
  415. ASSERT(tbStruct);
  416. // do not allow hidden button to be deleted as they just do not go
  417. // to the Add listbox.
  418. if ((tbStruct->tbButton.idCommand) && 
  419. GetToolBarCtrl().IsButtonHidden(tbStruct->tbButton.idCommand))
  420. *pResult = FALSE;
  421. else  
  422. *pResult = TRUE;  
  424. }
  426. // This function is called when the user begins dragging a toolbar
  427. // button or when the customization dialog is being populated with
  428. // toolbar information.  Basically, *pResult should be populated with
  429. // your answer to the question, "is the user allowed to insert a
  430. // button to the left of this one?".
  431. void CToolBarEx::OnToolBarQueryInsert(NMHDR *pNMHDR, LRESULT *pResult)
  432. {
  433. UNUSED_ALWAYS( pNMHDR );
  434. *pResult = TRUE;
  437. }
  439. // This function is called whenever the user makes a change to the
  440. // layout of the toolbar.  Calling the mainframe's RecalcLayout forces
  441. // the toolbar to repaint itself.
  442. void CToolBarEx::OnToolBarChange(NMHDR *pNMHDR, LRESULT *pResult)
  443. {
  444. UNUSED_ALWAYS( pNMHDR );
  445. UNUSED_ALWAYS( pResult );
  448. SetTextOptions(m_eTextOptions,FALSE);
  449. PositionControls();
  451. // force the frame window to recalculate the size
  452. GetParentFrame()->RecalcLayout();
  453. OnIdleUpdateCmdUI(TRUE, 0L);
  455. }
  458. // This function is called when the user initially calls up the toolbar
  459. // customization dialog box.
  460. void CToolBarEx::OnToolBarBeginAdjust(NMHDR *pNMHDR, LRESULT *pResult)
  461. {
  462. UNUSED_ALWAYS( pNMHDR );
  463. UNUSED_ALWAYS( pResult );
  466.     *pResult = 0;
  468. }
  470. LRESULT CToolBarEx::OnCustomize(WPARAM,LPARAM)
  471. {
  472. LONG lResult;
  474. ASSERT(m_pCustomizeDlg==NULL);
  475.     m_pCustomizeDlg = new CCustomizeDialog( this, m_eTextOptions, m_eIconOptions );
  476.     m_hCBTHook = ::SetWindowsHookEx( WH_CBT, CBTProc, 0, ::GetCurrentThreadId() );
  477.     ASSERT( m_hCBTHook != 0 );
  478.  
  479.     lResult = Default();
  481.     VERIFY( ::UnhookWindowsHookEx( m_hCBTHook ) );
  482.     m_hCBTHook = 0;
  484.  // if custom draw is not done then update Icon Draw at end
  485.  if (GetIconOptions()!=m_pCustomizeDlg->GetIconOptions())
  486. SetIconOptions(m_pCustomizeDlg->GetIconOptions(),TRUE);
  488.     delete m_pCustomizeDlg;
  489.     m_pCustomizeDlg = NULL;
  491. SaveState();
  492. ASSERT(m_pCustomizeDlg==NULL);
  494. return  lResult;
  496. }
  498. // This function is called when the user clicks on the help button on the
  499. // toolbar customization dialog box.
  500. void CToolBarEx::OnToolBarCustomHelp(NMHDR *pNMHDR, LRESULT *pResult)
  501. {
  502. UNUSED_ALWAYS( pNMHDR );
  503. UNUSED_ALWAYS( pResult );
  505. TRACE(_T("Help on Customize Toolbar called.n"));
  506. }
  508. // This function is called when the user dismisses the toolbar customization
  509. // dialog box.
  510. void CToolBarEx::OnToolBarEndAdjust(NMHDR *pNMHDR, LRESULT *pResult)
  511. {
  512. UNUSED_ALWAYS( pNMHDR );
  513. UNUSED_ALWAYS( pResult );
  515. }
  517. // This function is called to populate the toolbar customization dialog box
  518. // with information regarding all of the possible toolbar buttons.
  519. void CToolBarEx::OnToolBarGetButtonInfo(NMHDR *pNMHDR, LRESULT *pResult)
  520. {
  521. UNUSED_ALWAYS( pResult );
  523. TBNOTIFY* tbStruct; // data needed by customize dialog box
  525. // init the pointer
  526. tbStruct = (TBNOTIFY *)pNMHDR;
  528. // if the index is valid
  529. if ((0 <= tbStruct->iItem) && (tbStruct->iItem < m_ToolBarInfo.GetSize()))
  530. {
  531. // copy the stored button structure
  532. tbStruct->tbButton = m_ToolBarInfo[tbStruct->iItem].tbButton;
  534. // copy the text for the button label in the dialog
  535. _tcscpy(tbStruct->pszText, m_ToolBarInfo[tbStruct->iItem].btnText);
  537. // indicate valid data was sent
  538. *pResult = TRUE;
  539. }
  540. else   // else there is no button for this index
  541. {
  542. *pResult = FALSE;
  543. }
  544. }
  546. // This function is called when the user clicks on the reset button on the
  547. // toolbar customization dialog box.
  548. void CToolBarEx::OnToolBarReset(NMHDR *pNMHDR, LRESULT *pResult)
  549. {
  550. UNUSED_ALWAYS( pNMHDR );
  551. UNUSED_ALWAYS( pResult );
  554.       int         nCount, i;
  555.   CToolBarCtrl &  tbCtrl =GetToolBarCtrl();
  557.       // Remove all of the existing buttons 
  558.       nCount = tbCtrl.GetButtonCount();
  560.       for(i = nCount - 1; i >= 0; i--)
  561.  tbCtrl.DeleteButton(i);
  562.       
  563.       // Restore the buttons that were saved.
  564.   for (i=0;i<m_ToolBarInfo.GetSize();i++)
  565.   {
  566.   if (m_ToolBarInfo[i].bInitiallyVisible)
  567.  tbCtrl.AddButtons(1,&m_ToolBarInfo[i].tbButton);
  568.   }
  570. if (m_pCustomizeDlg)
  571. {
  572.    ASSERT_VALID(m_pCustomizeDlg);
  573.    m_pCustomizeDlg->SetTextOptions(m_eInitialTextOptions);
  574.    m_pCustomizeDlg->SetIconOptions(m_eInitialIconOptions);
  575. }
  578. SetTextOptions(m_eInitialTextOptions); //Default Values
  582. PositionControls();
  584. // force the frame window to recalculate the size
  585. GetParentFrame()->RecalcLayout();
  586. OnIdleUpdateCmdUI(TRUE, 0L);
  589. *pResult = TRUE;
  590. }
  594. void CToolBarEx::SetToolBarInfoForCustomization(const CToolBarEx::ToolBarInfoArray * pAdditional)
  595. {
  596.  m_ToolBarInfo.RemoveAll();
  597.  const int nCount = GetToolBarCtrl().GetButtonCount();
  598.  m_ToolBarInfo.SetSize(nCount); //SetSize
  601.  CToolBarCtrl & tbCtrl = GetToolBarCtrl();
  603.  for (int i=0;i<nCount;i++)
  604.  {
  605. CToolBarButtonInfo tbButtonInfo;
  607. tbCtrl.GetButton(i,&tbButtonInfo.tbButton);
  608. CString str;
  609. str.LoadString(tbButtonInfo.tbButton.idCommand);
  611. int nPos= str.ReverseFind(_T('n'));
  612. tbButtonInfo.btnText=str.Right(str.GetLength()-nPos-1);
  613. tbButtonInfo.bInitiallyVisible=TRUE;
  615. m_ToolBarInfo.SetAt(i,tbButtonInfo);
  618.  }
  620. m_nResButtons =m_ToolBarInfo.GetSize();
  622.  // add the addiotnal buttons
  623.  if (pAdditional)
  624.  {
  625.    ASSERT_VALID(pAdditional);
  626.    m_ToolBarInfo.Append(*pAdditional);
  627.  }
  629. m_ToolBarInfo.FreeExtra();
  632. ModifyStyle(0, CCS_ADJUSTABLE);
  634. SetTextOptions(m_eInitialTextOptions); //Default Values
  635. SetIconOptions(m_eInitialIconOptions);   //Default Values 
  638. }
  640. /////////////////////////////////////////////////////////////////////////////////////////
  641. // Overrides 
  643. int CToolBarEx::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  644. {
  645. if (CToolBar::OnCreate(lpCreateStruct) == -1)
  646. return -1;
  648. _GetComCtlVersion();
  649. ASSERT(_ComCtlVersion>=VERSION_IE5);
  651. //set version
  652. // int nVer=5;
  653. // DefWindowProc(CCM_SETVERSION,nVer,0);
  654. // ASSERT(nVer==DefWindowProc(CCM_GETVERSION,nVer,0));
  656. return 0;
  657. }
  660. void CToolBarEx::PositionControls()
  661. {
  662. GetToolBarCtrl().AutoSize();
  663. m_bDelayedButtonLayout=TRUE;
  664. }
  667. // the all important function
  668. CSize CToolBarEx::GetButtonSize(TBBUTTON* pData, int iButton, DWORD dwMode)
  669. {
  670. ASSERT(_ComCtlVersion > 0);
  672. // Get the actual size of the button, not what's in m_sizeButton.
  673. // Make sure to do SendMessage instead of calling MFC's GetItemRect,
  674. // which has all sorts of bad side-effects!
  675. // 
  676. CRect rc;
  677. SendMessage(TB_GETITEMRECT, iButton, (LPARAM)&rc);
  678. CSize sz = rc.Size();
  680. DWORD dwStyle = pData[iButton].fsStyle;
  681. BOOL bVertDocked= (!(dwMode&LM_HORZ) && !(dwMode&LM_STRETCH) ) ;
  683. // do not allow sepearot to be greater than Button height ( Have to check this)
  684. if (dwStyle & TBSTYLE_SEP)
  685. sz.cy = min(sz.cy ,HIWORD(GetToolBarCtrl().GetButtonSize()));
  689. // special cas  for custom controls
  690. if (m_bHideChildWndOnVertical)
  691. {
  692. if ((dwStyle & TBSTYLE_SEP) && 
  693. (pData[iButton].idCommand!=0))
  694. {
  696. if (bVertDocked)
  697. {
  698. sz.cx=sz.cy=0;
  699. }
  700. else
  701. {
  702.     // we will get 0,0 on hidden things
  703. if (GetToolBarCtrl().IsButtonHidden(pData[iButton].idCommand))
  704. {
  705.    CWnd * pWnd =GetDlgItem(pData[iButton].idCommand);
  707. ASSERT_VALID(pWnd);
  708. CRect rt;
  709. pWnd->GetWindowRect(rt);
  710. sz=rt.Size();
  711. }
  713. }
  714. }
  715. }  
  716. ////////////////
  717. // Now must do special case for various versions of comctl32.dll,
  718. //
  719. if ((pData[iButton].fsState & TBSTATE_WRAP)) 
  720. {
  721. if (dwStyle & TBSTYLE_SEP) 
  722. {
  723. CWnd *pWnd =GetDlgItem(pData[iButton].idCommand);
  725. // Check seperator is child window
  726. if (!pWnd)
  727. {
  728. // this is the last separator in the row (eg vertically docked)
  729. // fudge the height, and ignore the width. TB_GETITEMRECT will return
  730. // size = (8 x 22) even for a separator in vertical toolbar
  731. //
  732. if (_ComCtlVersion <= VERSION_IE3)
  733. sz.cy -= 3; // empircally good fudge factor
  734. else if (_ComCtlVersion != VERSION_IE4)
  735. sz.cy = sz.cx;
  737. sz.cx = 0; // separator takes no width if it's the last one
  738. }
  739. else
  740. {
  741.   // Do not set value in case of the child window
  742.   //WE should never get here 
  743.   ASSERT_VALID(pWnd);
  744.   ASSERT(FALSE);
  745. }
  747. } 
  750. }
  751. //  // drop down arrow check
  752. //  if ((dwStyle & TBSTYLE_DROPDOWN) && 
  753. //   (bVertDocked) &&
  754. //    !m_bShowDropdownArrowWhenVertical ) 
  755. //  {
  756. // // ignore width of dropdown
  757. // sz.cx = sz.cy;
  758. //  }
  760. return sz;
  761. }
  765. ////////////////////////////////////////////////////////////
  767. #define CX_OVERLAP  0
  769. CSize CToolBarEx::CalcSize(TBBUTTON* pData, int nCount,DWORD dwMode)
  770. {
  771. ASSERT(pData != NULL && nCount > 0);
  773. CPoint cur(0,0);
  774. CSize sizeResult(0,0);
  775. int cyTallestOnRow = 0;
  776. int nButtons=0;
  779. for (int i = 0; i < nCount; i++)
  780. {
  782. // also calculate for hidden custom controls
  783. if (  (pData[i].fsState & TBSTATE_HIDDEN)  &&
  784. !((pData[i].fsStyle & TBSTYLE_SEP) && (pData[i].idCommand!=0)))
  785. continue;
  787. // Load actual size of button into a local variable
  788. //
  789. CSize m_sizeButton = GetButtonSize(pData, i,dwMode);
  792. //  changed the logic below to be more correct.
  793. cyTallestOnRow = max(cyTallestOnRow, m_sizeButton.cy);
  794. sizeResult.cx = max(cur.x + m_sizeButton.cx, sizeResult.cx);
  795. sizeResult.cy = max(cur.y + m_sizeButton.cy, sizeResult.cy);
  797. cur.x += m_sizeButton.cx - CX_OVERLAP;
  798. if (!(pData[i].fsState & TBSTATE_HIDDEN)) nButtons++;
  800. if (pData[i].fsState & TBSTATE_WRAP)
  801. {
  802. //only seperator is present
  803. if ((nButtons==1) && (pData[i].fsStyle & TBSTYLE_SEP))
  804. {
  805. cyTallestOnRow = HIWORD(GetToolBarCtrl().GetButtonSize());
  806. }
  808. cur.x = 0;
  809. cur.y += cyTallestOnRow;
  810. cyTallestOnRow = 0;
  811. if (pData[i].fsStyle & TBSTYLE_SEP)
  812. cur.y += m_sizeButton.cy;
  813.  nButtons=0;
  814. }
  816. }
  817. return sizeResult;
  818. }
  820. int CToolBarEx::WrapToolBar(TBBUTTON* pData, int nCount, int nWidth, DWORD dwMode)
  821. {
  822. ASSERT(pData != NULL && nCount > 0);
  824. int nResult = 0;
  825. int x = 0;
  826. for (int i = 0; i < nCount; i++)
  827. {
  828. pData[i].fsState &= ~TBSTATE_WRAP;
  830. // also calculate for hidden custom controls
  831. if (  (pData[i].fsState & TBSTATE_HIDDEN)  &&
  832. !((pData[i].fsStyle & TBSTYLE_SEP) && (pData[i].idCommand!=0)))
  833. continue;
  835. int dx, dxNext;
  837. // Load actual size of button into a local variable
  838. CSize m_sizeButton = GetButtonSize(pData, i,dwMode);
  840. dx = m_sizeButton.cx;
  841. dxNext = dx - CX_OVERLAP;
  843. if (x + dx > nWidth)
  844. {
  845. BOOL bFound = FALSE;
  846. for (int j = i; j >= 0  &&  !(pData[j].fsState & TBSTATE_WRAP); j--)
  847. {
  848. // Find last separator that isn't hidden
  849. // a separator that has a command ID is not
  850. // a separator, but a custom control.
  851. if ((pData[j].fsStyle & TBSTYLE_SEP) &&
  852. (pData[j].idCommand == 0)
  853. && !(pData[j].fsState & TBSTATE_HIDDEN))
  854. {
  855. bFound = TRUE; i = j; x = 0;
  856. pData[j].fsState |= TBSTATE_WRAP;
  857. nResult++;
  858. break;
  859. }
  860. }
  861. if (!bFound)
  862. {
  863. for (int j = i - 1; j >= 0 && !(pData[j].fsState & TBSTATE_WRAP); j--)
  864. {
  865. // Never wrap anything that is hidden,
  866. // or any custom controls
  867. if ((pData[j].fsState & TBSTATE_HIDDEN) ||
  868. ((pData[j].fsStyle & TBSTYLE_SEP) &&
  869. (pData[j].idCommand != 0)))
  870. continue;
  872. bFound = TRUE; i = j; x = 0;
  873. pData[j].fsState |= TBSTATE_WRAP;
  874. nResult++;
  875. break;
  876. }
  877. if (!bFound)
  878. x += dxNext;
  879. }
  880. }
  881. else
  882. x += dxNext;
  883. }
  884. return nResult + 1;
  885. }
  887. /////////////////////////////////////////////////////////////////////////////////////////////
  889. void CToolBarEx::SizeToolBar(TBBUTTON* pData, int nCount, int nLength, BOOL bVert, DWORD dwMode)
  890. {
  891. ASSERT(pData != NULL && nCount > 0);
  893. if (!bVert)
  894. {
  895. int nMin, nMax, nTarget, nCurrent, nMid;
  897. // Wrap ToolBar as specified
  898. nMax = nLength;
  899. nTarget = WrapToolBar(pData, nCount, nMax,dwMode);
  901. // Wrap ToolBar vertically
  902. nMin = 0;
  903. nCurrent = WrapToolBar(pData, nCount, nMin,dwMode);
  905. if (nCurrent != nTarget)
  906. {
  907. while (nMin < nMax)
  908. {
  909. nMid = (nMin + nMax) / 2;
  910. nCurrent = WrapToolBar(pData, nCount, nMid,dwMode);
  912. if (nCurrent == nTarget)
  913. nMax = nMid;
  914. else
  915. {
  916. if (nMin == nMid)
  917. {
  918. WrapToolBar(pData, nCount, nMax,dwMode);
  919. break;
  920. }
  921. nMin = nMid;
  922. }
  923. }
  924. }
  925. CSize size = CalcSize(pData, nCount,dwMode);
  926. WrapToolBar(pData, nCount, size.cx,dwMode);
  927. }
  928. else
  929. {
  930. CSize sizeMax, sizeMin, sizeMid;
  932. // Wrap ToolBar vertically
  933. WrapToolBar(pData, nCount, 0,dwMode);
  934. sizeMin = CalcSize(pData, nCount,dwMode);
  936. // Wrap ToolBar horizontally
  937. WrapToolBar(pData, nCount, 32767,dwMode);
  938. sizeMax = CalcSize(pData, nCount,dwMode);
  940. while (sizeMin.cx < sizeMax.cx)
  941. {
  942. sizeMid.cx = (sizeMin.cx + sizeMax.cx) / 2;
  943. WrapToolBar(pData, nCount, sizeMid.cx,dwMode);
  944. sizeMid = CalcSize(pData, nCount,dwMode);
  946. if (nLength < sizeMid.cy)
  947. {
  948. if (sizeMin == sizeMid)
  949. {
  950. WrapToolBar(pData, nCount, sizeMax.cx,dwMode);
  951. return;
  952. }
  953. sizeMin = sizeMid;
  954. }
  955. else if (nLength > sizeMid.cy)
  956. {
  957. if (sizeMax == sizeMid)
  958. {
  959. WrapToolBar(pData, nCount, sizeMin.cx,dwMode);
  960. return;
  961. }
  962. sizeMax = sizeMid;
  963. }
  964. else
  965. return;
  966. }
  967. }
  968. }
  971. CSize CToolBarEx::CalcLayout(DWORD dwMode, int nLength)
  972. {
  973. ASSERT_VALID(this);
  974. ASSERT(::IsWindow(m_hWnd));
  975. if (dwMode & LM_HORZDOCK)
  976. ASSERT(dwMode & LM_HORZ);
  978. int nCount;
  979. TBBUTTON* pData = NULL;
  980. CSize sizeResult(0,0);
  982. //BLOCK: Load Buttons
  983. {
  984. nCount = DefWindowProc(TB_BUTTONCOUNT, 0, 0);
  985. if (nCount != 0)
  986. {
  987. int i;
  988. pData = new TBBUTTON[nCount];
  989. for (i = 0; i < nCount; i++)
  990. _GetButton(i, &pData[i]);
  991. }
  992. }
  994. if (nCount > 0)
  995. {
  996. if (!(m_dwStyle & CBRS_SIZE_FIXED))
  997. {
  998. BOOL bDynamic = m_dwStyle & CBRS_SIZE_DYNAMIC;
  1000. if (bDynamic && (dwMode & LM_MRUWIDTH))
  1001. SizeToolBar(pData, nCount, m_nMRUWidth,FALSE,dwMode);
  1002. else if (bDynamic && (dwMode & LM_HORZDOCK))
  1003. SizeToolBar(pData, nCount, 32767,FALSE,dwMode);
  1004. else if (bDynamic && (dwMode & LM_VERTDOCK))
  1005. SizeToolBar(pData, nCount, 0,FALSE,dwMode);
  1006. else if (bDynamic && (nLength != -1))
  1007. {
  1008. CRect rect; rect.SetRectEmpty();
  1009. CalcInsideRect(rect, (dwMode & LM_HORZ));
  1010. BOOL bVert = (dwMode & LM_LENGTHY);
  1011. int nLen = nLength + (bVert ? rect.Height() : rect.Width());
  1013. SizeToolBar(pData, nCount, nLen, bVert,dwMode);
  1014. }
  1015. else if (bDynamic && (m_dwStyle & CBRS_FLOATING))
  1016. SizeToolBar(pData, nCount, m_nMRUWidth,FALSE,dwMode);
  1017. else
  1018. SizeToolBar(pData, nCount, (dwMode & LM_HORZ) ? 32767 : 0,FALSE,dwMode);
  1019. }
  1021. sizeResult = CalcSize(pData, nCount,dwMode);
  1023. if (dwMode & LM_COMMIT)
  1024. {
  1025. int nControlCount = 0;
  1026. BOOL bIsDelayed = m_bDelayedButtonLayout;
  1027. m_bDelayedButtonLayout = FALSE;
  1028. BOOL bVert = (m_dwStyle & CBRS_ORIENT_VERT) != 0;
  1031. for (int i = 0; i < nCount; i++)
  1032. if ((pData[i].fsStyle & TBSTYLE_SEP) && (pData[i].idCommand != 0))
  1033. nControlCount++;
  1036. if (nControlCount > 0)
  1037. {
  1039. for(int i = 0; i < nCount; i++)
  1040. {
  1041. if ((pData[i].fsStyle & TBSTYLE_SEP) && (pData[i].idCommand != 0))
  1042. {
  1044. CRect rt;
  1045. CWnd* pWnd = GetDlgItem(pData[i].idCommand);
  1046. if (pWnd != NULL)
  1047. {
  1048. ASSERT_VALID(pWnd);
  1049.        pWnd->GetWindowRect(rt);
  1050. pData[i].iBitmap=rt.Width(); //width 
  1052. if (bVert && m_bHideChildWndOnVertical)
  1053.     pData[i].fsState |= TBSTATE_HIDDEN;
  1054. else    
  1055. pData[i].fsState &= ~TBSTATE_HIDDEN;
  1056. }
  1058. }
  1059. }
  1060. }
  1063. if ((m_dwStyle & CBRS_FLOATING) && (m_dwStyle & CBRS_SIZE_DYNAMIC))
  1064. m_nMRUWidth = sizeResult.cx;
  1065. for (i = 0; i < nCount; i++)
  1066. _SetButton(i, &pData[i]);
  1068. {  
  1069. //Now place the windows
  1070. CWnd * pWnd = GetWindow(GW_CHILD);
  1071. while(pWnd)
  1072. {
  1073.   ASSERT_VALID(pWnd);
  1075.   int id =pWnd->GetDlgCtrlID();
  1076.   ///////////////////////////
  1077. // make sure the id is valid, and set the button 
  1078. // style for a seperator.
  1079. int nIndex = CommandToIndex( id ) ;
  1080. if (nIndex>-1)
  1081. {
  1082. ASSERT( nIndex >= 0 );
  1083. // insert the control into the toolbar.
  1084. CRect rect;
  1085. GetItemRect( nIndex, &rect );
  1087. CRect rt;
  1088. pWnd->GetWindowRect(&rt);
  1089. rect.top+=max((rect.Height()-rt.Height())/2,0);
  1091. pWnd->SetWindowPos(0, rect.left, rect.top, 0, 0,
  1092. SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOCOPYBITS );
  1093. //pWnd->SetFont( GetFont( ));
  1096. if (bVert && m_bHideChildWndOnVertical)
  1097. {
  1098. ASSERT(GetToolBarCtrl().IsButtonHidden(id));
  1099. pWnd->ShowWindow( SW_HIDE );
  1100. }
  1101. else
  1102. {
  1103. ASSERT(!GetToolBarCtrl().IsButtonHidden(id));
  1104. pWnd->ShowWindow( SW_SHOW );
  1105. }
  1107. }
  1108. else
  1109. {
  1110. pWnd->ShowWindow( SW_HIDE);
  1111. }
  1112.   //////////////////////////
  1113.   pWnd=pWnd->GetNextWindow();
  1114. }
  1115. }
  1117. m_bDelayedButtonLayout = bIsDelayed;
  1118. }
  1120. delete[] pData;
  1121. }
  1123. //BLOCK: Adjust Margins
  1124. {
  1125. CRect rect; rect.SetRectEmpty();
  1126. CalcInsideRect(rect, (dwMode & LM_HORZ));
  1127. sizeResult.cy -= rect.Height();
  1128. sizeResult.cx -= rect.Width();
  1130. CSize size = CControlBar::CalcFixedLayout((dwMode & LM_STRETCH), (dwMode & LM_HORZ));
  1131. sizeResult.cx = max(sizeResult.cx, size.cx);
  1132. sizeResult.cy = max(sizeResult.cy, size.cy);
  1133. }
  1134. return sizeResult;
  1135. }
  1137. CSize CToolBarEx::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  1138. {
  1139. DWORD dwMode = bStretch ? LM_STRETCH : 0;
  1140. dwMode |= bHorz ? LM_HORZ : 0;
  1142. return CalcLayout(dwMode);
  1143. }
  1145. CSize CToolBarEx::CalcDynamicLayout(int nLength, DWORD dwMode)
  1146. {
  1147. if ((nLength == -1) && !(dwMode & LM_MRUWIDTH) && !(dwMode & LM_COMMIT) &&
  1148. ((dwMode & LM_HORZDOCK) || (dwMode & LM_VERTDOCK)))
  1149. {
  1150. return CalcFixedLayout(dwMode & LM_STRETCH, dwMode & LM_HORZDOCK);
  1151. }
  1152. return CalcLayout(dwMode, nLength);
  1153. }
  1155. /////////////////////////////////////////////////////////////////////////////
  1156. // CToolBarEx attribute access
  1158. void CToolBarEx::_GetButton(int nIndex, TBBUTTON* pButton) const
  1159. {
  1160. CToolBarEx* pBar = (CToolBarEx*)this;
  1161. VERIFY(pBar->DefWindowProc(TB_GETBUTTON, nIndex, (LPARAM)pButton));
  1162. // TBSTATE_ENABLED == TBBS_DISABLED so invert it
  1163. pButton->fsState ^= TBSTATE_ENABLED;
  1164. }
  1166. void CToolBarEx::_SetButton(int nIndex, TBBUTTON* pButton)
  1167. {
  1168. // get original button state
  1169. TBBUTTON button;
  1170. VERIFY(DefWindowProc(TB_GETBUTTON, nIndex, (LPARAM)&button));
  1172. // prepare for old/new button comparsion
  1173. button.bReserved[0] = 0;
  1174. button.bReserved[1] = 0;
  1175. // TBSTATE_ENABLED == TBBS_DISABLED so invert it
  1176. pButton->fsState ^= TBSTATE_ENABLED;
  1177. pButton->bReserved[0] = 0;
  1178. pButton->bReserved[1] = 0;
  1180. // nothing to do if they are the same
  1181. if (memcmp(pButton, &button, sizeof(TBBUTTON)) != 0)
  1182. {
  1183. // don't redraw everything while setting the button
  1184. DWORD dwStyle = GetStyle();
  1185. ModifyStyle(WS_VISIBLE, 0);
  1186. VERIFY(DefWindowProc(TB_DELETEBUTTON, nIndex, 0));
  1188. // Force a recalc of the toolbar's layout to work around a comctl bug
  1189. int iTextRows = (int)::SendMessage(m_hWnd, TB_GETTEXTROWS, 0, 0);
  1190. ::SendMessage(m_hWnd, WM_SETREDRAW, FALSE, 0);
  1191. ::SendMessage(m_hWnd, TB_SETMAXTEXTROWS, iTextRows+1, 0);
  1192. ::SendMessage(m_hWnd, TB_SETMAXTEXTROWS, iTextRows, 0);
  1193. ::SendMessage(m_hWnd, WM_SETREDRAW, TRUE, 0);
  1196. VERIFY(DefWindowProc(TB_INSERTBUTTON, nIndex, (LPARAM)pButton));
  1197. ModifyStyle(0, dwStyle & WS_VISIBLE);
  1199. // invalidate appropriate parts
  1200. if (((pButton->fsStyle ^ button.fsStyle) & TBSTYLE_SEP) ||
  1201. ((pButton->fsStyle & TBSTYLE_SEP) && pButton->iBitmap != button.iBitmap))
  1202. {
  1203. // changing a separator
  1204. Invalidate();
  1205. }
  1206. else
  1207. {
  1208. // invalidate just the button
  1209. CRect rect;
  1210. if (DefWindowProc(TB_GETITEMRECT, nIndex, (LPARAM)&rect))
  1211. InvalidateRect(rect);
  1212. }
  1213. }
  1214. }
  1223. BOOL CToolBarEx::SetDropDownButton(UINT nID, BOOL bArrow)
  1224. {
  1226. int iButton = CommandToIndex(nID);
  1228. DWORD dwStyle = GetButtonStyle(iButton);
  1229. dwStyle |= TBSTYLE_DROPDOWN|( (!bArrow) ?BTNS_WHOLEDROPDOWN :0);
  1230. SetButtonStyle(iButton, dwStyle);
  1232. GetToolBarCtrl().SetExtendedStyle(GetToolBarCtrl().GetExtendedStyle() |TBSTYLE_EX_DRAWDDARROWS);
  1234. return TRUE;
  1235. }
  1237. BOOL CToolBarEx::IsVertDocked()
  1238. {
  1239. UINT nID =GetParent()->GetDlgCtrlID();
  1240. return ( (nID ==AFX_IDW_DOCKBAR_LEFT) || (nID== AFX_IDW_DOCKBAR_RIGHT));
  1241. }
  1243. void CToolBarEx::OnPaint() 
  1244. {
  1245. CToolBar::OnPaint();
  1247. //I have to use this, as there is not customdraw mesasges for seperators
  1248. // draw the controls seperator again to hide it
  1249. for (int i=0;i<GetToolBarCtrl().GetButtonCount();i++)
  1250. {
  1251. TBBUTTON tb;
  1252. GetToolBarCtrl().GetButton(i,&tb);
  1254. //only for seperators controls
  1255. if  ( ((tb.fsStyle & TBSTYLE_SEP) == TBSTYLE_SEP) &&
  1256.    (tb.idCommand!=0) )
  1257. {
  1258. CRect rc;
  1259. GetItemRect(i,rc);
  1260. CClientDC dc(this);
  1262. CWnd *pWnd = GetDlgItem(tb.idCommand);
  1263. ASSERT_VALID(pWnd);
  1264. dc.FillSolidRect(rc, m_clrBtnFace);
  1266. if (pWnd)
  1267. {
  1268. pWnd->RedrawWindow();
  1269. }
  1270. }
  1271. }
  1273.  
  1274. }
  1276. void CToolBarEx::SetTextOptions(TextOptions eTextOptions, BOOL bUpdate)
  1277. {
  1278.     ASSERT( ::IsWindow( m_hWnd ) );
  1279.     ASSERT( eTextOptions != toNone );
  1281.     m_eTextOptions = eTextOptions;
  1284.     // Modify toolbar style according to new text options
  1285.     ModifyStyle(
  1286.         ( eTextOptions == toTextOnRight ) ? 0 : TBSTYLE_LIST,
  1287.         ( eTextOptions == toTextOnRight ) ? TBSTYLE_LIST : 0 );
  1289.     CToolBarCtrl& tbCtrl = GetToolBarCtrl();
  1291.     DWORD dwStyleEx = tbCtrl.GetExtendedStyle();
  1293. tbCtrl.SetExtendedStyle(
  1294.         ( eTextOptions == toTextOnRight ) ?
  1295.             ( dwStyleEx |  TBSTYLE_EX_MIXEDBUTTONS ) :
  1296.             ( dwStyleEx & ~TBSTYLE_EX_MIXEDBUTTONS ) );
  1300. for(int i=0;i<m_ToolBarInfo.GetSize();i++)
  1301.   { 
  1302.   // if ((m_ToolBarInfo[i].tbButton.fsStyle & TBSTYLE_SEP) !=  TBSTYLE_SEP)
  1303.   {
  1304.   int nIndex= CommandToIndex(m_ToolBarInfo[i].tbButton.idCommand);
  1305.  
  1306.   if (nIndex>-1)  // buton is there on bar
  1307. {
  1309.  TBBUTTON tbinfo;
  1311. _GetButton(nIndex,&tbinfo);
  1313. if ( !( tbinfo.fsStyle & TBSTYLE_SEP ) )  //check again
  1314. {
  1315.   // attempt to lookup string index in map
  1316. int nString = -1;
  1317. if ((eTextOptions==toTextLabels) || ((eTextOptions==toTextOnRight)))
  1318. {
  1319. void* p=NULL;
  1320. CString strTemp(m_ToolBarInfo[i].btnText);
  1321. if (m_pStringMap != NULL && m_pStringMap->Lookup(strTemp, p))
  1322. nString = (int)p;
  1324. // add new string if not already in map
  1325. if (nString == -1)
  1326. {
  1327. // initialize map if necessary
  1328. if (m_pStringMap == NULL)
  1329. {
  1330. m_pStringMap = new CMapStringToPtr;
  1331. ASSERT(m_pStringMap);
  1332. }
  1334. // add new string to toolbar list
  1335. nString = (int)DefWindowProc(TB_ADDSTRING, 0, (LPARAM)(LPCTSTR)strTemp);
  1336. if (nString != -1)
  1337. {
  1338. // cache string away in string map
  1339. m_pStringMap->SetAt(strTemp, (void*)nString);
  1340. ASSERT(m_pStringMap->Lookup(strTemp, p));
  1341. }
  1342. }
  1344. }
  1348. switch ( eTextOptions )
  1349. {
  1350. case toTextLabels:
  1351. {
  1352. tbinfo.iString =nString;
  1353. tbinfo.fsStyle &= ~BTNS_SHOWTEXT;
  1354. tbinfo.fsStyle |= TBSTYLE_AUTOSIZE;
  1355. }
  1356. break;
  1358. case toTextOnRight:
  1359. {
  1360. if ((nString!=-1) && 
  1361. (HasButtonText(m_ToolBarInfo[i].tbButton.idCommand)))
  1362. {
  1363. tbinfo.iString =nString;
  1364. tbinfo.fsStyle |= ( TBSTYLE_AUTOSIZE |BTNS_SHOWTEXT );
  1365. }
  1366. else
  1367. {
  1368. tbinfo.fsStyle &= ~BTNS_SHOWTEXT;
  1369. tbinfo.fsStyle |= TBSTYLE_AUTOSIZE;
  1370. }
  1371. }
  1372. break;
  1374. case toNoTextLabels:
  1375. {
  1376.   tbinfo.iString= -1;   //Set string to zero
  1377. tbinfo.fsStyle &= ~BTNS_SHOWTEXT;
  1378. tbinfo.fsStyle |= TBSTYLE_AUTOSIZE;
  1379. }
  1380. break;
  1381. default:
  1382. ASSERT(FALSE); // anew type added
  1383. }
  1385. //Delete & add the button
  1386. {
  1387. tbinfo.fsState ^= TBSTATE_ENABLED;
  1388. m_ToolBarInfo[i].tbButton=tbinfo;
  1389. tbinfo.fsState ^= TBSTATE_ENABLED;
  1390. _SetButton(nIndex,&tbinfo);
  1391. }
  1392.   }
  1393. }
  1394. }
  1395. }
  1397. int iTextRows = 0;
  1398. // now total setting
  1399. switch ( eTextOptions )
  1400. {
  1401. case toTextLabels:
  1402. {
  1403.    iTextRows=1;
  1404. }
  1405. break;
  1407. case toTextOnRight:
  1408. {
  1409.    iTextRows=1;
  1410. }
  1411. break;
  1413. case toNoTextLabels:
  1414. {
  1415.    iTextRows=0;
  1416. }
  1417. break;
  1418. default:
  1419. ASSERT(FALSE); // anew type added
  1420. }
  1422. ::SendMessage(m_hWnd, TB_SETMAXTEXTROWS, iTextRows, 0);
  1426.     // If requested, reflect changes immediately
  1427.     if ( bUpdate )
  1428.     {
  1429. PositionControls();
  1430. GetParentFrame()->RecalcLayout();
  1431. OnIdleUpdateCmdUI(TRUE, 0L);
  1432.     }
  1434. }
  1436.  
  1438. void CToolBarEx::SetIconOptions(IconOptions eIconOptions, BOOL bUpdate)
  1439. {
  1440.     ASSERT( ::IsWindow( m_hWnd ) );
  1441.     ASSERT( eIconOptions != ioNone );
  1443.     m_eIconOptions = eIconOptions;
  1446. switch(eIconOptions)
  1447. {
  1448.  case ioSmallIcons:
  1449.  m_sizeImage= m_szImageSmall ;
  1450.  SetIconOptionBitmap(ioSmallIcons);
  1451.  GetToolBarCtrl().SetBitmapSize(m_szImageSmall);
  1452. break;
  1454.  case ioLargeIcons:
  1455.  m_sizeImage= m_szImageLarge ;
  1456.  SetIconOptionBitmap(ioLargeIcons);
  1457.  GetToolBarCtrl().SetBitmapSize(m_szImageLarge);
  1458.  break;
  1459. }
  1461. // Force a recalc of the toolbar's layout to work around a comctl bug
  1462. int iTextRows = (int)::SendMessage(m_hWnd, TB_GETTEXTROWS, 0, 0);
  1463. ::SendMessage(m_hWnd, WM_SETREDRAW, FALSE, 0);
  1464. ::SendMessage(m_hWnd, TB_SETMAXTEXTROWS, iTextRows+1, 0);
  1465. ::SendMessage(m_hWnd, TB_SETMAXTEXTROWS, iTextRows, 0);
  1466. ::SendMessage(m_hWnd, WM_SETREDRAW, TRUE, 0);
  1469.     // If requested, reflect changes immediately
  1470.     if ( bUpdate )
  1471.     {
  1472. PositionControls();
  1473. GetParentFrame()->RecalcLayout();
  1474. OnIdleUpdateCmdUI(TRUE, 0L);
  1475.     }
  1477. }
  1479. //static ftn for Hook
  1481. LRESULT CALLBACK CToolBarEx::CBTProc( int nCode, WPARAM wParam, LPARAM lParam )
  1482. {
  1483.     ASSERT( m_pCustomizeDlg != NULL );
  1485. try
  1486. {
  1487. if ( ( nCode == HCBT_CREATEWND ) && (m_pCustomizeDlg) && ( m_pCustomizeDlg->m_hWnd == 0 ) )
  1488. {
  1489. // This is where we have a good chance to subclass standard
  1490. // "Customize toolbar" dialog in order to add to it some of
  1491. // our new features (ie. text and icon options selectors)
  1492. HWND hWnd = ( HWND )wParam;
  1493. VERIFY( m_pCustomizeDlg->SubclassWindow( hWnd ) );
  1494. }
  1495. }
  1496. catch(...) // if exception is not caught then we can get in infinite loop as assert window is opened.
  1497. {
  1498. TRACE0(_T("Exception thrown while Hooking-Extra Custom features unavaialble.n"));
  1500. //Call next
  1501. LRESULT lResult=::CallNextHookEx( m_hCBTHook, nCode, wParam, lParam );
  1502. VERIFY( ::UnhookWindowsHookEx( m_hCBTHook ) );
  1503. m_hCBTHook = 0;
  1504. if (m_pCustomizeDlg) delete m_pCustomizeDlg;
  1505. m_pCustomizeDlg = NULL;
  1506. return lResult;
  1507. }
  1509.     return ::CallNextHookEx( m_hCBTHook, nCode, wParam, lParam );
  1510. }
  1513. // has to override this
  1514. BOOL CToolBarEx::HasButtonText(int nID)
  1515. {
  1516. nID;
  1517.     return TRUE;
  1518. }
  1520. /*
  1521. DIBs use RGBQUAD format:
  1522. 0xbb 0xgg 0xrr 0x00
  1524. Reasonably efficient code to convert a COLORREF into an
  1525. RGBQUAD is byte-order-dependent, so we need different
  1526. code depending on the byte order we're targeting.
  1527. */
  1528. #define RGB_TO_RGBQUAD(r,g,b)   (RGB(b,g,r))
  1529. #define CLR_TO_RGBQUAD(clr)     (RGB(GetBValue(clr), GetGValue(clr), GetRValue(clr)))
  1531. static COLORREF MapToSysColor (COLORREF color, BOOL bUseRGBQUAD)
  1532. {
  1533. struct COLORMAP
  1534. {
  1535. // use DWORD instead of RGBQUAD so we can compare two RGBQUADs easily
  1536. DWORD rgbqFrom;
  1537. int iSysColorTo;
  1538. };
  1539. static const COLORMAP sysColorMap[] =
  1540. {
  1541. // mapping from color in DIB to system color
  1542. { RGB_TO_RGBQUAD(0x00, 0x00, 0x00),  COLOR_BTNTEXT },       // black
  1543. { RGB_TO_RGBQUAD(0x80, 0x80, 0x80),  COLOR_BTNSHADOW },     // dark grey
  1544. { RGB_TO_RGBQUAD(0xC0, 0xC0, 0xC0),  COLOR_BTNFACE },       // bright grey
  1545. { RGB_TO_RGBQUAD(0xFF, 0xFF, 0xFF),  COLOR_BTNHIGHLIGHT }   // white
  1546. };
  1547. const int nMaps = 4;
  1549. // look for matching RGBQUAD color in original
  1550. for (int i = 0; i < nMaps; i++)
  1551. {
  1552. if (color == sysColorMap[i].rgbqFrom)
  1553. {
  1554. return bUseRGBQUAD ? 
  1555. CLR_TO_RGBQUAD(::GetSysColor(sysColorMap[i].iSysColorTo)) :
  1556. ::GetSysColor(sysColorMap[i].iSysColorTo);
  1557. }
  1558. }
  1560. return color;
  1561. }
  1563. static HBITMAP LoadSysColorBitmapSize(HINSTANCE hInst, HRSRC hRsrc,CSize sz)
  1564. {
  1565. HGLOBAL hglb;
  1567. if ((hglb = LoadResource(hInst, hRsrc)) == NULL)
  1568. return NULL;
  1570. LPBITMAPINFOHEADER lpBitmap = (LPBITMAPINFOHEADER)LockResource(hglb);
  1571. if (lpBitmap == NULL)
  1572. return NULL;
  1574. UINT nSize=lpBitmap->biSize;
  1575. const int nColorTableSize = 16;
  1577. if (lpBitmap->biBitCount  <=8)
  1578. {
  1579. // make copy of BITMAPINFOHEADER so we can modify the color table
  1580. nSize = lpBitmap->biSize + nColorTableSize * sizeof(RGBQUAD);
  1581. }
  1584. LPBITMAPINFOHEADER lpBitmapInfo = (LPBITMAPINFOHEADER)::malloc(nSize);
  1585. if (lpBitmapInfo == NULL) return NULL;
  1587. memcpy(lpBitmapInfo, lpBitmap, nSize);
  1588. HBITMAP hbm =NULL;
  1589. if (lpBitmapInfo->biBitCount  <=8)
  1590. {
  1591. // color table is in RGBQUAD DIB format
  1592. DWORD* pColorTable =
  1593. (DWORD*)(((LPBYTE)lpBitmapInfo) + (UINT)lpBitmapInfo->biSize);
  1595. for (int iColor = 0; iColor < nColorTableSize; iColor++)
  1596. {
  1597. pColorTable[iColor] = MapToSysColor(pColorTable[iColor],TRUE) ;
  1598. }
  1600. int nWidth = (int)lpBitmapInfo->biWidth;
  1601. int nHeight = (int)lpBitmapInfo->biHeight;
  1602. HDC hDCScreen = ::GetDC(NULL);
  1603. hbm = ::CreateCompatibleBitmap(hDCScreen, sz.cx, sz.cy);
  1605. if (hbm != NULL)
  1606. {
  1607. HDC hDCGlyphs = ::CreateCompatibleDC(hDCScreen);
  1608. HBITMAP hbmOld = (HBITMAP)::SelectObject(hDCGlyphs, hbm);
  1610. LPBYTE lpBits;
  1611. lpBits = (LPBYTE)(lpBitmap + 1);
  1612. lpBits += (1 << (lpBitmapInfo->biBitCount)) * sizeof(RGBQUAD);
  1614. StretchDIBits(hDCGlyphs, 0, 0, sz.cx, sz.cy, 0, 0, nWidth, nHeight,
  1615. lpBits, (LPBITMAPINFO)lpBitmapInfo, DIB_RGB_COLORS, SRCCOPY);
  1616. SelectObject(hDCGlyphs, hbmOld);
  1617. ::DeleteDC(hDCGlyphs);
  1618. }
  1619. ::ReleaseDC(NULL, hDCScreen);
  1622. }
  1623. else
  1624. {
  1626. int nWidth = (int)lpBitmapInfo->biWidth;
  1627. int nHeight = (int)lpBitmapInfo->biHeight;
  1628. HDC hDCScreen = ::GetDC(NULL);
  1629. hbm = ::CreateCompatibleBitmap(hDCScreen, sz.cx, sz.cy);
  1631. if (hbm != NULL)
  1632. {
  1633. HDC hDCGlyphs = ::CreateCompatibleDC(hDCScreen);
  1634. HBITMAP hbmOld = (HBITMAP)::SelectObject(hDCGlyphs, hbm);
  1636. LPBYTE lpBits;
  1637. lpBits = (LPBYTE)(lpBitmap + 1);
  1639. StretchDIBits(hDCGlyphs, 0, 0, sz.cx, sz.cy, 0, 0, nWidth, nHeight,
  1640. lpBits, (LPBITMAPINFO)lpBitmapInfo, DIB_RGB_COLORS, SRCCOPY);
  1642. // Change a specific colors to system:
  1643. for (int x = 0; x < sz.cx; x ++)
  1644. {
  1645. for (int y = 0; y < sz.cy; y ++)
  1646. {
  1647. COLORREF clrOrig = ::GetPixel (hDCGlyphs, x, y);
  1648. COLORREF clrNew = MapToSysColor (clrOrig,FALSE);
  1650. if (clrOrig != clrNew)
  1651. {
  1652. ::SetPixel (hDCGlyphs, x, y, clrNew);
  1653. }
  1654. }
  1655. }
  1657. SelectObject(hDCGlyphs, hbmOld);
  1658. ::DeleteDC(hDCGlyphs);
  1659. }
  1660. ::ReleaseDC(NULL, hDCScreen);
  1662. }
  1665. // free copy of bitmap info struct and resource itself
  1666. ::free(lpBitmapInfo);
  1667. ::FreeResource(hglb);
  1669. return hbm;
  1670. }
  1673. BOOL CToolBarEx::SetIconOptionBitmap(IconOptions eIconOptions)
  1674. {
  1676. if ((m_hInstImageWell != NULL) && (m_hRsrcImageWell != NULL))
  1677. {
  1679. HBITMAP hBitmap=NULL;
  1680. HINSTANCE  hInstImageWell= m_hInstImageWell ;
  1681. HRSRC  hRsrcImageWell =  m_hRsrcImageWell ;
  1683. int nCount = 0;
  1685. for(UINT i=0;i<m_nResButtons;i++)
  1686. {
  1687.  
  1688. if ((m_ToolBarInfo[i].tbButton.idCommand !=0))
  1689. nCount++;
  1690. }
  1692. if (eIconOptions==ioSmallIcons)
  1693. {
  1694. CSize  sizeSmallImage(nCount *m_szImageSmall.cx,m_szImageSmall.cy);
  1695. hBitmap= LoadSysColorBitmapSize(m_hInstImageWell, m_hRsrcImageWell,sizeSmallImage);
  1696. }
  1697. else
  1698. {
  1699. ASSERT(eIconOptions==ioLargeIcons);
  1700. CSize  sizeLargeImage(nCount *m_szImageLarge.cx,m_szImageLarge.cy);
  1701. hBitmap= LoadSysColorBitmapSize(m_hInstImageWell, m_hRsrcImageWell,sizeLargeImage);
  1702. }
  1704. ASSERT(hBitmap);
  1705. SetBitmap(hBitmap);
  1707. m_hInstImageWell = hInstImageWell; // SetBitmap resets these
  1708. m_hRsrcImageWell = hRsrcImageWell; // SetBitmap resets these
  1709. return TRUE;
  1710. }
  1713. return FALSE;
  1714. }
  1716. void CToolBarEx::OnSysColorChange() 
  1717. {
  1718. m_clrBtnShadow=::GetSysColor(COLOR_BTNSHADOW);
  1719. m_clrBtnHilight=::GetSysColor(COLOR_BTNHILIGHT);
  1720. m_clrBtnFace  = ::GetSysColor(COLOR_BTNFACE);
  1721. SetIconOptions(m_eIconOptions); //load bitmap again
  1722. }
  1724. void CToolBarEx::OnSave( NMHDR* pNMHDR, LRESULT* pResult )
  1725. {
  1726.     NMTBSAVE* lpnmtb = ( NMTBSAVE* )pNMHDR;
  1727.     if ( lpnmtb->iItem == -1 )
  1728.     {
  1729.         lpnmtb->cbData  += sizeof( DWORD ) * 2;
  1730.         lpnmtb->pData    = ( LPDWORD )::GlobalAlloc( GMEM_FIXED, lpnmtb->cbData );  //freed by Toolbar ( Not sure)
  1731.         lpnmtb->pCurrent = lpnmtb->pData;
  1733.         *lpnmtb->pCurrent++ = (DWORD)m_eIconOptions;
  1734.         *lpnmtb->pCurrent++ = (DWORD)m_eTextOptions;
  1735.     }
  1737.     *pResult = 0;
  1738. }
  1740. void CToolBarEx::OnRestore( NMHDR* pNMHDR, LRESULT* pResult )
  1741. {
  1742.     NMTBRESTORE* lpnmtb = ( NMTBRESTORE* )pNMHDR;
  1744.     if ( lpnmtb->iItem == -1 )
  1745.     {
  1746.         lpnmtb->cButtons = ( lpnmtb->cbData - sizeof( DWORD ) * 2 ) / lpnmtb->cbBytesPerRecord;
  1747.         lpnmtb->pCurrent = lpnmtb->pData;
  1749.         m_eIconOptions=(IconOptions)*lpnmtb->pCurrent++ ;
  1750.         m_eTextOptions=(TextOptions)*lpnmtb->pCurrent++ ;
  1751.     }
  1753.     *pResult = 0;
  1754. }
  1757. BOOL CToolBarEx::ShowContextMenu(CPoint point)
  1758. {
  1760. if( GetToolBarCtrl().GetButtonCount() && m_ToolBarInfo.GetSize())
  1761. {
  1762. CPoint pt( point );
  1763. ClientToScreen( &pt );
  1765. // load and display popup menu
  1766. CMenu popupMenu;
  1767. VERIFY(popupMenu.CreatePopupMenu());
  1769. CFrameWnd * pFrame=(CFrameWnd *)AfxGetMainWnd();
  1771. if (pFrame && pFrame->IsKindOf(RUNTIME_CLASS(CFrameWnd)) )
  1772. {
  1773. ASSERT_VALID(pFrame);
  1774. POSITION pos = pFrame->m_listControlBars.GetHeadPosition();
  1776. while (pos != NULL)
  1777. {
  1778. const CControlBar* pBar = (CControlBar*)pFrame->m_listControlBars.GetNext(pos);
  1779. ASSERT(pBar != NULL);
  1781. if (pBar && 
  1782. pBar->IsKindOf(RUNTIME_CLASS(CToolBar))) // Put any other type
  1784. {
  1785. ASSERT_VALID(pBar);
  1786. CString strName;
  1787. pBar->GetWindowText(strName);
  1788. popupMenu.AppendMenu( (pBar->GetStyle()&WS_VISIBLE?MF_CHECKED:MF_UNCHECKED)|MF_STRING,
  1789. pBar->GetDlgCtrlID(),
  1790. strName);
  1791. }
  1792. }
  1794. //Add a Seperator
  1795. popupMenu.AppendMenu(MF_SEPARATOR) ;
  1796. }
  1799. //Finally a Customize
  1800. popupMenu.AppendMenu(MF_STRING ,ID_CUSTOMIZE_BAR, STR_CUSTOMIZE);
  1802. int nResult = popupMenu.TrackPopupMenu(TPM_LEFTALIGN|TPM_LEFTBUTTON|TPM_VERTICAL|TPM_RETURNCMD,pt.x, pt.y, this );
  1804. switch(nResult)
  1805. {
  1806. case 0: //Nothing clicked  on menu
  1807. break;
  1808. case ID_CUSTOMIZE_BAR  :
  1809. // open the customization dialog.
  1810. Customize();
  1811. break;
  1812. default:
  1813. {
  1814. ASSERT_VALID(pFrame);
  1815. if (pFrame && pFrame->IsKindOf(RUNTIME_CLASS(CFrameWnd)) )
  1816. {
  1817. pFrame->OnBarCheck(nResult);
  1818. }
  1819. }
  1820. }
  1821. return TRUE;
  1822. }
  1825. return FALSE;
  1827. }
  1829. void CToolBarEx::OnContextMenu(CWnd* pWnd, CPoint point) 
  1830. {
  1831. ASSERT_VALID(pWnd);
  1832. CPoint pt(point);
  1834. if (WindowFromPoint(pt)!=this) return;
  1836. ScreenToClient(&pt);
  1837. if (!ShowContextMenu(pt))
  1838. CToolBar::OnContextMenu(pWnd,point);
  1839. }
  1841. void CToolBarEx::Customize()
  1842. {
  1843. GetToolBarCtrl().Customize();
  1844. }
  1846. void CToolBarEx::OnInitCustomize( NMHDR* /*pNMHDR*/, LRESULT* pResult )
  1847. {
  1848.     *pResult = TBNRF_HIDEHELP;  // help button  is hidden      
  1849. }
  1851. void CToolBarEx::OnCustomDraw( NMHDR* pNMHDR, LRESULT* pResult )
  1852. {
  1853. LPNMTBCUSTOMDRAW lpNMCustomDraw = (LPNMTBCUSTOMDRAW) pNMHDR;
  1855. ASSERT_POINTER(lpNMCustomDraw,NMTBCUSTOMDRAW);
  1856. switch(lpNMCustomDraw->nmcd.dwDrawStage)
  1857. {
  1858. case CDDS_PREPAINT:
  1859. *pResult = CDRF_NOTIFYITEMDRAW    ;
  1860. break;
  1861. case CDDS_ITEMPREPAINT:
  1862. // draw the button
  1863. {
  1864. if (lpNMCustomDraw->nmcd.uItemState & CDIS_HOT)
  1865. {
  1866. //draw button
  1867. CDC dc;
  1868. CRect rt(lpNMCustomDraw->nmcd.rc);
  1869. TBBUTTONINFO bbi;
  1870. int xOffset=5,yOffset=3;
  1872. dc.Attach(lpNMCustomDraw->nmcd.hdc);
  1873. //Init button info
  1874. memset(&bbi,0,sizeof(bbi));
  1875. bbi.cbSize =sizeof(bbi);
  1876. bbi.dwMask = TBIF_IMAGE;
  1878. GetToolBarCtrl().GetButtonInfo(lpNMCustomDraw->nmcd.dwItemSpec,&bbi);
  1883. //draw shadow
  1884. CDC  dcGlyphs;
  1885. dcGlyphs.CreateCompatibleDC(NULL);
  1886. HBITMAP hbmOld = (HBITMAP)dcGlyphs.SelectObject(m_hbmImageWell);
  1888. dc.BitBlt(rt.left+xOffset+1,rt.top+yOffset+1,m_sizeImage.cx,m_sizeImage.cy,&dcGlyphs,m_sizeImage.cx*bbi.iImage,0,SRCCOPY);
  1889. dcGlyphs.SelectObject(hbmOld);
  1890. dcGlyphs.DeleteDC();
  1893. // darken the drawn thing
  1894. long r,g,b;
  1895. float  perc=0.07f;
  1896. for (int x= rt.left+1;x< rt.right;x++)
  1897. for (int y= rt.top+1;y< rt.bottom;y++)
  1898. {
  1899. COLORREF cr = dc.GetPixel(CPoint(x,y));
  1900. if (cr == m_clrBtnFace)
  1901. {
  1902. r = GetRValue(cr);
  1903. g = GetGValue(cr);
  1904. b = GetBValue(cr);
  1906. r -=(BYTE)(r*perc);
  1907. g -=(BYTE)(g*perc);
  1908. b -=(BYTE)(b*perc);
  1909. dc.SetPixel(CPoint(x,y),RGB(r,g,b));
  1910. }
  1911. else
  1912. dc.SetPixel(CPoint(x,y),m_clrBtnShadow);  // this creates shadow
  1914. }
  1918. dc.Draw3dRect(&rt,m_clrBtnShadow,m_clrBtnShadow);
  1922. dc.Detach();
  1924. *pResult = CDRF_SKIPDEFAULT;
  1925. }
  1926. else  // for normal cases
  1927. {
  1928. *pResult = CDRF_DODEFAULT ;
  1929. }
  1930. }
  1931. break;
  1932. case CDRF_NOTIFYPOSTPAINT :
  1933. *pResult = CDRF_DODEFAULT ;
  1934. ASSERT(FALSE);
  1935. break;
  1936. default:
  1937. *pResult = CDRF_DODEFAULT ;
  1938. }
  1939. }
  1944. void CToolBarEx::OnNcPaint() 
  1945. {
  1947. if( GetToolBarCtrl().GetStyle()& TBSTYLE_FLAT ) 
  1948. {
  1949. // get window DC that is clipped to the non-client area
  1950. CWindowDC dc(this);
  1951. CRect rectClient;
  1952. GetClientRect(rectClient);
  1953. CRect rectWindow;
  1954. GetWindowRect(rectWindow);
  1955. ScreenToClient(rectWindow);
  1956. rectClient.OffsetRect(-rectWindow.left, -rectWindow.top);
  1957. dc.ExcludeClipRect(rectClient);
  1959. // draw borders in non-client area
  1960. rectWindow.OffsetRect(-rectWindow.left, -rectWindow.top);
  1962. Draw3DBorders(&dc, rectWindow);
  1964. dc.IntersectClipRect(rectWindow);
  1966. // erase parts not drawn
  1967. SendMessage(WM_ERASEBKGND, (WPARAM)dc.m_hDC);
  1969. DrawGripper(&dc,rectWindow);
  1970. } 
  1971. else
  1972. {
  1973. CToolBar::OnNcPaint();
  1974. }
  1975. }
  1977. void CToolBarEx :: Draw3DBorders(CDC * pDC, CRect & rect) 
  1978. {
  1979. ASSERT_VALID(this);
  1980. ASSERT_VALID(pDC);
  1982. if( GetToolBarCtrl().GetStyle()& TBSTYLE_FLAT ) 
  1983. {
  1984. DWORD dwStyle = m_dwStyle;
  1985. if (!(dwStyle & CBRS_BORDER_ANY))
  1986. return;
  1988. COLORREF clr = (m_dwStyle & CBRS_BORDER_3D) ? m_clrBtnHilight : m_clrBtnShadow;
  1989. if(m_dwStyle & CBRS_BORDER_LEFT)
  1990. pDC->FillSolidRect(0, 0, 1, rect.Height() - 1, clr);
  1991. if(m_dwStyle & CBRS_BORDER_TOP)
  1992. pDC->FillSolidRect(0, 0, rect.Width()-1 , 1, clr);
  1995. // this for ver 6.0
  1996. if (dwStyle & CBRS_BORDER_ANY)
  1997. {
  1998. CRect rctBk;
  1999. rctBk.left = 0;
  2000. rctBk.right = rect.right;
  2001. rctBk.top = rect.top;
  2002. rctBk.bottom = rect.bottom;
  2004. pDC->FillSolidRect((LPRECT)rctBk, pDC->GetBkColor());
  2005. }
  2007. if(m_dwStyle & CBRS_BORDER_RIGHT)
  2008. pDC->FillSolidRect(rect.right, 1, -1, rect.Height() - 1, m_clrBtnShadow);
  2009. if(m_dwStyle & CBRS_BORDER_BOTTOM)
  2010. pDC->FillSolidRect(0, rect.bottom, rect.Width()-1, -1, m_clrBtnShadow);
  2014. // if undockable toolbar at top of frame, apply special formatting to mesh
  2015. // properly with frame menu
  2016. if(!m_pDockContext) 
  2017. {
  2018. pDC->FillSolidRect(0,0,rect.Width(),1,m_clrBtnShadow);
  2019. pDC->FillSolidRect(0,1,rect.Width(),1,m_clrBtnHilight);
  2020. }
  2022. if (dwStyle & CBRS_BORDER_LEFT)
  2023. ++rect.left;
  2024. if (dwStyle & CBRS_BORDER_TOP)
  2025. ++rect.top;
  2026. if (dwStyle & CBRS_BORDER_RIGHT)
  2027. --rect.right;
  2028. if (dwStyle & CBRS_BORDER_BOTTOM)
  2029. --rect.bottom;
  2030. } 
  2031. else
  2032. {
  2033. DrawBorders(pDC, rect);
  2034. }
  2037. }
  2038.  
  2039. BOOL CToolBarEx::LoadBitmap(LPCTSTR lpszResourceName)
  2040. {
  2041. ASSERT_VALID(this);
  2042. ASSERT(lpszResourceName != NULL);
  2044. // determine location of the bitmap in resource fork
  2045. HINSTANCE hInstImageWell = AfxFindResourceHandle(lpszResourceName, RT_BITMAP);
  2046. HRSRC hRsrcImageWell = ::FindResource(hInstImageWell, lpszResourceName, RT_BITMAP);
  2047. if (hRsrcImageWell == NULL)
  2048. return FALSE;
  2050. // delete last one
  2051. if (hRsrcImageWell) ::DeleteObject(hRsrcImageWell);
  2055. // remember the resource handles so the bitmap can be recolored if necessary
  2056. m_hInstImageWell = hInstImageWell;
  2057. m_hRsrcImageWell = hRsrcImageWell;
  2059. return TRUE;
  2060. }
  2062. /////////////////////////////////////////////////////////////////////////////
  2063. // CDockBarEx
  2065. CDockBarEx::CDockBarEx()
  2066. {
  2067. // TODO: add construction code here.
  2068. }
  2070. CDockBarEx::~CDockBarEx()
  2071. {
  2072. // TODO: add destruction code here.
  2073. }
  2075. IMPLEMENT_DYNAMIC(CDockBarEx, CDockBar)
  2077. BEGIN_MESSAGE_MAP(CDockBarEx, CDockBar)
  2078. //{{AFX_MSG_MAP(CDockBarEx)   
  2079. // NOTE - the ClassWizard will add and remove mapping macros here.
  2080. //    DO NOT EDIT what you see in these blocks of generated code!
  2081. //}}AFX_MSG_MAP
  2082. END_MESSAGE_MAP()
  2084. /////////////////////////////////////////////////////////////////////////////
  2085. // CDockBarEx message handlers
  2087. CSize CDockBarEx::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  2088. {
  2089. ASSERT_VALID(this);
  2091. CSize sizeFixed = CControlBar::CalcFixedLayout(bStretch, bHorz);
  2093. // get max size
  2094. CSize sizeMax;
  2095. if (!m_rectLayout.IsRectEmpty())
  2096. {
  2097. CRect rect = m_rectLayout;
  2098. CalcInsideRect(rect, bHorz);
  2099. sizeMax = rect.Size();
  2100. }
  2101. else
  2102. {
  2103. CRect rectFrame;
  2104. CFrameWnd* pFrame = GetParentFrame();
  2105. pFrame->GetClientRect(&rectFrame);
  2106. sizeMax = rectFrame.Size();
  2107. }
  2109. // prepare for layout
  2110. AFX_SIZEPARENTPARAMS layout;
  2111. layout.hDWP = m_bLayoutQuery ?
  2112. NULL : ::BeginDeferWindowPos(m_arrBars.GetSize());
  2113. int cxBorder = 2, cyBorder = 2;
  2114. CPoint pt(-cxBorder, -cyBorder);
  2115. int nWidth = 0;
  2117. BOOL bWrapped = FALSE;
  2119. // layout all the control bars
  2120. for (int nPos = 0; nPos < m_arrBars.GetSize(); nPos++)
  2121. {
  2122. CControlBar* pBar = GetDockedControlBar(nPos);
  2123. void* pVoid = m_arrBars[nPos];
  2125. if (pBar != NULL)
  2126. {
  2127. if(pBar->IsKindOf(RUNTIME_CLASS(CToolBarEx)))
  2128. {
  2129.   if (pBar->GetStyle() & TBSTYLE_FLAT)
  2130. cxBorder = cyBorder = 0;
  2131.   else
  2132. cxBorder = cyBorder = 2;
  2133. }
  2134. else
  2135. cxBorder = cyBorder = 2;
  2137. if (pBar->IsVisible())
  2138. {
  2139. // get ideal rect for bar
  2140. DWORD dwMode = 0;
  2141. if ((pBar->m_dwStyle & CBRS_SIZE_DYNAMIC) &&
  2142. (pBar->m_dwStyle & CBRS_FLOATING))
  2143. dwMode |= LM_HORZ | LM_MRUWIDTH;
  2144. else if (pBar->m_dwStyle & CBRS_ORIENT_HORZ)
  2145. dwMode |= LM_HORZ | LM_HORZDOCK;
  2146. else
  2147. dwMode |=  LM_VERTDOCK;
  2149. CSize sizeBar = pBar->CalcDynamicLayout(-1, dwMode);
  2151. CRect rect(pt, sizeBar);
  2153. // get current rect for bar
  2154. CRect rectBar;
  2155. pBar->GetWindowRect(&rectBar);
  2156. ScreenToClient(&rectBar);
  2158. if (bHorz)
  2159. {
  2160. // Offset Calculated Rect out to Actual
  2161. if (rectBar.left > rect.left && !m_bFloating)
  2162. rect.OffsetRect(rectBar.left - rect.left, 0);
  2164. // If ControlBar goes off the right, then right justify
  2165. if (rect.right > sizeMax.cx && !m_bFloating)
  2166. {
  2167. int x = rect.Width() - cxBorder;
  2168. x = max(sizeMax.cx - x, pt.x);
  2169. rect.OffsetRect(x - rect.left, 0);
  2170. }
  2172. // If ControlBar has been wrapped, then left justify
  2173. if (bWrapped)
  2174. {
  2175. bWrapped = FALSE;
  2176. rect.OffsetRect(-(rect.left + cxBorder), 0);
  2177. }
  2178. // If ControlBar is completely invisible, then wrap it
  2179. else if ((rect.left >= (sizeMax.cx - cxBorder)) &&
  2180. (nPos > 0) && (m_arrBars[nPos - 1] != NULL))
  2181. {
  2182. m_arrBars.InsertAt(nPos, (CObject*)NULL);
  2183. pBar = NULL; pVoid = NULL;
  2184. bWrapped = TRUE;
  2185. }
  2186. if (!bWrapped)
  2187. {
  2188. if (rect != rectBar)
  2189. {
  2190. if (!m_bLayoutQuery &&
  2191. !(pBar->m_dwStyle & CBRS_FLOATING))
  2192. {
  2193. pBar->m_pDockContext->m_rectMRUDockPos = rect;
  2194. }
  2195. AfxRepositionWindow(&layout, pBar->m_hWnd, &rect);
  2196. }
  2197. pt.x = rect.left + sizeBar.cx - cxBorder;
  2198. nWidth = max(nWidth, sizeBar.cy);
  2199. }
  2200. }
  2201. else
  2202. {
  2203. // Offset Calculated Rect out to Actual
  2204. if (rectBar.top > rect.top && !m_bFloating)
  2205. rect.OffsetRect(0, rectBar.top - rect.top);
  2207. // If ControlBar goes off the bottom, then bottom justify
  2208. if (rect.bottom > sizeMax.cy && !m_bFloating)
  2209. {
  2210. int y = rect.Height() - cyBorder;
  2211. y = max(sizeMax.cy - y, pt.y);
  2212. rect.OffsetRect(0, y - rect.top);
  2213. }
  2215. // If ControlBar has been wrapped, then top justify
  2216. if (bWrapped)
  2217. {
  2218. bWrapped = FALSE;
  2219. rect.OffsetRect(0, -(rect.top + cyBorder));
  2220. }
  2221. // If ControlBar is completely invisible, then wrap it
  2222. else if ((rect.top >= (sizeMax.cy - cyBorder)) &&
  2223. (nPos > 0) && (m_arrBars[nPos - 1] != NULL))
  2224. {
  2225. m_arrBars.InsertAt(nPos, (CObject*)NULL);
  2226. pBar = NULL; pVoid = NULL;
  2227. bWrapped = TRUE;
  2228. }
  2229. if (!bWrapped)
  2230. {
  2231. if (rect != rectBar)
  2232. {
  2233. if (!m_bLayoutQuery &&
  2234. !(pBar->m_dwStyle & CBRS_FLOATING))
  2235. {
  2236. pBar->m_pDockContext->m_rectMRUDockPos = rect;
  2237. }
  2238. AfxRepositionWindow(&layout, pBar->m_hWnd, &rect);
  2239. }
  2240. pt.y = rect.top + sizeBar.cy - cyBorder;
  2241. nWidth = max(nWidth, sizeBar.cx);
  2242. }
  2243. }
  2244. }
  2245. if (!bWrapped)
  2246. {
  2247. // handle any delay/show hide for the bar
  2248. pBar->RecalcDelayShow(&layout);
  2249. }
  2250. }
  2251. if (pBar == NULL && pVoid == NULL && nWidth != 0)
  2252. {
  2253. // end of row because pBar == NULL
  2254. if (bHorz)
  2255. {
  2256. pt.y += nWidth - cyBorder;
  2257. sizeFixed.cx = max(sizeFixed.cx, pt.x);
  2258. sizeFixed.cy = max(sizeFixed.cy, pt.y);
  2259. pt.x = -cxBorder;
  2260. }
  2261. else
  2262. {
  2263. pt.x += nWidth - cxBorder;
  2264. sizeFixed.cx = max(sizeFixed.cx, pt.x);
  2265. sizeFixed.cy = max(sizeFixed.cy, pt.y);
  2266. pt.y = -cyBorder;
  2267. }
  2268. nWidth = 0;
  2269. }
  2270. }
  2271. if (!m_bLayoutQuery)
  2272. {
  2273. // move and resize all the windows at once!
  2274. if (layout.hDWP == NULL || !::EndDeferWindowPos(layout.hDWP))
  2275. TRACE0("Warning: DeferWindowPos failed - low system resources.n");
  2276. }
  2278. // adjust size for borders on the dock bar itself
  2279. CRect rect;
  2280. rect.SetRectEmpty();
  2281. CalcInsideRect(rect, bHorz);
  2283. if ((!bStretch || !bHorz) && sizeFixed.cx != 0)
  2284. sizeFixed.cx += -rect.right + rect.left;
  2285. if ((!bStretch || bHorz) && sizeFixed.cy != 0)
  2286. sizeFixed.cy += -rect.bottom + rect.top;
  2288. return sizeFixed;
  2289. }
  2293. // dwDockBarMap
  2294. const DWORD dwDockBarMap[4][2] =
  2295. {
  2296. { AFX_IDW_DOCKBAR_TOP,      CBRS_TOP    },
  2297. { AFX_IDW_DOCKBAR_BOTTOM,   CBRS_BOTTOM },
  2298. { AFX_IDW_DOCKBAR_LEFT,     CBRS_LEFT   },
  2299. { AFX_IDW_DOCKBAR_RIGHT,    CBRS_RIGHT  },
  2300. };
  2303. void FrameEnableDocking(CFrameWnd * pFrame, DWORD dwDockStyle) 
  2304. {
  2305. ASSERT_VALID(pFrame);
  2307. // must be CBRS_ALIGN_XXX or CBRS_FLOAT_MULTI only
  2308. ASSERT((dwDockStyle & ~(CBRS_ALIGN_ANY|CBRS_FLOAT_MULTI)) == 0);
  2310. pFrame->EnableDocking(dwDockStyle);
  2312. for (int i = 0; i < 4; i++) {
  2313. if (dwDockBarMap[i][1] & dwDockStyle & CBRS_ALIGN_ANY) {
  2314. CDockBar* pDock = (CDockBar*)pFrame->GetControlBar(dwDockBarMap[i][0]);
  2316. // make sure the dock bar is of correct type
  2317. if( pDock == 0 || ! pDock->IsKindOf(RUNTIME_CLASS(CDockBarEx)) ) {
  2318. BOOL bNeedDelete = ! pDock->m_bAutoDelete;
  2319. pDock->m_pDockSite->RemoveControlBar(pDock);
  2320. pDock->m_pDockSite = 0; // avoid problems in destroying the dockbar
  2321. pDock->DestroyWindow();
  2322. if( bNeedDelete )
  2323. delete pDock;
  2324. pDock = 0;
  2325. }
  2327. if( pDock == 0 ) {
  2328. pDock = new CDockBarEx;
  2329. ASSERT_VALID(pDock);
  2330. if ((!pDock) || (!pDock->Create(pFrame,
  2331. WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_CHILD|WS_VISIBLE |
  2332. dwDockBarMap[i][1], dwDockBarMap[i][0]))) {
  2333. AfxThrowResourceException();
  2334. }
  2335. }
  2336. }
  2337. }
  2338. }
  2341. BOOL CToolBarEx::MarkDefaultState()
  2342. {
  2344.  CToolBarCtrl & tbCtrl = GetToolBarCtrl();
  2346.  //Set intial Visible info
  2347. for (int i=0;i<m_ToolBarInfo.GetSize();i++)
  2348. {
  2349. if  ( (m_ToolBarInfo[i].tbButton.fsStyle & TBSTYLE_SEP) == 0)  //   seperator ?
  2351. {  // Not a seperator
  2352.  if  (tbCtrl.CommandToIndex(m_ToolBarInfo[i].tbButton.idCommand)==-1) // button exists on toolbar
  2353. {
  2354. m_ToolBarInfo[i].bInitiallyVisible=FALSE;
  2355. }
  2356. else
  2357. {
  2358. m_ToolBarInfo[i].bInitiallyVisible=TRUE;
  2359. }
  2360. }
  2361. else
  2362. {
  2363. if (m_ToolBarInfo[i].tbButton.idCommand>0)
  2364. {
  2365. if (tbCtrl.CommandToIndex(m_ToolBarInfo[i].tbButton.idCommand)==-1)
  2366. {
  2367. m_ToolBarInfo[i].bInitiallyVisible=FALSE;
  2368. }
  2369. else
  2370. {
  2371. m_ToolBarInfo[i].bInitiallyVisible=TRUE;
  2372. }
  2373. }
  2374. else
  2375. {
  2376. m_ToolBarInfo[i].bInitiallyVisible=TRUE; // simple seperatores are visible
  2377. }
  2378. }
  2379. }
  2380. return TRUE;
  2381. }