SA3DToolBar.cpp
上传用户:shilei2004
上传日期:2020-07-18
资源大小:83k
文件大小:10k
源码类别:

RichEdit

开发平台:

Visual C++

  1. // SA3DToolBar.cpp : implementation file
  2. // Download by http://www.codefans.net
  3. #include "stdafx.h"
  4. #include "Edit.h"
  5. #include "SA3DToolBar.h"
  6. #ifdef _DEBUG
  7. #define new DEBUG_NEW
  8. #undef THIS_FILE
  9. static char THIS_FILE[] = __FILE__;
  10. #endif
  11. /////////////////////////////////////////////////////////////////////////////
  12. // CSA3DToolBar
  13. CSA3DToolBar::CSA3DToolBar()
  14. {
  15. m_clrBtnHilight=::GetSysColor(COLOR_BTNHILIGHT);
  16. m_clrBtnShadow=::GetSysColor(COLOR_BTNSHADOW);
  17. m_clrBtnFace  = ::GetSysColor(COLOR_BTNFACE);
  18. }
  19. CSA3DToolBar::~CSA3DToolBar()
  20. {
  21. }
  22. BEGIN_MESSAGE_MAP(CSA3DToolBar, CToolBar)
  23. //{{AFX_MSG_MAP(CSA3DToolBar)
  24. ON_WM_NCPAINT()
  25. //}}AFX_MSG_MAP
  26. END_MESSAGE_MAP()
  27. /////////////////////////////////////////////////////////////////////////////
  28. // CSA3DToolBar message handlers
  29. void CSA3DToolBar::OnNcPaint() 
  30. {
  31. if( GetToolBarCtrl().GetStyle()& TBSTYLE_FLAT ) 
  32. {
  33. // get window DC that is clipped to the non-client area
  34. CWindowDC dc(this);
  35. CRect rectClient;
  36. GetClientRect(rectClient);
  37. CRect rectWindow;
  38. GetWindowRect(rectWindow);
  39. ScreenToClient(rectWindow);
  40. rectClient.OffsetRect(-rectWindow.left, -rectWindow.top);
  41. dc.ExcludeClipRect(rectClient);
  42. // draw borders in non-client area
  43. rectWindow.OffsetRect(-rectWindow.left, -rectWindow.top);
  44. Draw3DBorders(&dc, rectWindow);
  45. dc.IntersectClipRect(rectWindow);
  46. // erase parts not drawn
  47. SendMessage(WM_ERASEBKGND, (WPARAM)dc.m_hDC);
  48. DrawGripper(&dc,rectWindow);
  49. else
  50. {
  51. CToolBar::OnNcPaint();
  52. }
  53. }
  54. void CSA3DToolBar::Draw3DBorders(CDC * pDC, CRect & rect) 
  55. {
  56. ASSERT_VALID(this);
  57. ASSERT_VALID(pDC);
  58. if( GetToolBarCtrl().GetStyle()& TBSTYLE_FLAT ) 
  59. {
  60. DWORD dwStyle = m_dwStyle;
  61. if (!(dwStyle & CBRS_BORDER_ANY))
  62. return;
  63. COLORREF clr = (m_dwStyle & CBRS_BORDER_3D) ? m_clrBtnHilight : m_clrBtnShadow;
  64. if(m_dwStyle & CBRS_BORDER_LEFT)
  65. pDC->FillSolidRect(0, 0, 1, rect.Height() - 1, clr);
  66. if(m_dwStyle & CBRS_BORDER_TOP)
  67. pDC->FillSolidRect(0, 0, rect.Width()-1 , 1, clr);
  68. if(m_dwStyle & CBRS_BORDER_RIGHT)
  69. pDC->FillSolidRect(rect.right, 1, -1, rect.Height() - 1, m_clrBtnShadow);
  70. if(m_dwStyle & CBRS_BORDER_BOTTOM)
  71. pDC->FillSolidRect(0, rect.bottom, rect.Width()-1, -1, m_clrBtnShadow);
  72. // if undockable toolbar at top of frame, apply special formatting to mesh
  73. // properly with frame menu
  74. if(!m_pDockContext) 
  75. {
  76. pDC->FillSolidRect(0,0,rect.Width(),1,m_clrBtnShadow);
  77. pDC->FillSolidRect(0,1,rect.Width(),1,m_clrBtnHilight);
  78. }
  79. if (dwStyle & CBRS_BORDER_LEFT)
  80. ++rect.left;
  81. if (dwStyle & CBRS_BORDER_TOP)
  82. ++rect.top;
  83. if (dwStyle & CBRS_BORDER_RIGHT)
  84. --rect.right;
  85. if (dwStyle & CBRS_BORDER_BOTTOM)
  86. --rect.bottom;
  87. else
  88. {
  89. DrawBorders(pDC, rect);
  90. }
  91. }
  92. /////////////////////////////////////////////////////////////////////////////
  93. // CDockBarEx
  94. CDockBarEx::CDockBarEx()
  95. {
  96. // TODO: add construction code here.
  97. }
  98. CDockBarEx::~CDockBarEx()
  99. {
  100. // TODO: add destruction code here.
  101. }
  102. IMPLEMENT_DYNAMIC(CDockBarEx, CDockBar)
  103. BEGIN_MESSAGE_MAP(CDockBarEx, CDockBar)
  104. //{{AFX_MSG_MAP(CDockBarEx)   
  105. // NOTE - the ClassWizard will add and remove mapping macros here.
  106. //    DO NOT EDIT what you see in these blocks of generated code!
  107. //}}AFX_MSG_MAP
  108. END_MESSAGE_MAP()
  109. /////////////////////////////////////////////////////////////////////////////
  110. // CDockBarEx message handlers
  111. CSize CDockBarEx::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  112. {
  113. ASSERT_VALID(this);
  114. CSize sizeFixed = CControlBar::CalcFixedLayout(bStretch, bHorz);
  115. // get max size
  116. CSize sizeMax;
  117. if (!m_rectLayout.IsRectEmpty())
  118. {
  119. CRect rect = m_rectLayout;
  120. CalcInsideRect(rect, bHorz);
  121. sizeMax = rect.Size();
  122. }
  123. else
  124. {
  125. CRect rectFrame;
  126. CFrameWnd* pFrame = GetParentFrame();
  127. pFrame->GetClientRect(&rectFrame);
  128. sizeMax = rectFrame.Size();
  129. }
  130. // prepare for layout
  131. AFX_SIZEPARENTPARAMS layout;
  132. layout.hDWP = m_bLayoutQuery ?
  133. NULL : ::BeginDeferWindowPos(m_arrBars.GetSize());
  134. int cxBorder = 2, cyBorder = 2;
  135. CPoint pt(-cxBorder, -cyBorder);
  136. int nWidth = 0;
  137. BOOL bWrapped = FALSE;
  138. // layout all the control bars
  139. for (int nPos = 0; nPos < m_arrBars.GetSize(); nPos++)
  140. {
  141. CControlBar* pBar = GetDockedControlBar(nPos);
  142. void* pVoid = m_arrBars[nPos];
  143. if (pBar != NULL)
  144. {
  145.   if (pBar->GetStyle() & TBSTYLE_FLAT)
  146. cxBorder = cyBorder = 0;
  147.   else
  148. cxBorder = cyBorder = 2;
  149. if (pBar->IsVisible())
  150. {
  151. // get ideal rect for bar
  152. DWORD dwMode = 0;
  153. if ((pBar->m_dwStyle & CBRS_SIZE_DYNAMIC) &&
  154. (pBar->m_dwStyle & CBRS_FLOATING))
  155. dwMode |= LM_HORZ | LM_MRUWIDTH;
  156. else if (pBar->m_dwStyle & CBRS_ORIENT_HORZ)
  157. dwMode |= LM_HORZ | LM_HORZDOCK;
  158. else
  159. dwMode |=  LM_VERTDOCK;
  160. CSize sizeBar = pBar->CalcDynamicLayout(-1, dwMode);
  161. CRect rect(pt, sizeBar);
  162. // get current rect for bar
  163. CRect rectBar;
  164. pBar->GetWindowRect(&rectBar);
  165. ScreenToClient(&rectBar);
  166. if (bHorz)
  167. {
  168. // Offset Calculated Rect out to Actual
  169. if (rectBar.left > rect.left && !m_bFloating)
  170. rect.OffsetRect(rectBar.left - rect.left, 0);
  171. // If ControlBar goes off the right, then right justify
  172. if (rect.right > sizeMax.cx && !m_bFloating)
  173. {
  174. int x = rect.Width() - cxBorder;
  175. x = max(sizeMax.cx - x, pt.x);
  176. rect.OffsetRect(x - rect.left, 0);
  177. }
  178. // If ControlBar has been wrapped, then left justify
  179. if (bWrapped)
  180. {
  181. bWrapped = FALSE;
  182. rect.OffsetRect(-(rect.left + cxBorder), 0);
  183. }
  184. // If ControlBar is completely invisible, then wrap it
  185. else if ((rect.left >= (sizeMax.cx - cxBorder)) &&
  186. (nPos > 0) && (m_arrBars[nPos - 1] != NULL))
  187. {
  188. m_arrBars.InsertAt(nPos, (CObject*)NULL);
  189. pBar = NULL; pVoid = NULL;
  190. bWrapped = TRUE;
  191. }
  192. if (!bWrapped)
  193. {
  194. if (rect != rectBar)
  195. {
  196. if (!m_bLayoutQuery &&
  197. !(pBar->m_dwStyle & CBRS_FLOATING))
  198. {
  199. pBar->m_pDockContext->m_rectMRUDockPos = rect;
  200. }
  201. AfxRepositionWindow(&layout, pBar->m_hWnd, &rect);
  202. }
  203. pt.x = rect.left + sizeBar.cx - cxBorder;
  204. nWidth = max(nWidth, sizeBar.cy);
  205. }
  206. }
  207. else
  208. {
  209. // Offset Calculated Rect out to Actual
  210. if (rectBar.top > rect.top && !m_bFloating)
  211. rect.OffsetRect(0, rectBar.top - rect.top);
  212. // If ControlBar goes off the bottom, then bottom justify
  213. if (rect.bottom > sizeMax.cy && !m_bFloating)
  214. {
  215. int y = rect.Height() - cyBorder;
  216. y = max(sizeMax.cy - y, pt.y);
  217. rect.OffsetRect(0, y - rect.top);
  218. }
  219. // If ControlBar has been wrapped, then top justify
  220. if (bWrapped)
  221. {
  222. bWrapped = FALSE;
  223. rect.OffsetRect(0, -(rect.top + cyBorder));
  224. }
  225. // If ControlBar is completely invisible, then wrap it
  226. else if ((rect.top >= (sizeMax.cy - cyBorder)) &&
  227. (nPos > 0) && (m_arrBars[nPos - 1] != NULL))
  228. {
  229. m_arrBars.InsertAt(nPos, (CObject*)NULL);
  230. pBar = NULL; pVoid = NULL;
  231. bWrapped = TRUE;
  232. }
  233. if (!bWrapped)
  234. {
  235. if (rect != rectBar)
  236. {
  237. if (!m_bLayoutQuery &&
  238. !(pBar->m_dwStyle & CBRS_FLOATING))
  239. {
  240. pBar->m_pDockContext->m_rectMRUDockPos = rect;
  241. }
  242. AfxRepositionWindow(&layout, pBar->m_hWnd, &rect);
  243. }
  244. pt.y = rect.top + sizeBar.cy - cyBorder;
  245. nWidth = max(nWidth, sizeBar.cx);
  246. }
  247. }
  248. }
  249. if (!bWrapped)
  250. {
  251. // handle any delay/show hide for the bar
  252. pBar->RecalcDelayShow(&layout);
  253. }
  254. }
  255. if (pBar == NULL && pVoid == NULL && nWidth != 0)
  256. {
  257. // end of row because pBar == NULL
  258. if (bHorz)
  259. {
  260. pt.y += nWidth - cyBorder;
  261. sizeFixed.cx = max(sizeFixed.cx, pt.x);
  262. sizeFixed.cy = max(sizeFixed.cy, pt.y);
  263. pt.x = -cxBorder;
  264. }
  265. else
  266. {
  267. pt.x += nWidth - cxBorder;
  268. sizeFixed.cx = max(sizeFixed.cx, pt.x);
  269. sizeFixed.cy = max(sizeFixed.cy, pt.y);
  270. pt.y = -cyBorder;
  271. }
  272. nWidth = 0;
  273. }
  274. }
  275. if (!m_bLayoutQuery)
  276. {
  277. // move and resize all the windows at once!
  278. if (layout.hDWP == NULL || !::EndDeferWindowPos(layout.hDWP))
  279. TRACE0("Warning: DeferWindowPos failed - low system resources.n");
  280. }
  281. // adjust size for borders on the dock bar itself
  282. CRect rect;
  283. rect.SetRectEmpty();
  284. CalcInsideRect(rect, bHorz);
  285. if ((!bStretch || !bHorz) && sizeFixed.cx != 0)
  286. sizeFixed.cx += -rect.right + rect.left;
  287. if ((!bStretch || bHorz) && sizeFixed.cy != 0)
  288. sizeFixed.cy += -rect.bottom + rect.top;
  289. return sizeFixed;
  290. }
  291. // dwDockBarMap
  292. const DWORD dwDockBarMap[4][2] =
  293. {
  294. { AFX_IDW_DOCKBAR_TOP,      CBRS_TOP    },
  295. { AFX_IDW_DOCKBAR_BOTTOM,   CBRS_BOTTOM },
  296. { AFX_IDW_DOCKBAR_LEFT,     CBRS_LEFT   },
  297. { AFX_IDW_DOCKBAR_RIGHT,    CBRS_RIGHT  },
  298. };
  299. void FrameEnableDocking(CFrameWnd * pFrame, DWORD dwDockStyle) 
  300. {
  301. ASSERT_VALID(pFrame);
  302. // must be CBRS_ALIGN_XXX or CBRS_FLOAT_MULTI only
  303. ASSERT((dwDockStyle & ~(CBRS_ALIGN_ANY|CBRS_FLOAT_MULTI)) == 0);
  304. pFrame->EnableDocking(dwDockStyle);
  305. for (int i = 0; i < 4; i++) {
  306. if (dwDockBarMap[i][1] & dwDockStyle & CBRS_ALIGN_ANY) {
  307. CDockBar* pDock = (CDockBar*)pFrame->GetControlBar(dwDockBarMap[i][0]);
  308. // make sure the dock bar is of correct type
  309. if( pDock == 0 || ! pDock->IsKindOf(RUNTIME_CLASS(CDockBarEx)) ) {
  310. BOOL bNeedDelete = ! pDock->m_bAutoDelete;
  311. pDock->m_pDockSite->RemoveControlBar(pDock);
  312. pDock->m_pDockSite = 0; // avoid problems in destroying the dockbar
  313. pDock->DestroyWindow();
  314. if( bNeedDelete )
  315. delete pDock;
  316. pDock = 0;
  317. }
  318. if( pDock == 0 ) {
  319. pDock = new CDockBarEx;
  320. ASSERT_VALID(pDock);
  321. if ((!pDock) || (!pDock->Create(pFrame,
  322. WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_CHILD|WS_VISIBLE |
  323. dwDockBarMap[i][1], dwDockBarMap[i][0]))) {
  324. AfxThrowResourceException();
  325. }
  326. }
  327. }
  328. }
  329. }