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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 语音合成与识别 > 查看源码
Toolbarex.cpp
资源名称：语音程序.rar　[点击查看]
上传用户：lczygg
上传日期：2007-07-03
资源大小：2947k
文件大小：56k
源码类别：

语音合成与识别

开发平台：

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 )
  157.     // Saving and restoring toolbar
  158.     ON_NOTIFY_REFLECT( TBN_SAVE, OnSave )
  159.     ON_NOTIFY_REFLECT( TBN_RESTORE, OnRestore )
  160. END_MESSAGE_MAP()
  163. /////////////////////////////////////////////////////////////////////////////
  164. // CToolBarEx message handlers
  166. //////////////////////////////////////////////////////////////////////
  167. // 1999 Kirk Stowell - Inserts a control into the toolbar at the given button id.
  168. //
  169. CWnd* CToolBarEx::InsertControl( CRuntimeClass* pClass, LPCTSTR lpszWindowName, CRect& rect, UINT nID, DWORD dwStyle )
  170. {
  171. CWnd *pCtrl = NULL;
  173. if( pClass->IsDerivedFrom( RUNTIME_CLASS( CComboBox ))) // CComboBox control.
  174. {
  175. pCtrl = new CComboBox;
  177. ASSERT_VALID( pCtrl );
  179. if(((CComboBox*)pCtrl)->Create( WS_CHILD|WS_VISIBLE|dwStyle, rect, this, nID ) == FALSE )
  180. {
  181. delete pCtrl;
  182. return NULL;
  183. }
  184. }
  185. //////////// xu add//////////////////////////
  186. else if( pClass->IsDerivedFrom( RUNTIME_CLASS( CProgressCtrl ))) // CProgressCtrl control.
  187. {
  188. pCtrl = new CProgressCtrl;
  190. ASSERT_VALID( pCtrl );
  192. if(((CProgressCtrl*)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( CStatic ))) // CStatic control.
  199. {
  200. pCtrl = new CProgressCtrl;
  202. ASSERT_VALID( pCtrl );
  204. if(((CProgressCtrl*)pCtrl)->Create( WS_CHILD|WS_VISIBLE|dwStyle, rect, this, nID ) == FALSE )
  205. {
  206. delete pCtrl;
  207. return NULL;
  208. }
  209. }
  210. //////////// xu add//////////////////////////
  211. else if( pClass->IsDerivedFrom( RUNTIME_CLASS( CEdit ))) // CEdit control.
  212. {
  213. pCtrl = new CEdit;
  215. ASSERT_VALID( pCtrl );
  217. if(((CEdit*)pCtrl)->Create( WS_CHILD|WS_VISIBLE|dwStyle, rect, this, nID ) == FALSE )
  218. {
  219. delete pCtrl;
  220. return NULL;
  221. }
  222. }
  223. else if( pClass->IsDerivedFrom( RUNTIME_CLASS( CButton ))) // CButton control.
  224. {
  225. pCtrl = new CButton;
  227. ASSERT_VALID( pCtrl );
  229. if(((CButton*)pCtrl)->Create( lpszWindowName, WS_CHILD|WS_VISIBLE|dwStyle, rect, this, nID ) == FALSE )
  230. {
  231. delete pCtrl;
  232. return NULL;
  233. }
  234. }
  235. else if( pClass->IsDerivedFrom( RUNTIME_CLASS( CWnd ))) // CWnd object.
  236. {
  237. pCtrl = new CWnd;
  239. ASSERT_VALID( pCtrl );
  241. #ifdef _UNICODE
  242. TCHAR szClassName[ 256 ];
  244. MultiByteToWideChar( CP_ACP,
  245.  MB_PRECOMPOSED,
  246.  pClass->m_lpszClassName,
  247.  -1,
  248.  szClassName,
  249.  255 );
  251. if(((CWnd*)pCtrl)->Create( szClassName, lpszWindowName, WS_CHILD|WS_VISIBLE|dwStyle, rect, this, nID ) == FALSE )
  252. {
  253. delete pCtrl;
  254. return NULL;
  255. }
  256. #else
  257. if(((CWnd*)pCtrl)->Create( pClass->m_lpszClassName, lpszWindowName, WS_CHILD|WS_VISIBLE|dwStyle, rect, this, nID ) == FALSE )
  258. {
  259. delete pCtrl;
  260. return NULL;
  261. }
  262. #endif
  263. }
  264. else // An invalid object was passed in
  265. {
  266. ASSERT( FALSE );
  267. return NULL;
  268. }
  270. // if our object list has not been allocated, do it now...
  271. if( m_pControls == NULL )
  272. {
  273. m_pControls = new CObList();
  274. ASSERT( m_pControls );
  275. }
  277. // we have to remember this control, so we can delete it later
  278. m_pControls->AddTail( pCtrl );
  280. return InsertControl( pCtrl, rect, nID );
  281. }
  283. CWnd* CToolBarEx::InsertControl(CWnd* pCtrl, CRect & rect, UINT nID)
  284. {
  285. ASSERT_VALID( pCtrl );
  286. ASSERT(IsWindow(pCtrl->m_hWnd));
  288. // make sure the id is valid, and set the button 
  289. // style for a seperator.
  290. int nIndex = CommandToIndex( nID ) ;
  291. if (nIndex>-1)
  292. {
  293. ASSERT( nIndex >= 0 );
  294. SetButtonInfo( nIndex, nID, TBBS_SEPARATOR, rect.Width());
  295. // insert the control into the toolbar.
  296. GetItemRect( nIndex, &rect );
  297. CRect rt;
  298. pCtrl->GetWindowRect(&rt);
  299. rect.top+=max((rect.Height()-rt.Height())/2,0);  //move to middle
  300. pCtrl->SetWindowPos(0, rect.left, rect.top, 0, 0,
  301. SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOCOPYBITS );
  302. pCtrl->SetFont( GetFont( ));
  304. BOOL bVert =  IsVertDocked(); //(m_dwStyle & CBRS_ORIENT_VERT) != 0;
  306. if (bVert && m_bHideChildWndOnVertical)
  307. {
  308.     int nState=GetToolBarCtrl().GetState(nIndex);
  309.     GetToolBarCtrl().SetState(nID,(nState | TBSTATE_HIDDEN));
  310. pCtrl->ShowWindow( SW_HIDE );
  311. }
  312. else
  313. {
  314.     int nState=GetToolBarCtrl().GetState(nIndex);
  315.     GetToolBarCtrl().SetState(nIndex,(nState & ~TBSTATE_HIDDEN));
  316. pCtrl->ShowWindow( SW_SHOW );
  317. }
  319. }
  320. else
  321. {
  322. pCtrl->ShowWindow( SW_HIDE);
  323. }
  325. ModifyStyle(0,WS_CLIPCHILDREN);
  326. return pCtrl;
  327. }
  329. BOOL CToolBarEx::AddDropDownButton(UINT nIDButton, UINT nIDMenu,BOOL bArrow)
  330. {
  331. ASSERT_VALID(this);
  333. CDropDownButtonInfo* pb = FindDropDownButtonInfo(nIDButton);
  335. if (!pb) 
  336. {
  337. pb = new CDropDownButtonInfo;
  338. ASSERT(pb);
  339. pb->pNext = m_pDropButtons;
  340. m_pDropButtons = pb;
  341. }
  343. pb->idButton = nIDButton;
  344. pb->idMenu   = nIDMenu;
  346.    return SetDropDownButton(nIDButton,bArrow);
  347. }
  349. CToolBarEx::CDropDownButtonInfo* CToolBarEx::FindDropDownButtonInfo(UINT nID)
  350. {
  351. for (CDropDownButtonInfo* pb = m_pDropButtons; pb; pb = pb->pNext) 
  352. {
  353. if (pb->idButton == nID)
  354. return pb;
  355. }
  356. return NULL;
  357. }
  359. BOOL CToolBarEx::OnToolBarBtnDropDown(NMHDR* pNMHDR, LRESULT* pRes)
  360. {
  361. UNUSED_ALWAYS( pRes );
  363. const NMTOOLBAR& nmtb = *(NMTOOLBAR*)pNMHDR;
  364.   
  365. // get location of button
  366. CRect rc;
  367. GetToolBarCtrl().GetRect(nmtb.iItem, rc);
  368. ClientToScreen(&rc);
  370. // call virtual function to display dropdown menu
  371. return OnDropDownButtonInfo(nmtb, nmtb.iItem, rc);
  372. }
  374. BOOL CToolBarEx::OnDropDownButtonInfo(const NMTOOLBAR& nmtb, UINT nID, CRect rc)
  375. {
  376. UNUSED_ALWAYS( nID );
  378. CDropDownButtonInfo* pb = FindDropDownButtonInfo(nmtb.iItem);
  379. if (pb && pb->idMenu) 
  380. {
  382. // load and display popup menu
  383. CMenu menu;
  384. VERIFY(menu.LoadMenu(pb->idMenu));
  385. CMenu* pPopup = (CMenu*)menu.GetSubMenu(0);
  386. ASSERT(pPopup);
  387. pPopup->TrackPopupMenu(TPM_LEFTALIGN|TPM_LEFTBUTTON|TPM_VERTICAL,
  388. rc.left, rc.bottom, AfxGetMainWnd(), &rc);
  389. return TRUE;
  390. }
  392. return FALSE;
  393. }
  396. // This function saves the state (visible buttons, toolbar position, etc.)
  397. // of the toolbar, using the registry key provided to the Create(...) function.
  398. void CToolBarEx::SaveState()
  399. {
  400. // if there is an associated registry subkey
  401. if (m_strSubKey.GetLength())
  402. {
  403. // save the toolbar state to the registry
  404. GetToolBarCtrl().SaveState( HKEY_CURRENT_USER, m_strSubKey, m_strValueName );
  405. }
  406. }
  408. // This function restores the state (visible buttons, toolbar position, etc.)
  409. // of the toolbar, using the registry key provided to the Create(...) function.
  410. void CToolBarEx::RestoreState()
  411. {
  412. IconOptions eIconOptions=GetIconOptions();
  413. TextOptions eTextOptions=GetTextOptions();
  415. // if there is an associated registry subkey
  416. if (m_strSubKey.GetLength())
  417. {
  418. // restore the toolbar state from the registry
  419. GetToolBarCtrl().RestoreState( HKEY_CURRENT_USER, m_strSubKey, m_strValueName );
  420. }
  422. //Set Icon/Text options if changed
  423. if (eTextOptions!=GetTextOptions()) SetTextOptions(GetTextOptions(),TRUE);
  424. if (eIconOptions!=GetIconOptions()) SetIconOptions(GetIconOptions(),TRUE);
  426. }
  428. // This function is called when the user begins dragging a toolbar
  429. // button or when the customization dialog is being populated with
  430. // toolbar information.  Basically, *pResult should be populated with
  431. // your answer to the question, "is the user allowed to delete this
  432. // button?".
  433. void CToolBarEx::OnToolBarQueryDelete(NMHDR *pNMHDR, LRESULT *pResult)
  434. {
  435. UNUSED_ALWAYS( pNMHDR );
  437. NMTOOLBAR * tbStruct=(TBNOTIFY *)pNMHDR;
  440. ASSERT(tbStruct);
  441. // do not allow hidden button to be deleted as they just do not go
  442. // to the Add listbox.
  443. if ((tbStruct->tbButton.idCommand) && 
  444. GetToolBarCtrl().IsButtonHidden(tbStruct->tbButton.idCommand))
  445. *pResult = FALSE;
  446. else  
  447. *pResult = TRUE;  
  449. }
  451. // This function is called when the user begins dragging a toolbar
  452. // button or when the customization dialog is being populated with
  453. // toolbar information.  Basically, *pResult should be populated with
  454. // your answer to the question, "is the user allowed to insert a
  455. // button to the left of this one?".
  456. void CToolBarEx::OnToolBarQueryInsert(NMHDR *pNMHDR, LRESULT *pResult)
  457. {
  458. UNUSED_ALWAYS( pNMHDR );
  459. *pResult = TRUE;
  462. }
  464. // This function is called whenever the user makes a change to the
  465. // layout of the toolbar.  Calling the mainframe's RecalcLayout forces
  466. // the toolbar to repaint itself.
  467. void CToolBarEx::OnToolBarChange(NMHDR *pNMHDR, LRESULT *pResult)
  468. {
  469. UNUSED_ALWAYS( pNMHDR );
  470. UNUSED_ALWAYS( pResult );
  473. SetTextOptions(m_eTextOptions,FALSE);
  474. PositionControls();
  476. // force the frame window to recalculate the size
  477. GetParentFrame()->RecalcLayout();
  478. OnIdleUpdateCmdUI(TRUE, 0L);
  480. }
  483. // This function is called when the user initially calls up the toolbar
  484. // customization dialog box.
  485. void CToolBarEx::OnToolBarBeginAdjust(NMHDR *pNMHDR, LRESULT *pResult)
  486. {
  487. UNUSED_ALWAYS( pNMHDR );
  488. UNUSED_ALWAYS( pResult );
  491.     *pResult = 0;
  493. }
  495. LRESULT CToolBarEx::OnCustomize(WPARAM,LPARAM)
  496. {
  497. LONG lResult;
  499. ASSERT(m_pCustomizeDlg==NULL);
  500.     m_pCustomizeDlg = new CCustomizeDialog( this, m_eTextOptions, m_eIconOptions );
  501.     m_hCBTHook = ::SetWindowsHookEx( WH_CBT, CBTProc, 0, ::GetCurrentThreadId() );
  502.     ASSERT( m_hCBTHook != 0 );
  503.  
  504.     lResult = Default();
  506.     VERIFY( ::UnhookWindowsHookEx( m_hCBTHook ) );
  507.     m_hCBTHook = 0;
  509. #ifndef CUSTOM_DRAW
  510.  // if custom draw is not done then update Icon Draw at end
  511.  if (GetIconOptions()!=m_pCustomizeDlg->GetIconOptions())
  512. SetIconOptions(m_pCustomizeDlg->GetIconOptions(),TRUE);
  513. #endif // CUSTOM_DRAW
  515.     delete m_pCustomizeDlg;
  516.     m_pCustomizeDlg = NULL;
  518. SaveState();
  519. ASSERT(m_pCustomizeDlg==NULL);
  521. return  lResult;
  523. }
  525. // This function is called when the user clicks on the help button on the
  526. // toolbar customization dialog box.
  527. void CToolBarEx::OnToolBarCustomHelp(NMHDR *pNMHDR, LRESULT *pResult)
  528. {
  529. UNUSED_ALWAYS( pNMHDR );
  530. UNUSED_ALWAYS( pResult );
  532. TRACE(_T("Help on Customize Toolbar called.n"));
  533. }
  535. // This function is called when the user dismisses the toolbar customization
  536. // dialog box.
  537. void CToolBarEx::OnToolBarEndAdjust(NMHDR *pNMHDR, LRESULT *pResult)
  538. {
  539. UNUSED_ALWAYS( pNMHDR );
  540. UNUSED_ALWAYS( pResult );
  542. }
  544. // This function is called to populate the toolbar customization dialog box
  545. // with information regarding all of the possible toolbar buttons.
  546. void CToolBarEx::OnToolBarGetButtonInfo(NMHDR *pNMHDR, LRESULT *pResult)
  547. {
  548. UNUSED_ALWAYS( pResult );
  550. TBNOTIFY* tbStruct; // data needed by customize dialog box
  552. // init the pointer
  553. tbStruct = (TBNOTIFY *)pNMHDR;
  555. // if the index is valid
  556. if ((0 <= tbStruct->iItem) && (tbStruct->iItem < m_ToolBarInfo.GetSize()))
  557. {
  558. // copy the stored button structure
  559. tbStruct->tbButton = m_ToolBarInfo[tbStruct->iItem].tbButton;
  561. // copy the text for the button label in the dialog
  562. _tcscpy(tbStruct->pszText, m_ToolBarInfo[tbStruct->iItem].btnText);
  564. // indicate valid data was sent
  565. *pResult = TRUE;
  566. }
  567. else   // else there is no button for this index
  568. {
  569. *pResult = FALSE;
  570. }
  571. }
  573. // This function is called when the user clicks on the reset button on the
  574. // toolbar customization dialog box.
  575. void CToolBarEx::OnToolBarReset(NMHDR *pNMHDR, LRESULT *pResult)
  576. {
  577. UNUSED_ALWAYS( pNMHDR );
  578. UNUSED_ALWAYS( pResult );
  581.       int         nCount, i;
  582.   CToolBarCtrl &  tbCtrl =GetToolBarCtrl();
  584.       // Remove all of the existing buttons 
  585.       nCount = tbCtrl.GetButtonCount();
  587.       for(i = nCount - 1; i >= 0; i--)
  588.  tbCtrl.DeleteButton(i);
  589.       
  590.       // Restore the buttons that were saved.
  591.   for (i=0;i<m_ToolBarInfo.GetSize();i++)
  592.   {
  593.   if (m_ToolBarInfo[i].bInitiallyVisible)
  594.  tbCtrl.AddButtons(1,&m_ToolBarInfo[i].tbButton);
  595.   }
  598. if (m_pCustomizeDlg)
  599. {
  600.    ASSERT_VALID(m_pCustomizeDlg);
  601.    m_pCustomizeDlg->SetTextOptions(GetTextOptions());
  602.    m_pCustomizeDlg->SetIconOptions(GetIconOptions());
  603. }
  605. SetTextOptions(m_eInitialTextOptions,FALSE); //Default Values
  606. SetIconOptions(m_eInitialIconOptions,FALSE);   //Default Values 
  609. PositionControls();
  611. // force the frame window to recalculate the size
  612. GetParentFrame()->RecalcLayout();
  613. OnIdleUpdateCmdUI(TRUE, 0L);
  616. *pResult = TRUE;
  617. }
  621. void CToolBarEx::SetToolBarInfoForCustomization(const CToolBarEx::ToolBarInfoArray * pAdditional)
  622. {
  623.  m_ToolBarInfo.RemoveAll();
  624.  const int nCount = GetToolBarCtrl().GetButtonCount();
  625.  m_ToolBarInfo.SetSize(nCount); //SetSize
  628.  CToolBarCtrl & tbCtrl = GetToolBarCtrl();
  630.  for (int i=0;i<nCount;i++)
  631.  {
  632. CToolBarButtonInfo tbButtonInfo;
  634. tbCtrl.GetButton(i,&tbButtonInfo.tbButton);
  635. CString str;
  636. str.LoadString(tbButtonInfo.tbButton.idCommand);
  638. int nPos= str.ReverseFind(_T('n'));
  639. tbButtonInfo.btnText=str.Right(str.GetLength()-nPos-1);
  640. tbButtonInfo.bInitiallyVisible=TRUE;
  642. m_ToolBarInfo.SetAt(i,tbButtonInfo);
  645.  }
  647. m_nResButtons =m_ToolBarInfo.GetSize();
  649.  // add the addiotnal buttons
  650.  if (pAdditional)
  651.  {
  652.    ASSERT_VALID(pAdditional);
  653.    m_ToolBarInfo.Append(*pAdditional);
  654.  }
  656. m_ToolBarInfo.FreeExtra();
  659. ModifyStyle(0, CCS_ADJUSTABLE);
  661. SetTextOptions(m_eInitialTextOptions); //Default Values
  662. SetIconOptions(m_eInitialIconOptions);   //Default Values 
  665. }
  667. /////////////////////////////////////////////////////////////////////////////////////////
  668. // Overrides 
  670. int CToolBarEx::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  671. {
  672. if (CToolBar::OnCreate(lpCreateStruct) == -1)
  673. return -1;
  675. _GetComCtlVersion();
  676. ASSERT(_ComCtlVersion>=VERSION_IE5);
  678. //set version
  679. int nVer=5;
  680. DefWindowProc(CCM_SETVERSION,nVer,0);
  681. ASSERT(nVer==DefWindowProc(CCM_GETVERSION,nVer,0));
  683. return 0;
  684. }
  687. void CToolBarEx::PositionControls()
  688. {
  689. GetToolBarCtrl().AutoSize();
  690. m_bDelayedButtonLayout=TRUE;
  691. }
  694. // the all important function
  695. CSize CToolBarEx::GetButtonSize(TBBUTTON* pData, int iButton, DWORD dwMode)
  696. {
  697. ASSERT(_ComCtlVersion > 0);
  699. // Get the actual size of the button, not what's in m_sizeButton.
  700. // Make sure to do SendMessage instead of calling MFC's GetItemRect,
  701. // which has all sorts of bad side-effects!
  702. // 
  703. CRect rc;
  704. SendMessage(TB_GETITEMRECT, iButton, (LPARAM)&rc);
  705. CSize sz = rc.Size();
  707. DWORD dwStyle = pData[iButton].fsStyle;
  708. BOOL bVertDocked= (!(dwMode&LM_HORZ) && !(dwMode&LM_STRETCH) ) ;
  710. // do not allow sepearot to be greater than Button height ( Have to check this)
  711. if (dwStyle & TBSTYLE_SEP)
  712. sz.cy = min(sz.cy ,HIWORD(GetToolBarCtrl().GetButtonSize()));
  716. // special cas  for custom controls
  717. if (m_bHideChildWndOnVertical)
  718. {
  719. if ((dwStyle & TBSTYLE_SEP) && 
  720. (pData[iButton].idCommand!=0))
  721. {
  723. if (bVertDocked)
  724. {
  725. sz.cx=sz.cy=0;
  726. }
  727. else
  728. {
  729.     // we will get 0,0 on hidden things
  730. if (GetToolBarCtrl().IsButtonHidden(pData[iButton].idCommand))
  731. {
  732.    CWnd * pWnd =GetDlgItem(pData[iButton].idCommand);
  734. ASSERT_VALID(pWnd);
  735. CRect rt;
  736. pWnd->GetWindowRect(rt);
  737. sz=rt.Size();
  738. }
  740. }
  741. }
  742. }  
  743. ////////////////
  744. // Now must do special case for various versions of comctl32.dll,
  745. //
  746. if ((pData[iButton].fsState & TBSTATE_WRAP)) 
  747. {
  748. if (dwStyle & TBSTYLE_SEP) 
  749. {
  750. CWnd *pWnd =GetDlgItem(pData[iButton].idCommand);
  752. // Check seperator is child window
  753. if (!pWnd)
  754. {
  755. // this is the last separator in the row (eg vertically docked)
  756. // fudge the height, and ignore the width. TB_GETITEMRECT will return
  757. // size = (8 x 22) even for a separator in vertical toolbar
  758. //
  759. if (_ComCtlVersion <= VERSION_IE3)
  760. sz.cy -= 3; // empircally good fudge factor
  761. else if (_ComCtlVersion != VERSION_IE4)
  762. sz.cy = sz.cx;
  764. sz.cx = 0; // separator takes no width if it's the last one
  765. }
  766. else
  767. {
  768.   // Do not set value in case of the child window
  769.   //WE should never get here 
  770.   ASSERT_VALID(pWnd);
  771.   ASSERT(FALSE);
  772. }
  774. } 
  777. }
  778. //  // drop down arrow check
  779. //  if ((dwStyle & TBSTYLE_DROPDOWN) && 
  780. //   (bVertDocked) &&
  781. //    !m_bShowDropdownArrowWhenVertical ) 
  782. //  {
  783. // // ignore width of dropdown
  784. // sz.cx = sz.cy;
  785. //  }
  787. return sz;
  788. }
  792. ////////////////////////////////////////////////////////////
  794. #define CX_OVERLAP  0
  796. CSize CToolBarEx::CalcSize(TBBUTTON* pData, int nCount,DWORD dwMode)
  797. {
  798. ASSERT(pData != NULL && nCount > 0);
  800. CPoint cur(0,0);
  801. CSize sizeResult(0,0);
  802. int cyTallestOnRow = 0;
  803. int nButtons=0;
  806. for (int i = 0; i < nCount; i++)
  807. {
  809. // also calculate for hidden custom controls
  810. if (  (pData[i].fsState & TBSTATE_HIDDEN)  &&
  811. !((pData[i].fsStyle & TBSTYLE_SEP) && (pData[i].idCommand!=0)))
  812. continue;
  814. // Load actual size of button into a local variable
  815. //
  816. CSize m_sizeButton = GetButtonSize(pData, i,dwMode);
  819. //  changed the logic below to be more correct.
  820. cyTallestOnRow = max(cyTallestOnRow, m_sizeButton.cy);
  821. sizeResult.cx = max(cur.x + m_sizeButton.cx, sizeResult.cx);
  822. sizeResult.cy = max(cur.y + m_sizeButton.cy, sizeResult.cy);
  824. cur.x += m_sizeButton.cx - CX_OVERLAP;
  825. if (!(pData[i].fsState & TBSTATE_HIDDEN)) nButtons++;
  827. if (pData[i].fsState & TBSTATE_WRAP)
  828. {
  829. //only seperator is present
  830. if ((nButtons==1) && (pData[i].fsStyle & TBSTYLE_SEP))
  831. {
  832. cyTallestOnRow = HIWORD(GetToolBarCtrl().GetButtonSize());
  833. }
  835. cur.x = 0;
  836. cur.y += cyTallestOnRow;
  837. cyTallestOnRow = 0;
  838. if (pData[i].fsStyle & TBSTYLE_SEP)
  839. cur.y += m_sizeButton.cy;
  840.  nButtons=0;
  841. }
  843. }
  844. return sizeResult;
  845. }
  847. int CToolBarEx::WrapToolBar(TBBUTTON* pData, int nCount, int nWidth, DWORD dwMode)
  848. {
  849. ASSERT(pData != NULL && nCount > 0);
  851. int nResult = 0;
  852. int x = 0;
  853. for (int i = 0; i < nCount; i++)
  854. {
  855. pData[i].fsState &= ~TBSTATE_WRAP;
  857. // also calculate for hidden custom controls
  858. if (  (pData[i].fsState & TBSTATE_HIDDEN)  &&
  859. !((pData[i].fsStyle & TBSTYLE_SEP) && (pData[i].idCommand!=0)))
  860. continue;
  862. int dx, dxNext;
  864. // Load actual size of button into a local variable
  865. CSize m_sizeButton = GetButtonSize(pData, i,dwMode);
  867. dx = m_sizeButton.cx;
  868. dxNext = dx - CX_OVERLAP;
  870. if (x + dx > nWidth)
  871. {
  872. BOOL bFound = FALSE;
  873. for (int j = i; j >= 0  &&  !(pData[j].fsState & TBSTATE_WRAP); j--)
  874. {
  875. // Find last separator that isn't hidden
  876. // a separator that has a command ID is not
  877. // a separator, but a custom control.
  878. if ((pData[j].fsStyle & TBSTYLE_SEP) &&
  879. (pData[j].idCommand == 0)
  880. && !(pData[j].fsState & TBSTATE_HIDDEN))
  881. {
  882. bFound = TRUE; i = j; x = 0;
  883. pData[j].fsState |= TBSTATE_WRAP;
  884. nResult++;
  885. break;
  886. }
  887. }
  888. if (!bFound)
  889. {
  890. for (int j = i - 1; j >= 0 && !(pData[j].fsState & TBSTATE_WRAP); j--)
  891. {
  892. // Never wrap anything that is hidden,
  893. // or any custom controls
  894. if ((pData[j].fsState & TBSTATE_HIDDEN) ||
  895. ((pData[j].fsStyle & TBSTYLE_SEP) &&
  896. (pData[j].idCommand != 0)))
  897. continue;
  899. bFound = TRUE; i = j; x = 0;
  900. pData[j].fsState |= TBSTATE_WRAP;
  901. nResult++;
  902. break;
  903. }
  904. if (!bFound)
  905. x += dxNext;
  906. }
  907. }
  908. else
  909. x += dxNext;
  910. }
  911. return nResult + 1;
  912. }
  914. /////////////////////////////////////////////////////////////////////////////////////////////
  916. void CToolBarEx::SizeToolBar(TBBUTTON* pData, int nCount, int nLength, BOOL bVert, DWORD dwMode)
  917. {
  918. ASSERT(pData != NULL && nCount > 0);
  920. if (!bVert)
  921. {
  922. int nMin, nMax, nTarget, nCurrent, nMid;
  924. // Wrap ToolBar as specified
  925. nMax = nLength;
  926. nTarget = WrapToolBar(pData, nCount, nMax,dwMode);
  928. // Wrap ToolBar vertically
  929. nMin = 0;
  930. nCurrent = WrapToolBar(pData, nCount, nMin,dwMode);
  932. if (nCurrent != nTarget)
  933. {
  934. while (nMin < nMax)
  935. {
  936. nMid = (nMin + nMax) / 2;
  937. nCurrent = WrapToolBar(pData, nCount, nMid,dwMode);
  939. if (nCurrent == nTarget)
  940. nMax = nMid;
  941. else
  942. {
  943. if (nMin == nMid)
  944. {
  945. WrapToolBar(pData, nCount, nMax,dwMode);
  946. break;
  947. }
  948. nMin = nMid;
  949. }
  950. }
  951. }
  952. CSize size = CalcSize(pData, nCount,dwMode);
  953. WrapToolBar(pData, nCount, size.cx,dwMode);
  954. }
  955. else
  956. {
  957. CSize sizeMax, sizeMin, sizeMid;
  959. // Wrap ToolBar vertically
  960. WrapToolBar(pData, nCount, 0,dwMode);
  961. sizeMin = CalcSize(pData, nCount,dwMode);
  963. // Wrap ToolBar horizontally
  964. WrapToolBar(pData, nCount, 32767,dwMode);
  965. sizeMax = CalcSize(pData, nCount,dwMode);
  967. while (sizeMin.cx < sizeMax.cx)
  968. {
  969. sizeMid.cx = (sizeMin.cx + sizeMax.cx) / 2;
  970. WrapToolBar(pData, nCount, sizeMid.cx,dwMode);
  971. sizeMid = CalcSize(pData, nCount,dwMode);
  973. if (nLength < sizeMid.cy)
  974. {
  975. if (sizeMin == sizeMid)
  976. {
  977. WrapToolBar(pData, nCount, sizeMax.cx,dwMode);
  978. return;
  979. }
  980. sizeMin = sizeMid;
  981. }
  982. else if (nLength > sizeMid.cy)
  983. {
  984. if (sizeMax == sizeMid)
  985. {
  986. WrapToolBar(pData, nCount, sizeMin.cx,dwMode);
  987. return;
  988. }
  989. sizeMax = sizeMid;
  990. }
  991. else
  992. return;
  993. }
  994. }
  995. }
  998. CSize CToolBarEx::CalcLayout(DWORD dwMode, int nLength)
  999. {
  1000. ASSERT_VALID(this);
  1001. ASSERT(::IsWindow(m_hWnd));
  1002. if (dwMode & LM_HORZDOCK)
  1003. ASSERT(dwMode & LM_HORZ);
  1005. int nCount;
  1006. TBBUTTON* pData = NULL;
  1007. CSize sizeResult(0,0);
  1009. //BLOCK: Load Buttons
  1010. {
  1011. nCount = DefWindowProc(TB_BUTTONCOUNT, 0, 0);
  1012. if (nCount != 0)
  1013. {
  1014. int i;
  1015. pData = new TBBUTTON[nCount];
  1016. for (i = 0; i < nCount; i++)
  1017. _GetButton(i, &pData[i]);
  1018. }
  1019. }
  1021. if (nCount > 0)
  1022. {
  1023. if (!(m_dwStyle & CBRS_SIZE_FIXED))
  1024. {
  1025. BOOL bDynamic = m_dwStyle & CBRS_SIZE_DYNAMIC;
  1027. if (bDynamic && (dwMode & LM_MRUWIDTH))
  1028. SizeToolBar(pData, nCount, m_nMRUWidth,FALSE,dwMode);
  1029. else if (bDynamic && (dwMode & LM_HORZDOCK))
  1030. SizeToolBar(pData, nCount, 32767,FALSE,dwMode);
  1031. else if (bDynamic && (dwMode & LM_VERTDOCK))
  1032. SizeToolBar(pData, nCount, 0,FALSE,dwMode);
  1033. else if (bDynamic && (nLength != -1))
  1034. {
  1035. CRect rect; rect.SetRectEmpty();
  1036. CalcInsideRect(rect, (dwMode & LM_HORZ));
  1037. BOOL bVert = (dwMode & LM_LENGTHY);
  1038. int nLen = nLength + (bVert ? rect.Height() : rect.Width());
  1040. SizeToolBar(pData, nCount, nLen, bVert,dwMode);
  1041. }
  1042. else if (bDynamic && (m_dwStyle & CBRS_FLOATING))
  1043. SizeToolBar(pData, nCount, m_nMRUWidth,FALSE,dwMode);
  1044. else
  1045. SizeToolBar(pData, nCount, (dwMode & LM_HORZ) ? 32767 : 0,FALSE,dwMode);
  1046. }
  1048. sizeResult = CalcSize(pData, nCount,dwMode);
  1050. if (dwMode & LM_COMMIT)
  1051. {
  1052. int nControlCount = 0;
  1053. BOOL bIsDelayed = m_bDelayedButtonLayout;
  1054. m_bDelayedButtonLayout = FALSE;
  1055. BOOL bVert = (m_dwStyle & CBRS_ORIENT_VERT) != 0;
  1058. for (int i = 0; i < nCount; i++)
  1059. if ((pData[i].fsStyle & TBSTYLE_SEP) && (pData[i].idCommand != 0))
  1060. nControlCount++;
  1063. if (nControlCount > 0)
  1064. {
  1066. for(int i = 0; i < nCount; i++)
  1067. {
  1068. if ((pData[i].fsStyle & TBSTYLE_SEP) && (pData[i].idCommand != 0))
  1069. {
  1071. CRect rt;
  1072. CWnd* pWnd = GetDlgItem(pData[i].idCommand);
  1073. if (pWnd != NULL)
  1074. {
  1075. ASSERT_VALID(pWnd);
  1076.        pWnd->GetWindowRect(rt);
  1077. pData[i].iBitmap=rt.Width(); //width 
  1079. if (bVert && m_bHideChildWndOnVertical)
  1080.     pData[i].fsState |= TBSTATE_HIDDEN;
  1081. else    
  1082. pData[i].fsState &= ~TBSTATE_HIDDEN;
  1083. }
  1085. }
  1086. }
  1087. }
  1090. if ((m_dwStyle & CBRS_FLOATING) && (m_dwStyle & CBRS_SIZE_DYNAMIC))
  1091. m_nMRUWidth = sizeResult.cx;
  1092. for (i = 0; i < nCount; i++)
  1093. _SetButton(i, &pData[i]);
  1095. {  
  1096. //Now place the windows
  1097. CWnd * pWnd = GetWindow(GW_CHILD);
  1098. while(pWnd)
  1099. {
  1100.   ASSERT_VALID(pWnd);
  1102.   int id =pWnd->GetDlgCtrlID();
  1103.   ///////////////////////////
  1104. // make sure the id is valid, and set the button 
  1105. // style for a seperator.
  1106. int nIndex = CommandToIndex( id ) ;
  1107. if (nIndex>-1)
  1108. {
  1109. ASSERT( nIndex >= 0 );
  1110. // insert the control into the toolbar.
  1111. CRect rect;
  1112. GetItemRect( nIndex, &rect );
  1114. CRect rt;
  1115. pWnd->GetWindowRect(&rt);
  1116. rect.top+=max((rect.Height()-rt.Height())/2,0);
  1118. pWnd->SetWindowPos(0, rect.left, rect.top, 0, 0,
  1119. SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOCOPYBITS );
  1120. //pWnd->SetFont( GetFont( ));
  1123. if (bVert && m_bHideChildWndOnVertical)
  1124. {
  1125. ASSERT(GetToolBarCtrl().IsButtonHidden(id));
  1126. pWnd->ShowWindow( SW_HIDE );
  1127. }
  1128. else
  1129. {
  1130. ASSERT(!GetToolBarCtrl().IsButtonHidden(id));
  1131. pWnd->ShowWindow( SW_SHOW );
  1132. }
  1134. }
  1135. else
  1136. {
  1137. pWnd->ShowWindow( SW_HIDE);
  1138. }
  1139.   //////////////////////////
  1140.   pWnd=pWnd->GetNextWindow();
  1141. }
  1142. }
  1144. m_bDelayedButtonLayout = bIsDelayed;
  1145. }
  1147. delete[] pData;
  1148. }
  1150. //BLOCK: Adjust Margins
  1151. {
  1152. CRect rect; rect.SetRectEmpty();
  1153. CalcInsideRect(rect, (dwMode & LM_HORZ));
  1154. sizeResult.cy -= rect.Height();
  1155. sizeResult.cx -= rect.Width();
  1157. CSize size = CControlBar::CalcFixedLayout((dwMode & LM_STRETCH), (dwMode & LM_HORZ));
  1158. sizeResult.cx = max(sizeResult.cx, size.cx);
  1159. sizeResult.cy = max(sizeResult.cy, size.cy);
  1160. }
  1161. return sizeResult;
  1162. }
  1164. CSize CToolBarEx::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  1165. {
  1166. DWORD dwMode = bStretch ? LM_STRETCH : 0;
  1167. dwMode |= bHorz ? LM_HORZ : 0;
  1169. return CalcLayout(dwMode);
  1170. }
  1172. CSize CToolBarEx::CalcDynamicLayout(int nLength, DWORD dwMode)
  1173. {
  1174. if ((nLength == -1) && !(dwMode & LM_MRUWIDTH) && !(dwMode & LM_COMMIT) &&
  1175. ((dwMode & LM_HORZDOCK) || (dwMode & LM_VERTDOCK)))
  1176. {
  1177. return CalcFixedLayout(dwMode & LM_STRETCH, dwMode & LM_HORZDOCK);
  1178. }
  1179. return CalcLayout(dwMode, nLength);
  1180. }
  1182. /////////////////////////////////////////////////////////////////////////////
  1183. // CToolBarEx attribute access
  1185. void CToolBarEx::_GetButton(int nIndex, TBBUTTON* pButton) const
  1186. {
  1187. CToolBarEx* pBar = (CToolBarEx*)this;
  1188. VERIFY(pBar->DefWindowProc(TB_GETBUTTON, nIndex, (LPARAM)pButton));
  1189. // TBSTATE_ENABLED == TBBS_DISABLED so invert it
  1190. pButton->fsState ^= TBSTATE_ENABLED;
  1191. }
  1193. void CToolBarEx::_SetButton(int nIndex, TBBUTTON* pButton)
  1194. {
  1195. // get original button state
  1196. TBBUTTON button;
  1197. VERIFY(DefWindowProc(TB_GETBUTTON, nIndex, (LPARAM)&button));
  1199. // prepare for old/new button comparsion
  1200. button.bReserved[0] = 0;
  1201. button.bReserved[1] = 0;
  1202. // TBSTATE_ENABLED == TBBS_DISABLED so invert it
  1203. pButton->fsState ^= TBSTATE_ENABLED;
  1204. pButton->bReserved[0] = 0;
  1205. pButton->bReserved[1] = 0;
  1207. // nothing to do if they are the same
  1208. if (memcmp(pButton, &button, sizeof(TBBUTTON)) != 0)
  1209. {
  1210. // don't redraw everything while setting the button
  1211. DWORD dwStyle = GetStyle();
  1212. ModifyStyle(WS_VISIBLE, 0);
  1213. VERIFY(DefWindowProc(TB_DELETEBUTTON, nIndex, 0));
  1215. // Force a recalc of the toolbar's layout to work around a comctl bug
  1216. int iTextRows = (int)::SendMessage(m_hWnd, TB_GETTEXTROWS, 0, 0);
  1217. ::SendMessage(m_hWnd, WM_SETREDRAW, FALSE, 0);
  1218. ::SendMessage(m_hWnd, TB_SETMAXTEXTROWS, iTextRows+1, 0);
  1219. ::SendMessage(m_hWnd, TB_SETMAXTEXTROWS, iTextRows, 0);
  1220. ::SendMessage(m_hWnd, WM_SETREDRAW, TRUE, 0);
  1223. VERIFY(DefWindowProc(TB_INSERTBUTTON, nIndex, (LPARAM)pButton));
  1224. ModifyStyle(0, dwStyle & WS_VISIBLE);
  1226. // invalidate appropriate parts
  1227. if (((pButton->fsStyle ^ button.fsStyle) & TBSTYLE_SEP) ||
  1228. ((pButton->fsStyle & TBSTYLE_SEP) && pButton->iBitmap != button.iBitmap))
  1229. {
  1230. // changing a separator
  1231. Invalidate();
  1232. }
  1233. else
  1234. {
  1235. // invalidate just the button
  1236. CRect rect;
  1237. if (DefWindowProc(TB_GETITEMRECT, nIndex, (LPARAM)&rect))
  1238. InvalidateRect(rect);
  1239. }
  1240. }
  1241. }
  1250. BOOL CToolBarEx::SetDropDownButton(UINT nID, BOOL bArrow)
  1251. {
  1253. int iButton = CommandToIndex(nID);
  1255. DWORD dwStyle = GetButtonStyle(iButton);
  1256. dwStyle |= TBSTYLE_DROPDOWN|( (!bArrow) ?BTNS_WHOLEDROPDOWN :0);
  1257. SetButtonStyle(iButton, dwStyle);
  1259. GetToolBarCtrl().SetExtendedStyle(GetToolBarCtrl().GetExtendedStyle() |TBSTYLE_EX_DRAWDDARROWS);
  1261. return TRUE;
  1262. }
  1264. BOOL CToolBarEx::IsVertDocked()
  1265. {
  1266. UINT nID =GetParent()->GetDlgCtrlID();
  1267. return ( (nID ==AFX_IDW_DOCKBAR_LEFT) || (nID== AFX_IDW_DOCKBAR_RIGHT));
  1268. }
  1270. void CToolBarEx::OnPaint() 
  1271. {
  1272. CToolBar::OnPaint();
  1274. //I have to use this, as there is not customdraw mesasges for seperators
  1277. // draw the controls seperator again to hide it
  1278. for (int i=0;i<GetToolBarCtrl().GetButtonCount();i++)
  1279. {
  1280. TBBUTTON tb;
  1281. GetToolBarCtrl().GetButton(i,&tb);
  1283. //only for seperators
  1284. if  ( ((tb.fsStyle & TBSTYLE_SEP) == TBSTYLE_SEP) &&
  1285.    (tb.idCommand!=0) )
  1286. {
  1287. CRect rc;
  1288. GetItemRect(i,rc);
  1289. CClientDC dc(this);
  1291. // draw the separator bar in the middle
  1292. int x = (rc.left + rc.right) / 2;
  1293. rc.left = x-1; rc.right = x+1;
  1294. dc.FillSolidRect(rc, m_clrBtnFace);
  1296. }
  1297. }
  1298.  
  1299. }
  1301. void CToolBarEx::SetTextOptions(TextOptions eTextOptions, BOOL bUpdate)
  1302. {
  1303.     ASSERT( ::IsWindow( m_hWnd ) );
  1304.     ASSERT( eTextOptions != toNone );
  1306.     m_eTextOptions = eTextOptions;
  1309.     // Modify toolbar style according to new text options
  1310.     ModifyStyle(
  1311.         ( eTextOptions == toTextOnRight ) ? 0 : TBSTYLE_LIST,
  1312.         ( eTextOptions == toTextOnRight ) ? TBSTYLE_LIST : 0 );
  1314.     CToolBarCtrl& tbCtrl = GetToolBarCtrl();
  1316.     DWORD dwStyleEx = tbCtrl.GetExtendedStyle();
  1318. tbCtrl.SetExtendedStyle(
  1319.         ( eTextOptions == toTextOnRight ) ?
  1320.             ( dwStyleEx |  TBSTYLE_EX_MIXEDBUTTONS ) :
  1321.             ( dwStyleEx & ~TBSTYLE_EX_MIXEDBUTTONS ) );
  1325. for(int i=0;i<m_ToolBarInfo.GetSize();i++)
  1326.   { 
  1327.   // if ((m_ToolBarInfo[i].tbButton.fsStyle & TBSTYLE_SEP) !=  TBSTYLE_SEP)
  1328.   {
  1329.   int nIndex= CommandToIndex(m_ToolBarInfo[i].tbButton.idCommand);
  1330.  
  1331.   if (nIndex>-1)  // buton is there on bar
  1332. {
  1334.  TBBUTTON tbinfo;
  1336. _GetButton(nIndex,&tbinfo);
  1338. if ( !( tbinfo.fsStyle & TBSTYLE_SEP ) )  //check again
  1339. {
  1340.   // attempt to lookup string index in map
  1341. int nString = -1;
  1342. if ((eTextOptions==toTextLabels) || ((eTextOptions==toTextOnRight)))
  1343. {
  1344. void* p=NULL;
  1345. CString strTemp(m_ToolBarInfo[i].btnText);
  1346. if (m_pStringMap != NULL && m_pStringMap->Lookup(strTemp, p))
  1347. nString = (int)p;
  1349. // add new string if not already in map
  1350. if (nString == -1)
  1351. {
  1352. // initialize map if necessary
  1353. if (m_pStringMap == NULL)
  1354. {
  1355. m_pStringMap = new CMapStringToPtr;
  1356. ASSERT(m_pStringMap);
  1357. }
  1359. // add new string to toolbar list
  1360. nString = (int)DefWindowProc(TB_ADDSTRING, 0, (LPARAM)(LPCTSTR)strTemp);
  1361. if (nString != -1)
  1362. {
  1363. // cache string away in string map
  1364. m_pStringMap->SetAt(strTemp, (void*)nString);
  1365. ASSERT(m_pStringMap->Lookup(strTemp, p));
  1366. }
  1367. }
  1369. }
  1373. switch ( eTextOptions )
  1374. {
  1375. case toTextLabels:
  1376. {
  1377. tbinfo.iString =nString;
  1378. tbinfo.fsStyle &= ~BTNS_SHOWTEXT;
  1379. tbinfo.fsStyle |= TBSTYLE_AUTOSIZE;
  1380. }
  1381. break;
  1383. case toTextOnRight:
  1384. {
  1385. if ((nString!=-1) && 
  1386. (HasButtonText(m_ToolBarInfo[i].tbButton.idCommand)))
  1387. {
  1388. tbinfo.iString =nString;
  1389. tbinfo.fsStyle |= ( TBSTYLE_AUTOSIZE |BTNS_SHOWTEXT );
  1390. }
  1391. else
  1392. {
  1393. tbinfo.fsStyle &= ~BTNS_SHOWTEXT;
  1394. tbinfo.fsStyle |= TBSTYLE_AUTOSIZE;
  1395. }
  1396. }
  1397. break;
  1399. case toNoTextLabels:
  1400. {
  1401.   tbinfo.iString= -1;   //Set string to zero
  1402. tbinfo.fsStyle &= ~BTNS_SHOWTEXT;
  1403. tbinfo.fsStyle |= TBSTYLE_AUTOSIZE;
  1404. }
  1405. break;
  1406. default:
  1407. ASSERT(FALSE); // anew type added
  1408. }
  1410. //Delete & add the button
  1411. {
  1412. tbinfo.fsState ^= TBSTATE_ENABLED;
  1413. m_ToolBarInfo[i].tbButton=tbinfo;
  1414. tbinfo.fsState ^= TBSTATE_ENABLED;
  1415. _SetButton(nIndex,&tbinfo);
  1416. }
  1417.   }
  1418. }
  1419. }
  1420. }
  1422. int iTextRows = 0;
  1423. // now total setting
  1424. switch ( eTextOptions )
  1425. {
  1426. case toTextLabels:
  1427. {
  1428.    iTextRows=1;
  1429. }
  1430. break;
  1432. case toTextOnRight:
  1433. {
  1434.    iTextRows=1;
  1435. }
  1436. break;
  1438. case toNoTextLabels:
  1439. {
  1440.    iTextRows=0;
  1441. }
  1442. break;
  1443. default:
  1444. ASSERT(FALSE); // anew type added
  1445. }
  1447. ::SendMessage(m_hWnd, TB_SETMAXTEXTROWS, iTextRows, 0);
  1451.     // If requested, reflect changes immediately
  1452.     if ( bUpdate )
  1453.     {
  1454. PositionControls();
  1455. GetParentFrame()->RecalcLayout();
  1456. OnIdleUpdateCmdUI(TRUE, 0L);
  1457.     }
  1459. }
  1461.  
  1463. void CToolBarEx::SetIconOptions(IconOptions eIconOptions, BOOL bUpdate)
  1464. {
  1465.     ASSERT( ::IsWindow( m_hWnd ) );
  1466.     ASSERT( eIconOptions != ioNone );
  1468.     m_eIconOptions = eIconOptions;
  1471. switch(eIconOptions)
  1472. {
  1473.  case ioSmallIcons:
  1474.  m_sizeImage= m_szImageSmall ;
  1475.  SetIconOptionBitmap(ioSmallIcons);
  1476.  GetToolBarCtrl().SetBitmapSize(m_szImageSmall);
  1477. break;
  1479.  case ioLargeIcons:
  1480.  m_sizeImage= m_szImageLarge ;
  1481.  SetIconOptionBitmap(ioLargeIcons);
  1482.  GetToolBarCtrl().SetBitmapSize(m_szImageLarge);
  1483.  break;
  1484. }
  1486. // Force a recalc of the toolbar's layout to work around a comctl bug
  1487. int iTextRows = (int)::SendMessage(m_hWnd, TB_GETTEXTROWS, 0, 0);
  1488. ::SendMessage(m_hWnd, WM_SETREDRAW, FALSE, 0);
  1489. ::SendMessage(m_hWnd, TB_SETMAXTEXTROWS, iTextRows+1, 0);
  1490. ::SendMessage(m_hWnd, TB_SETMAXTEXTROWS, iTextRows, 0);
  1491. ::SendMessage(m_hWnd, WM_SETREDRAW, TRUE, 0);
  1494.     // If requested, reflect changes immediately
  1495.     if ( bUpdate )
  1496.     {
  1497. PositionControls();
  1498. GetParentFrame()->RecalcLayout();
  1499. OnIdleUpdateCmdUI(TRUE, 0L);
  1500.     }
  1502. }
  1504. //static ftn for Hook
  1506. LRESULT CALLBACK CToolBarEx::CBTProc( int nCode, WPARAM wParam, LPARAM lParam )
  1507. {
  1508.     ASSERT( m_pCustomizeDlg != NULL );
  1510. try
  1511. {
  1512. if ( ( nCode == HCBT_CREATEWND ) && (m_pCustomizeDlg) && ( m_pCustomizeDlg->m_hWnd == 0 ) )
  1513. {
  1514. // This is where we have a good chance to subclass standard
  1515. // "Customize toolbar" dialog in order to add to it some of
  1516. // our new features (ie. text and icon options selectors)
  1517. HWND hWnd = ( HWND )wParam;
  1518. VERIFY( m_pCustomizeDlg->SubclassWindow( hWnd ) );
  1519. }
  1520. }
  1521. catch(...) // if exception is not caught then we can get in infinite loop as assert window is opened.
  1522. {
  1523. TRACE0(_T("Exception thrown while Hooking-Extra Custom features unavaialble.n"));
  1525. //Call next
  1526. LRESULT lResult=::CallNextHookEx( m_hCBTHook, nCode, wParam, lParam );
  1527. VERIFY( ::UnhookWindowsHookEx( m_hCBTHook ) );
  1528. m_hCBTHook = 0;
  1529. if (m_pCustomizeDlg) delete m_pCustomizeDlg;
  1530. m_pCustomizeDlg = NULL;
  1531. return lResult;
  1532. }
  1534.     return ::CallNextHookEx( m_hCBTHook, nCode, wParam, lParam );
  1535. }
  1538. // has to override this
  1539. BOOL CToolBarEx::HasButtonText(int nID)
  1540. {
  1541. nID;
  1542.     return TRUE;
  1543. }
  1545. /*
  1546. DIBs use RGBQUAD format:
  1547. 0xbb 0xgg 0xrr 0x00
  1549. Reasonably efficient code to convert a COLORREF into an
  1550. RGBQUAD is byte-order-dependent, so we need different
  1551. code depending on the byte order we're targeting.
  1552. */
  1553. #define RGB_TO_RGBQUAD(r,g,b)   (RGB(b,g,r))
  1554. #define CLR_TO_RGBQUAD(clr)     (RGB(GetBValue(clr), GetGValue(clr), GetRValue(clr)))
  1558. struct AFX_COLORMAP
  1559. {
  1560. // use DWORD instead of RGBQUAD so we can compare two RGBQUADs easily
  1561. DWORD rgbqFrom;
  1562. int iSysColorTo;
  1563. };
  1565. const AFX_COLORMAP _afxSysColorMap[] =
  1566. {
  1567. // mapping from color in DIB to system color
  1568. { RGB_TO_RGBQUAD(0x00, 0x00, 0x00),  COLOR_BTNTEXT },       // black
  1569. { RGB_TO_RGBQUAD(0x80, 0x80, 0x80),  COLOR_BTNSHADOW },     // dark gray
  1570. { RGB_TO_RGBQUAD(0xC0, 0xC0, 0xC0),  COLOR_BTNFACE },       // bright gray
  1571. { RGB_TO_RGBQUAD(0xFF, 0xFF, 0xFF),  COLOR_BTNHIGHLIGHT }   // white
  1572. };
  1574. static HBITMAP AfxLoadSysColorBitmapSize(HINSTANCE hInst, HRSRC hRsrc,CSize sz)
  1575. {
  1576. HGLOBAL hglb;
  1578. if ((hglb = LoadResource(hInst, hRsrc)) == NULL)
  1579. return NULL;
  1581. LPBITMAPINFOHEADER lpBitmap = (LPBITMAPINFOHEADER)LockResource(hglb);
  1582. if (lpBitmap == NULL)
  1583. return NULL;
  1585. // make copy of BITMAPINFOHEADER so we can modify the color table
  1586. const int nColorTableSize = 16;
  1587. UINT nSize = lpBitmap->biSize + nColorTableSize * sizeof(RGBQUAD);
  1588. LPBITMAPINFOHEADER lpBitmapInfo = (LPBITMAPINFOHEADER)::malloc(nSize);
  1590. if (lpBitmapInfo == NULL) return NULL;
  1592. memcpy(lpBitmapInfo, lpBitmap, nSize);
  1594. // color table is in RGBQUAD DIB format
  1595. DWORD* pColorTable =
  1596. (DWORD*)(((LPBYTE)lpBitmapInfo) + (UINT)lpBitmapInfo->biSize);
  1598. for (int iColor = 0; iColor < nColorTableSize; iColor++)
  1599. {
  1600. // look for matching RGBQUAD color in original
  1601. for (int i = 0; i < sizeof(_afxSysColorMap)/sizeof(_afxSysColorMap[0]); i++)
  1602. {
  1603. if (pColorTable[iColor] == _afxSysColorMap[i].rgbqFrom)
  1604. {
  1605. pColorTable[iColor] =
  1606. CLR_TO_RGBQUAD(::GetSysColor(_afxSysColorMap[i].iSysColorTo));
  1607. break;
  1608. }
  1609. }
  1610. }
  1612. int nWidth = (int)lpBitmapInfo->biWidth;
  1613. int nHeight = (int)lpBitmapInfo->biHeight;
  1614. HDC hDCScreen = ::GetDC(NULL);
  1615. HBITMAP hbm = ::CreateCompatibleBitmap(hDCScreen, sz.cx, sz.cy);
  1617. if (hbm != NULL)
  1618. {
  1619. HDC hDCGlyphs = ::CreateCompatibleDC(hDCScreen);
  1620. HBITMAP hbmOld = (HBITMAP)::SelectObject(hDCGlyphs, hbm);
  1622. LPBYTE lpBits;
  1623. lpBits = (LPBYTE)(lpBitmap + 1);
  1624. lpBits += (1 << (lpBitmapInfo->biBitCount)) * sizeof(RGBQUAD);
  1626. StretchDIBits(hDCGlyphs, 0, 0, sz.cx, sz.cy, 0, 0, nWidth, nHeight,
  1627. lpBits, (LPBITMAPINFO)lpBitmapInfo, DIB_RGB_COLORS, SRCCOPY);
  1628. SelectObject(hDCGlyphs, hbmOld);
  1629. ::DeleteDC(hDCGlyphs);
  1630. }
  1631. ::ReleaseDC(NULL, hDCScreen);
  1633. // free copy of bitmap info struct and resource itself
  1634. ::free(lpBitmapInfo);
  1635. ::FreeResource(hglb);
  1637. return hbm;
  1638. }
  1641. BOOL CToolBarEx::SetIconOptionBitmap(IconOptions eIconOptions)
  1642. {
  1644. if ((m_hInstImageWell != NULL) && (m_hRsrcImageWell != NULL))
  1645. {
  1647. HBITMAP hBitmap=NULL;
  1648. HINSTANCE  hInstImageWell= m_hInstImageWell ;
  1649. HRSRC  hRsrcImageWell =  m_hRsrcImageWell ;
  1651. int nCount = 0;
  1653. for(UINT i=0;i<m_nResButtons;i++)
  1654. {
  1655.  
  1656. if ((m_ToolBarInfo[i].tbButton.idCommand !=0))
  1657. nCount++;
  1658. }
  1660. if (eIconOptions==ioSmallIcons)
  1661. {
  1662. CSize  sizeSmallImage(nCount *m_szImageSmall.cx,m_szImageSmall.cy);
  1663. hBitmap= AfxLoadSysColorBitmapSize(m_hInstImageWell, m_hRsrcImageWell,sizeSmallImage);
  1664. }
  1665. else
  1666. {
  1667. ASSERT(eIconOptions==ioLargeIcons);
  1668. CSize  sizeLargeImage(nCount *m_szImageLarge.cx,m_szImageLarge.cy);
  1669. hBitmap= AfxLoadSysColorBitmapSize(m_hInstImageWell, m_hRsrcImageWell,sizeLargeImage);
  1670. }
  1672. ASSERT(hBitmap);
  1673. SetBitmap(hBitmap);
  1675. m_hInstImageWell = hInstImageWell; // SetBitmap resets these
  1676. m_hRsrcImageWell = hRsrcImageWell; // SetBitmap resets these
  1677. return TRUE;
  1678. }
  1681. return FALSE;
  1682. }
  1684. void CToolBarEx::OnSysColorChange() 
  1685. {
  1686. m_clrBtnShadow=::GetSysColor(COLOR_BTNSHADOW);
  1687. m_clrBtnHilight=::GetSysColor(COLOR_BTNHILIGHT);
  1688. m_clrBtnFace  = ::GetSysColor(COLOR_BTNFACE);
  1689. SetIconOptions(m_eIconOptions); //load bitmap again
  1690. }
  1692. void CToolBarEx::OnSave( NMHDR* pNMHDR, LRESULT* pResult )
  1693. {
  1694.     NMTBSAVE* lpnmtb = ( NMTBSAVE* )pNMHDR;
  1695.     if ( lpnmtb->iItem == -1 )
  1696.     {
  1697.         lpnmtb->cbData  += sizeof( DWORD ) * 2;
  1698.         lpnmtb->pData    = ( LPDWORD )::GlobalAlloc( GMEM_FIXED, lpnmtb->cbData );  //freed by Toolbar ( Not sure)
  1699.         lpnmtb->pCurrent = lpnmtb->pData;
  1701.         *lpnmtb->pCurrent++ = (DWORD)m_eIconOptions;
  1702.         *lpnmtb->pCurrent++ = (DWORD)m_eTextOptions;
  1703.     }
  1705.     *pResult = 0;
  1706. }
  1708. void CToolBarEx::OnRestore( NMHDR* pNMHDR, LRESULT* pResult )
  1709. {
  1710.     NMTBRESTORE* lpnmtb = ( NMTBRESTORE* )pNMHDR;
  1712.     if ( lpnmtb->iItem == -1 )
  1713.     {
  1714.         lpnmtb->cButtons = ( lpnmtb->cbData - sizeof( DWORD ) * 2 ) / lpnmtb->cbBytesPerRecord;
  1715.         lpnmtb->pCurrent = lpnmtb->pData;
  1717.         m_eIconOptions=(IconOptions)*lpnmtb->pCurrent++ ;
  1718.         m_eTextOptions=(TextOptions)*lpnmtb->pCurrent++ ;
  1719.     }
  1721.     *pResult = 0;
  1722. }
  1725. BOOL CToolBarEx::ShowContextMenu(CPoint point)
  1726. {
  1728. if( GetToolBarCtrl().GetButtonCount() && m_ToolBarInfo.GetSize())
  1729. {
  1730. CPoint pt( point );
  1731. ClientToScreen( &pt );
  1733. // load and display popup menu
  1734. CMenu popupMenu;
  1735. VERIFY(popupMenu.CreatePopupMenu());
  1737. CFrameWnd * pFrame=(CFrameWnd *)AfxGetMainWnd();
  1739. if (pFrame && pFrame->IsKindOf(RUNTIME_CLASS(CFrameWnd)) )
  1740. {
  1741. ASSERT_VALID(pFrame);
  1742. POSITION pos = pFrame->m_listControlBars.GetHeadPosition();
  1744. while (pos != NULL)
  1745. {
  1746. const CControlBar* pBar = (CControlBar*)pFrame->m_listControlBars.GetNext(pos);
  1747. ASSERT(pBar != NULL);
  1749. if (pBar && 
  1750. pBar->IsKindOf(RUNTIME_CLASS(CToolBar))) // Put any other type
  1752. {
  1753. ASSERT_VALID(pBar);
  1754. CString strName;
  1755. pBar->GetWindowText(strName);
  1756. popupMenu.AppendMenu( (pBar->GetStyle()&WS_VISIBLE?MF_CHECKED:MF_UNCHECKED)|MF_STRING,
  1757. pBar->GetDlgCtrlID(),
  1758. strName);
  1759. }
  1760. }
  1762. //Add a Seperator
  1763. popupMenu.AppendMenu(MF_SEPARATOR) ;
  1764. }
  1767. //Finally a Customize
  1768. popupMenu.AppendMenu(MF_STRING ,ID_CUSTOMIZE_BAR, STR_CUSTOMIZE);
  1770. int nResult = popupMenu.TrackPopupMenu(TPM_LEFTALIGN|TPM_LEFTBUTTON|TPM_VERTICAL|TPM_RETURNCMD,pt.x, pt.y, this );
  1772. switch(nResult)
  1773. {
  1774. case 0: //Nothing clicked  on menu
  1775. break;
  1776. case ID_CUSTOMIZE_BAR  :
  1777. // open the customization dialog.
  1778. Customize();
  1779. break;
  1780. default:
  1781. {
  1782. ASSERT_VALID(pFrame);
  1783. if (pFrame && pFrame->IsKindOf(RUNTIME_CLASS(CFrameWnd)) )
  1784. {
  1785. pFrame->OnBarCheck(nResult);
  1786. }
  1787. }
  1788. }
  1789. return TRUE;
  1790. }
  1793. return FALSE;
  1795. }
  1797. void CToolBarEx::OnContextMenu(CWnd* pWnd, CPoint point) 
  1798. {
  1799. ASSERT_VALID(pWnd);
  1800. CPoint pt(point);
  1802. if (WindowFromPoint(pt)!=this) return;
  1804. ScreenToClient(&pt);
  1805. if (!ShowContextMenu(pt))
  1806. CToolBar::OnContextMenu(pWnd,point);
  1807. }
  1809. void CToolBarEx::Customize()
  1810. {
  1811. GetToolBarCtrl().Customize();
  1812. }
  1814. void CToolBarEx::OnInitCustomize( NMHDR* /*pNMHDR*/, LRESULT* pResult )
  1815. {
  1816.     *pResult = TBNRF_HIDEHELP;  // help button  is hidden      
  1817. }
  1819. void CToolBarEx::OnNcPaint() 
  1820. {
  1821. if( GetToolBarCtrl().GetStyle()& TBSTYLE_FLAT ) 
  1822. {
  1823. // get window DC that is clipped to the non-client area
  1824. CWindowDC dc(this);
  1825. CRect rectClient;
  1826. GetClientRect(rectClient);
  1827. CRect rectWindow;
  1828. GetWindowRect(rectWindow);
  1829. ScreenToClient(rectWindow);
  1830. rectClient.OffsetRect(-rectWindow.left, -rectWindow.top);
  1831. dc.ExcludeClipRect(rectClient);
  1833. // draw borders in non-client area
  1834. rectWindow.OffsetRect(-rectWindow.left, -rectWindow.top);
  1836. Draw3DBorders(&dc, rectWindow);
  1838. dc.IntersectClipRect(rectWindow);
  1840. // erase parts not drawn
  1841. SendMessage(WM_ERASEBKGND, (WPARAM)dc.m_hDC);
  1843. DrawGripper(&dc,rectWindow);
  1844. } 
  1845. else
  1846. {
  1847. CToolBar::OnNcPaint();
  1848. }
  1849. }
  1851. void CToolBarEx :: Draw3DBorders(CDC * pDC, CRect & rect) 
  1852. {
  1853. ASSERT_VALID(this);
  1854. ASSERT_VALID(pDC);
  1856. if( GetToolBarCtrl().GetStyle()& TBSTYLE_FLAT ) 
  1857. {
  1858. DWORD dwStyle = m_dwStyle;
  1859. if (!(dwStyle & CBRS_BORDER_ANY))
  1860. return;
  1862. COLORREF clr = (m_dwStyle & CBRS_BORDER_3D) ? m_clrBtnHilight : m_clrBtnShadow;
  1863. if(m_dwStyle & CBRS_BORDER_LEFT)
  1864. pDC->FillSolidRect(0, 0, 1, rect.Height() - 1, clr);
  1865. if(m_dwStyle & CBRS_BORDER_TOP)
  1866. pDC->FillSolidRect(0, 0, rect.Width()-1 , 1, clr);
  1867. if(m_dwStyle & CBRS_BORDER_RIGHT)
  1868. pDC->FillSolidRect(rect.right, 1, -1, rect.Height() - 1, m_clrBtnShadow);
  1869. if(m_dwStyle & CBRS_BORDER_BOTTOM)
  1870. pDC->FillSolidRect(0, rect.bottom, rect.Width()-1, -1, m_clrBtnShadow);
  1872. // if undockable toolbar at top of frame, apply special formatting to mesh
  1873. // properly with frame menu
  1874. if(!m_pDockContext) 
  1875. {
  1876. pDC->FillSolidRect(0,0,rect.Width(),1,m_clrBtnShadow);
  1877. pDC->FillSolidRect(0,1,rect.Width(),1,m_clrBtnHilight);
  1878. }
  1880. if (dwStyle & CBRS_BORDER_LEFT)
  1881. ++rect.left;
  1882. if (dwStyle & CBRS_BORDER_TOP)
  1883. ++rect.top;
  1884. if (dwStyle & CBRS_BORDER_RIGHT)
  1885. --rect.right;
  1886. if (dwStyle & CBRS_BORDER_BOTTOM)
  1887. --rect.bottom;
  1888. } 
  1889. else
  1890. {
  1891. DrawBorders(pDC, rect);
  1892. }
  1895. }
  1896.  
  1898. /////////////////////////////////////////////////////////////////////////////
  1899. // CDockBarEx
  1901. CDockBarEx::CDockBarEx()
  1902. {
  1903. // TODO: add construction code here.
  1904. }
  1906. CDockBarEx::~CDockBarEx()
  1907. {
  1908. // TODO: add destruction code here.
  1909. }
  1911. IMPLEMENT_DYNAMIC(CDockBarEx, CDockBar)
  1913. BEGIN_MESSAGE_MAP(CDockBarEx, CDockBar)
  1914. //{{AFX_MSG_MAP(CDockBarEx)   
  1915. // NOTE - the ClassWizard will add and remove mapping macros here.
  1916. //    DO NOT EDIT what you see in these blocks of generated code!
  1917. //}}AFX_MSG_MAP
  1918. END_MESSAGE_MAP()
  1920. /////////////////////////////////////////////////////////////////////////////
  1921. // CDockBarEx message handlers
  1923. CSize CDockBarEx::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  1924. {
  1925. ASSERT_VALID(this);
  1927. CSize sizeFixed = CControlBar::CalcFixedLayout(bStretch, bHorz);
  1929. // get max size
  1930. CSize sizeMax;
  1931. if (!m_rectLayout.IsRectEmpty())
  1932. {
  1933. CRect rect = m_rectLayout;
  1934. CalcInsideRect(rect, bHorz);
  1935. sizeMax = rect.Size();
  1936. }
  1937. else
  1938. {
  1939. CRect rectFrame;
  1940. CFrameWnd* pFrame = GetParentFrame();
  1941. pFrame->GetClientRect(&rectFrame);
  1942. sizeMax = rectFrame.Size();
  1943. }
  1945. // prepare for layout
  1946. AFX_SIZEPARENTPARAMS layout;
  1947. layout.hDWP = m_bLayoutQuery ?
  1948. NULL : ::BeginDeferWindowPos(m_arrBars.GetSize());
  1949. int cxBorder = 2, cyBorder = 2;
  1950. CPoint pt(-cxBorder, -cyBorder);
  1951. int nWidth = 0;
  1953. BOOL bWrapped = FALSE;
  1955. // layout all the control bars
  1956. for (int nPos = 0; nPos < m_arrBars.GetSize(); nPos++)
  1957. {
  1958. CControlBar* pBar = GetDockedControlBar(nPos);
  1959. void* pVoid = m_arrBars[nPos];
  1961. if (pBar != NULL)
  1962. {
  1963. if(pBar->IsKindOf(RUNTIME_CLASS(CToolBarEx)))
  1964. {
  1965.   if (pBar->GetStyle() & TBSTYLE_FLAT)
  1966. cxBorder = cyBorder = 0;
  1967.   else
  1968. cxBorder = cyBorder = 2;
  1969. }
  1970. else
  1971. cxBorder = cyBorder = 2;
  1973. if (pBar->IsVisible())
  1974. {
  1975. // get ideal rect for bar
  1976. DWORD dwMode = 0;
  1977. if ((pBar->m_dwStyle & CBRS_SIZE_DYNAMIC) &&
  1978. (pBar->m_dwStyle & CBRS_FLOATING))
  1979. dwMode |= LM_HORZ | LM_MRUWIDTH;
  1980. else if (pBar->m_dwStyle & CBRS_ORIENT_HORZ)
  1981. dwMode |= LM_HORZ | LM_HORZDOCK;
  1982. else
  1983. dwMode |=  LM_VERTDOCK;
  1985. CSize sizeBar = pBar->CalcDynamicLayout(-1, dwMode);
  1987. CRect rect(pt, sizeBar);
  1989. // get current rect for bar
  1990. CRect rectBar;
  1991. pBar->GetWindowRect(&rectBar);
  1992. ScreenToClient(&rectBar);
  1994. if (bHorz)
  1995. {
  1996. // Offset Calculated Rect out to Actual
  1997. if (rectBar.left > rect.left && !m_bFloating)
  1998. rect.OffsetRect(rectBar.left - rect.left, 0);
  2000. // If ControlBar goes off the right, then right justify
  2001. if (rect.right > sizeMax.cx && !m_bFloating)
  2002. {
  2003. int x = rect.Width() - cxBorder;
  2004. x = max(sizeMax.cx - x, pt.x);
  2005. rect.OffsetRect(x - rect.left, 0);
  2006. }
  2008. // If ControlBar has been wrapped, then left justify
  2009. if (bWrapped)
  2010. {
  2011. bWrapped = FALSE;
  2012. rect.OffsetRect(-(rect.left + cxBorder), 0);
  2013. }
  2014. // If ControlBar is completely invisible, then wrap it
  2015. else if ((rect.left >= (sizeMax.cx - cxBorder)) &&
  2016. (nPos > 0) && (m_arrBars[nPos - 1] != NULL))
  2017. {
  2018. m_arrBars.InsertAt(nPos, (CObject*)NULL);
  2019. pBar = NULL; pVoid = NULL;
  2020. bWrapped = TRUE;
  2021. }
  2022. if (!bWrapped)
  2023. {
  2024. if (rect != rectBar)
  2025. {
  2026. if (!m_bLayoutQuery &&
  2027. !(pBar->m_dwStyle & CBRS_FLOATING))
  2028. {
  2029. pBar->m_pDockContext->m_rectMRUDockPos = rect;
  2030. }
  2031. AfxRepositionWindow(&layout, pBar->m_hWnd, &rect);
  2032. }
  2033. pt.x = rect.left + sizeBar.cx - cxBorder;
  2034. nWidth = max(nWidth, sizeBar.cy);
  2035. }
  2036. }
  2037. else
  2038. {
  2039. // Offset Calculated Rect out to Actual
  2040. if (rectBar.top > rect.top && !m_bFloating)
  2041. rect.OffsetRect(0, rectBar.top - rect.top);
  2043. // If ControlBar goes off the bottom, then bottom justify
  2044. if (rect.bottom > sizeMax.cy && !m_bFloating)
  2045. {
  2046. int y = rect.Height() - cyBorder;
  2047. y = max(sizeMax.cy - y, pt.y);
  2048. rect.OffsetRect(0, y - rect.top);
  2049. }
  2051. // If ControlBar has been wrapped, then top justify
  2052. if (bWrapped)
  2053. {
  2054. bWrapped = FALSE;
  2055. rect.OffsetRect(0, -(rect.top + cyBorder));
  2056. }
  2057. // If ControlBar is completely invisible, then wrap it
  2058. else if ((rect.top >= (sizeMax.cy - cyBorder)) &&
  2059. (nPos > 0) && (m_arrBars[nPos - 1] != NULL))
  2060. {
  2061. m_arrBars.InsertAt(nPos, (CObject*)NULL);
  2062. pBar = NULL; pVoid = NULL;
  2063. bWrapped = TRUE;
  2064. }
  2065. if (!bWrapped)
  2066. {
  2067. if (rect != rectBar)
  2068. {
  2069. if (!m_bLayoutQuery &&
  2070. !(pBar->m_dwStyle & CBRS_FLOATING))
  2071. {
  2072. pBar->m_pDockContext->m_rectMRUDockPos = rect;
  2073. }
  2074. AfxRepositionWindow(&layout, pBar->m_hWnd, &rect);
  2075. }
  2076. pt.y = rect.top + sizeBar.cy - cyBorder;
  2077. nWidth = max(nWidth, sizeBar.cx);
  2078. }
  2079. }
  2080. }
  2081. if (!bWrapped)
  2082. {
  2083. // handle any delay/show hide for the bar
  2084. pBar->RecalcDelayShow(&layout);
  2085. }
  2086. }
  2087. if (pBar == NULL && pVoid == NULL && nWidth != 0)
  2088. {
  2089. // end of row because pBar == NULL
  2090. if (bHorz)
  2091. {
  2092. pt.y += nWidth - cyBorder;
  2093. sizeFixed.cx = max(sizeFixed.cx, pt.x);
  2094. sizeFixed.cy = max(sizeFixed.cy, pt.y);
  2095. pt.x = -cxBorder;
  2096. }
  2097. else
  2098. {
  2099. pt.x += nWidth - cxBorder;
  2100. sizeFixed.cx = max(sizeFixed.cx, pt.x);
  2101. sizeFixed.cy = max(sizeFixed.cy, pt.y);
  2102. pt.y = -cyBorder;
  2103. }
  2104. nWidth = 0;
  2105. }
  2106. }
  2107. if (!m_bLayoutQuery)
  2108. {
  2109. // move and resize all the windows at once!
  2110. if (layout.hDWP == NULL || !::EndDeferWindowPos(layout.hDWP))
  2111. TRACE0("Warning: DeferWindowPos failed - low system resources.n");
  2112. }
  2114. // adjust size for borders on the dock bar itself
  2115. CRect rect;
  2116. rect.SetRectEmpty();
  2117. CalcInsideRect(rect, bHorz);
  2119. if ((!bStretch || !bHorz) && sizeFixed.cx != 0)
  2120. sizeFixed.cx += -rect.right + rect.left;
  2121. if ((!bStretch || bHorz) && sizeFixed.cy != 0)
  2122. sizeFixed.cy += -rect.bottom + rect.top;
  2124. return sizeFixed;
  2125. }
  2129. // dwDockBarMap
  2130. const DWORD dwDockBarMap[4][2] =
  2131. {
  2132. { AFX_IDW_DOCKBAR_TOP,      CBRS_TOP    },
  2133. { AFX_IDW_DOCKBAR_BOTTOM,   CBRS_BOTTOM },
  2134. { AFX_IDW_DOCKBAR_LEFT,     CBRS_LEFT   },
  2135. { AFX_IDW_DOCKBAR_RIGHT,    CBRS_RIGHT  },
  2136. };
  2139. void FrameEnableDocking(CFrameWnd * pFrame, DWORD dwDockStyle) 
  2140. {
  2141. ASSERT_VALID(pFrame);
  2143. // must be CBRS_ALIGN_XXX or CBRS_FLOAT_MULTI only
  2144. ASSERT((dwDockStyle & ~(CBRS_ALIGN_ANY|CBRS_FLOAT_MULTI)) == 0);
  2146. pFrame->EnableDocking(dwDockStyle);
  2148. for (int i = 0; i < 4; i++) {
  2149. if (dwDockBarMap[i][1] & dwDockStyle & CBRS_ALIGN_ANY) {
  2150. CDockBar* pDock = (CDockBar*)pFrame->GetControlBar(dwDockBarMap[i][0]);
  2152. // make sure the dock bar is of correct type
  2153. if( pDock == 0 || ! pDock->IsKindOf(RUNTIME_CLASS(CDockBarEx)) ) {
  2154. BOOL bNeedDelete = ! pDock->m_bAutoDelete;
  2155. pDock->m_pDockSite->RemoveControlBar(pDock);
  2156. pDock->m_pDockSite = 0; // avoid problems in destroying the dockbar
  2157. pDock->DestroyWindow();
  2158. if( bNeedDelete )
  2159. delete pDock;
  2160. pDock = 0;
  2161. }
  2163. if( pDock == 0 ) {
  2164. pDock = new CDockBarEx;
  2165. ASSERT_VALID(pDock);
  2166. if ((!pDock) || (!pDock->Create(pFrame,
  2167. WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_CHILD|WS_VISIBLE |
  2168. dwDockBarMap[i][1], dwDockBarMap[i][0]))) {
  2169. AfxThrowResourceException();
  2170. }
  2171. }
  2172. }
  2173. }
  2174. }
  2177. BOOL CToolBarEx::MarkDefaultState()
  2178. {
  2180.  CToolBarCtrl & tbCtrl = GetToolBarCtrl();
  2182.  //Set intial Visible info
  2183. for (int i=0;i<m_ToolBarInfo.GetSize();i++)
  2184. {
  2185. if  ( (m_ToolBarInfo[i].tbButton.fsStyle & TBSTYLE_SEP) == 0)  //   seperator ?
  2187. {  // Not a seperator
  2188.  if  (tbCtrl.CommandToIndex(m_ToolBarInfo[i].tbButton.idCommand)==-1) // button exists on toolbar
  2189. {
  2190. m_ToolBarInfo[i].bInitiallyVisible=FALSE;
  2191. }
  2192. else
  2193. {
  2194. m_ToolBarInfo[i].bInitiallyVisible=TRUE;
  2195. }
  2196. }
  2197. else
  2198. {
  2199. if (m_ToolBarInfo[i].tbButton.idCommand>0)
  2200. {
  2201. if (tbCtrl.CommandToIndex(m_ToolBarInfo[i].tbButton.idCommand)==-1)
  2202. {
  2203. m_ToolBarInfo[i].bInitiallyVisible=FALSE;
  2204. }
  2205. else
  2206. {
  2207. m_ToolBarInfo[i].bInitiallyVisible=TRUE;
  2208. }
  2209. }
  2210. else
  2211. {
  2212. m_ToolBarInfo[i].bInitiallyVisible=TRUE; // simple seperatores are visible
  2213. }
  2214. }
  2215. }
  2216. return TRUE;
  2217. }