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

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

工具条

开发平台：

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. Copyright (C) 1998 George H. Stahl (GStahl@VipMail.Com)
  7. - Added GenericToolBarModifyStyle
  9. This program is free software; you can redistribute it and/or modify it under the terms
  10. of the GNU General Public License as published by the Free Software Foundation; either
  11. version 2 of the License, or (at your option) any later version.
  13. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
  14. without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  15. See the GNU General Public License for more details.
  17. You should have received a copy of the GNU General Public License along with this program;
  18. if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19. */
  20. //////////////////////////////////////////////////////////////////////
  22. #include "stdafx.h"
  23. #include "NGenericToolBar.h"
  25. #include "afxpriv.h"
  26. #ifdef _DEBUG
  27. #undef THIS_FILE
  28. static char THIS_FILE[]=__FILE__;
  29. #define new DEBUG_NEW
  30. #endif
  32. IMPLEMENT_DYNAMIC(CNGenericToolBar,CToolBar)
  34. BEGIN_MESSAGE_MAP(CNGenericToolBar,CToolBar)
  35. //{{AFX_MSG_MAP(CNGenericToolBar)
  36. ON_WM_CONTEXTMENU()
  37. ON_WM_DESTROY()
  38. ON_WM_PAINT()
  39. ON_WM_NCCALCSIZE()
  40. ON_WM_NCPAINT()
  41. ON_WM_NCHITTEST()
  42. //}}AFX_MSG_MAP
  43. ON_COMMAND(IDM_BUTTONSONLY,OnButtonsOnly)
  44. ON_COMMAND(IDM_BUTTONSANDTEXT,OnTextAndButtons)
  45. ON_COMMAND(IDM_TEXTONLY,OnTextOnly)
  46. ON_COMMAND(IDM_RECALCSIZE,OnRecalcSize)
  47.  END_MESSAGE_MAP()
  49. CArray<CNGenericToolBar*,CNGenericToolBar*> CNGenericToolBar::m_ToolbarList;
  50. BOOL CNGenericToolBar::m_bButtons=FALSE;
  51. BOOL CNGenericToolBar::m_bText=FALSE;
  53. //////////////////////////////////////////////////////////////////////
  54. // Construction/Destruction
  55. //////////////////////////////////////////////////////////////////////
  57. CNGenericToolBar::CNGenericToolBar()
  58. {
  59. m_bHasText=FALSE;
  60. m_bHasBitmaps=TRUE;
  61. m_bForceText=FALSE;
  62. m_bSysMenuIcon=FALSE;
  63. m_dwGenericToolBarStyle = 0x0000;
  64. }
  66. CNGenericToolBar::~CNGenericToolBar()
  67. {
  69. }
  71. void CNGenericToolBar::OnRecalcSize()
  72. {
  73. SettingChange();
  74. RecalcSize();
  75. GetParentFrame()->DelayRecalcLayout();
  76. }
  78. void CNGenericToolBar::SettingChange()
  79. {
  80. TBBUTTON tb;
  81. for(int n=0; n<GetCount(); n++)
  82. {
  83. SendMessage(TB_GETBUTTON,n,(LPARAM)&tb);
  84. tb.iString=m_bText?m_TextIds[n]:-1;
  85. _SetButton(n,&tb);
  86. }
  87. SendMessage(TB_SETMAXTEXTROWS,m_bText||m_bForceText?4:0);
  88. SendMessage(TB_SETBITMAPSIZE,0,m_bButtons&&m_bHasBitmaps?MAKELONG(16,15):0);
  89. SendMessage(TB_AUTOSIZE);
  90. }
  92. BOOL CNGenericToolBar::RecalcSize()
  93. {
  94. CRect rect;
  95. int cx=0,cy=0;
  97. SendMessage(TB_AUTOSIZE);
  98. for(int n=0; n<GetToolBarCtrl().GetButtonCount(); n++)
  99. {
  100. GetItemRect(n,&rect);
  101. if(rect.Width()>cx) cx=rect.Width();
  102. if(rect.Height()>cy) cy=rect.Height();
  103. }
  104. m_sizeButton.cx=cx;
  105. m_sizeButton.cy=cy-2;
  106. m_bDelayedButtonLayout=TRUE;
  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. }
  179. return TRUE;
  180. }
  182. BOOL CNGenericToolBar::SetButtonText(int nIndex, LPCTSTR lpszText)
  183. {
  184. if(!CToolBar::SetButtonText(nIndex,lpszText)) return FALSE;
  185. return RecalcSize();
  186. }
  189. void CNGenericToolBar::OnContextMenu(CWnd* pWnd, CPoint point) 
  190. {
  191. m_pop.CheckMenuItem(IDM_BUTTONSONLY,m_bButtons&&!m_bText?MF_CHECKED:MF_UNCHECKED);
  192. m_pop.CheckMenuItem(IDM_BUTTONSANDTEXT,m_bButtons&&m_bText?MF_CHECKED:MF_UNCHECKED);
  193. m_pop.CheckMenuItem(IDM_TEXTONLY,!m_bButtons&&m_bText?MF_CHECKED:MF_UNCHECKED);
  194. m_pop.EnableMenuItem(IDM_BUTTONSONLY,MF_ENABLED);
  195. m_pop.EnableMenuItem(IDM_BUTTONSANDTEXT,m_bHasText?MF_ENABLED:MF_GRAYED);
  196. m_pop.EnableMenuItem(IDM_TEXTONLY,m_bHasText?MF_ENABLED:MF_GRAYED);
  197. m_pop.TrackPopupMenu(TPM_LEFTALIGN,point.x,point.y,pWnd);
  198. }
  200. void CNGenericToolBar::OnButtonsOnly()
  201. {
  202. if(!m_bText && m_bButtons) return;
  203. m_bText=FALSE;
  204. m_bButtons=TRUE;
  205. SendToAllToolbars(WM_COMMAND,IDM_RECALCSIZE);
  206. }
  208. void CNGenericToolBar::OnTextOnly()
  209. {
  210. if(m_bText && !m_bButtons) return;
  211. m_bText=TRUE;
  212. m_bButtons=FALSE;
  213. SendToAllToolbars(WM_COMMAND,IDM_RECALCSIZE);
  214. }
  216. void CNGenericToolBar::OnTextAndButtons()
  217. {
  218. if(m_bText && m_bButtons) return;
  219. m_bText=TRUE;
  220. m_bButtons=TRUE;
  221. SendToAllToolbars(WM_COMMAND,IDM_RECALCSIZE);
  222. }
  224. void CNGenericToolBar::OnDestroy() 
  225. {
  226. CToolBar::OnDestroy();
  227. for(int n=0; n<m_ToolbarList.GetSize(); n++)
  228. if(m_ToolbarList[n]==this)
  229. {
  230. m_ToolbarList.RemoveAt(n);
  231. break;
  232. }
  233. }
  235. void CNGenericToolBar::SendToAllToolbars(UINT uMsg, WPARAM wParam, LPARAM lParam)
  236. {
  237. for(int n=0; n<m_ToolbarList.GetSize(); n++)
  238. m_ToolbarList[n]->SendMessage(uMsg,wParam,lParam);
  239. }
  241. void CNGenericToolBar::SetVisualState(BOOL bButtons, BOOL bText)
  242. {
  243. if(!bText && !bButtons) bButtons=TRUE;
  244. m_bText=bText;
  245. m_bButtons=bButtons;
  246. SendToAllToolbars(WM_COMMAND,IDM_RECALCSIZE);
  247. }
  249. BOOL CNGenericToolBar::GetVisualState(BOOL bText)
  250. {
  251. if(bText) return m_bText;
  252. else return m_bButtons;
  253. }
  255. // Borrowed from MFC
  256. void CNGenericToolBar::_SetButton(int nIndex, TBBUTTON* pButton)
  257. {
  258. // get original button state
  259. TBBUTTON button;
  260. VERIFY(DefWindowProc(TB_GETBUTTON, nIndex, (LPARAM)&button));
  262. // prepare for old/new button comparsion
  263. button.bReserved[0] = 0;
  264. button.bReserved[1] = 0;
  265. // TBSTATE_ENABLED == TBBS_DISABLED so invert it
  266. pButton->fsState ^= TBSTATE_ENABLED;
  267. pButton->bReserved[0] = 0;
  268. pButton->bReserved[1] = 0;
  270. // nothing to do if they are the same
  271. if (memcmp(pButton, &button, sizeof(TBBUTTON)) != 0)
  272. {
  273. // don't redraw everything while setting the button
  274. DWORD dwStyle = GetStyle();
  275. ModifyStyle(WS_VISIBLE, 0);
  276. VERIFY(DefWindowProc(TB_DELETEBUTTON, nIndex, 0));
  277. VERIFY(DefWindowProc(TB_INSERTBUTTON, nIndex, (LPARAM)pButton));
  278. ModifyStyle(0, dwStyle & WS_VISIBLE);
  280. // invalidate appropriate parts
  281. if (((pButton->fsStyle ^ button.fsStyle) & TBSTYLE_SEP) ||
  282. ((pButton->fsStyle & TBSTYLE_SEP) && pButton->iBitmap != button.iBitmap))
  283. {
  284. // changing a separator
  285. Invalidate(FALSE);
  286. }
  287. else
  288. {
  289. // invalidate just the button
  290. CRect rect;
  291. SendMessage(TB_AUTOSIZE);
  292. if (DefWindowProc(TB_GETITEMRECT, nIndex, (LPARAM)&rect))
  293. InvalidateRect(rect, FALSE);    // don't erase background
  294. }
  295. }
  296. }
  298. // Calculate the non-client area - adjusting for grippers
  299. void CNGenericToolBar::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS* lpncsp)
  300. {
  301.      CToolBar::OnNcCalcSize(bCalcValidRects,lpncsp);
  302.      // adjust non-client area for gripper at left or top
  303.      if (m_dwStyle & CBRS_FLOATING)
  304.  {          // no grippers
  305.      }
  306.  else if (m_dwStyle & CBRS_ORIENT_HORZ)
  307.  {
  308.           // move 2 pixels right to make room
  309.           lpncsp->rgrc[0].left += 2;
  310.           lpncsp->rgrc[0].right += 2;
  311.      }
  312.  else
  313.  {          // move 4 pixels downto make room
  314.           lpncsp->rgrc[0].top += 4;
  315.           lpncsp->rgrc[0].bottom += 4;     
  316.  }
  318.  // Adjust for system menu icon
  319.  if(m_bSysMenuIcon)
  320.  {
  321. if(m_dwStyle&CBRS_ORIENT_HORZ)
  322. {
  323.   // move 16 pixels right to make room
  324.   lpncsp->rgrc[0].left += 16;
  325.   lpncsp->rgrc[0].right += 16;
  326. }
  327. else
  328. {    // move 16 pixels downto make room
  329.   lpncsp->rgrc[0].top += 16;
  330.   lpncsp->rgrc[0].bottom += 16;     
  331. }
  332.  }
  333. }
  335. // Draw the gripper at left or top
  336. void CNGenericToolBar::DrawGripper(CWindowDC *pDC, CRect& rectWindow)
  337. {
  338.      // get the gripper rect (1 pixel smaller than toolbar)
  339.      CRect gripper = rectWindow;
  340.      gripper.DeflateRect(1,1);
  341.      if (m_dwStyle & CBRS_FLOATING)
  342.  {          // no grippers
  343.      }
  344.  else if (m_dwStyle & CBRS_ORIENT_HORZ)
  345.  {          // gripper at left
  346.           gripper.right = gripper.left+3;
  347.           pDC->Draw3dRect(gripper,::GetSysColor(COLOR_3DHIGHLIGHT),::GetSysColor(COLOR_3DSHADOW));
  348.           gripper.OffsetRect(+4,0);
  349.           pDC->Draw3dRect(gripper,::GetSysColor(COLOR_3DHIGHLIGHT),::GetSysColor(COLOR_3DSHADOW));
  350.           rectWindow.left += 8; 
  351.  } else
  352.  {          // gripper at top
  353.           gripper.bottom = gripper.top+3;
  354.           pDC->Draw3dRect(gripper,::GetSysColor(COLOR_3DHIGHLIGHT),::GetSysColor(COLOR_3DSHADOW));
  355.           gripper.OffsetRect(0,+4);
  356.           pDC->Draw3dRect(gripper,::GetSysColor(COLOR_3DHIGHLIGHT),::GetSysColor(COLOR_3DSHADOW));
  357.           rectWindow.top += 8;
  358.      }
  359. }
  361. void CNGenericToolBar::DrawSysMenuIcon(CWindowDC* pDC, CRect& rectWindow)
  362. {
  363. if(!m_bSysMenuIcon) return; // Do nothing if this isn't needed
  365. if(m_dwStyle&CBRS_ORIENT_HORZ)
  366. {
  367. DrawIconEx(*pDC,rectWindow.left+2,rectWindow.top+6,m_hSysMenuIcon,16,16,0,NULL,DI_NORMAL);
  368. m_rectSysMenu.SetRect(rectWindow.left+2,rectWindow.top+6,rectWindow.left+2+16,rectWindow.top+6+16);
  369. rectWindow.left+=16;
  370. }
  371. else
  372. {
  373. DrawIconEx(*pDC,rectWindow.left+12,rectWindow.top+2,m_hSysMenuIcon,16,16,0,NULL,DI_NORMAL);
  374. m_rectSysMenu.SetRect(rectWindow.left+12,rectWindow.top+2,rectWindow.left+12+16,rectWindow.top+2+16);
  375. rectWindow.top+=16;
  376. }
  377. }
  380. // Erase the non-client area (borders) - copied from MFC implementation
  381. void CNGenericToolBar::EraseNonClient(BOOL bRaised)
  382. {
  383.      // get window DC that is clipped to the non-client area
  384.      CWindowDC dc(this);
  385.      CRect rectClient;
  386.      GetClientRect(rectClient);
  387.      CRect rectWindow;
  388.      GetWindowRect(rectWindow);
  389.      ScreenToClient(rectWindow);
  390.      rectClient.OffsetRect(-rectWindow.left, -rectWindow.top);
  391.      dc.ExcludeClipRect(rectClient);     // draw borders in non-client area
  392.      rectWindow.OffsetRect(-rectWindow.left, -rectWindow.top);
  393. DrawBorders(&dc, rectWindow);     // erase parts not drawn
  394.      dc.IntersectClipRect(rectWindow);
  395.      SendMessage(WM_ERASEBKGND, (WPARAM)dc.m_hDC);
  396.      DrawGripper(&dc, rectWindow); // <-- my addition to draw gripper}
  397.  DrawSysMenuIcon(&dc, rectWindow); // Draw icon for system menu, if needed
  398. }
  400. BOOL CNGenericToolBar::TranslateMenuChar(UINT nChar)
  401. {
  402. for(int n=0; n<m_accelList.GetSize(); n++)
  403. {
  404. if(m_accelList[n].nKey==(UINT)toupper(nChar))
  405. {
  406. m_pParent->PostMessage(WM_COMMAND,m_accelList[n].nId);
  407. return TRUE;
  408. }
  409. }
  411. return FALSE;
  412. }
  414. BOOL CNGenericToolBar::KeyboardFilter(UINT nChar, UINT nRepCnt, UINT nFlags)
  415. {
  416. return FALSE;
  417. }
  419. void CNGenericToolBar::DrawBorders(CDC* pDC, CRect& rect)
  420. {
  421. ASSERT_VALID(this);
  422. ASSERT_VALID(pDC);
  424. DWORD dwStyle = m_dwStyle;
  425. if (!(dwStyle & CBRS_BORDER_ANY))
  426. return;
  428. // prepare for dark lines
  429. ASSERT(rect.top == 0 && rect.left == 0);
  431. COLORREF clr=GetSysColor(COLOR_3DSHADOW);
  432. if(dwStyle&CBRS_BORDER_RIGHT)
  433. pDC->FillSolidRect(rect.right-1,0,rect.right,rect.bottom,clr); //right
  434. if(dwStyle&CBRS_BORDER_BOTTOM)
  435. pDC->FillSolidRect(0,rect.bottom-1,rect.right,rect.bottom,clr); //bottom
  437. clr=GetSysColor(COLOR_3DHIGHLIGHT);
  438. if(dwStyle&CBRS_BORDER_TOP)
  439. pDC->FillSolidRect(0,0,rect.right,1,clr); //top
  440. if(dwStyle&CBRS_BORDER_LEFT)
  441. pDC->FillSolidRect(0,0,1,rect.bottom,clr); //left
  443. if(dwStyle&CBRS_BORDER_TOP)
  444. rect.top++;
  445. if(dwStyle&CBRS_BORDER_RIGHT)
  446. rect.right--;
  447. if(dwStyle&CBRS_BORDER_BOTTOM)
  448. rect.bottom--;
  449. if(dwStyle&CBRS_BORDER_LEFT)
  450. rect.left++;
  451. }
  453. // Because buttons are transparent, we need to repaint the background
  454. void CNGenericToolBar::RepaintBackground()
  455. {
  456.      // get parent window (there should be one)
  457.      CWnd* pParent = GetParent();
  458.      if (pParent)
  459.  {
  460.           // get rect for this toolbar
  461.           CRect rw; GetWindowRect(&rw);
  462.           // convert rect to parent coords
  463.           CRect rc = rw; pParent->ScreenToClient(&rc);
  464.           // invalidate this part of parent
  465.           pParent->InvalidateRect(&rc);
  466.           // now do all the other toolbars (etc) that belong to the parent
  467.           for (CWnd* pSibling = pParent->GetWindow(GW_CHILD); pSibling; pSibling = pSibling->GetNextWindow(GW_HWNDNEXT))
  468.   {
  469.                // but do not draw ourselves
  470.                if (pSibling == this) continue;
  471.                // convert rect to siblings coords
  472.                CRect rc = rw; pSibling->ScreenToClient(&rc);
  473.                // invalidate this part of sibling
  474.                pSibling->InvalidateRect(&rc);
  475.           }
  476.      }
  477. }
  479. // Draw the separators in the client area
  480. void CNGenericToolBar::DrawSeparators()
  481. {
  482.      // get a dc for the client area
  483.      CClientDC dc(this);
  484.      // draw the separators on it
  485.      DrawSeparators(&dc);
  486. }
  488. // Draw the separators
  489. void CNGenericToolBar::DrawSeparators(CClientDC* pDC)
  490. {
  491.      // horizontal vs vertical
  492.      bool ishorz = (m_dwStyle & CBRS_ORIENT_HORZ) != 0;
  493.      // get number of buttons
  494.      int nIndexMax = (int)DefWindowProc(TB_BUTTONCOUNT, 0, 0);
  495.      int nIndex;
  496.      // try each button
  497.      for (nIndex = 0; nIndex < nIndexMax; nIndex++)
  498.  {
  499.           UINT dwStyle = GetButtonStyle(nIndex);
  500.           UINT wStyle = LOWORD(dwStyle);
  501.           // if it is a separator
  502.           if (wStyle == TBBS_SEPARATOR)
  503.   {
  504.                // get it's rectangle and width
  505.                CRect rect;
  506.                GetItemRect(nIndex,rect);
  507.                // if small enough to be a true separator
  508.                int w = rect.Width();
  509.                if (w <= 8)
  510.    {
  511.                     if (ishorz)
  512. {
  513.                          // draw the separator bar in the middle
  514.                          CRect rectbar = rect;
  515.                          int x = (rectbar.left+rectbar.right)/2;
  516.                          rectbar.left = x-1; rectbar.right = x+1;
  517.  rectbar.top++;
  518.  rectbar.bottom++;
  519.                          pDC->Draw3dRect(rectbar,::GetSysColor(COLOR_3DSHADOW),::GetSysColor(COLOR_3DHILIGHT));
  520.                     }
  521. else
  522. {
  523.                          // draw the separator bar in the middle
  524.                          CRect rectbar = rect;
  525.                          rectbar.left = rectbar.left - m_sizeButton.cx;
  526.                          rectbar.right = rectbar.left + m_sizeButton.cx;
  527.                          rectbar.top = rectbar.bottom+1;
  528.                          rectbar.bottom = rectbar.top+3;
  529.                          int y = (rectbar.top+rectbar.bottom)/2;
  530.                          rectbar.top = y-1; rectbar.bottom = y+1;
  531.                          pDC->Draw3dRect(rectbar,::GetSysColor(COLOR_3DSHADOW),::GetSysColor(COLOR_3DHILIGHT));
  532.                     }
  533.                }
  534.           }
  535.      }
  536. }
  538. // Because buttons are transparent, we need to repaint background if style changes
  539. void CNGenericToolBar::OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler)
  540. {
  541.      static CUIntArray styles;
  542.      // get the number of buttons
  543.      int nIndexMax = (int)DefWindowProc(TB_BUTTONCOUNT, 0, 0);
  544.      int nIndex;
  545.      // save styles
  546.      for (nIndex = 0; nIndex < nIndexMax; nIndex++)
  547.  {
  548.           UINT dwStyle = GetButtonStyle(nIndex);
  549.           styles.SetAtGrow(nIndex,dwStyle);
  550.      }
  551.      // do base class processing
  552.      CToolBar::OnUpdateCmdUI(pTarget,bDisableIfNoHndler);
  553.      // make checked button appear pushed in
  554.      for (nIndex = 0; nIndex < nIndexMax; nIndex++)
  555.  {
  556.           UINT dwStyle = GetButtonStyle(nIndex);
  557.           if (dwStyle & TBBS_DISABLED)
  558.   {
  559.                // don't touch if disabled (avoids flicker)
  560.           } else if (dwStyle & TBBS_CHECKBOX)
  561.   {
  562.                UINT dwStyleWas = dwStyle;
  563.                // if checked, make it pressed, else not pressed
  564.                if (dwStyle & TBBS_CHECKED)
  565.    {
  566.                     dwStyle |= TBBS_PRESSED;
  567.                } else if (!(styles[nIndex]&TBBS_CHECKED) && (styles[nIndex]&TBBS_PRESSED))
  568.    {
  569.                     dwStyle |= TBBS_PRESSED;
  570.                } else
  571.    {
  572.                     dwStyle &= ~TBBS_PRESSED;
  573.                }
  574.                // set new style if changed
  575.                if (dwStyleWas != dwStyle) SetButtonStyle(nIndex,dwStyle);
  576.           }
  577.      }
  578.      // check for changes to style (buttons presssed/released)
  579.      for (nIndex = 0; nIndex < nIndexMax; nIndex++)
  580.  {
  581.           UINT dwStyle = GetButtonStyle(nIndex);
  582.           if (styles[nIndex] != dwStyle)
  583.   {
  584.                // repaint whole toolbar (not just this button)
  585.                Invalidate();
  586.                // no need to check any more
  587.                break;
  588.           }
  589.      }
  590. }
  592. // Because buttons are transparent, we need to repaint background on size or move
  593. void CNGenericToolBar::OnWindowPosChanging(LPWINDOWPOS lpwp)
  594. {
  595.      // default processing
  596.      CToolBar::OnWindowPosChanging(lpwp);
  597.      RepaintBackground();
  598. }
  600. // Paint the toolbar
  601. void CNGenericToolBar::OnPaint()
  602. {
  603.      // standard toolbar
  604.      CToolBar::OnPaint();
  605.      // erase the background
  606.      EraseNonClient(FALSE);
  607.      // plus separators
  608.      DrawSeparators();
  609. }
  611. // Paint the non-client area - copied from MFC implementatios
  612. void CNGenericToolBar::OnNcPaint()
  613. {
  614.      //   EraseNonClient(); don't do it here
  615. }
  617. UINT CNGenericToolBar::OnNcHitTest(CPoint point) 
  618. {
  619. CPoint pt(point);
  620. CRect wRect;
  622. GetWindowRect(wRect);
  623. pt.x-=wRect.left;
  624. pt.y-=wRect.top;
  626. // If SysMenu icon is visible, hittest it specially
  627. if(m_bSysMenuIcon && m_rectSysMenu.PtInRect(pt))
  628. {
  629. OnOverSysMenu();
  630. return HTSYSMENU;
  631. }
  633. return CToolBar::OnNcHitTest(point);
  634. }
  636. BOOL CNGenericToolBar::GenericToolBarModifyStyle(DWORD dwRemove, DWORD dwAdd)
  637. {
  638. DWORD dwStyle = m_dwGenericToolBarStyle;
  639. DWORD dwNewStyle = (dwStyle & ~dwRemove) | dwAdd;
  640. if (dwStyle == dwNewStyle)
  641. return FALSE;
  643. m_dwGenericToolBarStyle = dwNewStyle;
  644. return TRUE;
  645. }