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

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

工具条

开发平台：

Visual C++

NGenericToolBar.cpp：源码内容
  1. // NGenericToolBar.cpp: implementation of the CNGenericToolBar class.
  2. //
  3. /*
  4. Copyright (C) 1998 Tony Hoyle (tmh@netfusion.co.uk)
  6. This program is free software; you can redistribute it and/or modify it under the terms
  7. of the GNU General Public License as published by the Free Software Foundation; either
  8. version 2 of the License, or (at your option) any later version.
  10. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
  11. without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12. See the GNU General Public License for more details.
  14. You should have received a copy of the GNU General Public License along with this program;
  15. if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  16. */
  17. //////////////////////////////////////////////////////////////////////
  19. #include "stdafx.h"
  20. #include "NGenericToolBar.h"
  21. #include "NGenericMenu.h"
  23. #include "afxpriv.h"
  24. #ifdef _DEBUG
  25. #undef THIS_FILE
  26. static char THIS_FILE[]=__FILE__;
  27. #define new DEBUG_NEW
  28. #endif
  30. IMPLEMENT_DYNAMIC(CNGenericToolBar,CToolBar)
  32. BEGIN_MESSAGE_MAP(CNGenericToolBar,CToolBar)
  33. //{{AFX_MSG_MAP(CNGenericToolBar)
  34. ON_WM_CONTEXTMENU()
  35. ON_WM_DESTROY()
  36. ON_WM_PAINT()
  37. ON_WM_NCCALCSIZE()
  38. ON_WM_NCPAINT()
  39. ON_WM_NCHITTEST()
  40. ON_WM_WINDOWPOSCHANGING() 
  41. //}}AFX_MSG_MAP
  42. ON_COMMAND(IDM_BUTTONSONLY,OnButtonsOnly)
  43. ON_COMMAND(IDM_BUTTONSANDTEXT,OnTextAndButtons)
  44. ON_COMMAND(IDM_TEXTONLY,OnTextOnly)
  45. ON_COMMAND(IDM_RECALCSIZE,OnRecalcSize)
  46.  END_MESSAGE_MAP()
  48. CArray<CNGenericToolBar*,CNGenericToolBar*> CNGenericToolBar::m_ToolbarList;
  49. BOOL CNGenericToolBar::m_bButtons=FALSE;
  50. BOOL CNGenericToolBar::m_bText=FALSE;
  52. //////////////////////////////////////////////////////////////////////
  53. // Construction/Destruction
  54. //////////////////////////////////////////////////////////////////////
  56. CNGenericToolBar::CNGenericToolBar()
  57. {
  58. m_bHasText=FALSE;
  59. m_bHasBitmaps=TRUE;
  60. m_bForceText=FALSE;
  61. m_bSysMenuIcon=FALSE;
  62. m_dwGenericToolBarStyle = 0x0000;
  63. }
  65. CNGenericToolBar::~CNGenericToolBar()
  66. {
  68. }
  70. void CNGenericToolBar::OnRecalcSize()
  71. {
  72. SettingChange();
  73. RecalcSize();
  74. GetParentFrame()->DelayRecalcLayout();
  75. }
  77. void CNGenericToolBar::SettingChange()
  78. {
  79. TBBUTTON tb;
  80. for(int n=0; n<GetCount(); n++)
  81. {
  82. SendMessage(TB_GETBUTTON,n,(LPARAM)&tb);
  83. tb.iString=m_bText?m_TextIds[n]:-1;
  84. _SetButton(n,&tb);
  85. }
  86. SendMessage(TB_SETMAXTEXTROWS,m_bText||m_bForceText?4:0);
  87. SendMessage(TB_SETBITMAPSIZE,0,m_bButtons&&m_bHasBitmaps?MAKELONG(16,15):0);
  88. SendMessage(TB_AUTOSIZE);
  89. }
  91. BOOL CNGenericToolBar::RecalcSize()
  92. {
  93. CRect rect;
  94. int cx=0,cy=0;
  96. SendMessage(TB_AUTOSIZE);
  97. for(int n=0; n<GetToolBarCtrl().GetButtonCount(); n++)
  98. {
  99. GetItemRect(n,&rect);
  100. if(rect.Width()>cx) cx=rect.Width();
  101. if(rect.Height()>cy) cy=rect.Height();
  102. }
  103. m_sizeButton.cx=cx;
  104. m_sizeButton.cy=cy-2;
  105. m_bDelayedButtonLayout=TRUE;
  106. ::InvalidateRect(*this,NULL,FALSE);
  107. return TRUE;
  108. }
  110. BOOL CNGenericToolBar::CreateEx(CWnd* pParentWnd, DWORD dwExStyle, DWORD dwStyle, UINT nID, LPCTSTR szTitle)
  111. {
  112. if(!CToolBar::Create(pParentWnd,dwStyle,nID)) return FALSE;
  113. if(szTitle) SetWindowText(szTitle);
  114. m_pParent=pParentWnd;
  115. ModifyStyle(0,dwExStyle);
  116. m_pop.CreatePopupMenu();
  117. m_pop.AppendMenu(MF_STRING,IDM_BUTTONSONLY,"&Buttons");
  118. m_pop.AppendMenu(MF_STRING,IDM_BUTTONSANDTEXT,"Buttons &and Text");
  119. m_pop.AppendMenu(MF_STRING,IDM_TEXTONLY,"&Text");
  120. m_ToolbarList.Add(this);
  121. return TRUE;
  122. }
  124. BOOL CNGenericToolBar::LoadToolBar(LPCTSTR lpszResourceName)
  125. {
  126. if(!CToolBar::LoadToolBar(lpszResourceName)) return FALSE;
  128. CString tmp;
  129. LPCTSTR p,q;
  130. SendMessage(TB_SETMAXTEXTROWS,4);
  131. m_accelList.SetSize(0);
  132. for(int n=0; n<GetCount(); n++)
  133. {
  134. if(GetItemID(n)!=-1)
  135. {
  136. tmp.LoadString(GetItemID(n));
  137. p=tmp;
  138. while(*p && *p!='n')
  139. p++;
  140. if(*p)
  141. {
  142. p++;
  143. while(*p && *p!='n')
  144. p++;
  145. }
  146. if(*p)
  147. {
  148. for(q=p; *q; q++)
  149. {
  150. if(*q=='&')
  151. {
  152. int s=m_accelList.GetSize();
  153. m_accelList.SetSize(s+1);
  154. m_accelList[s].nKey=toupper(*(q+1));
  155. m_accelList[s].nId=GetItemID(n);
  156. break;
  157. }
  158. }
  159. SetButtonText(n,p+1);
  160. m_bHasText=TRUE;
  161. m_bText=TRUE;
  162. }
  163. else
  164. {
  165. if(m_bHasText) SetButtonText(n," ");
  166. }
  167. }
  168. }
  171. TBBUTTON tb;
  172. m_TextIds.SetSize(0);
  173. for(n=0; n<GetCount(); n++)
  174. {
  175. SendMessage(TB_GETBUTTON,n,(LPARAM)&tb);
  176. m_TextIds.Add(tb.iString);
  177. tb.iString=m_bText?m_TextIds[n]:-1;
  178. }
  180. m_bButtons = TRUE;
  181. OnRecalcSize();
  183. return TRUE;
  184. }
  186. BOOL CNGenericToolBar::SetButtonText(int nIndex, LPCTSTR lpszText)
  187. {
  188. if(!CToolBar::SetButtonText(nIndex,lpszText)) return FALSE;
  189. return RecalcSize();
  190. }
  193. void CNGenericToolBar::OnContextMenu(CWnd* pWnd, CPoint point) 
  194. {
  195. m_pop.CheckMenuItem(IDM_BUTTONSONLY,m_bButtons&&!m_bText?MF_CHECKED:MF_UNCHECKED);
  196. m_pop.CheckMenuItem(IDM_BUTTONSANDTEXT,m_bButtons&&m_bText?MF_CHECKED:MF_UNCHECKED);
  197. m_pop.CheckMenuItem(IDM_TEXTONLY,!m_bButtons&&m_bText?MF_CHECKED:MF_UNCHECKED);
  198. m_pop.EnableMenuItem(IDM_BUTTONSONLY,MF_ENABLED);
  199. m_pop.EnableMenuItem(IDM_BUTTONSANDTEXT,m_bHasText?MF_ENABLED:MF_GRAYED);
  200. m_pop.EnableMenuItem(IDM_TEXTONLY,m_bHasText?MF_ENABLED:MF_GRAYED);
  201. m_pop.TrackPopupMenu(TPM_LEFTALIGN,point.x,point.y,pWnd);
  202. }
  204. void CNGenericToolBar::OnButtonsOnly()
  205. {
  206. if(!m_bText && m_bButtons) return;
  207. m_bText=FALSE;
  208. m_bButtons=TRUE;
  209. SendToAllToolbars(WM_COMMAND,IDM_RECALCSIZE);
  210. }
  212. void CNGenericToolBar::OnTextOnly()
  213. {
  214. if(m_bText && !m_bButtons) return;
  215. m_bText=TRUE;
  216. m_bButtons=FALSE;
  217. SendToAllToolbars(WM_COMMAND,IDM_RECALCSIZE);
  218. }
  220. void CNGenericToolBar::OnTextAndButtons()
  221. {
  222. if(m_bText && m_bButtons) return;
  223. m_bText=TRUE;
  224. m_bButtons=TRUE;
  225. SendToAllToolbars(WM_COMMAND,IDM_RECALCSIZE);
  226. }
  228. void CNGenericToolBar::OnDestroy() 
  229. {
  230. CToolBar::OnDestroy();
  231. for(int n=0; n<m_ToolbarList.GetSize(); n++)
  232. if(m_ToolbarList[n]==this)
  233. {
  234. m_ToolbarList.RemoveAt(n);
  235. break;
  236. }
  237. }
  239. void CNGenericToolBar::SendToAllToolbars(UINT uMsg, WPARAM wParam, LPARAM lParam)
  240. {
  241. for(int n=0; n<m_ToolbarList.GetSize(); n++)
  242. m_ToolbarList[n]->SendMessage(uMsg,wParam,lParam);
  243. }
  245. void CNGenericToolBar::SetVisualState(BOOL bButtons, BOOL bText)
  246. {
  247. if(!bText && !bButtons) bButtons=TRUE;
  248. m_bText=bText;
  249. m_bButtons=bButtons;
  250. SendToAllToolbars(WM_COMMAND,IDM_RECALCSIZE);
  251. }
  253. BOOL CNGenericToolBar::GetVisualState(BOOL bText)
  254. {
  255. if(bText) return m_bText;
  256. else return m_bButtons;
  257. }
  259. // Borrowed from MFC
  260. void CNGenericToolBar::_SetButton(int nIndex, TBBUTTON* pButton)
  261. {
  262. // get original button state
  263. TBBUTTON button;
  264. VERIFY(DefWindowProc(TB_GETBUTTON, nIndex, (LPARAM)&button));
  266. // prepare for old/new button comparsion
  267. button.bReserved[0] = 0;
  268. button.bReserved[1] = 0;
  269. // TBSTATE_ENABLED == TBBS_DISABLED so invert it
  270. pButton->fsState ^= TBSTATE_ENABLED;
  271. pButton->bReserved[0] = 0;
  272. pButton->bReserved[1] = 0;
  274. // nothing to do if they are the same
  275. if (memcmp(pButton, &button, sizeof(TBBUTTON)) != 0)
  276. {
  277. // don't redraw everything while setting the button
  278. DWORD dwStyle = GetStyle();
  279. ModifyStyle(WS_VISIBLE, 0);
  280. VERIFY(DefWindowProc(TB_DELETEBUTTON, nIndex, 0));
  281. VERIFY(DefWindowProc(TB_INSERTBUTTON, nIndex, (LPARAM)pButton));
  282. ModifyStyle(0, dwStyle & WS_VISIBLE);
  284. // invalidate appropriate parts
  285. if (((pButton->fsStyle ^ button.fsStyle) & TBSTYLE_SEP) ||
  286. ((pButton->fsStyle & TBSTYLE_SEP) && pButton->iBitmap != button.iBitmap))
  287. {
  288. // changing a separator
  289. Invalidate(FALSE);
  290. }
  291. else
  292. {
  293. // invalidate just the button
  294. CRect rect;
  295. SendMessage(TB_AUTOSIZE);
  296. if (DefWindowProc(TB_GETITEMRECT, nIndex, (LPARAM)&rect))
  297. InvalidateRect(rect, FALSE);    // don't erase background
  298. }
  299. }
  300. }
  302. // Calculate the non-client area - adjusting for grippers
  303. void CNGenericToolBar::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS* lpncsp)
  304. {
  305.      CToolBar::OnNcCalcSize(bCalcValidRects,lpncsp);
  306.      // adjust non-client area for gripper at left or top
  307.      if (m_dwStyle & CBRS_FLOATING)
  308.  {          // no grippers
  309.      }
  310.  else if (m_dwStyle & CBRS_ORIENT_HORZ)
  311.  {
  312.           // move 2 pixels right to make room
  313.           lpncsp->rgrc[0].left += 2;
  314.           lpncsp->rgrc[0].right += 2;
  315.           lpncsp->rgrc[0].top += 2;
  316.           lpncsp->rgrc[0].bottom += 2;
  317.      }
  318.  else
  319.  {          // move 4 pixels downto make room
  320.           lpncsp->rgrc[0].top += 4;
  321.           lpncsp->rgrc[0].bottom += 4;     
  322.  }
  323. }
  325. // Draw the gripper at left or top
  326. void CNGenericToolBar::DrawGripper(CWindowDC *pDC, CRect& rectWindow)
  327. {
  328.      // get the gripper rect (1 pixel smaller than toolbar)
  329.      CRect gripper = rectWindow;
  330.      gripper.DeflateRect(1,1);
  331.      if (m_dwStyle & CBRS_FLOATING)
  332.  {          // no grippers
  333.      }
  334.  else if (m_dwStyle & CBRS_ORIENT_HORZ)
  335.  {          // gripper at left
  336.           gripper.right = gripper.left+3;
  337.           pDC->Draw3dRect(gripper,::GetSysColor(COLOR_3DHIGHLIGHT),::GetSysColor(COLOR_3DSHADOW));
  338.           gripper.OffsetRect(+4,0);
  339.           pDC->Draw3dRect(gripper,::GetSysColor(COLOR_3DHIGHLIGHT),::GetSysColor(COLOR_3DSHADOW));
  340.           rectWindow.left += 8; 
  341.  } else
  342.  {          // gripper at top
  343.           gripper.bottom = gripper.top+3;
  344.           pDC->Draw3dRect(gripper,::GetSysColor(COLOR_3DHIGHLIGHT),::GetSysColor(COLOR_3DSHADOW));
  345.           gripper.OffsetRect(0,+4);
  346.           pDC->Draw3dRect(gripper,::GetSysColor(COLOR_3DHIGHLIGHT),::GetSysColor(COLOR_3DSHADOW));
  347.           rectWindow.top += 8;
  348.      }
  349. }
  351. void CNGenericToolBar::DrawSysMenuIcon(CWindowDC* pDC, CRect& rectWindow)
  352. {
  353. if(!m_bSysMenuIcon) return; // Do nothing if this isn't needed
  355. if(m_dwStyle&CBRS_ORIENT_HORZ)
  356. {
  357. DrawIconEx(*pDC,rectWindow.left+2,rectWindow.top+6,m_hSysMenuIcon,16,16,0,NULL,DI_NORMAL);
  358. m_rectSysMenu.SetRect(rectWindow.left+2,rectWindow.top+6,rectWindow.left+2+16,rectWindow.top+6+16);
  359. rectWindow.left+=16;
  360. }
  361. else
  362. {
  363. DrawIconEx(*pDC,rectWindow.left+12,rectWindow.top+2,m_hSysMenuIcon,16,16,0,NULL,DI_NORMAL);
  364. m_rectSysMenu.SetRect(rectWindow.left+12,rectWindow.top+2,rectWindow.left+12+16,rectWindow.top+2+16);
  365. rectWindow.top+=16;
  366. }
  367. }
  370. // Erase the non-client area (borders) - copied from MFC implementation
  371. void CNGenericToolBar::EraseNonClient(BOOL bRaised)
  372. {
  373.      // get window DC that is clipped to the non-client area
  374.      CWindowDC dc(this);
  375.      CRect rectClient;
  376.      GetClientRect(rectClient);
  377.      CRect rectWindow;
  378.      GetWindowRect(rectWindow);
  379.      ScreenToClient(rectWindow);
  380.      rectClient.OffsetRect(-rectWindow.left, -rectWindow.top);
  381.      dc.ExcludeClipRect(rectClient);     // draw borders in non-client area
  382.      rectWindow.OffsetRect(-rectWindow.left, -rectWindow.top);
  383. DrawBorders(&dc, rectWindow);     // erase parts not drawn
  384.      dc.IntersectClipRect(rectWindow);
  385.      SendMessage(WM_ERASEBKGND, (WPARAM)dc.m_hDC);
  386.      DrawGripper(&dc, rectWindow); // <-- my addition to draw gripper}
  387.  DrawSysMenuIcon(&dc, rectWindow); // Draw icon for system menu, if needed
  388. }
  390. BOOL CNGenericToolBar::TranslateMenuChar(UINT nChar)
  391. {
  392. for(int n=0; n<m_accelList.GetSize(); n++)
  393. {
  394. if(m_accelList[n].nKey==(UINT)toupper(nChar))
  395. {
  396. m_pParent->PostMessage(WM_COMMAND,m_accelList[n].nId);
  397. return TRUE;
  398. }
  399. }
  401. return FALSE;
  402. }
  404. BOOL CNGenericToolBar::KeyboardFilter(UINT nChar, UINT nRepCnt, UINT nFlags)
  405. {
  406. return FALSE;
  407. }
  409. void CNGenericToolBar::DrawBorders(CDC* pDC, CRect& rect)
  410. {
  411. ASSERT_VALID(this);
  412. ASSERT_VALID(pDC);
  414. DWORD dwStyle = m_dwStyle;
  415. if (!(dwStyle & CBRS_BORDER_ANY))
  416. return;
  418. // prepare for dark lines
  419. ASSERT(rect.top == 0 && rect.left == 0);
  421. COLORREF clr=GetSysColor(COLOR_3DSHADOW);
  422. if(dwStyle&CBRS_BORDER_RIGHT)
  423. pDC->FillSolidRect(rect.right-1,0,rect.right,rect.bottom,clr); //right
  424. if(dwStyle&CBRS_BORDER_BOTTOM)
  425. pDC->FillSolidRect(0,rect.bottom-1,rect.right,rect.bottom,clr); //bottom
  427. clr=GetSysColor(COLOR_3DHIGHLIGHT);
  428. if(dwStyle&CBRS_BORDER_TOP)
  429. pDC->FillSolidRect(0,0,rect.right,1,clr); //top
  430. if(dwStyle&CBRS_BORDER_LEFT)
  431. pDC->FillSolidRect(0,0,1,rect.bottom,clr); //left
  433. if(dwStyle&CBRS_BORDER_TOP)
  434. rect.top++;
  435. if(dwStyle&CBRS_BORDER_RIGHT)
  436. rect.right--;
  437. if(dwStyle&CBRS_BORDER_BOTTOM)
  438. rect.bottom--;
  439. if(dwStyle&CBRS_BORDER_LEFT)
  440. rect.left++;
  441. }
  443. // Because buttons are transparent, we need to repaint the background
  444. void CNGenericToolBar::RepaintBackground()
  445. {
  446.      // get parent window (there should be one)
  447.      CWnd* pParent = GetParent();
  448.      if (pParent)
  449.  {
  450.           // get rect for this toolbar
  451.           CRect rw; GetWindowRect(&rw);
  452.           // convert rect to parent coords
  453.           CRect rc = rw; pParent->ScreenToClient(&rc);
  454.           // invalidate this part of parent
  455.           pParent->InvalidateRect(&rc);
  456.           // now do all the other toolbars (etc) that belong to the parent
  457.           for (CWnd* pSibling = pParent->GetWindow(GW_CHILD); pSibling; pSibling = pSibling->GetNextWindow(GW_HWNDNEXT))
  458.   {
  459.                // but do not draw ourselves
  460.                if (pSibling == this) continue;
  461.                // convert rect to siblings coords
  462.                CRect rc = rw; pSibling->ScreenToClient(&rc);
  463.                // invalidate this part of sibling
  464.                pSibling->InvalidateRect(&rc);
  465.           }
  466.      }
  467. }
  469. // Revised by Zhenxin Li.
  470. // I remove these two functions, then the separators are drawn correctly.
  471. // I don't know why.
  473. // Draw the separators in the client area
  474. void CNGenericToolBar::DrawSeparators()
  475. {
  476. // get a dc for the client area
  477. // CClientDC dc(this);
  478. // draw the separators on it
  479. // DrawSeparators(&dc);
  480. }
  482. // Draw the separators
  483. void CNGenericToolBar::DrawSeparators(CClientDC* pDC)
  484. {
  485. /*     // horizontal vs vertical
  486.      bool ishorz = (m_dwStyle & CBRS_ORIENT_HORZ) != 0;
  487.      // get number of buttons
  488.      int nIndexMax = (int)DefWindowProc(TB_BUTTONCOUNT, 0, 0);
  489.      int nIndex;
  490.      // try each button
  491.      for (nIndex = 0; nIndex < nIndexMax; nIndex++)
  492.  {
  493.           UINT dwStyle = GetButtonStyle(nIndex);
  494.           UINT wStyle = LOWORD(dwStyle);
  495.           // if it is a separator
  496.           if (wStyle == TBBS_SEPARATOR)
  497.   {
  498.                // get it's rectangle and width
  499.                CRect rect;
  500.                GetItemRect(nIndex,rect);
  501.                // if small enough to be a true separator
  502.                int w = rect.Width();
  503.                if (w <= 8)
  504.    {
  505.                     if (ishorz)
  506. {
  507.                          // draw the separator bar in the middle
  508.                          CRect rectbar = rect;
  509.                          int x = (rectbar.left+rectbar.right)/2;
  510.                          rectbar.left = x-1; rectbar.right = x+1;
  511.  rectbar.top++;
  512.  rectbar.bottom++;
  513.                          pDC->Draw3dRect(rectbar,::GetSysColor(COLOR_3DSHADOW),::GetSysColor(COLOR_3DHILIGHT));
  514.                     }
  515. else
  516. {
  517.                          // draw the separator bar in the middle
  518.                          CRect rectbar = rect;
  519.                          rectbar.left = rectbar.left - m_sizeButton.cx;
  520.                          rectbar.right = rectbar.left + m_sizeButton.cx;
  521.                          rectbar.top = rectbar.bottom+1;
  522.                          rectbar.bottom = rectbar.top+3;
  523.                          int y = (rectbar.top+rectbar.bottom)/2;
  524.                          rectbar.top = y-1; rectbar.bottom = y+1;
  525.                          pDC->Draw3dRect(rectbar,::GetSysColor(COLOR_3DSHADOW),::GetSysColor(COLOR_3DHILIGHT));
  526.                     }
  527.                }
  528.           }
  529.      }*/
  530. }
  532. // Because buttons are transparent, we need to repaint background if style changes
  533. void CNGenericToolBar::OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler)
  534. {
  535. static CUIntArray styles;
  536.      // get the number of buttons
  537.      int nIndexMax = (int)DefWindowProc(TB_BUTTONCOUNT, 0, 0);
  538.      int nIndex;
  539.      // save styles
  540.      for (nIndex = 0; nIndex < nIndexMax; nIndex++)
  541.  {
  542.           UINT dwStyle = GetButtonStyle(nIndex);
  543.           styles.SetAtGrow(nIndex,dwStyle);
  544.      }
  545.      // do base class processing
  546.      CToolBar::OnUpdateCmdUI(pTarget,bDisableIfNoHndler);
  547.      // make checked button appear pushed in
  548.      for (nIndex = 0; nIndex < nIndexMax; nIndex++)
  549.  {
  550.           UINT dwStyle = GetButtonStyle(nIndex);
  551.           if (dwStyle & TBBS_DISABLED)
  552.   {
  553.                // don't touch if disabled (avoids flicker)
  554.           } else if (dwStyle & TBBS_CHECKBOX)
  555.   {
  556.                UINT dwStyleWas = dwStyle;
  557.                // if checked, make it pressed, else not pressed
  558.                if (dwStyle & TBBS_CHECKED)
  559.    {
  560.                     dwStyle |= TBBS_PRESSED;
  561.                } else if (!(styles[nIndex]&TBBS_CHECKED) && (styles[nIndex]&TBBS_PRESSED))
  562.    {
  563.                     dwStyle |= TBBS_PRESSED;
  564.                } else
  565.    {
  566.                     dwStyle &= ~TBBS_PRESSED;
  567.                }
  568.                // set new style if changed
  569.                if (dwStyleWas != dwStyle) SetButtonStyle(nIndex,dwStyle);
  570.           }
  571.      }
  572.      // check for changes to style (buttons presssed/released)
  573.      for (nIndex = 0; nIndex < nIndexMax; nIndex++)
  574.  {
  575.           UINT dwStyle = GetButtonStyle(nIndex);
  576.           if (styles[nIndex] != dwStyle)
  577.   {
  578.                // repaint whole toolbar (not just this button)
  579.                Invalidate();
  580.                // no need to check any more
  581.                break;
  582.           }
  583.      }
  584. }
  586. // Because buttons are transparent, we need to repaint background on size or move
  587. void CNGenericToolBar::OnWindowPosChanging(LPWINDOWPOS lpwp)
  588. {
  589.      // default processing
  590.      CToolBar::OnWindowPosChanging(lpwp);
  591.      RepaintBackground();
  592. }
  594. // Paint the toolbar
  595. void CNGenericToolBar::OnPaint()
  596. {
  597. // standard toolbar
  598. CToolBar::OnPaint();
  599. // erase the background
  600. EraseNonClient(FALSE);
  601. // plus separators
  602. DrawSeparators();
  603. }
  605. // Paint the non-client area - copied from MFC implementatios
  606. void CNGenericToolBar::OnNcPaint()
  607. {
  608.      //   EraseNonClient(); don't do it here
  609. }
  611. UINT CNGenericToolBar::OnNcHitTest(CPoint point) 
  612. {
  613. CPoint pt(point);
  614. CRect wRect;
  616. GetWindowRect(wRect);
  617. pt.x-=wRect.left;
  618. pt.y-=wRect.top;
  620. // If SysMenu icon is visible, hittest it specially
  621. if(m_bSysMenuIcon && m_rectSysMenu.PtInRect(pt))
  622. {
  623. OnOverSysMenu();
  624. return HTSYSMENU;
  625. }
  627. return CToolBar::OnNcHitTest(point);
  628. }
  630. BOOL CNGenericToolBar::GenericToolBarModifyStyle(DWORD dwRemove, DWORD dwAdd)
  631. {
  632. DWORD dwStyle = m_dwGenericToolBarStyle;
  633. DWORD dwNewStyle = (dwStyle & ~dwRemove) | dwAdd;
  634. if (dwStyle == dwNewStyle)
  635. return FALSE;
  637. m_dwGenericToolBarStyle = dwNewStyle;
  638. return TRUE;
  639. }
  641. CSize CNGenericToolBar::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  642. {
  643. DWORD dwMode = bStretch ? LM_STRETCH : 0;
  644. dwMode |= bHorz ? LM_HORZ : 0;
  645. CSize s = CalcLayout(dwMode);
  646. // Revised by Zhenxin Li.
  647. // Make room for gripper.
  648. if (m_dwStyle&CBRS_ORIENT_HORZ)
  649. s.cx += 2;
  650. else
  651. s.cy += 4;
  652. return s;
  653. }
  655. // Revised by Zhenxin Li.
  656. // Borrow from MFC source. Make a little change.
  657. void CNGenericToolBar::_GetButton(int nIndex, TBBUTTON* pButton) const
  658. {
  659. CNGenericToolBar* pBar = (CNGenericToolBar*)this;
  660. VERIFY(pBar->DefWindowProc(TB_GETBUTTON, nIndex, (LPARAM)pButton));
  661. // TBSTATE_ENABLED == TBBS_DISABLED so invert it
  662. pButton->fsState ^= TBSTATE_ENABLED;
  663. }
  665. #ifdef _MAC
  666. #define CX_OVERLAP  1
  667. #else
  668. #define CX_OVERLAP  0
  669. #endif
  671. struct _AFX_CONTROLPOS
  672. {
  673. int nIndex, nID;
  674. CRect rectOldPos;
  675. };
  677. // Revised by Zhenxin Li.
  678. // Borrow from MFC source. Recalculate each button's m_sizeButton value.
  679. int CNGenericToolBar::WrapToolBar(TBBUTTON* pData, int nCount, int nWidth)
  680. {
  681. ASSERT(pData != NULL && nCount > 0);
  683. int nResult = 0;
  684. int x = 0;
  686. CSize m_sizeButton = CToolBar::m_sizeButton;
  687. m_sizeButton.cy += 2;
  688. BOOL bMenuClass = IsKindOf(RUNTIME_CLASS(CNGenericMenu));
  690. for (int i = 0; i < nCount; i++)
  691. {
  692. pData[i].fsState &= ~TBSTATE_WRAP;
  694. if (pData[i].fsState & TBSTATE_HIDDEN)
  695. continue;
  697. if (bMenuClass)
  698. {
  699. CRect r;
  700. DefWindowProc(TB_GETITEMRECT, i, (LPARAM)&r);
  701. m_sizeButton = CSize(r.right-r.left, r.bottom-r.top);
  702. }
  704. int dx, dxNext;
  705. if (pData[i].fsStyle & TBSTYLE_SEP)
  706. {
  707. dx = pData[i].iBitmap;
  708. dxNext = dx;
  709. }
  710. else
  711. {
  712. dx = m_sizeButton.cx;
  713. dxNext = dx - CX_OVERLAP;
  714. }
  716. if (x + dx > nWidth)
  717. {
  718. BOOL bFound = FALSE;
  719. for (int j = i; j >= 0  &&  !(pData[j].fsState & TBSTATE_WRAP); j--)
  720. {
  721. // Find last separator that isn't hidden
  722. // a separator that has a command ID is not
  723. // a separator, but a custom control.
  724. if ((pData[j].fsStyle & TBSTYLE_SEP) &&
  725. (pData[j].idCommand == 0) &&
  726. !(pData[j].fsState & TBSTATE_HIDDEN))
  727. {
  728. bFound = TRUE; i = j; x = 0;
  729. pData[j].fsState |= TBSTATE_WRAP;
  730. nResult++;
  731. break;
  732. }
  733. }
  734. if (!bFound)
  735. {
  736. for (int j = i - 1; j >= 0 && !(pData[j].fsState & TBSTATE_WRAP); j--)
  737. {
  738. // Never wrap anything that is hidden,
  739. // or any custom controls
  740. if ((pData[j].fsState & TBSTATE_HIDDEN) ||
  741. ((pData[j].fsStyle & TBSTYLE_SEP) &&
  742. (pData[j].idCommand != 0)))
  743. continue;
  745. bFound = TRUE; i = j; x = 0;
  746. pData[j].fsState |= TBSTATE_WRAP;
  747. nResult++;
  748. break;
  749. }
  750. if (!bFound)
  751. x += dxNext;
  752. }
  753. }
  754. else
  755. x += dxNext;
  756. }
  757. return nResult + 1;
  758. }
  760. // Revised by Zhenxin Li.
  761. // Must borrow from MFC source, because this function is not virtual.
  762. // If not borrow, the new CalcSize function won't be called.
  763. void CNGenericToolBar::SizeToolBar(TBBUTTON* pData, int nCount, int nLength, BOOL bVert)
  764. {
  765. ASSERT(pData != NULL && nCount > 0);
  767. if (!bVert)
  768. {
  769. int nMin, nMax, nTarget, nCurrent, nMid;
  771. // Wrap ToolBar as specified
  772. nMax = nLength;
  773. nTarget = WrapToolBar(pData, nCount, nMax);
  775. // Wrap ToolBar vertically
  776. nMin = 0;
  777. nCurrent = WrapToolBar(pData, nCount, nMin);
  779. if (nCurrent != nTarget)
  780. {
  781. while (nMin < nMax)
  782. {
  783. nMid = (nMin + nMax) / 2;
  784. nCurrent = WrapToolBar(pData, nCount, nMid);
  786. if (nCurrent == nTarget)
  787. nMax = nMid;
  788. else
  789. {
  790. if (nMin == nMid)
  791. {
  792. WrapToolBar(pData, nCount, nMax);
  793. break;
  794. }
  795. nMin = nMid;
  796. }
  797. }
  798. }
  799. CSize size = CalcSize(pData, nCount);
  800. WrapToolBar(pData, nCount, size.cx);
  801. }
  802. else
  803. {
  804. CSize sizeMax, sizeMin, sizeMid;
  806. // Wrap ToolBar vertically
  807. WrapToolBar(pData, nCount, 0);
  808. sizeMin = CalcSize(pData, nCount);
  810. // Wrap ToolBar horizontally
  811. WrapToolBar(pData, nCount, 32767);
  812. sizeMax = CalcSize(pData, nCount);
  814. while (sizeMin.cx < sizeMax.cx)
  815. {
  816. sizeMid.cx = (sizeMin.cx + sizeMax.cx) / 2;
  817. WrapToolBar(pData, nCount, sizeMid.cx);
  818. sizeMid = CalcSize(pData, nCount);
  820. if (nLength < sizeMid.cy)
  821. {
  822. if (sizeMin == sizeMid)
  823. {
  824. WrapToolBar(pData, nCount, sizeMax.cx);
  825. return;
  826. }
  827. sizeMin = sizeMid;
  828. }
  829. else if (nLength > sizeMid.cy)
  830. sizeMax = sizeMid;
  831. else
  832. return;
  833. }
  834. }
  835. }
  837. CSize CNGenericToolBar::CalcSize(TBBUTTON* pData, int nCount)
  838. {
  839. ASSERT(pData != NULL && nCount > 0);
  841. CPoint cur(0,0);
  842. CSize sizeResult(0,0);
  844. CSize m_sizeButton = CToolBar::m_sizeButton;
  845. m_sizeButton.cy += 2;
  846. BOOL bMenuClass = IsKindOf(RUNTIME_CLASS(CNGenericMenu));
  848. for (int i = 0; i < nCount; i++)
  849. {
  850. if (pData[i].fsState & TBSTATE_HIDDEN)
  851. continue;
  853. if (bMenuClass)
  854. {
  855. CRect r;
  856. DefWindowProc(TB_GETITEMRECT, i, (LPARAM)&r);
  857. m_sizeButton = CSize(r.right-r.left, r.bottom-r.top);
  858. }
  860. if (pData[i].fsStyle & TBSTYLE_SEP)
  861. {
  862. // A separator represents either a height or width
  863. if (pData[i].fsState & TBSTATE_WRAP)
  864. // Revised by Zhenxin Li
  865. // Add 3 points for separator in flat toolbar.
  866. sizeResult.cy = max(cur.y + m_sizeButton.cy + pData[i].iBitmap * 2 / 3, sizeResult.cy) + 3;
  867. else
  868. sizeResult.cx = max(cur.x + pData[i].iBitmap, sizeResult.cx);
  869. }
  870. else
  871. {
  872. sizeResult.cx = max(cur.x + m_sizeButton.cx, sizeResult.cx);
  873. sizeResult.cy = max(cur.y + m_sizeButton.cy, sizeResult.cy);
  874. }
  876. if (pData[i].fsStyle & TBSTYLE_SEP)
  877. cur.x += pData[i].iBitmap;
  878. else
  879. cur.x += m_sizeButton.cx - CX_OVERLAP;
  881. if (pData[i].fsState & TBSTATE_WRAP)
  882. {
  883. cur.x = 0;
  884. cur.y += m_sizeButton.cy;
  885. if (pData[i].fsStyle & TBSTYLE_SEP)
  886. // Revised by Zhenxin Li
  887. // Like above, add 3 points for separator in flat toolbar.
  888. cur.y += pData[i].iBitmap * 2 / 3 + 3;
  889. }
  890. }
  891. return sizeResult;
  892. }
  894. CSize CNGenericToolBar::CalcLayout(DWORD dwMode, int nLength)
  895. {
  896. ASSERT_VALID(this);
  897. ASSERT(::IsWindow(m_hWnd));
  898. if (dwMode & LM_HORZDOCK)
  899. ASSERT(dwMode & LM_HORZ);
  901. int nCount;
  902. TBBUTTON* pData;
  903. CSize sizeResult(0,0);
  905. // Load Buttons
  906. {
  907. nCount = DefWindowProc(TB_BUTTONCOUNT, 0, 0);
  908. if (nCount != 0)
  909. {
  910. int i;
  911. pData = new TBBUTTON[nCount];
  912. for (i = 0; i < nCount; i++)
  913. _GetButton(i, &pData[i]);
  914. }
  915. }
  917. if (nCount > 0)
  918. {
  919. if (!(m_dwStyle & CBRS_SIZE_FIXED))
  920. {
  921. BOOL bDynamic = m_dwStyle & CBRS_SIZE_DYNAMIC;
  923. if (bDynamic && (dwMode & LM_MRUWIDTH))
  924. SizeToolBar(pData, nCount, m_nMRUWidth);
  925. else if (bDynamic && (dwMode & LM_HORZDOCK))
  926. SizeToolBar(pData, nCount, 32767);
  927. else if (bDynamic && (dwMode & LM_VERTDOCK))
  928. SizeToolBar(pData, nCount, 0);
  929. else if (bDynamic && (nLength != -1))
  930. {
  931. CRect rect; rect.SetRectEmpty();
  932. CalcInsideRect(rect, (dwMode & LM_HORZ));
  933. BOOL bVert = (dwMode & LM_LENGTHY);
  934. int nLen = nLength + (bVert ? rect.Height() : rect.Width());
  936. SizeToolBar(pData, nCount, nLen, bVert);
  937. }
  938. else if (bDynamic && (m_dwStyle & CBRS_FLOATING))
  939. SizeToolBar(pData, nCount, m_nMRUWidth);
  940. else
  941. SizeToolBar(pData, nCount, (dwMode & LM_HORZ) ? 32767 : 0);
  942. }
  944. sizeResult = CalcSize(pData, nCount);
  946. if (dwMode & LM_COMMIT)
  947. {
  948. _AFX_CONTROLPOS* pControl = NULL;
  949. int nControlCount = 0;
  950. BOOL bIsDelayed = m_bDelayedButtonLayout;
  951. m_bDelayedButtonLayout = FALSE;
  953. for(int i = 0; i < nCount; i++)
  954. if ((pData[i].fsStyle & TBSTYLE_SEP) && (pData[i].idCommand != 0))
  955. nControlCount++;
  957. if (nControlCount > 0)
  958. {
  959. pControl = new _AFX_CONTROLPOS[nControlCount];
  960. nControlCount = 0;
  962. for(int i = 0; i < nCount; i++)
  963. {
  964. if ((pData[i].fsStyle & TBSTYLE_SEP) && (pData[i].idCommand != 0))
  965. {
  966. pControl[nControlCount].nIndex = i;
  967. pControl[nControlCount].nID = pData[i].idCommand;
  969. CRect rect;
  970. GetItemRect(i, &rect);
  971. ClientToScreen(&rect);
  972. pControl[nControlCount].rectOldPos = rect;
  974. nControlCount++;
  975. }
  976. }
  977. }
  979. if ((m_dwStyle & CBRS_FLOATING) && (m_dwStyle & CBRS_SIZE_DYNAMIC))
  980. m_nMRUWidth = sizeResult.cx;
  981. for (i = 0; i < nCount; i++)
  982. _SetButton(i, &pData[i]);
  984. if (nControlCount > 0)
  985. {
  986. for (int i = 0; i < nControlCount; i++)
  987. {
  988. CWnd* pWnd = GetDlgItem(pControl[i].nID);
  989. if (pWnd != NULL)
  990. {
  991. CRect rect;
  992. pWnd->GetWindowRect(&rect);
  993. CPoint pt = rect.TopLeft() - pControl[i].rectOldPos.TopLeft();
  994. GetItemRect(pControl[i].nIndex, &rect);
  995. pt = rect.TopLeft() + pt;
  996. pWnd->SetWindowPos(NULL, pt.x, pt.y, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
  997. }
  998. }
  999. delete[] pControl;
  1000. }
  1001. m_bDelayedButtonLayout = bIsDelayed;
  1002. }
  1003. delete[] pData;
  1004. }
  1006. //BLOCK: Adjust Margins
  1007. {
  1008. CRect rect; rect.SetRectEmpty();
  1009. CalcInsideRect(rect, (dwMode & LM_HORZ));
  1010. sizeResult.cy -= rect.Height();
  1011. sizeResult.cx -= rect.Width();
  1013. CSize size = CControlBar::CalcFixedLayout((dwMode & LM_STRETCH), (dwMode & LM_HORZ));
  1014. sizeResult.cx = max(sizeResult.cx, size.cx);
  1015. sizeResult.cy = max(sizeResult.cy, size.cy);
  1016. }
  1017. return sizeResult;
  1018. }
  1020. CSize CNGenericToolBar::CalcDynamicLayout(int nLength, DWORD dwMode)
  1021. {
  1022. CSize s;
  1023. if ((nLength == -1) && !(dwMode & LM_MRUWIDTH) && !(dwMode & LM_COMMIT) &&
  1024. ((dwMode & LM_HORZDOCK) || (dwMode & LM_VERTDOCK)))
  1025. s = CalcFixedLayout(dwMode & LM_STRETCH, dwMode & LM_HORZDOCK);
  1026. else
  1027. s = CalcLayout(dwMode, nLength);
  1028. return s;
  1029. }