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

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

对话框与窗口

开发平台：

Visual C++

GuiDockContext.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.  ****************************************************************************/
  23. #include "stdafx.h"
  24. #include "GuiDockContext.h"
  25. #include "GuiDocBarExten.h"
  26. #include "GuiDocBarExtenEx.h"
  27. #include "GuiToolBarWnd.h"
  28. #include "MenuBar.h"
  29. #include "GuiControlBar.h"
  31. #define _AfxGetDlgCtrlID(hWnd)          ((UINT)(WORD)::GetDlgCtrlID(hWnd))
  33. #ifdef AFX_CORE3_SEG
  34. #pragma code_seg(AFX_CORE3_SEG)
  35. #endif
  37. #ifdef _DEBUG
  38. #undef THIS_FILE
  39. static char THIS_FILE[] = __FILE__;
  40. #define new DEBUG_NEW
  41. #endif
  43. #define HORZF(dw) (dw & CBRS_ORIENT_HORZ)
  44. #define VERTF(dw) (dw & CBRS_ORIENT_VERT)
  46. #define CX_BORDER   1
  47. #define CY_BORDER   1
  49. AFX_STATIC void AFXAPI _AfxAdjustRectangle(CRect& rect, CPoint pt)
  50. {
  51. int nXOffset = (pt.x < rect.left) ? (pt.x - rect.left) :
  52. (pt.x > rect.right) ? (pt.x - rect.right) : 0;
  53. int nYOffset = (pt.y < rect.top) ? (pt.y - rect.top) :
  54. (pt.y > rect.bottom) ? (pt.y - rect.bottom) : 0;
  55. rect.OffsetRect(nXOffset, nYOffset);
  56. }
  58. /////////////////////////////////////////////////////////////////////////////
  59. // CGuiDockContext
  61. CGuiDockContext::CGuiDockContext(CControlBar* pBar):CDockContext(pBar)
  62. {
  63. bFirstClic=TRUE;
  64. bSecondClic=TRUE;
  65. }
  67. CGuiDockContext::~CGuiDockContext()
  68. {
  69. }
  71. /////////////////////////////////////////////////////////////////////////////
  72. // CGuiDockContext Drag Operations
  74. void CGuiDockContext::StartDrag(CPoint pt)
  75. {
  76. ASSERT_VALID(m_pBar);
  77. m_bDragging = TRUE;
  79. InitLoop();
  81. // GetWindowRect returns screen coordinates(not mirrored),
  82. // so if the desktop is mirrored then turn off mirroring
  83. // for the desktop dc so that we get correct focus rect drawn.
  84. // This layout change should be remembered, just in case ...
  86. // if (m_pDC->GetLayout() & LAYOUT_RTL)
  87. // m_pDC->SetLayout(LAYOUT_LTR);
  89. if (m_pBar->m_dwStyle & CBRS_SIZE_DYNAMIC)
  90. {
  91. // get true bar size (including borders)
  92. CRect rect;
  93. m_pBar->GetWindowRect(rect);
  94. m_ptLast = pt;
  95. CSize sizeHorz = m_pBar->CalcDynamicLayout(0, LM_HORZ | LM_HORZDOCK);
  96. CSize sizeVert = m_pBar->CalcDynamicLayout(0, LM_VERTDOCK);
  97. CSize sizeFloat = m_pBar->CalcDynamicLayout(0, LM_HORZ | LM_MRUWIDTH);
  99. m_rectDragHorz = CRect(rect.TopLeft(), sizeHorz);
  100. m_rectDragVert = CRect(rect.TopLeft(), sizeVert);
  102. // calculate frame dragging rectangle
  103. m_rectFrameDragHorz = CRect(rect.TopLeft(), sizeFloat);
  104. m_rectFrameDragVert = CRect(rect.TopLeft(), sizeFloat);
  106. CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz);
  107. CMiniFrameWnd::CalcBorders(&m_rectFrameDragVert);
  109. // m_rectFrameDragHorz.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2);
  110. // m_rectFrameDragVert.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2);
  111. }
  112. else if (m_pBar->m_dwStyle & CBRS_SIZE_FIXED)
  113. {
  114. // get true bar size (including borders)
  115. CRect rect;
  116. m_pBar->GetWindowRect(rect);
  117. m_ptLast = pt;
  118. CSize sizeHorz = m_pBar->CalcDynamicLayout(-1, LM_HORZ | LM_HORZDOCK);
  119. CSize sizeVert = m_pBar->CalcDynamicLayout(-1, LM_VERTDOCK);
  121. // calculate frame dragging rectangle
  122. m_rectFrameDragHorz = m_rectDragHorz = CRect(rect.TopLeft(), sizeHorz);
  123. m_rectFrameDragVert = m_rectDragVert = CRect(rect.TopLeft(), sizeVert);
  125. CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz);
  126. CMiniFrameWnd::CalcBorders(&m_rectFrameDragVert);
  127. // m_rectFrameDragHorz.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2);
  128. // m_rectFrameDragVert.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2);
  129. }
  130. else
  131. {
  132. // get true bar size (including borders)
  133. CRect rect;
  134. m_pBar->GetWindowRect(rect);
  135. m_ptLast = pt;
  136. BOOL bHorz = HORZF(m_dwStyle);
  137. DWORD dwMode = !bHorz ? (LM_HORZ | LM_HORZDOCK) : LM_VERTDOCK;
  138. CSize size = m_pBar->CalcDynamicLayout(-1, dwMode);
  140. // calculate inverted dragging rect
  141. if (bHorz)
  142. {
  143. m_rectDragHorz = rect;
  144. m_rectDragVert = CRect(CPoint(pt.x - rect.Height()/2, rect.top), size);
  145. }
  146. else // vertical orientation
  147. {
  148. m_rectDragVert = rect;
  149. m_rectDragHorz = CRect(CPoint(rect.left, pt.y - rect.Width()/2), size);
  150. }
  152. // calculate frame dragging rectangle
  153. m_rectFrameDragHorz = m_rectDragHorz;
  154. m_rectFrameDragVert = m_rectDragVert;
  156. CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz);
  157. CMiniFrameWnd::CalcBorders(&m_rectFrameDragVert);
  158. // m_rectFrameDragHorz.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2);
  159. // m_rectFrameDragVert.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2);
  160. }
  162. // adjust rectangles so that point is inside
  163. _AfxAdjustRectangle(m_rectDragHorz, pt);
  164. _AfxAdjustRectangle(m_rectDragVert, pt);
  165. _AfxAdjustRectangle(m_rectFrameDragHorz, pt);
  166. _AfxAdjustRectangle(m_rectFrameDragVert, pt);
  168. // initialize tracking state and enter tracking loop
  169. m_dwOverDockStyle = CanDock();
  170. Move(pt);   // call it here to handle special keys
  171. m_pDockSite->RecalcLayout();
  172. Track();
  173. m_pDockSite->RecalcLayout();
  174. }
  176. void CGuiDockContext::Move(CPoint pt)
  177. {
  178. CPoint ptOffset = pt - m_ptLast;
  180. // offset all drag rects to new position
  181. m_rectDragHorz.OffsetRect(ptOffset);
  182. m_rectFrameDragHorz.OffsetRect(ptOffset);
  183. m_rectDragVert.OffsetRect(ptOffset);
  184. m_rectFrameDragVert.OffsetRect(ptOffset);
  185. m_ptLast = pt;
  187. // if control key is down don't dock
  188. m_dwOverDockStyle = m_bForceFrame ? 0 : CanDock();
  191. // update feedback
  193. DrawFocusRect();
  194. }
  196. void CGuiDockContext::OnKey(int nChar, BOOL bDown)
  197. {
  198. if (nChar == VK_CONTROL)
  199. UpdateState(&m_bForceFrame, bDown);
  200. if (nChar == VK_SHIFT)
  201. UpdateState(&m_bFlip, bDown);
  202. }
  204. #define AFX_IDW_DOCKBAR_TOP             0xE81B
  205. #define AFX_IDW_DOCKBAR_LEFT            0xE81C
  206. #define AFX_IDW_DOCKBAR_RIGHT           0xE81D
  207. #define AFX_IDW_DOCKBAR_BOTTOM          0xE81E
  208. #define AFX_IDW_DOCKBAR_FLOAT           0xE81F
  210. void CGuiDockContext::EndDrag()
  211. {
  212. CancelLoop();
  214. if (m_dwOverDockStyle != 0)
  215. {
  216. CDockBar* pDockBar = GetDockBar(m_dwOverDockStyle);
  217. ASSERT(pDockBar != NULL);
  219. CRect rect = (m_dwOverDockStyle & CBRS_ORIENT_VERT) ?
  220. m_rectDragVert : m_rectDragHorz;
  222. UINT uID = _AfxGetDlgCtrlID(pDockBar->m_hWnd);
  223. m_uMRUDockID = uID;
  224. m_rectMRUDockPos = rect;
  225. pDockBar->ScreenToClient(&m_rectMRUDockPos);
  226. m_pDockSite->DockControlBar(m_pBar, pDockBar, &rect);
  227. m_pDockSite->RecalcLayout();
  229. }
  230. else if ((m_dwStyle & CBRS_SIZE_DYNAMIC) || (HORZF(m_dwStyle) && !m_bFlip) ||
  231. (VERTF(m_dwStyle) && m_bFlip))
  232. {
  233. m_dwMRUFloatStyle = CBRS_ALIGN_TOP | (m_dwDockStyle & CBRS_FLOAT_MULTI);
  234. m_ptMRUFloatPos = m_rectFrameDragHorz.TopLeft();
  235. m_pDockSite->FloatControlBar(m_pBar, m_ptMRUFloatPos, m_dwMRUFloatStyle);
  236. }
  237. else // vertical float
  238. {
  239. m_dwMRUFloatStyle = CBRS_ALIGN_LEFT | (m_dwDockStyle & CBRS_FLOAT_MULTI);
  240. m_ptMRUFloatPos = m_rectFrameDragVert.TopLeft();
  241. m_pDockSite->FloatControlBar(m_pBar, m_ptMRUFloatPos, m_dwMRUFloatStyle);
  242. }
  243. bFirstClic=TRUE;
  244. bSecondClic=TRUE;
  246. }
  248. /////////////////////////////////////////////////////////////////////////////
  249. // CGuiDockContext Resize Operations
  251. #define m_rectRequestedSize     m_rectDragHorz
  252. #define m_rectActualSize        m_rectDragVert
  253. #define m_rectActualFrameSize   m_rectFrameDragHorz
  254. #define m_rectFrameBorders      m_rectFrameDragVert
  256. void CGuiDockContext::StartResize(int nHitTest, CPoint pt)
  257. {
  258. ASSERT_VALID(m_pBar);
  259. ASSERT(m_pBar->m_dwStyle & CBRS_SIZE_DYNAMIC);
  260. m_bDragging = FALSE;
  262. InitLoop();
  264. // GetWindowRect returns screen coordinates(not mirrored)
  265. // So if the desktop is mirrored then turn off mirroring
  266. // for the desktop dc so that we draw correct focus rect
  268. // if (m_pDC->GetLayout() & LAYOUT_RTL)
  269. // m_pDC->SetLayout(LAYOUT_LTR);
  271. // get true bar size (including borders)
  272. CRect rect;
  273. m_pBar->GetWindowRect(rect);
  274. m_ptLast = pt;
  275. m_nHitTest = nHitTest;
  277. CSize size = m_pBar->CalcDynamicLayout(0, LM_HORZ | LM_MRUWIDTH);
  278. m_rectRequestedSize = CRect(rect.TopLeft(), size);
  279. m_rectActualSize = CRect(rect.TopLeft(), size);
  280. m_rectActualFrameSize = CRect(rect.TopLeft(), size);
  282. // calculate frame rectangle
  283. CMiniFrameWnd::CalcBorders(&m_rectActualFrameSize);
  284. // m_rectActualFrameSize.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2);
  286. m_rectFrameBorders = CRect(CPoint(0,0),
  287. m_rectActualFrameSize.Size() - m_rectActualSize.Size());
  289. // initialize tracking state and enter tracking loop
  290. m_dwOverDockStyle = 0;
  291. Stretch(pt);   // call it here to handle special keys
  292. Track();
  293. }
  295. void CGuiDockContext::Stretch(CPoint pt)
  296. {
  297. CPoint ptOffset = pt - m_ptLast;
  299. // offset all drag rects to new position
  300. int nLength = 0;
  301. DWORD dwMode = LM_HORZ;
  302. if (m_nHitTest == HTLEFT || m_nHitTest == HTRIGHT)
  303. {
  304. if (m_nHitTest == HTLEFT)
  305. m_rectRequestedSize.left += ptOffset.x;
  306. else
  307. m_rectRequestedSize.right += ptOffset.x;
  308. nLength = m_rectRequestedSize.Width();
  309. }
  310. else
  311. {
  312. dwMode |= LM_LENGTHY;
  313. if (m_nHitTest == HTTOP)
  314. m_rectRequestedSize.top += ptOffset.y;
  315. else
  316. m_rectRequestedSize.bottom += ptOffset.y;
  317. nLength = m_rectRequestedSize.Height();
  318. }
  319. nLength = (nLength >= 0) ? nLength : 0;
  321. CSize size = m_pBar->CalcDynamicLayout(nLength, dwMode);
  323. CRect rectDesk;
  324. HWND hWndDesk = ::GetDesktopWindow();
  325. ::GetWindowRect(hWndDesk, &rectDesk);
  326. CRect rectTemp = m_rectActualFrameSize;
  328. if (m_nHitTest == HTLEFT || m_nHitTest == HTTOP)
  329. {
  330. rectTemp.left = rectTemp.right -
  331. (size.cx + m_rectFrameBorders.Width());
  332. rectTemp.top = rectTemp.bottom -
  333. (size.cy + m_rectFrameBorders.Height());
  334. CRect rect;
  335. if (rect.IntersectRect(rectDesk, rectTemp))
  336. {
  337. m_rectActualSize.left = m_rectActualSize.right - size.cx;
  338. m_rectActualSize.top = m_rectActualSize.bottom - size.cy;
  339. m_rectActualFrameSize.left = rectTemp.left;
  340. m_rectActualFrameSize.top = rectTemp.top;
  341. }
  342. }
  343. else
  344. {
  345. rectTemp.right = rectTemp.left +
  346. (size.cx + m_rectFrameBorders.Width());
  347. rectTemp.bottom = rectTemp.top +
  348. (size.cy + m_rectFrameBorders.Height());
  349. CRect rect;
  350. if (rect.IntersectRect(rectDesk, rectTemp))
  351. {
  352. m_rectActualSize.right = m_rectActualSize.left + size.cx;
  353. m_rectActualSize.bottom = m_rectActualSize.top + size.cy;
  354. m_rectActualFrameSize.right = rectTemp.right;
  355. m_rectActualFrameSize.bottom = rectTemp.bottom;
  356. }
  357. }
  358. m_ptLast = pt;
  360. // update feedback
  361. DrawFocusRect();
  362. }
  364. void CGuiDockContext::EndResize()
  365. {
  366. CancelLoop();
  368. m_pBar->CalcDynamicLayout(m_rectActualSize.Width(), LM_HORZ | LM_COMMIT);
  369. m_pDockSite->FloatControlBar(m_pBar, m_rectActualFrameSize.TopLeft(),
  370. CBRS_ALIGN_TOP | (m_dwDockStyle & CBRS_FLOAT_MULTI) | CBRS_SIZE_DYNAMIC);
  371. }
  373. /////////////////////////////////////////////////////////////////////////////
  374. // CGuiDockContext Double Click Operations
  376. void CGuiDockContext::ToggleDocking()
  377. {
  378. if (m_pBar->IsFloating())
  379. {
  380. // Dock it only if is allowed to be docked
  381. if (m_pBar->m_dwDockStyle & CBRS_ALIGN_ANY)
  382. {
  383. //ASSERT((m_uMRUDockID >= AFX_IDW_DOCKBAR_TOP &&
  384. // m_uMRUDockID <= AFX_IDW_DOCKBAR_BOTTOM) ||
  385. // m_uMRUDockID == 0);
  387. CRect rect = m_rectMRUDockPos;
  388. CDockBar* pDockBar = NULL;
  389. if (m_uMRUDockID != 0)
  390. {
  391. pDockBar = (CDockBar*)m_pDockSite->GetControlBar(m_uMRUDockID);
  392. pDockBar->ClientToScreen(&rect);
  393. }
  395. // dock it at the specified position, RecalcLayout will snap
  396. m_pDockSite->ReDockControlBar(m_pBar, pDockBar, &rect);
  397. m_pDockSite->RecalcLayout();
  398. }
  399. }
  400. else
  401. {
  402. CPoint ptFloat = m_ptMRUFloatPos;
  403. if (ptFloat.x < 0 || ptFloat.y < 0)
  404. {
  405. ptFloat = m_rectMRUDockPos.TopLeft();
  406. m_pBar->GetParent()->ClientToScreen(&ptFloat);
  407. }
  408. m_pDockSite->FloatControlBar(m_pBar, ptFloat, m_dwMRUFloatStyle);
  409. }
  410. }
  412. /////////////////////////////////////////////////////////////////////////////
  413. // CGuiDockContext Operations
  415. void CGuiDockContext::InitLoop()
  416. {
  417. // handle pending WM_PAINT messages
  418. MSG msg;
  419. while (::PeekMessage(&msg, NULL, WM_PAINT, WM_PAINT, PM_NOREMOVE))
  420. {
  421. if (!GetMessage(&msg, NULL, WM_PAINT, WM_PAINT))
  422. return;
  423. DispatchMessage(&msg);
  424. }
  426. // get styles from bar
  427. m_dwDockStyle = m_pBar->m_dwDockStyle;
  428. m_dwStyle = m_pBar->m_dwStyle & CBRS_ALIGN_ANY;
  429. ASSERT(m_dwStyle != 0);
  431. // initialize state
  432. m_rectLast.SetRectEmpty();
  433. m_sizeLast.cx = m_sizeLast.cy = 0;
  434. m_bForceFrame = m_bFlip = m_bDitherLast = FALSE;
  436. // lock window update while dragging
  437. ASSERT(m_pDC == NULL);
  438. CWnd* pWnd = CWnd::GetDesktopWindow();
  439. if (pWnd->LockWindowUpdate())
  440. m_pDC = pWnd->GetDCEx(NULL, DCX_WINDOW|DCX_CACHE|DCX_LOCKWINDOWUPDATE);
  441. else
  442. m_pDC = pWnd->GetDCEx(NULL, DCX_WINDOW|DCX_CACHE);
  443. ASSERT(m_pDC != NULL);
  444. }
  446. void CGuiDockContext::CancelLoop()
  447. {
  448. DrawFocusRect(TRUE);    // gets rid of focus rect
  449. ReleaseCapture();
  451. CWnd* pWnd = CWnd::GetDesktopWindow();
  452. pWnd->UnlockWindowUpdate();
  453. if (m_pDC != NULL)
  454. {
  455. pWnd->ReleaseDC(m_pDC);
  456. m_pDC = NULL;
  457. }
  458. }
  460. /////////////////////////////////////////////////////////////////////////////
  461. // Implementation
  463. void CGuiDockContext::DrawFocusRect(BOOL bRemoveRect)
  464. {
  465. ASSERT(m_pDC != NULL);
  467. // default to thin frame
  468. CSize size(CX_BORDER, CY_BORDER);
  470. // determine new rect and size
  471. CRect rect;
  472. CBrush* pWhiteBrush = CBrush::FromHandle((HBRUSH)::GetStockObject(WHITE_BRUSH));
  473. CBrush* pDitherBrush = CDC::GetHalftoneBrush();
  474. CBrush* pBrush = pWhiteBrush;
  475. CBrush cb;
  476. size.cx = GetSystemMetrics(SM_CXFRAME) - CX_BORDER;
  477. size.cy = GetSystemMetrics(SM_CYFRAME) - CY_BORDER;
  478. pBrush = pDitherBrush;
  479. if (HORZF(m_dwOverDockStyle))
  480. rect = m_rectDragHorz;
  481. else if (VERTF(m_dwOverDockStyle))
  482. rect = m_rectDragVert;
  483. else
  484. {
  485. // use thick frame instead
  487. if ((HORZF(m_dwStyle) && !m_bFlip) || (VERTF(m_dwStyle) && m_bFlip))
  488. rect = m_rectFrameDragHorz;
  489. else
  490. rect = m_rectFrameDragVert;
  492. }
  493. if (bRemoveRect)
  494. size.cx = size.cy = 0;
  496. /* if (afxData.bWin4 &&
  497. (HORZF(m_dwOverDockStyle) || VERTF(m_dwOverDockStyle)))
  498. {
  499. // looks better one pixel in (makes the bar look pushed down)
  500. rect.InflateRect(-CX_BORDER, -CY_BORDER);
  501. }
  502. */
  503. // draw it and remember last size
  504. //rect.DeflateRect(2,2);
  506. if (bFirstClic==TRUE)
  507. {
  508. bFirstClic=FALSE;
  509. }
  510. else{
  511. if (bSecondClic==TRUE)
  512. {
  513.   m_pDC->DrawDragRect(&rect, size, &m_rectLast, m_sizeLast,
  514. pBrush, m_bDitherLast ? pDitherBrush : pWhiteBrush);
  515.   m_bDitherLast = (pBrush == pDitherBrush);
  516.    m_pDC->DrawDragRect(&rect, size, &m_rectLast, m_sizeLast,
  517. pBrush, m_bDitherLast ? pDitherBrush : pWhiteBrush);
  518.   bSecondClic=FALSE;
  519. }
  520. else
  521. {
  522. m_pDC->DrawDragRect(&rect, size, &m_rectLast, m_sizeLast,
  523. pBrush, m_bDitherLast ? pDitherBrush : pWhiteBrush);
  524. m_rectLast = rect;
  525. m_sizeLast = size;
  526. m_bDitherLast = (pBrush == pDitherBrush);
  527. }
  528. }
  529. m_pBar->ShowWindow(SW_SHOW);
  531. //m_pDC->DrawDragRect(&rect, size, &m_rectLast, m_sizeLast/*,
  532. // pBrush, m_bDitherLast ? pDitherBrush : pWhiteBrush*/);
  533. /* m_rectLast = rect;
  534. m_sizeLast = size;
  535. m_bDitherLast = (pBrush == pDitherBrush);*/
  536. }
  538. void CGuiDockContext::UpdateState(BOOL* pFlag, BOOL bNewValue)
  539. {
  540. if (*pFlag != bNewValue)
  541. {
  542. *pFlag = bNewValue;
  543. m_bFlip = (HORZF(m_dwDockStyle) && VERTF(m_dwDockStyle) && m_bFlip); // shift key
  544. m_dwOverDockStyle = (m_bForceFrame) ? 0 : CanDock();
  545. DrawFocusRect();
  546. }
  547. }
  549. DWORD CGuiDockContext::CanDock()
  550. {
  551. BOOL bStyleHorz;
  552. DWORD dwDock = 0; // Dock Canidate
  553. DWORD dwCurr = 0; // Current Orientation
  555. // let's check for something in our current orientation first
  556. // then if the shift key is not forcing our orientation then
  557. // check for horizontal or vertical orientations as long
  558. // as we are close enough
  559. ASSERT(m_dwStyle != 0);
  561. bStyleHorz = HORZF(m_dwStyle);
  562. bStyleHorz = m_bFlip ? !bStyleHorz : bStyleHorz;
  564. if (bStyleHorz && HORZF(m_dwDockStyle))
  565. dwDock = CanDock(m_rectDragHorz,
  566.   m_dwDockStyle & ~CBRS_ORIENT_VERT);
  567. else if (VERTF(m_dwDockStyle))
  568. dwDock = CanDock(m_rectDragVert,
  569.   m_dwDockStyle & ~CBRS_ORIENT_HORZ);
  571. if (!m_bFlip)
  572. {
  573. if (dwDock == 0 && HORZF(m_dwDockStyle))
  574. {
  575. dwCurr = CanDock(m_rectDragVert,
  576.   m_dwDockStyle & ~CBRS_ORIENT_VERT);
  577. dwDock = CanDock(m_rectDragHorz,
  578.   m_dwDockStyle & ~CBRS_ORIENT_VERT);
  579. dwDock = (dwDock == dwCurr) ? dwDock : 0;
  580. }
  581. if (dwDock == 0 && VERTF(m_dwDockStyle))
  582. {
  583. dwCurr = CanDock(m_rectDragHorz,
  584.   m_dwDockStyle & ~CBRS_ORIENT_HORZ);
  585. dwDock = CanDock(m_rectDragVert,
  586.   m_dwDockStyle & ~CBRS_ORIENT_HORZ);
  587. dwDock = (dwDock == dwCurr) ? dwDock : 0;
  588. }
  589. }
  591. return dwDock;
  592. }
  594. DWORD CGuiDockContext::CanDock(CRect rect, DWORD dwDockStyle, CDockBar** ppDockBar)
  595. {
  596. // dwDockStyle -- allowable styles of bar
  597. // don't allow to dock to floating unless multi is specified
  598. BOOL bTipoToolBar=m_pBar->IsKindOf(RUNTIME_CLASS( CGuiToolBarWnd)) ||
  599.               m_pBar->IsKindOf(RUNTIME_CLASS( CMenuBar));
  600. dwDockStyle &= CBRS_ALIGN_ANY|CBRS_FLOAT_MULTI;
  601. if (ppDockBar != NULL)
  602. *ppDockBar = NULL;
  603. POSITION pos = m_pDockSite->m_listControlBars.GetHeadPosition();
  604. while (pos != NULL)
  605. {
  606. CDockBar* pDockBar = (CDockBar*)m_pDockSite->m_listControlBars.GetNext(pos);
  607. if (pDockBar->IsDockBar() && pDockBar->IsWindowVisible() &&
  608. (pDockBar->m_dwStyle & dwDockStyle & CBRS_ALIGN_ANY) &&
  609. (!pDockBar->m_bFloating ||
  610. (dwDockStyle & pDockBar->m_dwStyle & CBRS_FLOAT_MULTI)))
  611. {
  613. int nSize=pDockBar->m_arrBars.GetSize();
  614. for (int i=0;i <nSize;  i++)
  615. {
  616. UINT m_nDockBarID = pDockBar->GetDlgCtrlID();
  617. CControlBar* pBar;
  618.  pBar = (CControlBar*) pDockBar->m_arrBars[i];
  619.  if (HIWORD(pBar) == 0) continue; // placeholder
  620.  if (!pBar->IsVisible()) continue;
  621.  CRect rectBar;
  622.  pBar->GetWindowRect(&rectBar);
  625. if (pDockBar->IsKindOf(RUNTIME_CLASS(CGuiDocBarExten)) && pBar->IsKindOf(RUNTIME_CLASS( CMenuBar)))
  626. {
  627. return 0;
  629. }
  631.  if (pDockBar->IsKindOf(RUNTIME_CLASS(CGuiDocBarExtenEx)) && pBar->IsKindOf(RUNTIME_CLASS( CGuiControlBar)))
  632. {
  633. return 0;
  635. }
  637. if (pDockBar->IsKindOf(RUNTIME_CLASS(CGuiDocBarExten)) && pBar->IsKindOf(RUNTIME_CLASS( CGuiToolBarWnd)))
  638. {
  639. return 0;
  641. }
  643. //***********************************************
  644. if (rectBar.IntersectRect(rectBar, rect))
  645. {
  646. if (bTipoToolBar)
  647. {
  648. if (pBar->IsKindOf(RUNTIME_CLASS( CGuiControlBar)))
  649. return 0;
  650. }
  651. if (ppDockBar != NULL)
  652. *ppDockBar = pDockBar;
  653. return pDockBar->m_dwStyle & dwDockStyle;
  655. }
  656.  
  657. }//fin del for
  660. CRect rectBar;
  661. pDockBar->GetWindowRect(&rectBar);
  662. if (rectBar.Width() == 0)
  663. rectBar.right++;
  664. if (rectBar.Height() == 0)
  665. rectBar.bottom++;
  666. if (rectBar.IntersectRect(rectBar, rect)  )
  667. {
  669. if (pDockBar->IsKindOf(RUNTIME_CLASS(CGuiDocBarExten)) && m_pBar->IsKindOf(RUNTIME_CLASS( CMenuBar)))
  670. {
  671. return 0;
  673. }
  674. if (pDockBar->IsKindOf(RUNTIME_CLASS(CGuiDocBarExtenEx)) && m_pBar->IsKindOf(RUNTIME_CLASS( CGuiControlBar)))
  675. {
  676. return 0;
  678. }
  680. if (pDockBar->IsKindOf(RUNTIME_CLASS(CGuiDocBarExten)) && m_pBar->IsKindOf(RUNTIME_CLASS( CGuiToolBarWnd)))
  681. {
  682. return 0;
  684. }
  685. if (ppDockBar != NULL)
  686. *ppDockBar = pDockBar;
  687. return pDockBar->m_dwStyle & dwDockStyle;
  688. }
  689. }
  690. }
  691. return 0;
  692. }
  694. BOOL CGuiDockContext::Track()
  695. {
  696. // don't handle if capture already set
  697. if (::GetCapture() != NULL)
  698. return FALSE;
  700. // set capture to the window which received this message
  701. m_pBar->SetCapture();
  702. ASSERT(m_pBar == CWnd::GetCapture());
  704. // get messages until capture lost or cancelled/accepted
  705. while (CWnd::GetCapture() == m_pBar)
  706. {
  707. MSG msg;
  708. if (!::GetMessage(&msg, NULL, 0, 0))
  709. {
  710. AfxPostQuitMessage(msg.wParam);
  711. break;
  712. }
  714. switch (msg.message)
  715. {
  716. case WM_LBUTTONUP:
  717. if (m_bDragging)
  718. EndDrag();
  719. else
  720. EndResize();
  721. return TRUE;
  722. case WM_MOUSEMOVE:
  723. if (m_bDragging)
  724. Move(msg.pt);
  725. else
  726. Stretch(msg.pt);
  727. break;
  728. case WM_KEYUP:
  729. if (m_bDragging)
  730. OnKey((int)msg.wParam, FALSE);
  731. break;
  732. case WM_KEYDOWN:
  733. if (m_bDragging)
  734. OnKey((int)msg.wParam, TRUE);
  735. if (msg.wParam == VK_ESCAPE)
  736. {
  737. CancelLoop();
  738. return FALSE;
  739. }
  740. break;
  741. case WM_RBUTTONDOWN:
  742. CancelLoop();
  743. return FALSE;
  745. // just dispatch rest of the messages
  746. default:
  747. DispatchMessage(&msg);
  748. break;
  749. }
  750. }
  752. CancelLoop();
  754. return FALSE;
  755. }
  757. CDockBar* CGuiDockContext::GetDockBar(DWORD dwOverDockStyle)
  758. {
  759. DWORD dw = 0;
  760. CDockBar* pBar;
  761. if (HORZF(dwOverDockStyle))
  762. {
  763. dw = CanDock(m_rectDragHorz,
  764. dwOverDockStyle & ~CBRS_ORIENT_VERT, &pBar);
  765. ASSERT(dw != 0);
  766. ASSERT(pBar != NULL);
  767. return pBar;
  768. }
  769. if (VERTF(dwOverDockStyle))
  770. {
  771. dw =CanDock(m_rectDragVert,
  772. dwOverDockStyle & ~CBRS_ORIENT_HORZ, &pBar);
  773. ASSERT(dw != 0);
  774. ASSERT(pBar != NULL);
  775. return pBar;
  776. }
  777. return NULL;
  778. }