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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
GuiToolBarWnd.cpp
资源名称：sourcecode.zip　[点击查看]
上传用户：wlkj888
上传日期：2022-08-01
资源大小：806k
文件大小：42k
源码类别：

对话框与窗口

开发平台：

Visual C++

GuiToolBarWnd.cpp：源码内容
  1. /****************************************************************************
  2.  * *  
  3.  * GuiToolKit   *
  4.  *  (MFC extension) *  
  5.  * Created by Francisco Campos G. www.beyondata.com fcampos@beyondata.com *
  6.  *--------------------------------------------------------------------------*    
  7.  * *
  8.  * This program is free software;so you are free to use it any of your *
  9.  * applications (Freeware, Shareware, Commercial),but leave this header *
  10.  * intact. *
  11.  * *
  12.  * These files are provided "as is" without warranty of any kind. *
  13.  * *
  14.  *        GuiToolKit is forever FREE CODE !!!!! *
  15.  * *
  16.  *--------------------------------------------------------------------------*
  17.  * Created by: Francisco Campos G. *
  18.  * Bug Fixes and improvements : (Add your name) *
  19.  * -Francisco Campos *
  20.  * -Serge Koroleuve  *
  21.  * -Ernesto Garcia *
  22.  ****************************************************************************/
  24. #include "stdafx.h" 
  25. #include "GuiToolBarWnd.h"
  26. #include "GuiDrawlayer.h"
  27. #include "GuiDockContext.h"
  28. #include "GuiMiniFrameWnd.h"
  30. #ifdef _DEBUG
  31. #undef THIS_FILE
  32. static char THIS_FILE[]=__FILE__;
  33. #define new DEBUG_NEW
  34. #endif
  35. #define BTNS_SHOWTEXT           0x0040
  37. extern int gbintHorz; //Horz=0, Vert=1
  38. extern CRect rcMenu; //CRect of button
  40. class CDropmenu
  41. {
  42. public:
  43. UINT nIDboton;
  44. UINT nMenu;
  45. CWnd* m_pWnd;
  46. LPCTSTR mTitle;
  47. CDropmenu(UINT nID,UINT nMENU)
  48. {
  49. nIDboton=nID;
  50. nMenu=nMENU;
  51. m_pWnd=NULL;
  52. mTitle=NULL;
  53. }
  55. CDropmenu(UINT nID,CWnd* pWnd,LPCTSTR lpTitle)
  56. {
  57. nIDboton=nID;
  58. nMenu=NULL;
  59. m_pWnd=pWnd;
  60. mTitle=lpTitle;
  62. }
  63. };
  64. //////////////////////////////////////////////////////////////////////
  65. // Construction/Destruction
  66. //////////////////////////////////////////////////////////////////////
  67. IMPLEMENT_DYNAMIC(CGuiToolBarWnd,CToolBar)
  69. BEGIN_MESSAGE_MAP(CGuiToolBarWnd,CToolBar)
  70. //{{AFX_MSG_MAP(CGuiToolBarWnd)
  71. ON_WM_PAINT()
  72. ON_WM_NCPAINT()
  73. ON_WM_NCCALCSIZE()
  74. ON_WM_WINDOWPOSCHANGING()
  75. ON_WM_LBUTTONDOWN()
  76. ON_WM_LBUTTONDBLCLK()
  77. ON_WM_RBUTTONDOWN()
  78. ON_NOTIFY_REFLECT_EX(TBN_DROPDOWN,OnDropDown)
  79. ON_WM_TIMER()
  80. ON_WM_LBUTTONUP()
  81. ON_WM_SYSCOLORCHANGE()
  82. ON_WM_SETCURSOR()
  83. ON_WM_CREATE()
  85. //}}AFX_MSG_MAP
  86. ON_WM_DESTROY()
  87. ON_WM_MOUSEMOVE()
  89. END_MESSAGE_MAP()
  92. int _afxDropDownWidth = -1;
  94. int AFXAPI _AfxGetDropDownWidth()
  95. {
  96. // return cached version if already determined...
  97. if (_afxDropDownWidth != -1)
  98. return _afxDropDownWidth;
  100. // otherwise calculate it...
  101. HDC hDC = GetDC(NULL);
  102. ASSERT(hDC != NULL);
  103. HFONT hFont;
  104. if ((hFont = CreateFont(GetSystemMetrics(SM_CYMENUCHECK), 0, 0, 0,
  105. FW_NORMAL, 0, 0, 0, SYMBOL_CHARSET, 0, 0, 0, 0, _T("Marlett"))) != NULL)
  106. hFont = (HFONT)SelectObject(hDC, hFont);
  107. VERIFY(GetCharWidth(hDC, '6', '6', &_afxDropDownWidth));
  108. if (hFont != NULL)
  109. {
  110. SelectObject(hDC, hFont);
  111. DeleteObject(hFont);
  112. }
  113. ReleaseDC(NULL, hDC);
  114. ASSERT(_afxDropDownWidth != -1);
  115. return _afxDropDownWidth;
  116. }
  117.  
  118. int CGuiToolBarWnd::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  119. {
  120. lpCreateStruct->dwExStyle |= WS_CLIPSIBLINGS|WS_CLIPCHILDREN; // prevents flashing
  121. if (CToolBar::OnCreate(lpCreateStruct) == -1)
  122. return -1;
  123. if (m_pDockContext==NULL)
  124. m_pDockContext=new CGuiDockContext(this);
  125. ASSERT(m_pDockContext);
  126. ModifyStyle(0,TBSTYLE_FLAT);
  127. SetSizes(m_sizeButton, m_sizeImage);
  128. return 0;
  129. }
  134. void CGuiToolBarWnd::SetTextOptions()
  135. {
  136.     ASSERT( ::IsWindow( m_hWnd ) );
  137.     CToolBarCtrl& tbCtrl = GetToolBarCtrl();
  138.     DWORD dwStyleEx = tbCtrl.GetExtendedStyle();
  139. ModifyStyle(TBSTYLE_LIST,TBSTYLE_LIST  );
  140. TBBUTTON tbButton;
  141. int nCountBtn;
  142. UINT nID;
  143. UINT nStyle;
  144. WORD wStyle, wState;
  145. int iBitmap;
  146. nCountBtn = SendMessage (TB_BUTTONCOUNT, 0, 0);
  147. for(int i=0; i < nCountBtn; i++)
  148. {
  149. SendMessage(TB_GETBUTTON, i, (LPARAM)&tbButton);
  150. GetButtonInfo(i,nID,nStyle,iBitmap);
  151. wStyle= LOWORD(nStyle);
  152. wState= HIWORD(nStyle);
  153. bOver=FALSE;
  154. if (wState & TBSTATE_HIDDEN) continue;
  155. if (wStyle != TBSTYLE_SEP)
  156. {
  157.   CString m_szCad=GetButtonText(i);
  159. if (!m_szCad.IsEmpty())
  160. {
  162. int nString = (int)DefWindowProc(TB_ADDSTRING, 0, (LPARAM)(LPCTSTR)m_szCad);
  163. if (nString != -1)
  164. {
  165. ModifyStyle(0,wStyle|TBSTYLE_AUTOSIZE |BTNS_SHOWTEXT);
  166. }
  167. else
  168. {
  169. wStyle &= ~BTNS_SHOWTEXT;
  170. wStyle |= TBSTYLE_AUTOSIZE;
  171. ModifyStyle(0,wStyle);
  172. }
  173. wState ^= TBSTATE_ENABLED;
  174. wState ^= TBSTATE_ENABLED;
  175. _SetButton(i,&tbButton);
  176. }
  177. }
  178. }
  180. ::SendMessage(m_hWnd, TB_SETMAXTEXTROWS, 1, 0);
  183. GetParentFrame()->RecalcLayout();
  184. OnIdleUpdateCmdUI(TRUE, 0L);
  185. SetSizes(m_sizeButton, m_sizeImage);
  187. }
  190. //***********************************************************************************
  191. void CGuiToolBarWnd::OnUpdateCmdUI( CFrameWnd* pTarget, BOOL bDisableIfNoHndler ) 
  192. {
  193.  CToolBar::OnUpdateCmdUI( pTarget, bDisableIfNoHndler ); 
  194. }
  196. //***********************************************************************************
  197. void CGuiToolBarWnd::OnWindowPosChanging(WINDOWPOS FAR* lpwndpos) 
  198. {
  199. CToolBar::OnWindowPosChanging(lpwndpos);
  200. /*if(!(m_dwStyle & CBRS_FLOATING))  
  201. SetSizes(m_sizeButton, m_sizeImage);
  202. */
  203. if( !(lpwndpos->flags & SWP_NOMOVE) )
  204. Invalidate(FALSE);
  205. }
  207. //***********************************************************************************
  208. void CGuiToolBarWnd::OnSysColorChange( )
  209. {
  210. CToolBar::OnSysColorChange( );
  211. /*if(!(m_dwStyle & CBRS_FLOATING))  
  212. SetSizes(m_sizeButton, m_sizeImage);*/
  213. Invalidate(TRUE);
  214. GetParentFrame()->RecalcLayout();
  215. }
  217. //***********************************************************************************
  219. CGuiToolBarWnd::CGuiToolBarWnd()
  220. {
  221. m_style = Office97;  //by default
  222. m_pArray.RemoveAll();
  223. m_iElements=0;
  224. m_bIsXp=TRUE;
  225. bPressDown=FALSE;
  226. m_imgArrow.Create(IDB_GUI_DOCKBAR,9,10,RGB(255,0,255));
  227. _AfxGetDropDownWidth();
  228. //m_iWidthDrowDown=GetSystemMetrics(SM_CXHTHUMB);
  229. CBitmap cbmp;
  230. BITMAP bmp;
  231. cbmp.LoadBitmap(IDB_GUI_DOCKBAR);
  232. cbmp.GetBitmap(&bmp);
  233. mHeight=CPoint(bmp.bmWidth,bmp.bmHeight);
  234. //m_cfont.CreateFont(-11,0,0,0,400,0,0,0,0,1,2,1,34,"MS Sans Serif");
  235. m_cfont.CreateFont(14,0,0,0,400,0,0,0,0,1,2,1,34,_T("Marlett"));
  236. m_idLock=-1;
  237. bLoad=FALSE;
  238. m_ActualBtn=-1;
  239. m_StyleDisplay=GUISTYLE_XP;
  241. }
  243. CGuiToolBarWnd::~CGuiToolBarWnd()
  244. {
  245. m_pArray.RemoveAll();
  246. m_imgList.Detach();
  248. }
  252. void CGuiToolBarWnd::SetTextButton(int IdButton,CString sztexto)
  253. {
  255. //sztexto+=sztexto.Find( '&' ) == -1 ?"   ":"    ";
  256. CClientDC dc(this);
  257. SetButtonText(IdButton,sztexto);
  258. SetButtonStyle(IdButton,TBSTYLE_AUTOSIZE);
  259. SetTextOptions();
  260. SetSizes(m_sizeButton, m_sizeImage);
  261.             
  262. }
  265. void CGuiToolBarWnd::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp) 
  266. {
  267. CToolBar::OnNcCalcSize(bCalcValidRects, lpncsp);
  268. }
  272. BOOL CGuiToolBarWnd::CreateCombo(CComboBox* pControl,UINT nID,int iSize,DWORD dwStyle)
  273. {
  274. CRect rect;
  275. CFont m_Font;
  276. m_Font.CreateStockObject (DEFAULT_GUI_FONT);
  277. int nIndex = this->GetToolBarCtrl().CommandToIndex(nID);
  278. this->SetButtonInfo(nIndex, nID, TBBS_SEPARATOR, iSize);
  279. this->GetToolBarCtrl().GetItemRect(nIndex, &rect);
  280. rect.top = 1;
  281. //rect.bottom-=1;
  282. rect.bottom = rect.top +iSize/*drop height*/;
  283. if(!pControl->Create(dwStyle, rect, this, nID))
  284. {
  285. TRACE(_T("Failed to create combo-boxn"));
  286. return FALSE;
  287. }
  289. return TRUE;
  290. }
  293. BOOL CGuiToolBarWnd::CreateCombo(CComboBoxEx* pControl,UINT nID,int iSize,CImageList* m_imgList,DWORD dwStyle)
  294. {
  295. CRect rect;
  296. int nIndex = this->GetToolBarCtrl().CommandToIndex(nID);
  297. this->SetButtonInfo(nIndex, nID, TBBS_SEPARATOR, iSize);
  298. this->GetToolBarCtrl().GetItemRect(nIndex, &rect);
  299. rect.top = 1;
  300. rect.bottom = rect.top + 250 /*drop height*/;
  301. if(!pControl->Create(dwStyle, rect, this, nID))
  302. {
  303. TRACE(_T("Failed to create combo-boxn"));
  304. return FALSE;
  305. }
  306. pControl->SetImageList(m_imgList);
  307. return TRUE;
  309. }
  311. void CGuiToolBarWnd::AddRowComBoboxEx(CComboBoxEx* pControl,CString szMsg,int iItem,int iImage)
  312. {
  313. COMBOBOXEXITEM cb;
  314. cb.mask=CBEIF_TEXT | CBEIF_IMAGE |CBEIF_SELECTEDIMAGE;       
  316. cb.pszText=(LPTSTR)(LPCTSTR)szMsg;
  317. cb.iItem=iItem;
  318. cb.iImage=cb.iSelectedImage=iImage;
  319. cb.cchTextMax=20; 
  320. pControl->InsertItem(&cb);
  322. }
  324. void CGuiToolBarWnd::SetButtonDropDown(UINT nID,int iImage,UINT nMENU)
  325. {
  326. CToolBarCtrl &m_tbc= GetToolBarCtrl();
  327. m_tbc.SetExtendedStyle(TBSTYLE_EX_DRAWDDARROWS);
  328. m_tbc.SetStyle(m_tbc.GetStyle() | TBSTYLE_LIST | CCS_ADJUSTABLE);
  329. int nIndex = this->GetToolBarCtrl().CommandToIndex(nID);
  330. this->SetButtonInfo(nIndex, nID, TBBS_DROPDOWN, iImage);
  331. m_pArray.SetAtGrow(m_iElements,new CDropmenu(nID,nMENU));
  332. m_iElements++;
  333. }
  336. void CGuiToolBarWnd::SetButtonDropDown(UINT nID,int iImage,CWnd* pWnd,LPCTSTR lpTitle)
  337. {
  338. CToolBarCtrl &m_tbc= GetToolBarCtrl();
  339. m_tbc.SetExtendedStyle(TBSTYLE_EX_DRAWDDARROWS);
  340. m_tbc.SetStyle(m_tbc.GetStyle() | TBSTYLE_LIST | CCS_ADJUSTABLE);
  341. int nIndex = this->GetToolBarCtrl().CommandToIndex(nID);
  342. this->SetButtonInfo(nIndex, nID, TBBS_DROPDOWN, iImage);
  343. pWnd->ShowWindow(SW_HIDE);
  344. m_pArray.SetAtGrow(m_iElements,new CDropmenu(nID,pWnd,lpTitle));
  345. m_iElements++;
  346. }
  349. BOOL CGuiToolBarWnd::OnDropDown(NMHDR* pNMHDR, LRESULT* pRes)
  350. {
  352. const NMTOOLBAR& m_nmTb = *(NMTOOLBAR*)pNMHDR;
  353. CRect rc;
  354. BOOL bFind=FALSE;
  355. GetToolBarCtrl().GetRect(m_nmTb.iItem, rc);
  356. ClientToScreen(&rc);
  357. for(int i=0; i < m_iElements; i++)
  358. {
  359. if (((CDropmenu*)m_pArray[i])->nIDboton == (UINT)m_nmTb.iItem)
  360. {
  361. bFind=TRUE;
  362. break;
  363. }
  364. }
  366. if (!bFind) return FALSE;
  368. if (((CDropmenu*)m_pArray[i])->nMenu > 0)
  369. {
  370. bPressDown=TRUE;
  371. CMenu m_menu;
  372. m_menu.LoadMenu(((CDropmenu*)m_pArray[i])->nMenu);
  373. CMenu* m_SubMenu = m_menu.GetSubMenu(0);
  374. gbintHorz=0; //Horz=0, Vert=1
  375. rcMenu=rc; //CRect of button
  376. m_SubMenu->TrackPopupMenu(TPM_LEFTALIGN|TPM_LEFTBUTTON|TPM_VERTICAL,
  377. rc.left, rc.bottom-2, AfxGetMainWnd(), &rc);
  378. bPressDown=FALSE;
  379. }
  380. else
  381. {
  383. if(((CDropmenu*)m_pArray[i])->m_pWnd)
  384. {
  385. bPressDown=TRUE;
  386. CRect rc;
  388. GetItemRect (CommandToIndex (((CDropmenu*)m_pArray[i])->nIDboton), rc);
  389. m_idLock=((CDropmenu*)m_pArray[i])->nIDboton;
  390. ClientToScreen (rc);
  391. rc.bottom += 1;
  392. CGuiMiniFrameWnd* p = new CGuiMiniFrameWnd;
  393. if (!p->Create(this,((CDropmenu*)m_pArray[i])->m_pWnd,rc,
  394. ((CDropmenu*)m_pArray[i])->mTitle,rc.Width()-1))
  395. {
  396. if (((CDropmenu*)m_pArray[i])->m_pWnd->IsWindowVisible())
  397. {
  398. UnlockWindowUpdate();
  399. bPressDown=FALSE;
  400. return TRUE;
  401. }
  402. }
  403. InvalidateRect(m_rcSaveFloat,TRUE);
  404. UpdateWindow();
  405. LockWindowUpdate();
  406. bPressDown=FALSE;
  408. }
  409. }
  410. return TRUE;
  411. }
  413. //Thanks to Ernesto Garcia 
  414. void CGuiToolBarWnd::OnDestroy()
  415. {
  416. for( int i=0; i<m_iElements; i++ )
  417.     {
  418.     CDropmenu *pArr = (CDropmenu*)m_pArray.GetAt(i);
  419.     if( pArr )
  420.         delete pArr;
  421.     }
  422. CToolBar::OnDestroy();
  423. // TODO: Add your message handler code here
  424. }
  426. void CGuiToolBarWnd::OnNcPaint()
  427. {
  429. CRect rcWindow;
  430. CRect rcClient;
  431. CWindowDC dc(this);
  432. GetWindowRect(&rcWindow);
  433. GetClientRect(&rcClient);
  435.     rcClient.OffsetRect(-rcWindow.TopLeft());
  436.     rcWindow.OffsetRect(-rcWindow.TopLeft());
  437.     ScreenToClient(rcWindow);
  438. rcClient.OffsetRect(-rcWindow.left,-rcWindow.top);
  439. //if (!m_bIsXp)
  440. // if (m_dwStyle & CBRS_ORIENT_HORZ && !(m_dwStyle & CBRS_FLOATING))
  441. // {rcClient.top+=2;rcClient.left+=1;}
  443. dc.ExcludeClipRect(rcClient);   
  444. rcWindow.OffsetRect(-rcWindow.left, -rcWindow.top);
  445. // office xp
  446. if (m_StyleDisplay==GUISTYLE_XP)
  447. rcWindow.DeflateRect(1,1);
  448. //pintamos la izquierda
  449. dc.FillSolidRect(0,0,rcWindow.right+1,rcWindow.bottom+2,GuiDrawLayer::GetRGBColorFace(m_StyleDisplay)); 
  450. dc.FillSolidRect(0,rcWindow.top+1,rcWindow.right+1,1,GuiDrawLayer::GetRGBColorFace(m_StyleDisplay)); 
  451. //pintamos el borde inferior
  452. dc.FillSolidRect(1,rcWindow.bottom-1,rcWindow.right+1,rcWindow.bottom-1,GuiDrawLayer::GetRGBColorFace(m_StyleDisplay)); 
  453. dc.FillSolidRect(0,rcWindow.bottom+1,rcWindow.right+1,rcWindow.bottom+1, GuiDrawLayer::GetRGBColorFace(m_StyleDisplay)); 
  454. if (m_StyleDisplay==GUISTYLE_2003)
  455. dc.FillSolidRect(0,rcWindow.bottom+1,rcWindow.right+1,rcWindow.bottom+1,GuiDrawLayer::GetRGBColorShadow(m_StyleDisplay)); 
  456. //pintamos la derecha
  457. dc.FillSolidRect(rcWindow.right,0,rcWindow.right-1,rcWindow.bottom,GuiDrawLayer::GetRGBColorFace(m_StyleDisplay)); 
  458. dc.FillSolidRect(rcWindow.right+1,-1,rcWindow.right+4,rcWindow.bottom+4,GuiDrawLayer::GetRGBColorFace(m_StyleDisplay)); 
  461. dc.IntersectClipRect(rcWindow);
  463. //office xp
  464. CBrush cb;
  465. cb.CreateSolidBrush(GuiDrawLayer::GetRGBColorFace(m_StyleDisplay));
  466. dc.FillRect(rcWindow,&cb);
  467. CRect rcW=rcWindow;
  468. DrawGripper(&dc,&rcWindow);
  471. return;
  472. }
  477. void CGuiToolBarWnd::OnPaint()
  478. {
  479. CPaintDC dc (this);
  480. TBBUTTON tbButton;
  481. HIMAGELIST hiImg;
  482. int nCountBtn;
  483. CRect rcBtn;
  484. CBrush cb;
  485. CRect rcClient;
  486. CRect rcAreaUpdate;
  487. UINT nID;
  488. UINT nStyle;
  489. WORD wStyle, wState;
  490. int iBitmap;
  491. int iUltbot=0;
  492. BOOL mbIsPress;
  493. BOOL mbIsEnabled;
  494. BOOL mIsSilver2003=FALSE;
  495. int OldMode=dc.SetBkMode(TRANSPARENT);
  496. GetClientRect(&rcClient);
  497. hiImg = (HIMAGELIST)SendMessage (TB_GETIMAGELIST, 0, 0);
  498.     nCountBtn = SendMessage (TB_BUTTONCOUNT, 0, 0);
  500. if (m_StyleDisplay == GUISTYLE_2003)
  501. {
  502. COLORREF clrNear=dc.GetNearestColor(GuiDrawLayer::GetRGBCaptionXP());
  503. if(clrNear ==13221564)
  504. mIsSilver2003=TRUE;
  505. if (m_dwStyle & CBRS_ORIENT_HORZ)
  506. {
  508. CGradient M(CSize(rcClient.Width(),rcClient.Height()));
  509. if (GuiDrawLayer::m_Theme)
  510. M.PrepareVertical(&dc,m_StyleDisplay,GuiDrawLayer::GetRGBFondoXP());
  511. else
  512. M.PrepareVertical(&dc,m_StyleDisplay);
  513. M.Draw(&dc,0,0,0,0,rcClient.Width(),rcClient.Height(),SRCCOPY);
  515. }
  516. else
  517. {
  518. CGradient M(CSize(rcClient.Width(),rcClient.Height()));
  519. if (GuiDrawLayer::m_Theme)
  520. M.PrepareHorizontal(&dc,m_StyleDisplay,GuiDrawLayer::GetRGBFondoXP());
  521. else
  522. M.PrepareHorizontal(&dc,m_StyleDisplay);
  523. M.Draw(&dc,0,0,0,0,rcClient.Width(),rcClient.Height(),SRCCOPY);
  524. }
  526. }
  527. else
  528. {
  529. //  oficce xp
  530. cb.CreateSolidBrush(GuiDrawLayer::GetRGBColorXP());
  531. dc.FillRect(rcClient,&cb);
  532. }
  533. int j=0;
  534. dc.GetClipBox (rcAreaUpdate);
  535. for(int i=0; i < nCountBtn; i++)
  536. {
  537. SendMessage(TB_GETBUTTON, i, (LPARAM)&tbButton);
  538. GetItemRect(i,&rcBtn);
  539. GetButtonInfo(i,nID,nStyle,iBitmap);
  540. wStyle= LOWORD(nStyle);
  541. wState= HIWORD(nStyle);
  542. bOver=FALSE;
  543. if (wState & TBSTATE_HIDDEN) continue;
  545. if (wStyle == TBSTYLE_SEP)
  546. {
  547. if (!(wState & TBSTATE_WRAP) || ! IsFloating() )
  548. {
  549. CRect m_Separ;
  550. m_Separ=rcBtn;
  552. //si existe un separador vertical
  553. if (m_dwStyle & CBRS_ORIENT_HORZ)
  554. {
  555. // dc.FillRect(&rcBtn,&cb);
  556. int nhalf=(m_Separ.Width()/2)-1;
  557. m_Separ.top+=m_StyleDisplay == GUISTYLE_2003? 4:1;
  558. m_Separ.left+=nhalf;
  559. m_Separ.right=m_Separ.left+1;
  560. m_Separ.bottom-=m_StyleDisplay == GUISTYLE_2003? 2:1;
  562. }
  563. else
  564. {
  565. int nhalf=(m_Separ.Width()/2)-1;
  566. int iHeigh=m_Separ.Height();
  568. m_Separ.left=0;
  569. m_Separ.right=m_Separ.left+m_Separ.Height()+1;
  570. m_Separ.top=iUltbot;
  571. m_Separ.bottom=m_Separ.top+m_Separ.Width();
  572. // dc.FillRect(&m_Separ,&cb);
  574. m_Separ.left=0;
  575. m_Separ.right=m_Separ.left+iHeigh+1;
  576. m_Separ.top=iUltbot+nhalf;
  577. m_Separ.bottom=m_Separ.top+1;
  580. }
  581. CBrush cbt;
  582. cbt.CreateSolidBrush(GuiDrawLayer::GetRGBColorShadow(m_StyleDisplay));
  584. if (!((wStyle &  TBSTYLE_SEP) &&(nID !=0)))
  585. {
  586. dc.FillRect(m_Separ,&cbt);
  587. cbt.DeleteObject();
  588. cbt.CreateSolidBrush(GuiDrawLayer::GetRGBColorTabs());
  589. m_Separ.left+=2;
  590. m_Separ.top+=1;
  591. m_Separ.bottom+=1;
  592. dc.FillRect(m_Separ,&cbt);
  594. }
  595. cbt.DeleteObject();
  596. continue;
  598. }
  601. }
  602. else
  603. {
  604. if( ! CRect().IntersectRect(rcAreaUpdate, rcBtn) )
  605. continue;
  606. mbIsPress=(wState & TBSTATE_CHECKED) || (wState & TBSTATE_PRESSED);
  607. mbIsEnabled= GetToolBarCtrl().IsButtonEnabled((int)nID);
  608. if (mbIsEnabled)
  609. {
  611. CPoint pt;
  612. GetCursorPos(&pt);
  613. ScreenToClient(&pt);
  614. CBrush cblu;
  615. if(!rcBtn.PtInRect(pt))
  616. {
  618. if (wState & TBSTATE_CHECKED)
  619. {
  621. dc.Draw3dRect(rcBtn,GuiDrawLayer::GetRGBCaptionXP(),GuiDrawLayer::GetRGBCaptionXP());
  622. rcBtn.DeflateRect(1,1);
  623. if (m_StyleDisplay == GUISTYLE_2003)
  624. cblu.CreateSolidBrush(GuiDrawLayer::m_Theme? RGB(249,200,102):GuiDrawLayer::GetRGBFondoXP());
  625. else
  626. cblu.CreateSolidBrush(GuiDrawLayer::GetRGBFondoXP());
  627. dc.FillRect(rcBtn,&cblu);
  628. }
  629. else
  630. {
  631. if (m_StyleDisplay == GUISTYLE_XP)
  632. dc.FillRect(rcBtn,&cb);
  633. }
  634. }
  635. else
  636. {
  638. if (bPressDown )
  639. dc.Draw3dRect(rcBtn,GuiDrawLayer::GetRGBMenu(),GuiDrawLayer::GetRGBMenu());
  640. else  
  641. if (!mIsSilver2003)
  642. dc.Draw3dRect(rcBtn,GuiDrawLayer::GetRGBCaptionXP(),GuiDrawLayer::GetRGBCaptionXP());
  643. else
  644. dc.Draw3dRect(rcBtn,GuiDrawLayer::GetRGBColorShadow(GuiDrawLayer::m_Style),GuiDrawLayer::GetRGBColorShadow(GuiDrawLayer::m_Style));
  645. rcBtn.DeflateRect(1,1);
  646. if (wState & TBSTATE_CHECKED)
  647. {
  648. cblu.CreateSolidBrush(GuiDrawLayer::GetRGBFondoXP());
  649. dc.FillRect(rcBtn,&cblu);
  650. }
  651. else
  652. {
  654. if (bPressDown)
  655. {
  656. if (m_StyleDisplay == GUISTYLE_2003)
  657. if(wStyle != TBSTYLE_DROPDOWN) 
  658. cblu.CreateSolidBrush(GuiDrawLayer::m_Theme? RGB(249,200,102):GuiDrawLayer::GetRGBColorXP());
  659. else
  660. {
  661. if (mbIsPress)
  662. cblu.CreateSolidBrush(RGB(249,200,102));
  663. else
  664. cblu.CreateStockObject(NULL_BRUSH);
  665. }
  666. else
  667. cblu.CreateSolidBrush(GuiDrawLayer::GetRGBColorXP());
  668. dc.FillRect(rcBtn,&cblu);
  669. }
  670. else
  671. {
  672. if (m_StyleDisplay == GUISTYLE_2003)
  673. {
  674. if (GuiDrawLayer::m_Theme)
  675. {
  676. if(wStyle != TBSTYLE_DROPDOWN) 
  677. cblu.CreateSolidBrush(mbIsPress?RGB(249,200,102):RGB(252,230,186));
  678. else
  679. cblu.CreateSolidBrush(mbIsPress?GuiDrawLayer::GetRGBFondoXP():RGB(252,230,186));
  680. }
  681. else
  682. cblu.CreateSolidBrush(mbIsPress?GuiDrawLayer::GetRGBPressBXP():GuiDrawLayer::GetRGBFondoXP());
  683. }
  684. else
  685. cblu.CreateSolidBrush(mbIsPress?GuiDrawLayer::GetRGBPressBXP():GuiDrawLayer::GetRGBFondoXP());
  686. dc.FillRect(rcBtn,&cblu);
  687. }
  688. if (wStyle == 8) 
  689. {
  691. CRect rcCli=rcBtn;
  692. int dif=rcBtn.right-_afxDropDownWidth;
  693. rcCli.left=dif+1;
  695. if (!bPressDown)
  696. {
  697. CPen Cp( PS_SOLID, 1, GuiDrawLayer::GetRGBCaptionXP());
  698. CPen* oldPen= dc.SelectObject(&Cp);
  699. dc.MoveTo(dif,rcBtn.top);
  700. dc.LineTo(dif,rcBtn.bottom);
  701. dc.SelectObject(oldPen);
  702. }
  704. }
  705. if (!mbIsPress && !bPressDown)
  706. bOver=TRUE;
  707. else
  708. bOver=FALSE;
  709.   
  710. }
  711. rcBtn.InflateRect(1,1);
  712. }
  713. }
  715. }
  718. if (wStyle != TBSTYLE_SEP)
  719. {
  722. HICON hIcon = ImageList_ExtractIcon (NULL, hiImg, iBitmap);
  723. IMAGEINFO pImageInfo;
  724. CRect rcima =pImageInfo.rcImage;
  725. CSize siImg=CSize(rcima.Width(),rcima.Height());
  726. CPoint pti(rcBtn.left+2,rcBtn.top+4);
  727. CString mszText=GetButtonText(i);
  728. CFont* m_fontOld=dc.SelectObject(&m_cfont);
  731. if (!(wState & TBSTATE_ENABLED))
  732. {
  733. if (GuiDrawLayer::m_Style != GUISTYLE_2003)
  734. if (bOver==TRUE)
  735. {
  736. pti.x+=1;
  737. pti.y+=1;
  738. dc.DrawState(pti,m_sizeImage,hIcon,DSS_MONO,CBrush (GuiDrawLayer::GetRGBColorShadow()));
  739. pti.x-=2; pti.y-=2;
  742. }
  744. dc.DrawState(pti,m_sizeImage,hIcon,DSS_NORMAL,CBrush (GuiDrawLayer::GetRGBColorShadow()));
  747. // m_imgList.Draw(&m_dc, iBitmap, pti, ILD_TRANSPARENT);
  748. if (mszText.GetLength() > 0 && !bVertDocked)
  749. {
  750. CRect m_rctext=rcBtn;
  751. m_rctext.left+=m_sizeImage.cx+4;
  752. m_rctext.bottom-=1;
  753. dc.DrawText(mszText,&m_rctext,DT_SINGLELINE|DT_BOTTOM);
  754. }
  758. }
  759. else
  760. {
  762.  dc.DrawState(pti,m_sizeImage,hIcon,DSS_MONO,CBrush (GuiDrawLayer::GetRGBColorShadow()));
  764. // m_dc.DrawState(pti,siImg,m_imgList.ExtractIcon(iBitmap),DSS_DISABLED,(CBrush*)NULL);
  765.  CRect m_rctext=rcBtn;
  766.  m_rctext.left+=m_sizeImage.cx+4;
  767.  m_rctext.bottom-=1;
  768.  CSize szText=dc.GetTextExtent(mszText);
  769.  pti.x= m_rctext.left+2;
  770.  pti.y=(m_rctext.Height()/2)-1;
  771.  //DrawState(pt, m_Csize, m_szCaption, DSS_DISABLED, TRUE, 0, (HBRUSH)NULL);
  772.  dc.DrawState(pti,szText,mszText,DSS_DISABLED,TRUE,0,(HBRUSH)NULL);
  773. }
  774. DestroyIcon (hIcon);
  775. if (wStyle == 8) 
  776. DrawArrow(&dc,rcBtn);
  777. iBitmap++;
  778. iUltbot=rcBtn.bottom;
  779. j++;
  780. dc.SelectObject(m_fontOld);
  781. }
  783. }
  785. dc.SetBkMode(OldMode);
  788. }
  791. void CGuiToolBarWnd::DrawArrow(CDC* pDC,CRect m_rc)
  792. {
  793. int difh =m_rc.Height()-mHeight.y;
  794. difh/=2;
  796. m_rc.left=m_rc.right-_AfxGetDropDownWidth();
  797. m_imgArrow.Draw(pDC,0,CPoint(m_rc.left+2,m_rc.top+difh),ILD_TRANSPARENT);
  799. }
  801. void CGuiToolBarWnd::DrawGripper(CWindowDC* dc,CRect* rcWin)
  802. {
  804. if (m_StyleDisplay == GUISTYLE_2003)
  805. {
  806. if (m_dwStyle & CBRS_ORIENT_HORZ)
  807. {
  808. CGradient M(CSize(rcWin->Width(),rcWin->Height()));
  809. M.PrepareVertical(dc,m_StyleDisplay);
  810. M.Draw(dc,0,2,2,4,1,rcWin->Height()-1,SRCCOPY);
  811. M.Draw(dc,1,1,1,0,1,rcWin->Height()-1,SRCCOPY);
  812. M.Draw(dc,2,0,0,0,rcWin->Width()-4,rcWin->Height(),SRCCOPY);
  813. M.Draw(dc,rcWin->Width()-1,3,0,1,rcWin->Width(),rcWin->Height()-1,SRCCOPY);
  814. M.Draw(dc,rcWin->Width()-2,2,0,1,rcWin->Width(),rcWin->Height()-1,SRCCOPY);
  815. if (m_StyleDisplay==GUISTYLE_2003)
  816.  dc->FillSolidRect(rcWin->left+1,rcWin->bottom,rcWin->right-2,rcWin->bottom,GuiDrawLayer::GetRGBColorShadow(m_StyleDisplay)); 
  818. }
  819. else
  820. {
  822. CGradient M(CSize(rcWin->Width(),rcWin->Height()));
  823. M.PrepareHorizontal(dc,m_StyleDisplay);
  824. M.Draw(dc,0,0,0,0,rcWin->Width()-4,rcWin->Height(),SRCCOPY);
  825. }
  826. }
  827. else
  828. {
  830.  dc->FillSolidRect(rcWin,GuiDrawLayer::GetRGBColorXP()); 
  831. }
  833. if (m_dwStyle & CBRS_FLOATING) return ;
  835. if(m_StyleDisplay == GUISTYLE_2003) //no es XP
  836. {
  837. if (m_dwStyle & CBRS_ORIENT_HORZ)
  838. {
  839. rcWin->top+=7;
  840. rcWin->left+=5;
  841. rcWin->right=rcWin->left+2;
  842. rcWin->bottom-=4;
  843. CRect rcBlack;
  845. for (int i=0; i < rcWin->Height(); i+=4)
  846. {
  847. CRect rcWindow;
  848. CBrush cb;
  849. cb.CreateSolidBrush(::GetSysColor(COLOR_BTNHIGHLIGHT));
  850. rcWindow=rcWin;
  851. rcWindow.top=rcWin->top+i;
  852. rcWindow.bottom=rcWindow.top+2;
  853. dc->FillRect(rcWindow,&cb);
  854. rcBlack=rcWindow;
  855. rcBlack.left-=1;
  856. rcBlack.top=(rcWin->top+i)-1;
  857. rcBlack.bottom=rcBlack.top+2;
  858. rcBlack.right=rcBlack.left+2;
  859. cb.DeleteObject();
  860. cb.CreateSolidBrush(GuiDrawLayer::GetRGBColorShadow(m_StyleDisplay));
  861. dc->FillRect(rcBlack,&cb);
  863. }
  866. }
  867. else
  868. {
  870. rcWin->top+=3;
  871. rcWin->left+=4;
  872. rcWin->right-=2;
  873. rcWin->bottom=rcWin->top+2;
  874. CRect rcBlack;
  875. for (int i=0; i < rcWin->Width(); i+=4)
  876. {
  877. CRect rcWindow;
  878. CBrush cb;
  879. cb.CreateSolidBrush(::GetSysColor(COLOR_BTNHIGHLIGHT));
  880. rcWindow=rcWin;
  881. rcWindow.left=rcWindow.left+i;
  882. rcWindow.right=rcWindow.left+2;
  883. dc->FillRect(rcWindow,&cb);
  884. rcBlack=rcWindow;
  885. rcBlack.top-=1;
  886. rcBlack.left-=1;
  887. rcBlack.bottom=rcBlack.top+2;
  888. rcBlack.right=rcBlack.left+2;
  889. cb.DeleteObject();
  890. cb.CreateSolidBrush(GuiDrawLayer::GetRGBColorShadow(m_StyleDisplay));
  891. dc->FillRect(rcBlack,&cb);
  893. }
  894. }
  895. }
  896. else
  897. {
  898. if (m_dwStyle & CBRS_ORIENT_HORZ)
  899. {
  901. rcWin->top+=6;
  902. rcWin->left+=4;
  903. rcWin->right=rcWin->left+3;
  904. rcWin->bottom-=3;
  907. for (int i=0; i < rcWin->Height(); i+=2)
  908. {
  909. CRect rcWindow;
  910. CBrush cb;
  911. cb.CreateSolidBrush(::GetSysColor(COLOR_BTNSHADOW));
  912. rcWindow=rcWin;
  913. rcWindow.top=rcWin->top+i;
  914. rcWindow.bottom=rcWindow.top+1;
  915. dc->FillRect(rcWindow,&cb);
  917. }
  919. }
  920. else
  921. {
  922. rcWin->top+=2;
  923. rcWin->left+=2;
  924. rcWin->right-=2;
  925. rcWin->bottom=rcWin->top+3;
  926. for (int i=0; i < rcWin->Width(); i+=2)
  927. {
  928. CRect rcWindow;
  929. CBrush cb;
  930. cb.CreateSolidBrush(::GetSysColor(COLOR_BTNSHADOW));
  931. rcWindow=rcWin;
  932. rcWindow.left=rcWindow.left+i;
  933. rcWindow.right=rcWindow.left+1;
  934. dc->FillRect(rcWindow,&cb);
  936. }
  938. }
  939. }
  941. }
  943. void CGuiToolBarWnd::OnLButtonDown(UINT nFlags, CPoint point) 
  944. {
  945. CToolBar::OnLButtonDown(nFlags, point);
  947. if (m_iSelected == 1) return;
  948. m_iSelected =1;
  952. }
  954. void CGuiToolBarWnd::OnRButtonDown(UINT nFlags, CPoint point) 
  955. {
  956. CToolBar::OnRButtonDown(nFlags,point);
  957. ClientToScreen (&point);
  958. CMenu m_menu;
  959. m_menu.LoadMenu(MenuContext);
  960. if (!m_menu.GetSafeHmenu())
  961. return ;
  962. CMenu* m_SubMenu = m_menu.GetSubMenu(0);
  963. m_SubMenu->TrackPopupMenu(TPM_LEFTALIGN|TPM_LEFTBUTTON|TPM_VERTICAL,
  964. point.x, point.y-2, AfxGetMainWnd());
  965. Invalidate();
  966. UpdateWindow();
  968. }
  971. void CGuiToolBarWnd::OnLButtonDblClk(UINT nFlags, CPoint point) 
  972. {
  973. }
  975. BOOL CGuiToolBarWnd::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  976. {
  978. CPoint ptCurPos; 
  979. CRect rc;GetClientRect(rc);
  980. GetCursorPos (&ptCurPos);
  981. ScreenToClient (&ptCurPos);
  982. if (m_dwStyle & CBRS_ORIENT_HORZ)
  983. {
  984. rc.right=rc.left+2;
  985. if (ptCurPos.x< 0)
  986. {
  987. SetCursor (LoadCursor(NULL, IDC_SIZEALL));
  988. return TRUE;
  989. }
  990. }
  991. else
  992. {
  993. rc.bottom=rc.top+2;
  994. if (ptCurPos.y< 0)
  995. {
  996. SetCursor (LoadCursor(NULL, IDC_SIZEALL));
  997. return TRUE;
  998. }
  999. }
  1000. return CToolBar::OnSetCursor(pWnd, nHitTest, message);
  1002. }
  1006. void CGuiToolBarWnd::OnLButtonUp(UINT nFlags, CPoint point) 
  1007. {
  1008. CToolBar::OnLButtonUp(nFlags, point);
  1010. if (m_iSelected == 1)
  1011. {
  1012. m_iSelected =0;
  1013. KillTimer(1);
  1014. SetTimer(1,10,NULL);
  1015. }
  1016. }
  1018. void CGuiToolBarWnd::OnTimer(UINT nIDEvent) 
  1019. {
  1020. // TODO: Add your message handler code here and/or call default
  1021. CRect m_rect;
  1022. CPoint pt(GetMessagePos());
  1023. ScreenToClient(&pt);
  1024. GetClientRect(m_rect);
  1025. if (nIDEvent == 1)
  1026. {
  1028. if (!m_rcBtnGlobal.PtInRect(pt))
  1029. {
  1030. m_iSelected =0;
  1031. KillTimer(1);
  1032. if (!bPressDown)
  1033. {
  1034. InvalidateRect(m_rcBtnGlobal);
  1035. UpdateWindow();
  1036. }
  1038. m_rcBtnGlobal.SetRectEmpty();
  1040. }
  1041. }
  1042. CToolBar::OnTimer(nIDEvent);
  1043. }
  1047. //**************************************************************************
  1048. int CGuiToolBarWnd::GetLastPos()
  1049. {
  1051. int nNumBars=(int)m_pDockBar->m_arrBars.GetSize();
  1052. int m_pos=m_pDockBar->FindBar(this);
  1053. for(int i=m_pos+1; i< nNumBars;i++)
  1054. {
  1055. if (m_pDockBar->m_arrBars[i]== NULL)
  1056.     return i-1;
  1057. }
  1058. return -1;
  1059. }
  1061. //**************************************************************************
  1062. int CGuiToolBarWnd::GetFirstPos()
  1063. {
  1064. int m_pos=m_pDockBar->FindBar(this);
  1065. for(int i=m_pos; i>=0;i--)
  1066. {
  1067. if (m_pDockBar->m_arrBars[i]== NULL)
  1068.     return i+1;
  1069. }
  1070. return -1;
  1072. }
  1073. //**************************************************************************
  1074. CRect CGuiToolBarWnd::GetDockRect()
  1075. {
  1076. CRect rcWin;
  1077. rcWin.SetRectEmpty();
  1078. if(!m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_LEFT)->GetSafeHwnd())
  1079. return rcWin;
  1080. if(!m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_RIGHT)->GetSafeHwnd())
  1081. return rcWin;
  1082. if(!m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_BOTTOM)->GetSafeHwnd())
  1083. return rcWin;
  1084. if(!m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_TOP)->GetSafeHwnd())
  1085. return rcWin;
  1086. if (IsVert())
  1087. if (IsLeft())
  1088. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_LEFT)->GetWindowRect(rcWin);
  1089. else
  1090. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_RIGHT)->GetWindowRect(rcWin);
  1091. else
  1092. if(IsBottom())
  1093. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_BOTTOM)->GetWindowRect(rcWin);
  1094. else
  1095. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_TOP)->GetWindowRect(rcWin);
  1097. return rcWin;
  1098. }
  1099. //**************************************************************************
  1100. int CGuiToolBarWnd::GetHiWid()
  1101. {
  1102. CRect rcWin;
  1103. rcWin=GetDockRect();
  1104. if (rcWin.IsRectEmpty())
  1105. return rcWin.Width() ;
  1106. if (!(m_dwStyle & CBRS_ORIENT_HORZ))
  1107. {
  1108. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_LEFT)->GetWindowRect(rcWin);
  1109. return rcWin.Height() ;
  1110. }
  1111. else
  1112. {
  1113. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_TOP)->GetWindowRect(rcWin);
  1114. return rcWin.Width() ;
  1115. }
  1116. }
  1117. //**************************************************************************
  1119. void CGuiToolBarWnd::SetRealSize()
  1120. {
  1121. CRect rcWinFrame;
  1122. CRect rcThisBar;
  1124. int nVisibles=0;
  1126. int nThis = m_pDockBar->FindBar(this);
  1127. int nFirst= GetFirstPos();
  1128. int nLast=  GetLastPos();
  1129. UINT m_nDockBarID = m_pDockBar->GetDlgCtrlID();
  1130. int  nMaxlen=GetHiWid();
  1131.     int  nLen=0; 
  1132. for (int i=nFirst;i <nLast;  i++)
  1133. {
  1135. CGuiToolBarWnd* pBar;
  1136. pBar = (CGuiToolBarWnd*) m_pDockBar->m_arrBars[i];
  1137. if (HIWORD(pBar) == 0) continue; 
  1138. if (!pBar->IsVisible()) continue;
  1140. CRect rc;
  1141. pBar->GetWindowRect(rc);
  1142. if (IsVert())
  1143. nLen+=rc.Height() ;
  1144. else
  1145. nLen+= rc.Width() ;
  1146. nVisibles++;
  1147. }
  1149. if ( nLen > nMaxlen)
  1150. {
  1151. int nDif=nLen-nMaxlen;
  1154. }
  1158. /* if (rcThisBar.Width() > nAfterThis)
  1159. {
  1160. if (nVisibles > 0)
  1161. nAfterThis/=nVisibles;
  1164. }
  1165. */
  1166. }
  1168. #define CX_OVERLAP  0
  1169. //***************************************************************************
  1170. CSize  CGuiToolBarWnd::CalcSize(TBBUTTON* pData, int nCount)
  1171. {
  1172. ASSERT(pData != NULL && nCount > 0);
  1173. BOOL bDrow=FALSE;
  1174. int  nNumDrow=0;
  1175. CPoint cur(0,0);
  1176. CSize sizeResult(0,0);
  1177. CClientDC dc(this);
  1178. int xSizeMin=32;
  1179. //if(m_dwStyle & CBRS_FLOATING )  
  1181. int nSizeBar=0;
  1182. int nSizeBarReal=0;
  1183. int nSizeHoWid=GetHiWid();
  1185. DWORD dwExtendedStyle = DefWindowProc(TB_GETEXTENDEDSTYLE, 0, 0);
  1186. for (int i = 0; i < nCount; i++)
  1187. {
  1188. CRect rcButton;
  1189. GetItemRect ( i, &rcButton );
  1191. if ((pData[i].fsStyle &  TBSTYLE_SEP) &&(pData[i].idCommand!=0))
  1192. {
  1193.     if (bVertDocked || IsFloating())
  1194. {
  1195.  CWnd * pWnd =GetDlgItem(pData[i].idCommand);
  1196.  ASSERT_VALID(pWnd);
  1197.  pWnd->ShowWindow( SW_HIDE   );
  1198.  pData[i].fsState |= TBSTATE_HIDDEN;
  1199.  continue;
  1201. }
  1202. else
  1203. {
  1205. CWnd * pWnd =GetDlgItem(pData[i].idCommand);
  1206. ASSERT_VALID(pWnd);
  1207. pData[i].fsState &= ~TBSTATE_HIDDEN;
  1208. pWnd->ShowWindow( SW_SHOW   );
  1211. }
  1212. }
  1214. int cySep = pData[i].iBitmap;
  1215. cySep = cySep * 2 / 3;
  1216. CRect rci;
  1217. GetItemRect(i, &rci);
  1218. int cx=rci.Width();
  1219. xSizeMin=min(xSizeMin,cx);
  1220. if (pData[i].fsStyle & TBSTYLE_SEP)
  1221. {
  1222. // a separator represents either a height or width
  1223. if (pData[i].fsState & TBSTATE_WRAP)
  1224. sizeResult.cy = max(cur.y + m_sizeButton.cy + cySep, sizeResult.cy);
  1225. else
  1226. sizeResult.cx = max(cur.x + pData[i].iBitmap, sizeResult.cx);
  1227. }
  1228. else
  1229. {
  1230. // check for dropdown style, but only if the buttons are being drawn
  1231. if ((pData[i].fsStyle & TBSTYLE_DROPDOWN) &&
  1232. (dwExtendedStyle & TBSTYLE_EX_DRAWDDARROWS))
  1233. {
  1234. // add size of drop down
  1235. cx += (_afxDropDownWidth);
  1236. nNumDrow++;
  1237. bDrow=TRUE;
  1238. }
  1239. sizeResult.cx = max(cur.x + cx, sizeResult.cx);
  1240. sizeResult.cy = max(cur.y + m_sizeButton.cy, sizeResult.cy);
  1241. }
  1245. if (pData[i].fsStyle & TBSTYLE_SEP)
  1246. cur.x += pData[i].iBitmap;
  1247. else
  1248. cur.x += cx - CX_OVERLAP;
  1250. if (pData[i].fsState & TBSTATE_WRAP)
  1251. {
  1252. cur.x = 0;
  1253. cur.y += m_sizeButton.cy;
  1254. if (pData[i].fsStyle & TBSTYLE_SEP)
  1255. cur.y += cySep;
  1256. }
  1257. }
  1258. if (bDrow == TRUE)
  1259. {
  1261. if (bVertDocked)
  1262. {
  1263. sizeResult.cx-=_afxDropDownWidth;
  1264. sizeResult.cy+=_afxDropDownWidth-2;//*nNumDrow;
  1265. }
  1266. else
  1267. {
  1268. sizeResult.cx-=_afxDropDownWidth*nNumDrow;
  1270. }
  1271. }
  1272. else
  1273. {
  1274. if (bVertDocked)
  1275. sizeResult.cy+=_afxDropDownWidth/2;
  1276. }
  1278. return sizeResult;
  1279. }
  1281. int  CGuiToolBarWnd::WrapToolBar(TBBUTTON* pData, int nCount, int nWidth)
  1282. {
  1283. ASSERT(pData != NULL && nCount > 0);
  1285. int nResult = 0;
  1286. int x = 0;
  1287. for (int i = 0; i < nCount; i++)
  1288. {
  1289. pData[i].fsState &= ~TBSTATE_WRAP;
  1291. if (pData[i].fsState & TBSTATE_HIDDEN)
  1292. continue;
  1294. int dx, dxNext;
  1295. if (pData[i].fsStyle & TBSTYLE_SEP)
  1296. {
  1297. dx = pData[i].iBitmap;
  1298. dxNext = dx;
  1299. }
  1300. else
  1301. {
  1302. dx = m_sizeButton.cx;
  1303. dxNext = dx - CX_OVERLAP;
  1304. }
  1306. if (x + dx > nWidth)
  1307. {
  1308. BOOL bFound = FALSE;
  1309. for (int j = i; j >= 0  &&  !(pData[j].fsState & TBSTATE_WRAP); j--)
  1310. {
  1311. // Find last separator that isn't hidden
  1312. // a separator that has a command ID is not
  1313. // a separator, but a custom control.
  1314. if ((pData[j].fsStyle & TBSTYLE_SEP) &&
  1315. (pData[j].idCommand == 0) &&
  1316. !(pData[j].fsState & TBSTATE_HIDDEN))
  1317. {
  1318. bFound = TRUE; i = j; x = 0;
  1319. pData[j].fsState |= TBSTATE_WRAP;
  1320. nResult++;
  1321. break;
  1322. }
  1323. }
  1324. if (!bFound)
  1325. {
  1326. for (int j = i - 1; j >= 0 && !(pData[j].fsState & TBSTATE_WRAP); j--)
  1327. {
  1328. // Never wrap anything that is hidden,
  1329. // or any custom controls
  1330. if ((pData[j].fsState & TBSTATE_HIDDEN) ||
  1331. ((pData[j].fsStyle & TBSTYLE_SEP) &&
  1332. (pData[j].idCommand != 0)))
  1333. continue;
  1335. bFound = TRUE; i = j; x = 0;
  1336. pData[j].fsState |= TBSTATE_WRAP;
  1337. nResult++;
  1338. break;
  1339. }
  1340. if (!bFound)
  1341. x += dxNext;
  1342. }
  1343. }
  1344. else
  1345. x += dxNext;
  1346. }
  1347. return nResult + 1;
  1348. }
  1350. void   CGuiToolBarWnd::SizeToolBar(TBBUTTON* pData, int nCount, int nLength, BOOL bVert)
  1351. {
  1352. ASSERT(pData != NULL && nCount > 0);
  1353. bVert;
  1355. if (!bVert)
  1356. {
  1357. int nMin, nMax, nTarget, nCurrent, nMid;
  1359. // Wrap ToolBar as specified
  1360. nMax = nLength;
  1361. nTarget = WrapToolBar(pData, nCount, nMax);
  1363. // Wrap ToolBar vertically
  1364. nMin = 0;
  1365. nCurrent = WrapToolBar(pData, nCount, nMin);
  1367. if (nCurrent != nTarget)
  1368. {
  1369. while (nMin < nMax)
  1370. {
  1371. nMid = (nMin + nMax) / 2;
  1372. nCurrent = WrapToolBar(pData, nCount, nMid);
  1374. if (nCurrent == nTarget)
  1375. nMax = nMid;
  1376. else
  1377. {
  1378. if (nMin == nMid)
  1379. {
  1380. WrapToolBar(pData, nCount, nMax);
  1381. break;
  1382. }
  1383. nMin = nMid;
  1384. }
  1385. }
  1386. }
  1387. CSize size = CalcSize(pData, nCount);
  1388. WrapToolBar(pData, nCount, size.cx);
  1389. }
  1390. else
  1391. {
  1392. CSize sizeMax, sizeMin, sizeMid;
  1394. // Wrap ToolBar vertically
  1395. WrapToolBar(pData, nCount, 0);
  1396. sizeMin = CalcSize(pData, nCount);
  1398. // Wrap ToolBar horizontally
  1399. WrapToolBar(pData, nCount, 32767);
  1400. sizeMax = CalcSize(pData, nCount);
  1402. while (sizeMin.cx < sizeMax.cx)
  1403. {
  1404. sizeMid.cx = (sizeMin.cx + sizeMax.cx) / 2;
  1405. WrapToolBar(pData, nCount, sizeMid.cx);
  1406. sizeMid = CalcSize(pData, nCount);
  1408. if (nLength < sizeMid.cy)
  1409. {
  1410. if (sizeMin == sizeMid)
  1411. {
  1412. WrapToolBar(pData, nCount, sizeMax.cx);
  1413. return;
  1414. }
  1415. sizeMin = sizeMid;
  1416. }
  1417. else if (nLength > sizeMid.cy)
  1418. sizeMax = sizeMid;
  1419. else
  1420. return;
  1421. }
  1422. }
  1423. }
  1425. struct _AFX_CONTROLPOS
  1426. {
  1427. int nIndex, nID;
  1428. CRect rectOldPos;
  1429. };
  1431. CSize  CGuiToolBarWnd::CalcLayout(DWORD dwMode, int nLength)
  1432. {
  1433. ASSERT_VALID(this);
  1434. ASSERT(::IsWindow(m_hWnd));
  1435. if (dwMode & LM_HORZDOCK)
  1436. ASSERT(dwMode & LM_HORZ);
  1438. if (dwMode & LM_HORZ)
  1439. bVertDocked=FALSE;
  1440. else
  1441. bVertDocked=TRUE;
  1442. int nCount;
  1443. TBBUTTON* pData = NULL;
  1444. CSize sizeResult(0,0);
  1445. //BLOCK: Load Buttons
  1446. {
  1447. nCount = DefWindowProc(TB_BUTTONCOUNT, 0, 0);
  1448. if (nCount != 0)
  1449. {
  1450. int i;
  1451. pData = new TBBUTTON[nCount];
  1452. for (i = 0; i < nCount; i++)
  1453. {
  1454. _GetButton(i, &pData[i]);
  1455. }
  1456. }
  1457. }
  1459. if (nCount > 0)
  1460. {
  1461. if (!(m_dwStyle & CBRS_SIZE_FIXED))
  1462. {
  1463. BOOL bDynamic = m_dwStyle & CBRS_SIZE_DYNAMIC;
  1465. if (bDynamic && (dwMode & LM_MRUWIDTH))
  1466. SizeToolBar(pData, nCount, m_nMRUWidth);
  1467. else if (bDynamic && (dwMode & LM_HORZDOCK))
  1468. SizeToolBar(pData, nCount, 32767);
  1469. else if (bDynamic && (dwMode & LM_VERTDOCK))
  1470. SizeToolBar(pData, nCount, 0);
  1471. else if (bDynamic && (nLength != -1))
  1472. {
  1473. CRect rect; rect.SetRectEmpty();
  1474. CalcInsideRect(rect, (dwMode & LM_HORZ));
  1475. BOOL bVert = (dwMode & LM_LENGTHY);
  1476. int nLen = nLength + (bVert ? rect.Height() : rect.Width());
  1478. SizeToolBar(pData, nCount, nLen, bVert);
  1479. }
  1480. else if (bDynamic && (m_dwStyle & CBRS_FLOATING))
  1481. SizeToolBar(pData, nCount, m_nMRUWidth);
  1482. else
  1483. SizeToolBar(pData, nCount, (dwMode & LM_HORZ) ? 32767 : 0);
  1484. }
  1486. sizeResult = CalcSize(pData, nCount);
  1488. if (dwMode & LM_COMMIT)
  1489. {
  1490. _AFX_CONTROLPOS* pControl = NULL;
  1491. int nControlCount = 0;
  1492. BOOL bIsDelayed = m_bDelayedButtonLayout;
  1493. m_bDelayedButtonLayout = FALSE;
  1495. for (int i = 0; i < nCount; i++)
  1496. if ((pData[i].fsStyle & TBSTYLE_SEP) && (pData[i].idCommand != 0))
  1497. nControlCount++;
  1499. if (nControlCount > 0)
  1500. {
  1501. pControl = new _AFX_CONTROLPOS[nControlCount];
  1502. nControlCount = 0;
  1504. for(int i = 0; i < nCount; i++)
  1505. {
  1506. if ((pData[i].fsStyle & TBSTYLE_SEP) && (pData[i].idCommand != 0))
  1507. {
  1508. pControl[nControlCount].nIndex = i;
  1509. pControl[nControlCount].nID = pData[i].idCommand;
  1511. CRect rect;
  1512. GetItemRect(i, &rect);
  1513. ClientToScreen(&rect);
  1514. pControl[nControlCount].rectOldPos = rect;
  1516. nControlCount++;
  1517. }
  1518. }
  1519. }
  1521. if ((m_dwStyle & CBRS_FLOATING) && (m_dwStyle & CBRS_SIZE_DYNAMIC))
  1522. m_nMRUWidth = sizeResult.cx;
  1523. for (i = 0; i < nCount; i++)
  1524. _SetButton(i, &pData[i]);
  1526. if (nControlCount > 0)
  1527. {
  1528. for (int i = 0; i < nControlCount; i++)
  1529. {
  1530. CWnd* pWnd = GetDlgItem(pControl[i].nID);
  1531. if (pWnd != NULL)
  1532. {
  1533. CRect rect;
  1534. pWnd->GetWindowRect(&rect);
  1535. CPoint pt = rect.TopLeft() - pControl[i].rectOldPos.TopLeft();
  1536. GetItemRect(pControl[i].nIndex, &rect);
  1537. pt = rect.TopLeft() + pt;
  1538. pWnd->SetWindowPos(NULL, pt.x, pt.y, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
  1539. }
  1540. }
  1541. delete[] pControl;
  1542. }
  1543. m_bDelayedButtonLayout = bIsDelayed;
  1544. }
  1545. delete[] pData;
  1546. }
  1548. //BLOCK: Adjust Margins
  1549. {
  1550. CRect rect; rect.SetRectEmpty();
  1551. CalcInsideRect(rect, (dwMode & LM_HORZ));
  1552. sizeResult.cy -= rect.Height();
  1553. sizeResult.cx -= rect.Width();
  1555. CSize size = CControlBar::CalcFixedLayout((dwMode & LM_STRETCH), (dwMode & LM_HORZ));
  1556. sizeResult.cx = max(sizeResult.cx, size.cx);
  1557. sizeResult.cy = max(sizeResult.cy, size.cy);
  1558. }
  1560. return sizeResult;
  1561. }
  1563. CSize  CGuiToolBarWnd::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  1564. {
  1565. DWORD dwMode = bStretch ? LM_STRETCH : 0;
  1566. dwMode |= bHorz ? LM_HORZ : 0;
  1568. return CalcLayout(dwMode);
  1569. }
  1571. CSize  CGuiToolBarWnd::CalcDynamicLayout(int nLength, DWORD dwMode)
  1572. {
  1573. if ((nLength == -1) && !(dwMode & LM_MRUWIDTH) && !(dwMode & LM_COMMIT) &&
  1574. ((dwMode & LM_HORZDOCK) || (dwMode & LM_VERTDOCK)))
  1575. {
  1576. return CalcFixedLayout(dwMode & LM_STRETCH, dwMode & LM_HORZDOCK);
  1577. }
  1578. return CalcLayout(dwMode, nLength);
  1579. }
  1581. void   CGuiToolBarWnd::_GetButton(int nIndex, TBBUTTON* pButton) const
  1582. {
  1583. CGuiToolBarWnd* pBar = (CGuiToolBarWnd*)this;
  1584. VERIFY(pBar->DefWindowProc(TB_GETBUTTON, nIndex, (LPARAM)pButton));
  1585. // TBSTATE_ENABLED == TBBS_DISABLED so invert it
  1586. pButton->fsState ^= TBSTATE_ENABLED;
  1587. }
  1589. void   CGuiToolBarWnd::_SetButton(int nIndex, TBBUTTON* pButton)
  1590. {
  1591. // get original button state
  1592. TBBUTTON button;
  1593. VERIFY(DefWindowProc(TB_GETBUTTON, nIndex, (LPARAM)&button));
  1595. // prepare for old/new button comparsion
  1596. button.bReserved[0] = 0;
  1597. button.bReserved[1] = 0;
  1598. // TBSTATE_ENABLED == TBBS_DISABLED so invert it
  1599. pButton->fsState ^= TBSTATE_ENABLED;
  1600. pButton->bReserved[0] = 0;
  1601. pButton->bReserved[1] = 0;
  1603. // nothing to do if they are the same
  1604. if (memcmp(pButton, &button, sizeof(TBBUTTON)) != 0)
  1605. {
  1606. // don't redraw everything while setting the button
  1607. DWORD dwStyle = GetStyle();
  1608. ModifyStyle(WS_VISIBLE, 0);
  1609. VERIFY(DefWindowProc(TB_DELETEBUTTON, nIndex, 0));
  1610. VERIFY(DefWindowProc(TB_INSERTBUTTON, nIndex, (LPARAM)pButton));
  1611. ModifyStyle(0, dwStyle & WS_VISIBLE);
  1613. // invalidate appropriate parts
  1614. if (((pButton->fsStyle ^ button.fsStyle) & TBSTYLE_SEP) ||
  1615. ((pButton->fsStyle & TBSTYLE_SEP) && pButton->iBitmap != button.iBitmap))
  1616. {
  1617. // changing a separator
  1618. Invalidate();
  1619. }
  1620. else
  1621. {
  1622. // invalidate just the button
  1623. CRect rect;
  1624. if (DefWindowProc(TB_GETITEMRECT, nIndex, (LPARAM)&rect))
  1625. InvalidateRect(rect);
  1626. }
  1627. }
  1628. }
  1630. BOOL CGuiToolBarWnd::IsLeft()
  1631. {
  1632. if (nDockBarAling == AFX_IDW_DOCKBAR_LEFT) return TRUE;
  1633. return FALSE;
  1634. }
  1636. BOOL CGuiToolBarWnd::IsRight()
  1637. {
  1638. if (nDockBarAling == AFX_IDW_DOCKBAR_RIGHT) return TRUE;
  1639. return FALSE;
  1640. }
  1642. BOOL CGuiToolBarWnd::IsTop()
  1643. {
  1644. if (nDockBarAling == AFX_IDW_DOCKBAR_TOP) return TRUE;
  1645. return FALSE;
  1646. }
  1648. BOOL CGuiToolBarWnd::IsBottom()
  1649. {
  1650. if (nDockBarAling == AFX_IDW_DOCKBAR_BOTTOM) return TRUE;
  1651. return FALSE;
  1652. }
  1654. BOOL CGuiToolBarWnd::IsVert()
  1655. {
  1656. if (IsLeft() || IsRight())
  1657. return TRUE;
  1658. return FALSE;
  1659. }
  1661. BOOL CGuiToolBarWnd::IsHorz()
  1662. {
  1663. if (IsTop() || IsBottom())
  1664. return TRUE;
  1665. return FALSE;
  1666. }
  1668. BOOL CGuiToolBarWnd::IsFloating()
  1669. {
  1670. if (nDockBarAling == AFX_IDW_DOCKBAR_FLOAT)
  1671. return TRUE;
  1672. return FALSE;
  1674. }
  1676. void CGuiToolBarWnd::OnMouseMove(UINT nFlags, CPoint point)
  1677. {
  1678. // TODO: Add your message handler code here and/or call default
  1679. int nCountBtn=  nCountBtn = SendMessage (TB_BUTTONCOUNT, 0, 0);
  1680. CRect rc;
  1681. if (!IsTopParentActive() || !GetTopLevelParent()->IsWindowEnabled())
  1682. return;
  1684. for (int i=0; i< nCountBtn; i++)
  1685. {
  1686. GetItemRect(i,rc);
  1687. if (GetButtonStyle(i) == TBBS_SEPARATOR)
  1688. continue;
  1689. else
  1690. {
  1692. if (rc.PtInRect(point) && m_ActualBtn != i)
  1693. {
  1694. m_ActualBtn=i;
  1695. InvalidateRect(rc,TRUE);
  1696. m_rcBtnGlobal=rc;
  1697. m_rcSaveFloat=rc;
  1698. }
  1699. if (m_ActualBtn == i)
  1700. m_rcBtnGlobal=rc;
  1701. }
  1703. }
  1704. SetTimer(1, 250, 0);
  1705. CToolBar::OnMouseMove(nFlags, point);
  1707. }