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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 金融证券系统 > 查看源码
GuiDockContext.cpp
资源名称：clking_src.rar　[点击查看]
上传用户：zhanglf88
上传日期：2013-11-19
资源大小：6036k
文件大小：23k
源码类别：

金融证券系统

开发平台：

Visual C++

GuiDockContext.cpp：源码内容
  1. //-----------------------------------------------------------------------//
  2. // This is a part of the GuiLib MFC Extention.  //
  3. // Autor  :  Francisco Campos  //
  4. // (C) 2002 Francisco Campos <www.beyondata.com> All rights reserved     //
  5. // This code is provided "as is", with absolutely no warranty expressed  //
  6. // or implied. Any use is at your own risk.  //
  7. // You must obtain the author's consent before you can include this code //
  8. // in a software library.  //
  9. // If the source code in  this file is used in any application  //
  10. // then acknowledgement must be made to the author of this program  //
  11. // fcampos@tutopia.com  //
  12. //-----------------------------------------------------------------------//
  14. #include "stdafx.h"
  15. #include "GuiDockContext.h"
  16. #include "GuiToolBarWnd.h"
  17. #include "MenuBar.h"
  18. #include "GuiControlBar.h"
  19. #define _AfxGetDlgCtrlID(hWnd)          ((UINT)(WORD)::GetDlgCtrlID(hWnd))
  20. #ifdef AFX_CORE3_SEG
  21. #pragma code_seg(AFX_CORE3_SEG)
  22. #endif
  24. #ifdef _DEBUG
  25. #undef THIS_FILE
  26. static char THIS_FILE[] = __FILE__;
  27. #endif
  29. #define new DEBUG_NEW
  31. #define HORZF(dw) (dw & CBRS_ORIENT_HORZ)
  32. #define VERTF(dw) (dw & CBRS_ORIENT_VERT)
  33. #define CX_BORDER   1
  34. #define CY_BORDER   1
  37. AFX_STATIC void AFXAPI _AfxAdjustRectangle(CRect& rect, CPoint pt)
  38. {
  39. int nXOffset = (pt.x < rect.left) ? (pt.x - rect.left) :
  40. (pt.x > rect.right) ? (pt.x - rect.right) : 0;
  41. int nYOffset = (pt.y < rect.top) ? (pt.y - rect.top) :
  42. (pt.y > rect.bottom) ? (pt.y - rect.bottom) : 0;
  43. rect.OffsetRect(nXOffset, nYOffset);
  44. }
  46. /////////////////////////////////////////////////////////////////////////////
  47. // CGuiDockContext
  49. CGuiDockContext::CGuiDockContext(CControlBar* pBar):CDockContext(pBar)
  50. {
  51. bFirstClic=TRUE;
  52. bSecondClic=TRUE;
  53. }
  55. CGuiDockContext::~CGuiDockContext()
  56. {
  57. }
  59. /////////////////////////////////////////////////////////////////////////////
  60. // CGuiDockContext Drag Operations
  62. void CGuiDockContext::StartDrag(CPoint pt)
  63. {
  64. ASSERT_VALID(m_pBar);
  65. m_bDragging = TRUE;
  67. InitLoop();
  69. // GetWindowRect returns screen coordinates(not mirrored),
  70. // so if the desktop is mirrored then turn off mirroring
  71. // for the desktop dc so that we get correct focus rect drawn.
  72. // This layout change should be remembered, just in case ...
  74. if (m_pDC->GetLayout() & LAYOUT_RTL)
  75. m_pDC->SetLayout(LAYOUT_LTR);
  77. if (m_pBar->m_dwStyle & CBRS_SIZE_DYNAMIC)
  78. {
  79. // get true bar size (including borders)
  80. CRect rect;
  81. m_pBar->GetWindowRect(rect);
  82. m_ptLast = pt;
  83. AdjustWindowForFloat(rect);
  84. CSize sizeHorz = m_pBar->CalcDynamicLayout(0, LM_HORZ | LM_HORZDOCK);
  85. CSize sizeVert = m_pBar->CalcDynamicLayout(0, LM_VERTDOCK);
  86. CSize sizeFloat = m_pBar->CalcDynamicLayout(0, LM_HORZ | LM_MRUWIDTH);
  88. m_rectDragHorz = CRect(rect.TopLeft(), sizeHorz);
  89. m_rectDragVert = CRect(rect.TopLeft(), sizeVert);
  91. // calculate frame dragging rectangle
  92. m_rectFrameDragHorz = CRect(rect.TopLeft(), sizeFloat);
  93. m_rectFrameDragVert = CRect(rect.TopLeft(), sizeFloat);
  95. CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz);
  96. CMiniFrameWnd::CalcBorders(&m_rectFrameDragVert);
  98. // m_rectFrameDragHorz.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2);
  99. // m_rectFrameDragVert.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2);
  100. }
  101. else if (m_pBar->m_dwStyle & CBRS_SIZE_FIXED)
  102. {
  103. // get true bar size (including borders)
  104. CRect rect;
  105. m_pBar->GetWindowRect(rect);
  106. AdjustWindowForFloat(rect);
  107. m_ptLast = pt;
  108. CSize sizeHorz = m_pBar->CalcDynamicLayout(-1, LM_HORZ | LM_HORZDOCK);
  109. CSize sizeVert = m_pBar->CalcDynamicLayout(-1, LM_VERTDOCK);
  111. // calculate frame dragging rectangle
  112. m_rectFrameDragHorz = m_rectDragHorz = CRect(rect.TopLeft(), sizeHorz);
  113. m_rectFrameDragVert = m_rectDragVert = CRect(rect.TopLeft(), sizeVert);
  115. CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz);
  116. CMiniFrameWnd::CalcBorders(&m_rectFrameDragVert);
  117. // m_rectFrameDragHorz.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2);
  118. // m_rectFrameDragVert.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2);
  119. }
  120. else
  121. {
  122. // get true bar size (including borders)
  123. CRect rect;
  124. m_pBar->GetWindowRect(rect);
  125. AdjustWindowForFloat(rect);
  126. m_ptLast = pt;
  127. BOOL bHorz = HORZF(m_dwStyle);
  128. DWORD dwMode = !bHorz ? (LM_HORZ | LM_HORZDOCK) : LM_VERTDOCK;
  129. CSize size = m_pBar->CalcDynamicLayout(-1, dwMode);
  131. // calculate inverted dragging rect
  132. if (bHorz)
  133. {
  134. m_rectDragHorz = rect;
  135. m_rectDragVert = CRect(CPoint(pt.x - rect.Height()/2, rect.top), size);
  136. }
  137. else // vertical orientation
  138. {
  139. m_rectDragVert = rect;
  140. m_rectDragHorz = CRect(CPoint(rect.left, pt.y - rect.Width()/2), size);
  141. }
  143. // calculate frame dragging rectangle
  144. m_rectFrameDragHorz = m_rectDragHorz;
  145. m_rectFrameDragVert = m_rectDragVert;
  147. CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz);
  148. CMiniFrameWnd::CalcBorders(&m_rectFrameDragVert);
  149. // m_rectFrameDragHorz.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2);
  150. // m_rectFrameDragVert.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2);
  151. }
  153. // adjust rectangles so that point is inside
  154. _AfxAdjustRectangle(m_rectDragHorz, pt);
  155. _AfxAdjustRectangle(m_rectDragVert, pt);
  156. _AfxAdjustRectangle(m_rectFrameDragHorz, pt);
  157. _AfxAdjustRectangle(m_rectFrameDragVert, pt);
  159. // initialize tracking state and enter tracking loop
  160. m_dwOverDockStyle = CanDock();
  161. Move(pt);   // call it here to handle special keys
  162. Track();
  163. }
  165. void CGuiDockContext::AdjustWindowForFloat(CRect& rect)
  166. {
  167. if( m_pBar->IsFloating())
  168. {
  169. rect.top+=(GetSystemMetrics(SM_CYCAPTION));
  170. rect.bottom-=(GetSystemMetrics(SM_CYFRAME)+GetSystemMetrics(SM_CYCAPTION))*2;
  171. }
  172. }
  174. void CGuiDockContext::Move(CPoint pt)
  175. {
  176. CPoint ptOffset = pt - m_ptLast;
  178. // offset all drag rects to new position
  179. m_rectDragHorz.OffsetRect(ptOffset);
  180. m_rectFrameDragHorz.OffsetRect(ptOffset);
  181. m_rectDragVert.OffsetRect(ptOffset);
  182. m_rectFrameDragVert.OffsetRect(ptOffset);
  183. m_ptLast = pt;
  185. // if control key is down don't dock
  186. m_dwOverDockStyle = m_bForceFrame ? 0 : CanDock();
  188. // update feedback
  189. DrawFocusRect();
  190. }
  192. void CGuiDockContext::OnKey(int nChar, BOOL bDown)
  193. {
  194. if (nChar == VK_CONTROL)
  195. UpdateState(&m_bForceFrame, bDown);
  196. if (nChar == VK_SHIFT)
  197. UpdateState(&m_bFlip, bDown);
  198. }
  200. void CGuiDockContext::EndDrag()
  201. {
  202. CancelLoop();
  204. if (m_dwOverDockStyle != 0)
  205. {
  206. CDockBar* pDockBar = GetDockBar(m_dwOverDockStyle);
  207. ASSERT(pDockBar != NULL);
  209. CRect rect = (m_dwOverDockStyle & CBRS_ORIENT_VERT) ?
  210. m_rectDragVert : m_rectDragHorz;
  212. UINT uID = _AfxGetDlgCtrlID(pDockBar->m_hWnd);
  213. if (uID >= AFX_IDW_DOCKBAR_TOP &&
  214. uID <= AFX_IDW_DOCKBAR_BOTTOM)
  215. {
  217. m_uMRUDockID = uID;
  218. m_rectMRUDockPos = rect;
  219. pDockBar->ScreenToClient(&m_rectMRUDockPos);
  220. }
  222. // dock it at the specified position, RecalcLayout will snap
  223. m_pDockSite->DockControlBar(m_pBar, pDockBar, &rect);
  224. m_pDockSite->RecalcLayout();
  225. }
  226. else if ((m_dwStyle & CBRS_SIZE_DYNAMIC) || (HORZF(m_dwStyle) && !m_bFlip) ||
  227. (VERTF(m_dwStyle) && m_bFlip))
  228. {
  229. m_dwMRUFloatStyle = CBRS_ALIGN_TOP | (m_dwDockStyle & CBRS_FLOAT_MULTI);
  230. m_ptMRUFloatPos = m_rectFrameDragHorz.TopLeft();
  231. m_pDockSite->FloatControlBar(m_pBar, m_ptMRUFloatPos, m_dwMRUFloatStyle);
  232. }
  233. else // vertical float
  234. {
  235. m_dwMRUFloatStyle = CBRS_ALIGN_LEFT | (m_dwDockStyle & CBRS_FLOAT_MULTI);
  236. m_ptMRUFloatPos = m_rectFrameDragVert.TopLeft();
  237. m_pDockSite->FloatControlBar(m_pBar, m_ptMRUFloatPos, m_dwMRUFloatStyle);
  238. }
  239. }
  241. /////////////////////////////////////////////////////////////////////////////
  242. // CGuiDockContext Resize Operations
  244. #define m_rectRequestedSize     m_rectDragHorz
  245. #define m_rectActualSize        m_rectDragVert
  246. #define m_rectActualFrameSize   m_rectFrameDragHorz
  247. #define m_rectFrameBorders      m_rectFrameDragVert
  249. void CGuiDockContext::StartResize(int nHitTest, CPoint pt)
  250. {
  251. ASSERT_VALID(m_pBar);
  252. ASSERT(m_pBar->m_dwStyle & CBRS_SIZE_DYNAMIC);
  253. m_bDragging = FALSE;
  255. InitLoop();
  257. // GetWindowRect returns screen coordinates(not mirrored)
  258. // So if the desktop is mirrored then turn off mirroring
  259. // for the desktop dc so that we draw correct focus rect
  261. if (m_pDC->GetLayout() & LAYOUT_RTL)
  262. m_pDC->SetLayout(LAYOUT_LTR);
  264. // get true bar size (including borders)
  265. CRect rect;
  266. m_pBar->GetWindowRect(rect);
  267. m_ptLast = pt;
  268. m_nHitTest = nHitTest;
  270. CSize size = m_pBar->CalcDynamicLayout(0, LM_HORZ | LM_MRUWIDTH);
  271. m_rectRequestedSize = CRect(rect.TopLeft(), size);
  272. m_rectActualSize = CRect(rect.TopLeft(), size);
  273. m_rectActualFrameSize = CRect(rect.TopLeft(), size);
  275. // calculate frame rectangle
  276. CMiniFrameWnd::CalcBorders(&m_rectActualFrameSize);
  277. // m_rectActualFrameSize.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2);
  279. m_rectFrameBorders = CRect(CPoint(0,0),
  280. m_rectActualFrameSize.Size() - m_rectActualSize.Size());
  282. // initialize tracking state and enter tracking loop
  283. m_dwOverDockStyle = 0;
  284. Stretch(pt);   // call it here to handle special keys
  285. Track();
  286. }
  288. void CGuiDockContext::Stretch(CPoint pt)
  289. {
  290. CPoint ptOffset = pt - m_ptLast;
  292. // offset all drag rects to new position
  293. int nLength = 0;
  294. DWORD dwMode = LM_HORZ;
  295. if (m_nHitTest == HTLEFT || m_nHitTest == HTRIGHT)
  296. {
  297. if (m_nHitTest == HTLEFT)
  298. m_rectRequestedSize.left += ptOffset.x;
  299. else
  300. m_rectRequestedSize.right += ptOffset.x;
  301. nLength = m_rectRequestedSize.Width();
  302. }
  303. else
  304. {
  305. dwMode |= LM_LENGTHY;
  306. if (m_nHitTest == HTTOP)
  307. m_rectRequestedSize.top += ptOffset.y;
  308. else
  309. m_rectRequestedSize.bottom += ptOffset.y;
  310. nLength = m_rectRequestedSize.Height();
  311. }
  312. nLength = (nLength >= 0) ? nLength : 0;
  314. CSize size = m_pBar->CalcDynamicLayout(nLength, dwMode);
  316. CRect rectDesk;
  317. HWND hWndDesk = ::GetDesktopWindow();
  318. ::GetWindowRect(hWndDesk, &rectDesk);
  319. CRect rectTemp = m_rectActualFrameSize;
  321. if (m_nHitTest == HTLEFT || m_nHitTest == HTTOP)
  322. {
  323. rectTemp.left = rectTemp.right -
  324. (size.cx + m_rectFrameBorders.Width());
  325. rectTemp.top = rectTemp.bottom -
  326. (size.cy + m_rectFrameBorders.Height());
  327. CRect rect;
  328. if (rect.IntersectRect(rectDesk, rectTemp))
  329. {
  330. m_rectActualSize.left = m_rectActualSize.right - size.cx;
  331. m_rectActualSize.top = m_rectActualSize.bottom - size.cy;
  332. m_rectActualFrameSize.left = rectTemp.left;
  333. m_rectActualFrameSize.top = rectTemp.top;
  334. }
  335. }
  336. else
  337. {
  338. rectTemp.right = rectTemp.left +
  339. (size.cx + m_rectFrameBorders.Width());
  340. rectTemp.bottom = rectTemp.top +
  341. (size.cy + m_rectFrameBorders.Height());
  342. CRect rect;
  343. if (rect.IntersectRect(rectDesk, rectTemp))
  344. {
  345. m_rectActualSize.right = m_rectActualSize.left + size.cx;
  346. m_rectActualSize.bottom = m_rectActualSize.top + size.cy;
  347. m_rectActualFrameSize.right = rectTemp.right;
  348. m_rectActualFrameSize.bottom = rectTemp.bottom;
  349. }
  350. }
  351. m_ptLast = pt;
  353. // update feedback
  354. DrawFocusRect();
  355. }
  357. void CGuiDockContext::EndResize()
  358. {
  359. CancelLoop();
  361. m_pBar->CalcDynamicLayout(m_rectActualSize.Width(), LM_HORZ | LM_COMMIT);
  362. m_pDockSite->FloatControlBar(m_pBar, m_rectActualFrameSize.TopLeft(),
  363. CBRS_ALIGN_TOP | (m_dwDockStyle & CBRS_FLOAT_MULTI) | CBRS_SIZE_DYNAMIC);
  364. }
  366. /////////////////////////////////////////////////////////////////////////////
  367. // CGuiDockContext Double Click Operations
  369. void CGuiDockContext::ToggleDocking()
  370. {
  371. if (m_pBar->IsFloating())
  372. {
  373. // Dock it only if is allowed to be docked
  374. if (m_pBar->m_dwDockStyle & CBRS_ALIGN_ANY)
  375. {
  376. ASSERT((m_uMRUDockID >= AFX_IDW_DOCKBAR_TOP &&
  377. m_uMRUDockID <= AFX_IDW_DOCKBAR_BOTTOM) ||
  378. m_uMRUDockID == 0);
  380. CRect rect = m_rectMRUDockPos;
  381. CDockBar* pDockBar = NULL;
  382. if (m_uMRUDockID != 0)
  383. {
  384. pDockBar = (CDockBar*)m_pDockSite->GetControlBar(m_uMRUDockID);
  385. pDockBar->ClientToScreen(&rect);
  386. }
  388. // dock it at the specified position, RecalcLayout will snap
  389. m_pDockSite->ReDockControlBar(m_pBar, pDockBar, &rect);
  390. m_pDockSite->RecalcLayout();
  391. }
  392. }
  393. else
  394. {
  395. CPoint ptFloat = m_ptMRUFloatPos;
  396. if (ptFloat.x < 0 || ptFloat.y < 0)
  397. {
  398. ptFloat = m_rectMRUDockPos.TopLeft();
  399. m_pBar->GetParent()->ClientToScreen(&ptFloat);
  400. }
  401. m_pDockSite->FloatControlBar(m_pBar, ptFloat, m_dwMRUFloatStyle);
  402. }
  403. }
  405. /////////////////////////////////////////////////////////////////////////////
  406. // CGuiDockContext Operations
  408. void CGuiDockContext::InitLoop()
  409. {
  410. // handle pending WM_PAINT messages
  411. MSG msg;
  412. while (::PeekMessage(&msg, NULL, WM_PAINT, WM_PAINT, PM_NOREMOVE))
  413. {
  414. if (!GetMessage(&msg, NULL, WM_PAINT, WM_PAINT))
  415. return;
  416. DispatchMessage(&msg);
  417. }
  419. // get styles from bar
  420. m_dwDockStyle = m_pBar->m_dwDockStyle;
  421. m_dwStyle = m_pBar->m_dwStyle & CBRS_ALIGN_ANY;
  422. ASSERT(m_dwStyle != 0);
  424. // initialize state
  425. m_rectLast.SetRectEmpty();
  426. m_sizeLast.cx = m_sizeLast.cy = 0;
  427. m_bForceFrame = m_bFlip = m_bDitherLast = FALSE;
  429. // lock window update while dragging
  430. ASSERT(m_pDC == NULL);
  431. CWnd* pWnd = CWnd::GetDesktopWindow();
  432. if (pWnd->LockWindowUpdate())
  433. m_pDC = pWnd->GetDCEx(NULL, DCX_WINDOW|DCX_CACHE|DCX_LOCKWINDOWUPDATE);
  434. else
  435. m_pDC = pWnd->GetDCEx(NULL, DCX_WINDOW|DCX_CACHE);
  436. ASSERT(m_pDC != NULL);
  437. }
  439. void CGuiDockContext::CancelLoop()
  440. {
  441. DrawFocusRect(TRUE);    // gets rid of focus rect
  442. ReleaseCapture();
  444. CWnd* pWnd = CWnd::GetDesktopWindow();
  445. pWnd->UnlockWindowUpdate();
  446. if (m_pDC != NULL)
  447. {
  448. pWnd->ReleaseDC(m_pDC);
  449. m_pDC = NULL;
  450. }
  451. bFirstClic=TRUE;
  452. bSecondClic=TRUE;
  453. }
  455. /////////////////////////////////////////////////////////////////////////////
  456. // Implementation
  458. void CGuiDockContext::DrawFocusRect(BOOL bRemoveRect)
  459. {
  460. ASSERT(m_pDC != NULL);
  462. // default to thin frame
  463. CSize size(CX_BORDER, CY_BORDER);
  465. // determine new rect and size
  466. CRect rect;
  467. CBrush* pWhiteBrush = CBrush::FromHandle((HBRUSH)::GetStockObject(WHITE_BRUSH));
  468. CBrush* pDitherBrush = CDC::GetHalftoneBrush();
  469. CBrush* pBrush = pWhiteBrush;
  471. if (HORZF(m_dwOverDockStyle))
  472. rect = m_rectDragHorz;
  473. else if (VERTF(m_dwOverDockStyle))
  474. rect = m_rectDragVert;
  475. else
  476. {
  477. // use thick frame instead
  478. size.cx = GetSystemMetrics(SM_CXFRAME) - CX_BORDER;
  479. size.cy = GetSystemMetrics(SM_CYFRAME) - CY_BORDER;
  480. if ((HORZF(m_dwStyle) && !m_bFlip) || (VERTF(m_dwStyle) && m_bFlip))
  481. rect = m_rectFrameDragHorz;
  482. else
  483. rect = m_rectFrameDragVert;
  484. pBrush = pDitherBrush;
  485. }
  486. if (bRemoveRect)
  487. size.cx = size.cy = 0;
  489. /* if (afxData.bWin4 &&
  490. (HORZF(m_dwOverDockStyle) || VERTF(m_dwOverDockStyle)))
  491. {
  492. // looks better one pixel in (makes the bar look pushed down)
  493. rect.InflateRect(-CX_BORDER, -CY_BORDER);
  494. }
  495. */
  496. // draw it and remember last size
  498. if (bFirstClic==TRUE)
  499. {
  500. bFirstClic=FALSE;
  501. }
  502. else{
  503. if (bSecondClic==TRUE)
  504. {
  505.   m_pDC->DrawDragRect(&rect, size, &m_rectLast, m_sizeLast,
  506. pBrush, m_bDitherLast ? pDitherBrush : pWhiteBrush);
  507.   m_bDitherLast = (pBrush == pDitherBrush);
  508.    m_pDC->DrawDragRect(&rect, size, &m_rectLast, m_sizeLast,
  509. pBrush, m_bDitherLast ? pDitherBrush : pWhiteBrush);
  510.   bSecondClic=FALSE;
  511. }
  512. else
  513. {
  514. m_pDC->DrawDragRect(&rect, size, &m_rectLast, m_sizeLast,
  515. pBrush, m_bDitherLast ? pDitherBrush : pWhiteBrush);
  516. m_rectLast = rect;
  517. m_sizeLast = size;
  518. m_bDitherLast = (pBrush == pDitherBrush);
  519. }
  520. }
  522. }
  524. void CGuiDockContext::UpdateState(BOOL* pFlag, BOOL bNewValue)
  525. {
  526. if (*pFlag != bNewValue)
  527. {
  528. *pFlag = bNewValue;
  529. m_bFlip = (HORZF(m_dwDockStyle) && VERTF(m_dwDockStyle) && m_bFlip); // shift key
  530. m_dwOverDockStyle = (m_bForceFrame) ? 0 : CanDock();
  531. DrawFocusRect();
  532. }
  533. }
  535. DWORD CGuiDockContext::CanDock()
  536. {
  537. BOOL bStyleHorz;
  538. DWORD dwDock = 0; // Dock Canidate
  539. DWORD dwCurr = 0; // Current Orientation
  541. // let's check for something in our current orientation first
  542. // then if the shift key is not forcing our orientation then
  543. // check for horizontal or vertical orientations as long
  544. // as we are close enough
  545. ASSERT(m_dwStyle != 0);
  547. bStyleHorz = HORZF(m_dwStyle);
  548. bStyleHorz = m_bFlip ? !bStyleHorz : bStyleHorz;
  550. if (bStyleHorz && HORZF(m_dwDockStyle))
  551. dwDock = CanDock(m_rectDragHorz,
  552.   m_dwDockStyle & ~CBRS_ORIENT_VERT);
  553. else if (VERTF(m_dwDockStyle))
  554. dwDock = CanDock(m_rectDragVert,
  555.   m_dwDockStyle & ~CBRS_ORIENT_HORZ);
  557. if (!m_bFlip)
  558. {
  559. if (dwDock == 0 && HORZF(m_dwDockStyle))
  560. {
  561. dwCurr = CanDock(m_rectDragVert,
  562.   m_dwDockStyle & ~CBRS_ORIENT_VERT);
  563. dwDock = CanDock(m_rectDragHorz,
  564.   m_dwDockStyle & ~CBRS_ORIENT_VERT);
  565. dwDock = (dwDock == dwCurr) ? dwDock : 0;
  566. }
  567. if (dwDock == 0 && VERTF(m_dwDockStyle))
  568. {
  569. dwCurr = CanDock(m_rectDragHorz,
  570.   m_dwDockStyle & ~CBRS_ORIENT_HORZ);
  571. dwDock = CanDock(m_rectDragVert,
  572.   m_dwDockStyle & ~CBRS_ORIENT_HORZ);
  573. dwDock = (dwDock == dwCurr) ? dwDock : 0;
  574. }
  575. }
  577. return dwDock;
  578. }
  581. DWORD CGuiDockContext::CanDock(CRect rect, DWORD dwDockStyle, CDockBar** ppDockBar)
  582. {
  583. // dwDockStyle -- allowable styles of bar
  584. // don't allow to dock to floating unless multi is specified
  585. BOOL bTipoToolBar=m_pBar->IsKindOf(RUNTIME_CLASS( CGuiToolBarWnd)) ||
  586.               m_pBar->IsKindOf(RUNTIME_CLASS( CMenuBar));
  587. dwDockStyle &= CBRS_ALIGN_ANY|CBRS_FLOAT_MULTI;
  588. if (ppDockBar != NULL)
  589. *ppDockBar = NULL;
  590. POSITION pos = m_pDockSite->m_listControlBars.GetHeadPosition();
  591. while (pos != NULL)
  592. {
  593. CDockBar* pDockBar = (CDockBar*)m_pDockSite->m_listControlBars.GetNext(pos);
  594. if (pDockBar->IsDockBar() && pDockBar->IsWindowVisible() &&
  595. (pDockBar->m_dwStyle & dwDockStyle & CBRS_ALIGN_ANY) &&
  596. (!pDockBar->m_bFloating ||
  597. (dwDockStyle & pDockBar->m_dwStyle & CBRS_FLOAT_MULTI)))
  598. {
  600. int nSize=pDockBar->m_arrBars.GetSize();
  601. for (int i=0;i <nSize;  i++)
  602. {
  603. UINT m_nDockBarID = pDockBar->GetDlgCtrlID();
  604. CControlBar* pBar;
  605.  pBar = (CControlBar*) pDockBar->m_arrBars[i];
  606.  if (HIWORD(pBar) == 0) continue; // placeholder
  607.  if (!pBar->IsVisible()) continue;
  608.  CRect rectBar;
  609.  pBar->GetWindowRect(&rectBar);
  610.  if (rectBar.Width() == 0)
  611. rectBar.right++;
  612.  if (rectBar.Height() == 0)
  613. rectBar.bottom++;
  614.  CRect rectBar1;
  615.  pDockBar->GetWindowRect(&rectBar1);
  616.  if (dwDockStyle==CBRS_ORIENT_VERT)
  617.  {
  618.  if (m_nDockBarID==AFX_IDW_DOCKBAR_LEFT)
  619.   rectBar1.right=rectBar1.left+10;
  620.  if(m_nDockBarID==AFX_IDW_DOCKBAR_RIGHT)
  621.  rectBar1.left=rectBar1.right-10;
  622.  }
  623.  else
  624.  {
  626. if (m_nDockBarID==AFX_IDW_DOCKBAR_BOTTOM)
  627. rectBar1.top=rectBar1.bottom-10;
  628. if (m_nDockBarID==AFX_IDW_DOCKBAR_TOP)
  629. rectBar1.bottom=rectBar1.top+10;
  631.  }
  632.  if (rectBar1.IntersectRect(rectBar1, rect))
  633.  {
  634. if (ppDockBar != NULL)
  636. *ppDockBar = pDockBar;
  638. return pDockBar->m_dwStyle & dwDockStyle;
  639.  }
  642. //***********************************************
  643. if (rectBar.IntersectRect(rectBar, rect))
  644. {
  645. if (bTipoToolBar)
  646. {
  647. if (pBar->IsKindOf(RUNTIME_CLASS( CGuiControlBar)))
  648. return 0;
  649. }
  650. if (ppDockBar != NULL)
  651. *ppDockBar = pDockBar;
  652. return pDockBar->m_dwStyle & dwDockStyle;
  654.  
  656. }
  657.  
  658. }//fin del for
  661. CRect rectBar;
  662. pDockBar->GetWindowRect(&rectBar);
  663. if (rectBar.Width() == 0)
  664. rectBar.right++;
  665. if (rectBar.Height() == 0)
  666. rectBar.bottom++;
  667. if (rectBar.IntersectRect(rectBar, rect))
  668. {
  669. if (ppDockBar != NULL)
  670. *ppDockBar = pDockBar;
  671. return pDockBar->m_dwStyle & dwDockStyle;
  672. }
  673. }
  674. }
  675. return 0;
  676. }
  678. //*********************************************
  679. // return 0 no acepta el docking
  680. //        1 lo acepta
  681. //        2 continue
  682. int  CGuiDockContext::VerLeft(int i,int nSize,CDockBar* pDockBar,CControlBar* pBar)
  683. {
  684. BOOL bTipoToolBar=m_pBar->IsKindOf(RUNTIME_CLASS( CGuiToolBarWnd));
  685. //i--;
  686. if (i+1 < nSize)
  687. {
  688. CControlBar* pBartemp;
  689.   pBartemp = (CControlBar*) pDockBar->m_arrBars[i+1];
  690. if (HIWORD(pBartemp) == 0) return 2; // placeholder
  691. if (!pBartemp->IsVisible()) return 2;
  692. if (bTipoToolBar)
  693. if (!pBartemp->IsKindOf(RUNTIME_CLASS( CGuiToolBarWnd)))
  694. return 0;
  695. }
  696. if (i > 0)
  697. {
  698. CControlBar* pBartemp;
  699. pBartemp = (CControlBar*) pDockBar->m_arrBars[i-1];
  700. if (HIWORD(pBartemp) == 0) return 2; // placeholder
  701. if (!pBartemp->IsVisible()) return 2;
  702. if (bTipoToolBar)
  703. if (!pBartemp->IsKindOf(RUNTIME_CLASS( CGuiToolBarWnd)))
  704. return 0;
  705. }
  707. return 1;
  709. }
  711. //*********************************************
  712. // return 0 no acepta el docking
  713. //        1 lo acepta
  714. //        2 continue
  716. int  CGuiDockContext::VerRight(int i,int nSize,CDockBar* pDockBar,CControlBar* pBar)
  718. {
  719. BOOL bTipoToolBar=m_pBar->IsKindOf(RUNTIME_CLASS( CGuiToolBarWnd));
  720. //i--;
  721. if (i==0)
  722. {
  723. CControlBar* pBartemp;
  724. pBartemp = (CControlBar*) pDockBar->m_arrBars[i+1];
  725. if (HIWORD(pBartemp) == 0) return 2; // placeholder
  726. if (!pBartemp->IsVisible()) return 2;
  727. if (bTipoToolBar)
  728. if (!pBartemp->IsKindOf(RUNTIME_CLASS( CGuiToolBarWnd)))
  729. return 0;
  730. }
  731. if (i > 0)
  732. {
  733. CControlBar* pBartemp;
  734. pBartemp = (CControlBar*) pDockBar->m_arrBars[i-1];
  735. if (HIWORD(pBartemp) == 0) return 2; // placeholder
  736. if (!pBartemp->IsVisible()) return 2;
  737. if (bTipoToolBar)
  738. if (!pBartemp->IsKindOf(RUNTIME_CLASS( CGuiToolBarWnd)))
  739. return 0;
  741. }
  742. return 1;
  743. }
  745. CDockBar* CGuiDockContext::GetDockBar(DWORD dwOverDockStyle)
  746. {
  747. DWORD dw = 0;
  748. CDockBar* pBar;
  749. if (HORZF(dwOverDockStyle))
  750. {
  751. dw = CanDock(m_rectDragHorz,
  752. dwOverDockStyle & ~CBRS_ORIENT_VERT, &pBar);
  753. ASSERT(dw != 0);
  754. ASSERT(pBar != NULL);
  755. return pBar;
  756. }
  757. if (VERTF(dwOverDockStyle))
  758. {
  759. dw =CanDock(m_rectDragVert,
  760. dwOverDockStyle & ~CBRS_ORIENT_HORZ, &pBar);
  761. ASSERT(dw != 0);
  762. ASSERT(pBar != NULL);
  763. return pBar;
  764. }
  765. return NULL;
  766. }
  768. BOOL CGuiDockContext::Track()
  769. {
  770. // don't handle if capture already set
  771. if (::GetCapture() != NULL)
  772. return FALSE;
  774. // set capture to the window which received this message
  775. m_pBar->SetCapture();
  776. ASSERT(m_pBar == CWnd::GetCapture());
  778. // get messages until capture lost or cancelled/accepted
  779. while (CWnd::GetCapture() == m_pBar)
  780. {
  781. MSG msg;
  782. if (!::GetMessage(&msg, NULL, 0, 0))
  783. {
  784. AfxPostQuitMessage(msg.wParam);
  785. break;
  786. }
  788. switch (msg.message)
  789. {
  790. case WM_LBUTTONUP:
  791. if (m_bDragging)
  792. EndDrag();
  793. else
  794. EndResize();
  795. return TRUE;
  796. case WM_MOUSEMOVE:
  797. if (m_bDragging)
  798. Move(msg.pt);
  799. else
  800. Stretch(msg.pt);
  801. break;
  802. case WM_KEYUP:
  803. if (m_bDragging)
  804. OnKey((int)msg.wParam, FALSE);
  805. break;
  806. case WM_KEYDOWN:
  807. if (m_bDragging)
  808. OnKey((int)msg.wParam, TRUE);
  809. if (msg.wParam == VK_ESCAPE)
  810. {
  811. CancelLoop();
  812. return FALSE;
  813. }
  814. break;
  815. case WM_RBUTTONDOWN:
  816. CancelLoop();
  817. return FALSE;
  819. // just dispatch rest of the messages
  820. default:
  821. DispatchMessage(&msg);
  822. break;
  823. }
  824. }
  826. CancelLoop();
  828. return FALSE;
  829. }