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

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

对话框与窗口

开发平台：

Visual C++

GuiDocBarExtenEx.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.  * *
  21.  ****************************************************************************/
  24. #include "stdafx.h"
  25. #include "GuiToolBarWnd.h"
  26. #include "GuiDocBarExtenEx.h"
  27. #include "GuiControlBar.h"
  28. #include "MenuBar.h"
  30. const int cxBorder2 = ::GetSystemMetrics(SM_CXBORDER)*2;
  31. const int cyBorder2 = ::GetSystemMetrics(SM_CYBORDER)*2;
  33. #ifdef _DEBUG
  34. #undef THIS_FILE
  35. static char THIS_FILE[]=__FILE__;
  36. #define new DEBUG_NEW
  37. #endif
  39. //////////////////////////////////////////////////////////////////////
  40. // Construction/Destruction
  41. //////////////////////////////////////////////////////////////////////
  42. IMPLEMENT_DYNCREATE(CGuiDocBarExtenEx,CDockBar)
  44. BEGIN_MESSAGE_MAP(CGuiDocBarExtenEx,CDockBar)
  45. //{{AFX_MSG_MAP(CGuiDocBarExtenEx)
  46. //}}AFX_MSG_MAP
  47. END_MESSAGE_MAP()
  50. CGuiDocBarExtenEx::CGuiDocBarExtenEx()
  51. {
  52. m_StyleDisplay=GUISTYLE_XP;
  53. }
  55. CGuiDocBarExtenEx::~CGuiDocBarExtenEx()
  56. {
  59. }
  60. /////////////////////////////////////////////////////////////////////////////
  61. // CDockBarEx message handlers
  63. BOOL CGuiDocBarExtenEx::_IsMenuBar(int nPos, CPtrArray& arrBars)
  64. {
  65. if (nPos < arrBars.GetSize()) {
  66. CControlBar* pBar = (CControlBar*)arrBars[nPos];
  67. if (pBar && pBar->GetDlgCtrlID() == AFX_IDW_MENUBAR)
  68. return TRUE;
  69. else
  70. return FALSE;
  71. }
  72. else
  73. return FALSE;
  74. }
  76. void CGuiDocBarExtenEx::BarsDocking(CFrameWnd * pFrame, DWORD dwDockStyle) 
  77. {
  78. ASSERT_VALID(pFrame);
  80. // must be CBRS_ALIGN_XXX or CBRS_FLOAT_MULTI only
  81. ASSERT((dwDockStyle & ~(CBRS_ALIGN_ANY|CBRS_FLOAT_MULTI)) == 0);
  83. pFrame->EnableDocking(dwDockStyle);
  85. for (int i = 0; i < 4; i++) {
  86. if (dwDockBarMap[i][1] & dwDockStyle & CBRS_ALIGN_ANY) {
  87. CDockBar* pDock = (CDockBar*)pFrame->GetControlBar(dwDockBarMap[i][0]);
  88. if( pDock == 0 || ! pDock->IsKindOf(RUNTIME_CLASS(CGuiDocBarExtenEx)) ) {
  89. BOOL bNeedDelete = ! pDock->m_bAutoDelete;
  90. pDock->m_pDockSite->RemoveControlBar(pDock);
  91. pDock->m_pDockSite = 0;
  92. pDock->DestroyWindow();
  93. if( bNeedDelete )
  94. delete pDock;
  95. pDock = 0;
  96. }
  98. if( pDock == 0 ) {
  99. pDock = new CGuiDocBarExtenEx;
  100. ASSERT_VALID(pDock);
  101. if ((!pDock) || (!pDock->Create(pFrame,
  102. WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_CHILD|WS_VISIBLE |
  103. dwDockBarMap[i][1], dwDockBarMap[i][0]))) {
  104. AfxThrowResourceException();
  105. }
  106. }
  107. }
  108. }
  109. }
  111. CSize CGuiDocBarExtenEx::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  112. {
  113. ASSERT_VALID(this);
  115. CSize sizeFixed = CControlBar::CalcFixedLayout(bStretch, bHorz);
  117. // get max size
  118. CSize sizeMax;
  119. if (!m_rectLayout.IsRectEmpty())
  120. {
  121. CRect rect = m_rectLayout;
  122. CalcInsideRect(rect, bHorz);
  123. sizeMax = rect.Size();
  124. }
  125. else
  126. {
  127. CRect rectFrame;
  128. CFrameWnd* pFrame = GetParentFrame();
  129. pFrame->GetClientRect(&rectFrame);
  130. sizeMax = rectFrame.Size();
  131. }
  133. // prepare for layout
  134. AFX_SIZEPARENTPARAMS layout;
  135. layout.hDWP = m_bLayoutQuery ?
  136. NULL : ::BeginDeferWindowPos(m_arrBars.GetSize());
  137. int cxBorder = 2, cyBorder = 2;
  138. CPoint pt(-cxBorder, -cyBorder);
  139. int nWidth = 0;
  141. BOOL bWrapped = FALSE;
  143. // layout all the control bars
  144. for (int nPos = 0; nPos < m_arrBars.GetSize(); nPos++)
  145. {
  146. CControlBar* pBar = GetDockedControlBar(nPos);
  147. if (HIWORD(pBar) != 0)
  148. if (pBar->IsKindOf(RUNTIME_CLASS(CGuiControlBar)))
  149. {
  150.      CGuiControlBar* pbar=(CGuiControlBar*)pBar;
  151. CPoint pt(GetMessagePos());
  152. //m_pDockSite->FloatControlBar(pBar,pt);
  153. // pbar->ReleaseCapture();
  154. //m_pDockContext->ToggleDocking();
  155. m_pDockSite->DockControlBar(pBar);
  156. continue;
  157. }
  158. void* pVoid = m_arrBars[nPos];
  160. if (pBar != NULL)
  161. {
  162. if(pBar->IsKindOf(RUNTIME_CLASS(CGuiToolBarWnd)) ||
  163. pBar->IsKindOf(RUNTIME_CLASS(CMenuBar)) )
  164. cxBorder = cyBorder = 0;
  165. else
  166. cxBorder = cyBorder = 2;
  168. if (pBar->IsVisible())
  169. {
  170. // get ideal rect for bar
  171. DWORD dwMode = 0;
  172. if ((pBar->m_dwStyle & CBRS_SIZE_DYNAMIC) &&
  173. (pBar->m_dwStyle & CBRS_FLOATING))
  174. dwMode |= LM_HORZ | LM_MRUWIDTH;
  175. else if (pBar->m_dwStyle & CBRS_ORIENT_HORZ)
  176. dwMode |= LM_HORZ | LM_HORZDOCK;
  177. else
  178. dwMode |=  LM_VERTDOCK;
  180. CSize sizeBar = pBar->CalcDynamicLayout(-1, dwMode);
  182. CRect rect(pt, sizeBar);
  184. // get current rect for bar
  185. CRect rectBar;
  186. pBar->GetWindowRect(&rectBar);
  187. ScreenToClient(&rectBar);
  189. if (bHorz)
  190. {
  191. // Offset Calculated Rect out to Actual
  192. if (rectBar.left > rect.left && !m_bFloating)
  193. rect.OffsetRect(rectBar.left - rect.left, 0);
  195. // If ControlBar goes off the right, then right justify
  196. if (rect.right > sizeMax.cx && !m_bFloating)
  197. {
  198. int x = rect.Width() - cxBorder;
  199. x = max(sizeMax.cx - x, pt.x);
  200. rect.OffsetRect(x - rect.left, 0);
  201. }
  203. // If ControlBar has been wrapped, then left justify
  204. if (bWrapped)
  205. {
  206. bWrapped = FALSE;
  207. rect.OffsetRect(-(rect.left + cxBorder), 0);
  208. }
  209. // If ControlBar is completely invisible, then wrap it
  210. else if ((rect.left >= (sizeMax.cx - cxBorder2) || _IsMenuBar(nPos, m_arrBars))
  211. && (nPos > 0) && (m_arrBars[nPos - 1] != NULL))
  212. {
  213. m_arrBars.InsertAt(nPos, (CObject*)NULL);
  214. pBar = NULL; pVoid = NULL;
  215. bWrapped = TRUE;
  216. }
  217. if (!bWrapped)
  218. {
  219. if (rect != rectBar)
  220. {
  221. if (!m_bLayoutQuery &&
  222. !(pBar->m_dwStyle & CBRS_FLOATING))
  223. {
  224. pBar->m_pDockContext->m_rectMRUDockPos = rect;
  225. }
  226. AfxRepositionWindow(&layout, pBar->m_hWnd, &rect);
  227. }
  228. pt.x = rect.left + sizeBar.cx - cxBorder;
  229. nWidth = max(nWidth, sizeBar.cy);
  230. }
  231. }
  232. else
  233. {
  234. // Offset Calculated Rect out to Actual
  235. if (rectBar.top > rect.top && !m_bFloating)
  236. rect.OffsetRect(0, rectBar.top - rect.top);
  238. // If ControlBar goes off the bottom, then bottom justify
  239. if (rect.bottom > sizeMax.cy && !m_bFloating)
  240. {
  241. int y = rect.Height() - cyBorder;
  242. y = max(sizeMax.cy - y, pt.y);
  243. rect.OffsetRect(0, y - rect.top);
  244. }
  246. // If ControlBar has been wrapped, then top justify
  247. if (bWrapped)
  248. {
  249. bWrapped = FALSE;
  250. rect.OffsetRect(0, -(rect.top + cyBorder));
  251. }
  252. // If ControlBar is completely invisible, then wrap it
  253. else if ((rect.left >= (sizeMax.cx - cxBorder2) || _IsMenuBar(nPos, m_arrBars))
  254. && (nPos > 0) && (m_arrBars[nPos - 1] != NULL))
  255. {
  256. m_arrBars.InsertAt(nPos, (CObject*)NULL);
  257. pBar = NULL; pVoid = NULL;
  258. bWrapped = TRUE;
  259. }
  260. if (!bWrapped)
  261. {
  262. if (rect != rectBar)
  263. {
  264. if (!m_bLayoutQuery &&
  265. !(pBar->m_dwStyle & CBRS_FLOATING))
  266. {
  267. pBar->m_pDockContext->m_rectMRUDockPos = rect;
  268. }
  269. AfxRepositionWindow(&layout, pBar->m_hWnd, &rect);
  270. }
  271. pt.y = rect.top + sizeBar.cy - cyBorder;
  272. nWidth = max(nWidth, sizeBar.cx);
  273. }
  274. }
  275. }
  276. if (!bWrapped)
  277. {
  278. // handle any delay/show hide for the bar
  279. pBar->RecalcDelayShow(&layout);
  280. }
  281. }
  282. if (pBar == NULL && pVoid == NULL && nWidth != 0)
  283. {
  284. // end of row because pBar == NULL
  285. if (bHorz)
  286. {
  287. pt.y += nWidth - cyBorder;
  288. sizeFixed.cx = max(sizeFixed.cx, pt.x);
  289. sizeFixed.cy = max(sizeFixed.cy, pt.y);
  290. pt.x = -cxBorder;
  291. }
  292. else
  293. {
  294. pt.x += nWidth - cxBorder;
  295. sizeFixed.cx = max(sizeFixed.cx, pt.x);
  296. sizeFixed.cy = max(sizeFixed.cy, pt.y);
  297. pt.y = -cyBorder;
  298. }
  299. nWidth = 0;
  300. }
  301. }
  302. if (!m_bLayoutQuery)
  303. {
  304. // move and resize all the windows at once!
  305. if (layout.hDWP == NULL || !::EndDeferWindowPos(layout.hDWP))
  306. TRACE0("Warning: DeferWindowPos failed - low system resources.n");
  307. }
  309. // adjust size for borders on the dock bar itself
  310. CRect rect;
  311. rect.SetRectEmpty();
  312. CalcInsideRect(rect, bHorz);
  314. if ((!bStretch || !bHorz) && sizeFixed.cx != 0)
  315. sizeFixed.cx += -rect.right + rect.left;
  316. if ((!bStretch || bHorz) && sizeFixed.cy != 0)
  317. sizeFixed.cy += -rect.bottom + rect.top;
  319. return sizeFixed;
  320. }
  323. /*CSize CGuiDocBarExtenEx::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  324. {
  325. // LTRACE(_T("CMenuDockBar::CalcFixedLayoutn"));
  326. ASSERT_VALID(this);
  328. CSize sizeFixed = CControlBar::CalcFixedLayout(bStretch, bHorz);
  330. // get max size
  331. CSize sizeMax;
  332. if (!m_rectLayout.IsRectEmpty())
  333. sizeMax = m_rectLayout.Size();
  334. else
  335. {
  336. CRect rectFrame;
  337. CFrameWnd* pFrame = GetParentFrame();
  338. pFrame->GetClientRect(&rectFrame);
  339. sizeMax = rectFrame.Size();
  340. }
  342. // prepare for layout
  343. AFX_SIZEPARENTPARAMS layout;
  344. layout.hDWP = m_bLayoutQuery ?
  345. NULL : ::BeginDeferWindowPos(m_arrBars.GetSize());
  346. CPoint pt(-cxBorder2, -cyBorder2);
  347. int nWidth = 0;
  349. BOOL bWrapped = FALSE;
  351. // layout all the control bars
  352. for (int nPos = 0; nPos < m_arrBars.GetSize(); nPos++)
  353. {
  354. CControlBar* pBar = GetDockedControlBar(nPos);
  355. void* pVoid = m_arrBars[nPos];
  357. if (pBar != NULL)// pBar is valid
  358. {
  359. if (pBar->IsVisible())// visible
  360. {
  361. // get ideal rect for bar
  362. DWORD dwMode = 0;
  363. if ((pBar->m_dwStyle & CBRS_SIZE_DYNAMIC) &&
  364. (pBar->m_dwStyle & CBRS_FLOATING))
  365. dwMode |= LM_HORZ | LM_MRUWIDTH;
  366. else if (pBar->m_dwStyle & CBRS_ORIENT_HORZ)
  367. dwMode |= LM_HORZ | LM_HORZDOCK;
  368. else
  369. dwMode |=  LM_VERTDOCK;
  371. CSize sizeBar = pBar->CalcDynamicLayout(-1, dwMode);
  373. CRect rect(pt, sizeBar);
  375. // get current rect for bar
  376. CRect rectBar;
  377. pBar->GetWindowRect(&rectBar);
  378. ScreenToClient(&rectBar);
  380. if (bHorz)// horizontal
  381. {
  382. // Offset Calculated Rect out to Actual
  383. if (rectBar.left > rect.left && !m_bFloating)
  384. rect.OffsetRect(rectBar.left - rect.left, 0);
  386. // If ControlBar goes off the right, then right justify
  387. if (rect.right > sizeMax.cx && !m_bFloating)
  388. {
  389. int x = rect.Width() - cxBorder2;
  390. x = max(sizeMax.cx - x, pt.x);
  391. rect.OffsetRect(x - rect.left, 0);
  392. }
  394. // If ControlBar has been wrapped, then left justify
  395. if (bWrapped)
  396. {
  397. bWrapped = FALSE;
  398. rect.OffsetRect(-(rect.left + cxBorder2), 0);
  399. }
  400. // If ControlBar is completely invisible, then wrap it
  401. else if ((rect.left >= (sizeMax.cx - cxBorder2) || _IsMenuBar(nPos, m_arrBars))
  402. && (nPos > 0) && (m_arrBars[nPos - 1] != NULL))
  403. {
  404. m_arrBars.InsertAt(nPos, (CObject*)NULL);
  405. pBar = NULL; pVoid = NULL;
  406. bWrapped = TRUE;
  407. }
  408. if (!bWrapped)
  409. {
  410. if (rect != rectBar)
  411. {
  412. if (!m_bLayoutQuery &&
  413. !(pBar->m_dwStyle & CBRS_FLOATING))
  414. {
  415. pBar->m_pDockContext->m_rectMRUDockPos = rect;
  416. }
  417. AfxRepositionWindow(&layout, pBar->m_hWnd, &rect);
  418. }
  419. pt.x = rect.left + sizeBar.cx - cxBorder2;
  420. nWidth = max(nWidth, sizeBar.cy);
  421. }
  422. }
  423. else // vertical
  424. {
  425. // Offset Calculated Rect out to Actual
  426. if (rectBar.top > rect.top && !m_bFloating)
  427. rect.OffsetRect(0, rectBar.top - rect.top);
  429. // If ControlBar goes off the bottom, then bottom justify
  430. if (rect.bottom > sizeMax.cy && !m_bFloating)
  431. {
  432. int y = rect.Height() - cyBorder2;
  433. y = max(sizeMax.cy - y, pt.y);
  434. rect.OffsetRect(0, y - rect.top);
  435. }
  437. // If ControlBar has been wrapped, then top justify
  438. if (bWrapped)
  439. {
  440. bWrapped = FALSE;
  441. rect.OffsetRect(0, -(rect.top + cyBorder2));
  442. }
  443. // If ControlBar is completely invisible, then wrap it
  444. else if ((rect.top >= (sizeMax.cy - cyBorder2) || _IsMenuBar(nPos, m_arrBars))
  445. && (nPos > 0) && (m_arrBars[nPos - 1] != NULL))
  446. {
  447. m_arrBars.InsertAt(nPos, (CObject*)NULL);
  448. pBar = NULL; pVoid = NULL;
  449. bWrapped = TRUE;
  450. }
  452. if (!bWrapped)
  453. {
  454. if (rect != rectBar)
  455. {
  456. if (!m_bLayoutQuery &&
  457. !(pBar->m_dwStyle & CBRS_FLOATING))
  458. {
  459. pBar->m_pDockContext->m_rectMRUDockPos = rect;
  460. }
  461. AfxRepositionWindow(&layout, pBar->m_hWnd, &rect);
  462. }
  463. pt.y = rect.top + sizeBar.cy - cyBorder2;
  464. nWidth = max(nWidth, sizeBar.cx);
  465. }
  466. }// if vertical
  467. }// if visible
  468. if (!bWrapped)
  469. {
  470. // handle any delay/show hide for the bar
  471. pBar->RecalcDelayShow(&layout);
  472. }
  473. }// if pBar is valid
  474. if (pBar == NULL && pVoid == NULL && nWidth != 0)
  475. {
  476. // end of row because pBar == NULL
  477. if (bHorz)
  478. {
  479. pt.y += nWidth - cyBorder2;
  480. sizeFixed.cx = max(sizeFixed.cx, pt.x);
  481. sizeFixed.cy = max(sizeFixed.cy, pt.y);
  482. pt.x = -cxBorder2;
  483. }
  484. else
  485. {
  486. pt.x += nWidth - cxBorder2;
  487. sizeFixed.cx = max(sizeFixed.cx, pt.x);
  488. sizeFixed.cy = max(sizeFixed.cy, pt.y);
  489. pt.y = -cyBorder2;
  490. }
  491. nWidth = 0;
  492. }
  493. }// for
  494. if (!m_bLayoutQuery)
  495. {
  496. // move and resize all the windows at once!
  497. if (layout.hDWP == NULL || !::EndDeferWindowPos(layout.hDWP))
  498. TRACE0("Warning: DeferWindowPos failed - low system resources.n");
  499. }
  501. // adjust size for borders on the dock bar itself
  502. CRect rect;
  503. rect.SetRectEmpty();
  504. CalcInsideRect(rect, bHorz);
  506. if ((!bStretch || !bHorz) && sizeFixed.cx != 0)
  507. sizeFixed.cx += -rect.right + rect.left;
  508. if ((!bStretch || bHorz) && sizeFixed.cy != 0)
  509. sizeFixed.cy += -rect.bottom + rect.top;
  511. return sizeFixed;
  513. }*/
  515. void CGuiDocBarExtenEx::DoPaint(CDC* pDC)
  516. {
  517. CRect rect;
  518. GetClientRect(rect);
  519. CBrush cbr;
  520. cbr.CreateSolidBrush(GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style));
  521. pDC->FillRect(rect,&cbr);
  523. }