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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 金融证券系统 > 查看源码
GuiToolBarWnd.cpp
资源名称：clking_src.rar　[点击查看]
上传用户：zhanglf88
上传日期：2013-11-19
资源大小：6036k
文件大小：33k
源码类别：

金融证券系统

开发平台：

Visual C++

GuiToolBarWnd.cpp：源码内容
  1. //-----------------------------------------------------------------------//
  2. // This is a part of the GuiLib MFC Extention.  //
  3. // Autor  :  Francisco Campos  //
  4. // (C) 2002 Francisco Campos <www.beyondata.com> All rights reserved     //
  5. // This code is provided "as is", with absolutely no warranty expressed  //
  6. // or implied. Any use is at your own risk.  //
  7. // You must obtain the author's consent before you can include this code //
  8. // in a software library.  //
  9. // If the source code in  this file is used in any application  //
  10. // then acknowledgement must be made to the author of this program  //
  11. // fcampos@tutopia.com  //
  12. //-----------------------------------------------------------------------//
  15. #include "stdafx.h"
  16. #include "GuiToolBarWnd.h"
  17. #include "resource.h"
  18. #include "GuiDrawlayer.h"
  19. #include "GuiDockContext.h"
  20. //#include "GuiColors.h"
  21. #ifdef _DEBUG
  22. #undef THIS_FILE
  23. static char THIS_FILE[]=__FILE__;
  24. #define new DEBUG_NEW
  25. #endif
  26. #define BTNS_SHOWTEXT           0x0040
  28. extern int gbintHorz; //Horz=0, Vert=1
  29. extern CRect rcMenu; //CRect of button
  31. class CDropmenu
  32. {
  33. public:
  34. UINT nIDboton;
  35. UINT nMenu;
  36. CDropmenu(UINT nID,UINT nMENU)
  37. {
  38. nIDboton=nID;
  39. nMenu=nMENU;
  40. }
  41. };
  42. //////////////////////////////////////////////////////////////////////
  43. // Construction/Destruction
  44. //////////////////////////////////////////////////////////////////////
  45. IMPLEMENT_DYNAMIC(CGuiToolBarWnd,CToolBar)
  47. BEGIN_MESSAGE_MAP(CGuiToolBarWnd,CToolBar)
  48. //{{AFX_MSG_MAP(CGuiToolBarWnd)
  49. ON_WM_PAINT()
  50. ON_WM_NCPAINT()
  51. ON_WM_NCCALCSIZE()
  52. ON_WM_WINDOWPOSCHANGING()
  53. ON_WM_LBUTTONDOWN()
  54. ON_NOTIFY_REFLECT_EX(TBN_DROPDOWN,OnDropDown)
  55. ON_WM_TIMER()
  56. ON_WM_LBUTTONUP()
  57. ON_WM_SYSCOLORCHANGE()
  58. ON_WM_SETCURSOR()
  59. ON_WM_CREATE()
  61. //}}AFX_MSG_MAP
  62.  END_MESSAGE_MAP()
  65. int _afxDropDownWidth = -1;
  67. int AFXAPI _AfxGetDropDownWidth()
  68. {
  69. // return cached version if already determined...
  70. if (_afxDropDownWidth != -1)
  71. return _afxDropDownWidth;
  73. // otherwise calculate it...
  74. HDC hDC = GetDC(NULL);
  75. ASSERT(hDC != NULL);
  76. HFONT hFont;
  77. if ((hFont = CreateFont(GetSystemMetrics(SM_CYMENUCHECK), 0, 0, 0,
  78. FW_NORMAL, 0, 0, 0, SYMBOL_CHARSET, 0, 0, 0, 0, _T("Marlett"))) != NULL)
  79. hFont = (HFONT)SelectObject(hDC, hFont);
  80. VERIFY(GetCharWidth(hDC, '6', '6', &_afxDropDownWidth));
  81. if (hFont != NULL)
  82. {
  83. SelectObject(hDC, hFont);
  84. DeleteObject(hFont);
  85. }
  86. ReleaseDC(NULL, hDC);
  87. ASSERT(_afxDropDownWidth != -1);
  88. return _afxDropDownWidth;
  89. }
  91. int CGuiToolBarWnd::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  92. {
  93. lpCreateStruct->dwExStyle |= WS_CLIPCHILDREN; // prevents flashing
  94. if (CToolBar::OnCreate(lpCreateStruct) == -1)
  95. return -1;
  96. if (m_pDockContext==NULL)
  97. m_pDockContext=new CGuiDockContext(this);
  98. ASSERT(m_pDockContext);
  99. //ModifyStyle(WS_CAPTION,0);
  101. return 0;
  102. }
  105. //***********************************************************************************
  106. void CGuiToolBarWnd::OnUpdateCmdUI( CFrameWnd* pTarget, BOOL bDisableIfNoHndler ) 
  107. {
  108.  CToolBar::OnUpdateCmdUI( pTarget, bDisableIfNoHndler ); 
  109. }
  111. //***********************************************************************************
  112. void CGuiToolBarWnd::OnWindowPosChanging(WINDOWPOS FAR* lpwndpos) 
  113. {
  114. CToolBar::OnWindowPosChanging(lpwndpos);
  115. if(!(m_dwStyle & CBRS_FLOATING))  
  116. SetSizes(m_sizeButton, m_sizeImage);
  118. if( !(lpwndpos->flags & SWP_NOMOVE) )
  119. Invalidate(FALSE);
  120. }
  122. //***********************************************************************************
  123. void CGuiToolBarWnd::OnSysColorChange( )
  124. {
  125. CToolBar::OnSysColorChange( );
  126. if(!(m_dwStyle & CBRS_FLOATING))  
  127. SetSizes(m_sizeButton, m_sizeImage);
  128. Invalidate(TRUE);
  129. GetParentFrame()->RecalcLayout();
  130. }
  132. //***********************************************************************************
  134. CGuiToolBarWnd::CGuiToolBarWnd()
  135. {
  136. m_style = Office2000; //Office97;  //by default
  137. m_pArray.RemoveAll();
  138. m_iElements=0;
  139. m_bIsXp=TRUE;
  140. bPressDown=FALSE;
  141. m_imgArrow.Create(IDB_DOCKBAR,9,10,RGB(255,0,255));
  142. _AfxGetDropDownWidth();
  143. //m_iWidthDrowDown=GetSystemMetrics(SM_CXHTHUMB);
  144. CBitmap cbmp;
  145. BITMAP bmp;
  146. cbmp.LoadBitmap(IDB_DOCKBAR);
  147. cbmp.GetBitmap(&bmp);
  148. mHeight=CPoint(bmp.bmWidth,bmp.bmHeight);
  149. // Modified Bu SunZhenyu
  150. if( !m_cfont.CreateStockObject( DEFAULT_GUI_FONT ) )
  151. m_cfont.CreateStockObject( ANSI_VAR_FONT );
  152. // m_cfont.CreateFont(14,0,0,0,400,0,0,0,0,1,2,1,34,_T("Marlett"));
  153. }
  155. CGuiToolBarWnd::~CGuiToolBarWnd()
  156. {
  157. /* Modified By SunZhenyu 2003/8/22, Add next 7 lines. */
  158. for(int i=0; i<m_pArray.GetSize(); i++)
  159. {
  160. CDropmenu * p = (CDropmenu*)m_pArray[i];
  161. if( p )
  162. delete p;
  163. }
  164. m_pArray.RemoveAll();
  165. }
  167. void CGuiToolBarWnd::SetXp(BOOL m_bXp)
  168. {
  169. m_bIsXp=m_bXp;
  170. }
  172. void CGuiToolBarWnd::SetTextButton(int IdButton,CString sztexto)
  173. {
  174. // CToolBarCtrl &tbc=GetToolBarCtrl();
  175. // tbc.SetStyle(tbc.GetStyle()| TBSTYLE_LIST | CCS_ADJUSTABLE);
  177. sztexto+=sztexto.Find( '&' ) == -1 ?"   ":"    ";
  178. CClientDC dc(this);
  179. SetButtonText(IdButton,sztexto);
  180. SetButtonStyle(IdButton,TBSTYLE_AUTOSIZE);
  181. SetSizes(m_sizeButton, m_sizeImage);
  182.             
  183. }
  186. void CGuiToolBarWnd::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp) 
  187. {
  188. CToolBar::OnNcCalcSize(bCalcValidRects, lpncsp);
  189. }
  192. BOOL CGuiToolBarWnd::CreateCombo(CComboBox* pControl,UINT nID,int iSize,DWORD dwStyle)
  193. {
  194. CRect rect;
  195. CFont m_Font;
  196. m_Font.CreateStockObject (DEFAULT_GUI_FONT);
  197. int nIndex = this->GetToolBarCtrl().CommandToIndex(nID);
  198. this->SetButtonInfo(nIndex, nID, TBBS_SEPARATOR, iSize);
  199. this->GetToolBarCtrl().GetItemRect(nIndex, &rect);
  200. rect.bottom-=1;
  201. rect.top = 1;
  202. rect.bottom = rect.top +iSize/*drop height*/;
  203. if(!pControl->Create(dwStyle, rect, this, nID))
  204. {
  205. TRACE(_T("Failed to create combo-boxn"));
  206. return FALSE;
  207. }
  209. return TRUE;
  210. }
  213. BOOL CGuiToolBarWnd::CreateCombo(CComboBoxEx* pControl,UINT nID,int iSize,CImageList* m_imgList,DWORD dwStyle)
  214. {
  215. CRect rect;
  216. int nIndex = this->GetToolBarCtrl().CommandToIndex(nID);
  217. this->SetButtonInfo(nIndex, nID, TBBS_SEPARATOR, iSize);
  218. this->GetToolBarCtrl().GetItemRect(nIndex, &rect);
  219. rect.top = 1;
  220. rect.bottom = rect.top + 250 /*drop height*/;
  221. if(!pControl->Create(dwStyle, rect, this, nID))
  222. {
  223. TRACE(_T("Failed to create combo-boxn"));
  224. return FALSE;
  225. }
  226. pControl->SetImageList(m_imgList);
  227. return TRUE;
  229. }
  231. void CGuiToolBarWnd::AddRowComBoboxEx(CComboBoxEx* pControl,CString szMsg,int iItem,int iImage)
  232. {
  233. COMBOBOXEXITEM cb;
  234. cb.mask=CBEIF_TEXT | CBEIF_IMAGE |CBEIF_SELECTEDIMAGE;       
  236. cb.pszText=(LPTSTR)(LPCTSTR)szMsg;
  237. cb.iItem=iItem;
  238. cb.iImage=cb.iSelectedImage=iImage;
  239. cb.cchTextMax=20; 
  240. pControl->InsertItem(&cb);
  242. }
  244. void CGuiToolBarWnd::SetButtonDropDown(UINT nID,int iImage,UINT nMENU)
  245. {
  246. CToolBarCtrl &m_tbc= GetToolBarCtrl();
  247. m_tbc.SetExtendedStyle(TBSTYLE_EX_DRAWDDARROWS);
  248. m_tbc.SetStyle(m_tbc.GetStyle() | TBSTYLE_LIST | CCS_ADJUSTABLE);
  249. int nIndex = this->GetToolBarCtrl().CommandToIndex(nID);
  250. this->SetButtonInfo(nIndex, nID, TBBS_DROPDOWN, iImage);
  251. m_pArray.SetAtGrow(m_iElements,new CDropmenu(nID,nMENU));
  252. m_iElements++;
  253. }
  255. BOOL CGuiToolBarWnd::OnDropDown(NMHDR* pNMHDR, LRESULT* pRes)
  256. {
  258. const NMTOOLBAR& m_nmTb = *(NMTOOLBAR*)pNMHDR;
  259. CRect rc;
  260. GetToolBarCtrl().GetRect(m_nmTb.iItem, rc);
  261. ClientToScreen(&rc);
  262. for(int i=0; i < m_iElements; i++)
  263. {
  264. if (((CDropmenu*)m_pArray[i])->nIDboton == (UINT)m_nmTb.iItem)
  265. break;
  266. }
  267. bPressDown=TRUE;
  268. CMenu m_menu;
  269. m_menu.LoadMenu(((CDropmenu*)m_pArray[i])->nMenu);
  270. CMenu* m_SubMenu = m_menu.GetSubMenu(0);
  271. gbintHorz=0; //Horz=0, Vert=1
  272. rcMenu=rc; //CRect of button
  273. m_SubMenu->TrackPopupMenu(TPM_LEFTALIGN|TPM_LEFTBUTTON|TPM_VERTICAL,
  274. rc.left, rc.bottom-2, AfxGetMainWnd(), &rc);
  275. bPressDown=FALSE;
  276. return TRUE;
  277. }
  279. void CGuiToolBarWnd::OnNcPaint()
  280. {
  282. CRect rcWindow;
  283. CRect rcClient;
  284. CWindowDC dc(this);
  285. GetWindowRect(&rcWindow);
  286. GetClientRect(&rcClient);
  288.     rcClient.OffsetRect(-rcWindow.TopLeft());
  289.     rcWindow.OffsetRect(-rcWindow.TopLeft());
  290.     ScreenToClient(rcWindow);
  291. rcClient.OffsetRect(-rcWindow.left,-rcWindow.top);
  292. //if (!m_bIsXp)
  293. if (m_dwStyle & CBRS_ORIENT_HORZ && !(m_dwStyle & CBRS_FLOATING))
  294. {rcClient.top+=2;rcClient.left+=1;}
  296. dc.ExcludeClipRect(rcClient);   
  297. rcWindow.OffsetRect(-rcWindow.left, -rcWindow.top);
  298. rcWindow.DeflateRect(1,1);
  299. //pintamos la izquierda
  300. dc.FillSolidRect(0,0,rcWindow.right+1,rcWindow.bottom+2,::GetSysColor(COLOR_BTNFACE)); 
  301. dc.FillSolidRect(0,rcWindow.top+1,rcWindow.right+1,1,::GetSysColor(COLOR_BTNFACE)); 
  302. //pintamos el borde inferior
  303. dc.FillSolidRect(1,rcWindow.bottom-1,rcWindow.right+1,rcWindow.bottom-1,::GetSysColor(COLOR_BTNFACE)); 
  304. dc.FillSolidRect(0,rcWindow.bottom+1,rcWindow.right+1,rcWindow.bottom+1,::GetSysColor(COLOR_BTNFACE )); 
  305. //pintamos la derecha
  306. dc.FillSolidRect(rcWindow.right,0,rcWindow.right-1,rcWindow.bottom,::GetSysColor(COLOR_BTNFACE)); 
  307. dc.FillSolidRect(rcWindow.right+1,-1,rcWindow.right+4,rcWindow.bottom+4,::GetSysColor(COLOR_BTNFACE )); 
  310. dc.IntersectClipRect(rcWindow);
  311. CBrush cb;
  312. cb.CreateSolidBrush(GuiDrawLayer::GetRGBColorXP());
  313. dc.FillRect(rcWindow,&cb);
  315. DrawGripper(&dc,&rcWindow);
  317. }
  319. void CGuiToolBarWnd::OnPaint()
  320. {
  322. CPaintDC dc(this);  
  323. CRect rcBtn;
  325. int nBtn=GetToolBarCtrl().GetButtonCount();
  326. int iBitmap;
  327. UINT nID;
  328. UINT nStyle;
  329. WORD wStyle, wState;
  330. DWORD dwBarStyle = GetToolBarCtrl().GetStyle();
  331. BOOL mbIsPress;
  332. BOOL mbIsEnabled;
  333. CBrush cb;
  334. CImageList m_imgList;
  335. CRect rcUpdate;
  336. int iUltbot;
  337. CRect rcClient;
  338. GetClientRect(&rcClient);
  339. cb.CreateSolidBrush(GuiDrawLayer::GetRGBColorXP());
  341.     // draw borders in non-client area
  342.     CRect rcDraw = rcClient;
  343.  
  344. dc.FillRect(rcDraw, &cb);
  347. HIMAGELIST hiImg = 0;
  348. iBitmap=0;
  349. hiImg = HIMAGELIST(SendMessage(TB_GETIMAGELIST));
  350. m_imgList.Attach(hiImg);
  351. int j=0;
  352. for(int i=0; i < nBtn; i++)
  353. {
  355. bOver=FALSE;
  356. GetItemRect(i,&rcBtn);
  357. GetButtonInfo(i,nID,nStyle,iBitmap);
  358. wStyle= LOWORD(nStyle);
  359. wState= HIWORD(nStyle);
  360. if (wState & TBSTATE_HIDDEN) continue;
  361. if (wStyle == TBSTYLE_SEP)
  362. {
  363. if (!(wState & TBSTATE_WRAP) || ! IsFloating() )
  364. {
  365. CRect m_Separ;
  366. m_Separ=rcBtn;
  368. //si existe un separador vertical
  369. if (m_dwStyle & CBRS_ORIENT_HORZ)
  370. {
  371. dc.FillRect(&rcBtn,&cb);
  372. int nhalf=(m_Separ.Width()/2)-1;
  373. m_Separ.top-=1;
  374. m_Separ.left+=nhalf;
  375. m_Separ.right=m_Separ.left+1;
  376. m_Separ.bottom+=1;
  378. }
  379. else
  380. {
  381. int nhalf=(m_Separ.Width()/2)-1;
  382. int iHeigh=m_Separ.Height();
  384. m_Separ.left=0;
  385. m_Separ.right=m_Separ.left+m_Separ.Height()+1;
  386. m_Separ.top=iUltbot;
  387. m_Separ.bottom=m_Separ.top+m_Separ.Width();
  388. dc.FillRect(&m_Separ,&cb);
  390. m_Separ.left=0;
  391. m_Separ.right=m_Separ.left+iHeigh+1;
  392. m_Separ.top=iUltbot+nhalf;
  393. m_Separ.bottom=m_Separ.top+1;
  396. }
  397. CBrush cbt;
  398. cbt.CreateSolidBrush(RGB(167, 167, 167));
  399. dc.FillRect(m_Separ,&cbt);
  400. continue;
  402. }
  404.  
  405. }
  406. else {
  408. mbIsPress=(wState & TBSTATE_CHECKED) || (wState & TBSTATE_PRESSED);
  409. mbIsEnabled= GetToolBarCtrl().IsButtonEnabled((int)nID);
  410. CPoint pt;
  411. GetCursorPos(&pt);
  412. ScreenToClient(&pt);
  413. CBrush cblu;
  414. if(!rcBtn.PtInRect(pt))
  415. {
  416. if (wState & TBSTATE_CHECKED)
  417. {
  418. cblu.CreateSolidBrush(GuiDrawLayer::GetRGBPressBXP());
  419. dc.FillRect(rcBtn,&cblu);
  420. }
  421. else
  422. {
  423. dc.FillRect(rcBtn,&cb);
  424. }
  425. }
  426. else
  427. {
  429. if (bPressDown)
  430. dc.Draw3dRect(rcBtn,GuiDrawLayer::GetRGBColorShadow(),GuiDrawLayer::GetRGBColorShadow());
  431. else
  432. dc.Draw3dRect(rcBtn,GuiDrawLayer::GetRGBCaptionXP(),GuiDrawLayer::GetRGBCaptionXP());
  433. rcBtn.DeflateRect(1,1);
  434. if (wState & TBSTATE_CHECKED)
  435. {
  436. cblu.CreateSolidBrush(GuiDrawLayer::GetRGBFondoXP());
  437. dc.FillRect(rcBtn,&cblu);
  438. }
  439. else
  440. {
  442. if (bPressDown)
  443. {
  444. cblu.CreateSolidBrush(GuiDrawLayer::GetRGBColorXP());
  445. dc.FillRect(rcBtn,&cblu);
  446. }
  447. else
  448. {
  449. cblu.CreateSolidBrush(mbIsPress?GuiDrawLayer::GetRGBPressBXP():GuiDrawLayer::GetRGBFondoXP());
  450. dc.FillRect(rcBtn,&cblu);
  451. }
  452. if (wStyle == 8) 
  453. {
  455. CRect rcCli=rcBtn;
  456. int dif=rcBtn.right-_afxDropDownWidth;
  457. rcCli.left=dif+1;
  459. if (!bPressDown)
  460. {
  461. CPen Cp( PS_SOLID, 1, GuiDrawLayer::GetRGBCaptionXP());
  462. CPen* oldPen= dc.SelectObject(&Cp);
  463. dc.MoveTo(dif,rcBtn.top);
  464. dc.LineTo(dif,rcBtn.bottom);
  465. dc.SelectObject(oldPen);
  466. }
  468. }
  469. if (!mbIsPress && !bPressDown)
  470. bOver=TRUE;
  471. else
  472. bOver=FALSE;
  473. if (!bPressDown) 
  474. SetTimer(1,10,NULL);
  475. else
  476. KillTimer(1);
  478. }
  479. rcBtn.InflateRect(1,1);
  481. }
  483. }
  485. if (wStyle != TBSTYLE_SEP)
  486. {
  488. int OldMode=dc.SetBkMode(TRANSPARENT);
  489. IMAGEINFO pImageInfo;
  490. m_imgList.GetImageInfo(iBitmap,&pImageInfo);
  491. CRect rcima =pImageInfo.rcImage;
  492. CSize siImg=CSize(rcima.Width(),rcima.Height());
  493. /* Modified By SunZhenyu 2003/6/27, Replace by the next 5 lines, CPoint pti(rcBtn.left+2,rcBtn.top+4); */
  494. CPoint pti(rcBtn.left+(rcBtn.Width()-siImg.cx)/2,rcBtn.top+4);
  495. if( dwBarStyle & TBSTYLE_LIST ) // 文字在右边
  496. pti = CPoint(rcBtn.left+4,rcBtn.top+(rcBtn.Height()-siImg.cy)/2);
  497. else if( wStyle & TBSTYLE_DROPDOWN )
  498. pti.x -= _AfxGetDropDownWidth()/2;
  499. CString mszText=GetButtonText(i);
  500. CFont* m_fontOld=dc.SelectObject(&m_cfont);
  501. if (!(wState & TBSTATE_ENABLED))
  502. {
  503. if (bOver==TRUE)
  504. {
  505. pti.x+=1;
  506. pti.y+=1;
  507. dc.DrawState(pti,siImg,m_imgList.ExtractIcon(iBitmap),DSS_MONO,CBrush (GuiDrawLayer::GetRGBColorShadow()));
  508. pti.x-=2; pti.y-=2;
  510. }
  511. m_imgList.Draw(&dc, iBitmap, pti, ILD_TRANSPARENT);
  512. if (mszText.GetLength() > 0 && !bVertDocked)
  513. {
  514. CRect m_rctext=rcBtn;
  515. /* Modified By SunZhenyu 2003/6/27, Replace by the next 6 line, m_rctext.left+=siImg.cx+4; */
  516. if( dwBarStyle & TBSTYLE_LIST )
  517. m_rctext.left += siImg.cx+4;
  518. else
  519. m_rctext.top += siImg.cy+4;
  520. if( wStyle & TBSTYLE_DROPDOWN )
  521. m_rctext.right -= _AfxGetDropDownWidth();
  522. m_rctext.bottom-=1;
  523. /* Modified By SunZhenyu 2003/6/27, Replace by the next 5 line
  524. dc.DrawText(mszText,&m_rctext,DT_SINGLELINE|DT_BOTTOM|DT_CENTER);
  525. */
  526. m_rctext.right-=1;
  527. if( dwBarStyle & TBSTYLE_LIST )
  528. dc.DrawText(mszText,&m_rctext,DT_SINGLELINE|DT_VCENTER|DT_RIGHT);
  529. else
  530. dc.DrawText(mszText,&m_rctext,DT_SINGLELINE|DT_BOTTOM|DT_CENTER);
  531. }
  532. }
  533. else
  534. {
  535. dc.DrawState(pti,siImg,m_imgList.ExtractIcon(iBitmap),DSS_DISABLED,(CBrush*)NULL);
  536. CRect m_rctext=rcBtn;
  537. /* Modified By SunZhenyu 2003/6/27, Replace by the next 5 line, m_rctext.left+=siImg.cx+4; */
  538. if( dwBarStyle & TBSTYLE_LIST )
  539. m_rctext.left += siImg.cx+4;
  540. else
  541. m_rctext.top += siImg.cy+4;
  542. m_rctext.bottom-=1;
  543. CSize szText=dc.GetTextExtent(mszText);
  544. /* Modified By SunZhenyu 2003/6/27, Replace by the next 4 lines,
  545. pti.x= m_rctext.left+2;
  546. pti.y= (m_rctext.Height()/2)-1;
  547. */
  548. pti.x = m_rctext.left+(m_rctext.Width()-szText.cx)/2;
  549. if( wStyle & TBSTYLE_DROPDOWN )
  550. pti.x = m_rctext.left+(m_rctext.Width()-szText.cx-_AfxGetDropDownWidth())/2;
  551. pti.y= m_rctext.top+(m_rctext.Height()-szText.cy)/2;
  552. //DrawState(pt, m_Csize, m_szCaption, DSS_DISABLED, TRUE, 0, (HBRUSH)NULL);
  553. dc.DrawState(pti,szText,mszText,DSS_DISABLED,TRUE,0,(HBRUSH)NULL);
  554. }
  556. if (wStyle == TBSTYLE_DROPDOWN) 
  557. DrawArrow(&dc,rcBtn);
  558. dc.SetBkMode(OldMode);
  559. // Modified By SunZhenyu
  560. dc.SelectObject(m_fontOld);
  561. iBitmap++;
  562. iUltbot=rcBtn.bottom;
  563. j++;
  564. }
  565. }
  566. m_imgList.Detach();
  569.     ReleaseDC(&dc);
  571.   
  572. }
  575. void CGuiToolBarWnd::DrawArrow(CDC* pDC,CRect m_rc)
  576. {
  577. int difh =m_rc.Height()-mHeight.y;
  578. difh/=2;
  580. m_rc.left=m_rc.right-_AfxGetDropDownWidth();
  581. m_imgArrow.Draw(pDC,0,CPoint(m_rc.left+2,m_rc.top+difh),ILD_TRANSPARENT);
  583. }
  585. void CGuiToolBarWnd::DrawGripper(CWindowDC* dc,CRect* rcWin)
  586. {
  588. if (m_dwStyle & CBRS_FLOATING) return ;
  589. if(!m_bIsXp) //no es XP
  590. {
  591. if (m_dwStyle & CBRS_ORIENT_HORZ)
  592. {
  593. rcWin->top+=2;
  594. rcWin->left+=2;
  595. rcWin->right=rcWin->left+3;
  596. rcWin->bottom-=1;
  597. dc->Draw3dRect(rcWin,::GetSysColor(COLOR_BTNHIGHLIGHT),
  598.  ::GetSysColor(COLOR_BTNSHADOW));
  599. if (m_style == Office97)
  600. {
  601. rcWin->left=rcWin->right+1;
  602. rcWin->right=rcWin->left+3;
  603. dc->Draw3dRect(rcWin,::GetSysColor(COLOR_BTNHIGHLIGHT),
  604.  ::GetSysColor(COLOR_BTNSHADOW));
  605. }
  606. }
  607. else
  608. {
  609. rcWin->top+=2;
  610. //rcWin->left+=1;
  611. rcWin->right-=2;
  612. rcWin->bottom=rcWin->top+3;
  613. dc->Draw3dRect(rcWin,::GetSysColor(COLOR_BTNHIGHLIGHT),
  614.  ::GetSysColor(COLOR_BTNSHADOW));
  615. if (m_style == Office97)
  616. {
  617. rcWin->top=rcWin->bottom+1;
  618. rcWin->bottom=rcWin->top+3;
  619. dc->Draw3dRect(rcWin,::GetSysColor(COLOR_BTNHIGHLIGHT),
  620.  ::GetSysColor(COLOR_BTNSHADOW));
  621. }
  623. }
  624. }
  625. else
  626. {
  627. if (m_dwStyle & CBRS_ORIENT_HORZ)
  628. {
  630. rcWin->top+=5;
  631. rcWin->left+=4;
  632. rcWin->right=rcWin->left+3;
  633. rcWin->bottom-=3;
  635. for (int i=0; i < rcWin->Height(); i+=2)
  636. {
  637. CRect rcWindow;
  638. CBrush cb;
  639. cb.CreateSolidBrush(::GetSysColor(COLOR_BTNSHADOW));
  640. rcWindow=rcWin;
  641. rcWindow.top=rcWin->top+i;
  642. rcWindow.bottom=rcWindow.top+1;
  643. dc->FillRect(rcWindow,&cb);
  645. }
  647. }
  648. else
  649. {
  650. rcWin->top+=2;
  651. rcWin->left+=2;
  652. rcWin->right-=2;
  653. rcWin->bottom=rcWin->top+3;
  654. for (int i=0; i < rcWin->Width(); i+=2)
  655. {
  656. CRect rcWindow;
  657. CBrush cb;
  658. cb.CreateSolidBrush(::GetSysColor(COLOR_BTNSHADOW));
  659. rcWindow=rcWin;
  660. rcWindow.left=rcWindow.left+i;
  661. rcWindow.right=rcWindow.left+1;
  662. dc->FillRect(rcWindow,&cb);
  664. }
  666. }
  667. }
  669. }
  671. void CGuiToolBarWnd::OnLButtonDown(UINT nFlags, CPoint point) 
  672. {
  673. CToolBar::OnLButtonDown(nFlags, point);
  675. if (m_iSelected == 1) return;
  676. m_iSelected =1;
  680. }
  682. BOOL CGuiToolBarWnd::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  683. {
  685. CPoint ptCurPos; 
  686. CRect rc;GetClientRect(rc);
  687. GetCursorPos (&ptCurPos);
  688. ScreenToClient (&ptCurPos);
  689. if (m_dwStyle & CBRS_ORIENT_HORZ)
  690. {
  691. rc.right=rc.left+2;
  692. if (ptCurPos.x< 0)
  693. {
  694. SetCursor (LoadCursor(NULL, IDC_SIZEALL));
  695. return TRUE;
  696. }
  697. }
  698. else
  699. {
  700. rc.bottom=rc.top+2;
  701. if (ptCurPos.y< 0)
  702. {
  703. SetCursor (LoadCursor(NULL, IDC_SIZEALL));
  704. return TRUE;
  705. }
  706. }
  707. return CToolBar::OnSetCursor(pWnd, nHitTest, message);
  709. }
  713. void CGuiToolBarWnd::OnLButtonUp(UINT nFlags, CPoint point) 
  714. {
  715. CToolBar::OnLButtonUp(nFlags, point);
  717. if (m_iSelected == 1)
  718. {
  719. m_iSelected =0;
  720. KillTimer(1);
  721. SetTimer(1,10,NULL);
  722. }
  723. }
  725. void CGuiToolBarWnd::OnTimer(UINT nIDEvent) 
  726. {
  727. // TODO: Add your message handler code here and/or call default
  728. CRect m_rect;
  729. CPoint pt(GetMessagePos());
  730. ScreenToClient(&pt);
  731. GetClientRect(m_rect);
  732. if (nIDEvent == 1)
  733. {
  735. if (!m_rect.PtInRect(pt))
  736. {
  737. m_iSelected =0;
  738. KillTimer(1);
  739. Invalidate();
  740. UpdateWindow();
  742. }
  743. }
  744. CToolBar::OnTimer(nIDEvent);
  745. }
  749. //**************************************************************************
  750. int CGuiToolBarWnd::GetLastPos()
  751. {
  753. int nNumBars=(int)m_pDockBar->m_arrBars.GetSize();
  754. int m_pos=m_pDockBar->FindBar(this);
  755. for(int i=m_pos+1; i< nNumBars;i++)
  756. {
  757. if (m_pDockBar->m_arrBars[i]== NULL)
  758.     return i-1;
  759. }
  760. return -1;
  761. }
  763. //**************************************************************************
  764. int CGuiToolBarWnd::GetFirstPos()
  765. {
  766. int m_pos=m_pDockBar->FindBar(this);
  767. for(int i=m_pos; i>=0;i--)
  768. {
  769. if (m_pDockBar->m_arrBars[i]== NULL)
  770.     return i+1;
  771. }
  772. return -1;
  774. }
  775. //**************************************************************************
  776. CRect CGuiToolBarWnd::GetDockRect()
  777. {
  778. CRect rcWin;
  779. if (IsVert())
  780. if (IsLeft())
  781. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_LEFT)->GetWindowRect(rcWin);
  782. else
  783. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_RIGHT)->GetWindowRect(rcWin);
  784. else
  785. if(IsBottom())
  786. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_BOTTOM)->GetWindowRect(rcWin);
  787. else
  788. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_TOP)->GetWindowRect(rcWin);
  789. return rcWin;
  790. }
  791. //**************************************************************************
  792. int CGuiToolBarWnd::GetHiWid()
  793. {
  794. CRect rcWin;
  795. rcWin=GetDockRect();
  796. if (IsVert())
  797. return rcWin.Height() ;
  798. else
  799. return rcWin.Width() ;
  800. }
  801. //**************************************************************************
  803. void CGuiToolBarWnd::SetRealSize()
  804. {
  805. CRect rcWinFrame;
  806. CRect rcThisBar;
  808. int nVisibles=0;
  810. int nThis = m_pDockBar->FindBar(this);
  811. int nFirst= GetFirstPos();
  812. int nLast=  GetLastPos();
  813. UINT m_nDockBarID = m_pDockBar->GetDlgCtrlID();
  814. int  nMaxlen=GetHiWid();
  815.     int  nLen=0; 
  816. for (int i=nFirst;i <nLast;  i++)
  817. {
  819. CGuiToolBarWnd* pBar;
  820. pBar = (CGuiToolBarWnd*) m_pDockBar->m_arrBars[i];
  821. if (HIWORD(pBar) == 0) continue; 
  822. if (!pBar->IsVisible()) continue;
  824. CRect rc;
  825. pBar->GetWindowRect(rc);
  826. if (IsVert())
  827. nLen+=rc.Height() ;
  828. else
  829. nLen+= rc.Width() ;
  830. nVisibles++;
  831. }
  833. if ( nLen > nMaxlen)
  834. {
  835. int nDif=nLen-nMaxlen;
  838. }
  842. /* if (rcThisBar.Width() > nAfterThis)
  843. {
  844. if (nVisibles > 0)
  845. nAfterThis/=nVisibles;
  848. }
  849. */
  850. }
  852. #define CX_OVERLAP  0
  853. //***************************************************************************
  854. CSize  CGuiToolBarWnd::CalcSize(TBBUTTON* pData, int nCount)
  855. {
  856. ASSERT(pData != NULL && nCount > 0);
  857. BOOL bDrow=FALSE;
  858. int  nNumDrow=0;
  859. CPoint cur(0,0);
  860. CSize sizeResult(0,0);
  861. CClientDC dc(this);
  862. int xSizeMin=32;
  863. if(m_dwStyle & CBRS_FLOATING )  
  864. SetSizes(m_sizeButton, m_sizeImage);
  865. if (bVertDocked)
  866.  ::SendMessage(m_hWnd, TB_SETMAXTEXTROWS, 0, 0);
  867. else
  868.  ::SendMessage(m_hWnd, TB_SETMAXTEXTROWS, 1, 0);
  869. //CFont* m_fontOld=dc.SelectObject(&m_cfont);
  870. // SetRealSize();
  871. DWORD dwExtendedStyle = DefWindowProc(TB_GETEXTENDEDSTYLE, 0, 0);
  872. for (int i = 0; i < nCount; i++)
  873. {
  875. if ((pData[i].fsStyle &  TBSTYLE_SEP) &&(pData[i].idCommand!=0))
  876. {
  877.     if (bVertDocked)
  878. {
  879.  CWnd * pWnd =GetDlgItem(pData[i].idCommand);
  880.  ASSERT_VALID(pWnd);
  881.  pWnd->ShowWindow( SW_HIDE   );
  882.  pData[i].fsState |= TBSTATE_HIDDEN;
  883.  continue;
  885. }
  886. else
  887. {
  889. CWnd * pWnd =GetDlgItem(pData[i].idCommand);
  890. ASSERT_VALID(pWnd);
  891. pData[i].fsState &= ~TBSTATE_HIDDEN;
  892. pWnd->ShowWindow( SW_SHOW   );
  895. }
  896. }
  898. int cySep = pData[i].iBitmap;
  899. cySep = cySep * 2 / 3;
  900. CRect rci;
  901. GetItemRect(i, &rci);
  902. int cx=rci.Width();
  903. xSizeMin=min(xSizeMin,cx);
  904. if (pData[i].fsStyle & TBSTYLE_SEP)
  905. {
  906. // a separator represents either a height or width
  907. if (pData[i].fsState & TBSTATE_WRAP)
  908. sizeResult.cy = max(cur.y + m_sizeButton.cy + cySep, sizeResult.cy);
  909. else
  910. sizeResult.cx = max(cur.x + pData[i].iBitmap, sizeResult.cx);
  911. }
  912. else
  913. {
  914. // check for dropdown style, but only if the buttons are being drawn
  915. if ((pData[i].fsStyle & TBSTYLE_DROPDOWN) &&
  916. (dwExtendedStyle & TBSTYLE_EX_DRAWDDARROWS))
  917. {
  918. // add size of drop down
  919. cx += (_afxDropDownWidth);
  920. nNumDrow++;
  921. bDrow=TRUE;
  922. }
  923. sizeResult.cx = max(cur.x + cx, sizeResult.cx);
  924. sizeResult.cy = max(cur.y + m_sizeButton.cy, sizeResult.cy);
  925. }
  929. if (pData[i].fsStyle & TBSTYLE_SEP)
  930. cur.x += pData[i].iBitmap;
  931. else
  932. cur.x += cx - CX_OVERLAP;
  934. if (pData[i].fsState & TBSTATE_WRAP)
  935. {
  936. cur.x = 0;
  937. cur.y += m_sizeButton.cy;
  938. if (pData[i].fsStyle & TBSTYLE_SEP)
  939. cur.y += cySep;
  940. }
  941. }
  942. if (bDrow == TRUE)
  943. {
  945. if (bVertDocked)
  946. {
  947. sizeResult.cx-=_afxDropDownWidth;
  948. sizeResult.cy+=_afxDropDownWidth-2;//*nNumDrow;
  949. }
  950. else
  951. {
  952. sizeResult.cx-=_afxDropDownWidth*nNumDrow;
  953. }
  954. }
  955. else
  956. {
  957. if (bVertDocked)
  958. sizeResult.cy+=_afxDropDownWidth/2;
  959. }
  960. return sizeResult;
  961. }
  963. int  CGuiToolBarWnd::WrapToolBar(TBBUTTON* pData, int nCount, int nWidth)
  964. {
  965. ASSERT(pData != NULL && nCount > 0);
  967. int nResult = 0;
  968. int x = 0;
  969. for (int i = 0; i < nCount; i++)
  970. {
  971. pData[i].fsState &= ~TBSTATE_WRAP;
  973. if (pData[i].fsState & TBSTATE_HIDDEN)
  974. continue;
  976. int dx, dxNext;
  977. if (pData[i].fsStyle & TBSTYLE_SEP)
  978. {
  979. dx = pData[i].iBitmap;
  980. dxNext = dx;
  981. }
  982. else
  983. {
  984. dx = m_sizeButton.cx;
  985. dxNext = dx - CX_OVERLAP;
  986. }
  988. if (x + dx > nWidth)
  989. {
  990. BOOL bFound = FALSE;
  991. for (int j = i; j >= 0  &&  !(pData[j].fsState & TBSTATE_WRAP); j--)
  992. {
  993. // Find last separator that isn't hidden
  994. // a separator that has a command ID is not
  995. // a separator, but a custom control.
  996. if ((pData[j].fsStyle & TBSTYLE_SEP) &&
  997. (pData[j].idCommand == 0) &&
  998. !(pData[j].fsState & TBSTATE_HIDDEN))
  999. {
  1000. bFound = TRUE; i = j; x = 0;
  1001. pData[j].fsState |= TBSTATE_WRAP;
  1002. nResult++;
  1003. break;
  1004. }
  1005. }
  1006. if (!bFound)
  1007. {
  1008. for (int j = i - 1; j >= 0 && !(pData[j].fsState & TBSTATE_WRAP); j--)
  1009. {
  1010. // Never wrap anything that is hidden,
  1011. // or any custom controls
  1012. if ((pData[j].fsState & TBSTATE_HIDDEN) ||
  1013. ((pData[j].fsStyle & TBSTYLE_SEP) &&
  1014. (pData[j].idCommand != 0)))
  1015. continue;
  1017. bFound = TRUE; i = j; x = 0;
  1018. pData[j].fsState |= TBSTATE_WRAP;
  1019. nResult++;
  1020. break;
  1021. }
  1022. if (!bFound)
  1023. x += dxNext;
  1024. }
  1025. }
  1026. else
  1027. x += dxNext;
  1028. }
  1029. return nResult + 1;
  1030. }
  1032. void   CGuiToolBarWnd::SizeToolBar(TBBUTTON* pData, int nCount, int nLength, BOOL bVert)
  1033. {
  1034. ASSERT(pData != NULL && nCount > 0);
  1035. bVert;
  1036. if (!bVert)
  1037. {
  1038. int nMin, nMax, nTarget, nCurrent, nMid;
  1040. // Wrap ToolBar as specified
  1041. nMax = nLength;
  1042. nTarget = WrapToolBar(pData, nCount, nMax);
  1044. // Wrap ToolBar vertically
  1045. nMin = 0;
  1046. nCurrent = WrapToolBar(pData, nCount, nMin);
  1048. if (nCurrent != nTarget)
  1049. {
  1050. while (nMin < nMax)
  1051. {
  1052. nMid = (nMin + nMax) / 2;
  1053. nCurrent = WrapToolBar(pData, nCount, nMid);
  1055. if (nCurrent == nTarget)
  1056. nMax = nMid;
  1057. else
  1058. {
  1059. if (nMin == nMid)
  1060. {
  1061. WrapToolBar(pData, nCount, nMax);
  1062. break;
  1063. }
  1064. nMin = nMid;
  1065. }
  1066. }
  1067. }
  1068. CSize size = CalcSize(pData, nCount);
  1069. WrapToolBar(pData, nCount, size.cx);
  1070. }
  1071. else
  1072. {
  1073. CSize sizeMax, sizeMin, sizeMid;
  1075. // Wrap ToolBar vertically
  1076. WrapToolBar(pData, nCount, 0);
  1077. sizeMin = CalcSize(pData, nCount);
  1079. // Wrap ToolBar horizontally
  1080. WrapToolBar(pData, nCount, 32767);
  1081. sizeMax = CalcSize(pData, nCount);
  1083. while (sizeMin.cx < sizeMax.cx)
  1084. {
  1085. sizeMid.cx = (sizeMin.cx + sizeMax.cx) / 2;
  1086. WrapToolBar(pData, nCount, sizeMid.cx);
  1087. sizeMid = CalcSize(pData, nCount);
  1089. if (nLength < sizeMid.cy)
  1090. {
  1091. if (sizeMin == sizeMid)
  1092. {
  1093. WrapToolBar(pData, nCount, sizeMax.cx);
  1094. return;
  1095. }
  1096. sizeMin = sizeMid;
  1097. }
  1098. else if (nLength > sizeMid.cy)
  1099. sizeMax = sizeMid;
  1100. else
  1101. return;
  1102. }
  1103. }
  1104. }
  1106. struct _AFX_CONTROLPOS
  1107. {
  1108. int nIndex, nID;
  1109. CRect rectOldPos;
  1110. };
  1112. CSize  CGuiToolBarWnd::CalcLayout(DWORD dwMode, int nLength)
  1113. {
  1114. ASSERT_VALID(this);
  1115. ASSERT(::IsWindow(m_hWnd));
  1116. if (dwMode & LM_HORZDOCK)
  1117. ASSERT(dwMode & LM_HORZ);
  1119. if (dwMode & LM_HORZ)
  1120. bVertDocked=FALSE;
  1121. else
  1122. bVertDocked=TRUE;
  1123. int nCount;
  1124. TBBUTTON* pData = NULL;
  1125. CSize sizeResult(0,0);
  1127. //BLOCK: Load Buttons
  1128. {
  1129. nCount = DefWindowProc(TB_BUTTONCOUNT, 0, 0);
  1130. if (nCount != 0)
  1131. {
  1132. int i;
  1133. pData = new TBBUTTON[nCount];
  1134. for (i = 0; i < nCount; i++)
  1135. _GetButton(i, &pData[i]);
  1136. }
  1137. }
  1139. if (nCount > 0)
  1140. {
  1141. if (!(m_dwStyle & CBRS_SIZE_FIXED))
  1142. {
  1143. BOOL bDynamic = m_dwStyle & CBRS_SIZE_DYNAMIC;
  1145. if (bDynamic && (dwMode & LM_MRUWIDTH))
  1146. SizeToolBar(pData, nCount, m_nMRUWidth);
  1147. else if (bDynamic && (dwMode & LM_HORZDOCK))
  1148. SizeToolBar(pData, nCount, 32767);
  1149. else if (bDynamic && (dwMode & LM_VERTDOCK))
  1150. SizeToolBar(pData, nCount, 0);
  1151. else if (bDynamic && (nLength != -1))
  1152. {
  1153. CRect rect; rect.SetRectEmpty();
  1154. CalcInsideRect(rect, (dwMode & LM_HORZ));
  1155. BOOL bVert = (dwMode & LM_LENGTHY);
  1156. int nLen = nLength + (bVert ? rect.Height() : rect.Width());
  1158. SizeToolBar(pData, nCount, nLen, bVert);
  1159. }
  1160. else if (bDynamic && (m_dwStyle & CBRS_FLOATING))
  1161. SizeToolBar(pData, nCount, m_nMRUWidth);
  1162. else
  1163. SizeToolBar(pData, nCount, (dwMode & LM_HORZ) ? 32767 : 0);
  1164. }
  1166. sizeResult = CalcSize(pData, nCount);
  1168. if (dwMode & LM_COMMIT)
  1169. {
  1170. _AFX_CONTROLPOS* pControl = NULL;
  1171. int nControlCount = 0;
  1172. BOOL bIsDelayed = m_bDelayedButtonLayout;
  1173. m_bDelayedButtonLayout = FALSE;
  1175. for (int i = 0; i < nCount; i++)
  1176. if ((pData[i].fsStyle & TBSTYLE_SEP) && (pData[i].idCommand != 0))
  1177. nControlCount++;
  1179. if (nControlCount > 0)
  1180. {
  1181. pControl = new _AFX_CONTROLPOS[nControlCount];
  1182. nControlCount = 0;
  1184. for(int i = 0; i < nCount; i++)
  1185. {
  1186. if ((pData[i].fsStyle & TBSTYLE_SEP) && (pData[i].idCommand != 0))
  1187. {
  1188. pControl[nControlCount].nIndex = i;
  1189. pControl[nControlCount].nID = pData[i].idCommand;
  1191. CRect rect;
  1192. GetItemRect(i, &rect);
  1193. ClientToScreen(&rect);
  1194. pControl[nControlCount].rectOldPos = rect;
  1196. nControlCount++;
  1197. }
  1198. }
  1199. }
  1201. if ((m_dwStyle & CBRS_FLOATING) && (m_dwStyle & CBRS_SIZE_DYNAMIC))
  1202. m_nMRUWidth = sizeResult.cx;
  1203. for (i = 0; i < nCount; i++)
  1204. _SetButton(i, &pData[i]);
  1206. if (nControlCount > 0)
  1207. {
  1208. for (int i = 0; i < nControlCount; i++)
  1209. {
  1210. CWnd* pWnd = GetDlgItem(pControl[i].nID);
  1211. if (pWnd != NULL)
  1212. {
  1213. CRect rect;
  1214. pWnd->GetWindowRect(&rect);
  1215. CPoint pt = rect.TopLeft() - pControl[i].rectOldPos.TopLeft();
  1216. GetItemRect(pControl[i].nIndex, &rect);
  1217. pt = rect.TopLeft() + pt;
  1218. pWnd->SetWindowPos(NULL, pt.x, pt.y, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
  1219. }
  1220. }
  1221. delete[] pControl;
  1222. }
  1223. m_bDelayedButtonLayout = bIsDelayed;
  1224. }
  1225. delete[] pData;
  1226. }
  1228. //BLOCK: Adjust Margins
  1229. {
  1230. CRect rect; rect.SetRectEmpty();
  1231. CalcInsideRect(rect, (dwMode & LM_HORZ));
  1232. sizeResult.cy -= rect.Height();
  1233. sizeResult.cx -= rect.Width();
  1235. CSize size = CControlBar::CalcFixedLayout((dwMode & LM_STRETCH), (dwMode & LM_HORZ));
  1236. sizeResult.cx = max(sizeResult.cx, size.cx);
  1237. sizeResult.cy = max(sizeResult.cy, size.cy);
  1238. }
  1239. return sizeResult;
  1240. }
  1242. CSize  CGuiToolBarWnd::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  1243. {
  1244. DWORD dwMode = bStretch ? LM_STRETCH : 0;
  1245. dwMode |= bHorz ? LM_HORZ : 0;
  1247. return CalcLayout(dwMode);
  1248. }
  1250. CSize  CGuiToolBarWnd::CalcDynamicLayout(int nLength, DWORD dwMode)
  1251. {
  1252. if ((nLength == -1) && !(dwMode & LM_MRUWIDTH) && !(dwMode & LM_COMMIT) &&
  1253. ((dwMode & LM_HORZDOCK) || (dwMode & LM_VERTDOCK)))
  1254. {
  1255. return CalcFixedLayout(dwMode & LM_STRETCH, dwMode & LM_HORZDOCK);
  1256. }
  1257. return CalcLayout(dwMode, nLength);
  1258. }
  1260. void   CGuiToolBarWnd::_GetButton(int nIndex, TBBUTTON* pButton) const
  1261. {
  1262. CGuiToolBarWnd* pBar = (CGuiToolBarWnd*)this;
  1263. VERIFY(pBar->DefWindowProc(TB_GETBUTTON, nIndex, (LPARAM)pButton));
  1264. // TBSTATE_ENABLED == TBBS_DISABLED so invert it
  1265. pButton->fsState ^= TBSTATE_ENABLED;
  1266. }
  1268. void   CGuiToolBarWnd::_SetButton(int nIndex, TBBUTTON* pButton)
  1269. {
  1270. // get original button state
  1271. TBBUTTON button;
  1272. VERIFY(DefWindowProc(TB_GETBUTTON, nIndex, (LPARAM)&button));
  1274. // prepare for old/new button comparsion
  1275. button.bReserved[0] = 0;
  1276. button.bReserved[1] = 0;
  1277. // TBSTATE_ENABLED == TBBS_DISABLED so invert it
  1278. pButton->fsState ^= TBSTATE_ENABLED;
  1279. pButton->bReserved[0] = 0;
  1280. pButton->bReserved[1] = 0;
  1282. // nothing to do if they are the same
  1283. if (memcmp(pButton, &button, sizeof(TBBUTTON)) != 0)
  1284. {
  1285. // don't redraw everything while setting the button
  1286. DWORD dwStyle = GetStyle();
  1287. ModifyStyle(WS_VISIBLE, 0);
  1288. VERIFY(DefWindowProc(TB_DELETEBUTTON, nIndex, 0));
  1289. VERIFY(DefWindowProc(TB_INSERTBUTTON, nIndex, (LPARAM)pButton));
  1290. ModifyStyle(0, dwStyle & WS_VISIBLE);
  1292. // invalidate appropriate parts
  1293. if (((pButton->fsStyle ^ button.fsStyle) & TBSTYLE_SEP) ||
  1294. ((pButton->fsStyle & TBSTYLE_SEP) && pButton->iBitmap != button.iBitmap))
  1295. {
  1296. // changing a separator
  1297. Invalidate();
  1298. }
  1299. else
  1300. {
  1301. // invalidate just the button
  1302. CRect rect;
  1303. if (DefWindowProc(TB_GETITEMRECT, nIndex, (LPARAM)&rect))
  1304. InvalidateRect(rect);
  1305. }
  1306. }
  1307. }
  1310. BOOL CGuiToolBarWnd::IsLeft()
  1311. {
  1312. if (nDockBarAling == AFX_IDW_DOCKBAR_LEFT) return TRUE;
  1313. return FALSE;
  1314. }
  1316. BOOL CGuiToolBarWnd::IsRight()
  1317. {
  1318. if (nDockBarAling == AFX_IDW_DOCKBAR_RIGHT) return TRUE;
  1319. return FALSE;
  1320. }
  1322. BOOL CGuiToolBarWnd::IsTop()
  1323. {
  1324. if (nDockBarAling == AFX_IDW_DOCKBAR_TOP) return TRUE;
  1325. return FALSE;
  1326. }
  1328. BOOL CGuiToolBarWnd::IsBottom()
  1329. {
  1330. if (nDockBarAling == AFX_IDW_DOCKBAR_BOTTOM) return TRUE;
  1331. return FALSE;
  1332. }
  1334. BOOL CGuiToolBarWnd::IsVert()
  1335. {
  1336. if (IsLeft() || IsRight()) return TRUE;
  1337. return FALSE;
  1338. }
  1340. BOOL CGuiToolBarWnd::IsHorz()
  1341. {
  1342. if (IsTop() || IsBottom()) return TRUE;
  1343. return FALSE;
  1344. }
  1346. BOOL CGuiToolBarWnd::IsFloating()
  1347. {
  1348. if (nDockBarAling == AFX_IDW_DOCKBAR_FLOAT) return TRUE;
  1349. return FALSE;
  1351. }