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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
XTPDockingPaneContext.cpp
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：50k
源码类别：

对话框与窗口

开发平台：

Visual C++

XTPDockingPaneContext.cpp：源码内容
  1. // XTPDockingPaneContext.cpp : implementation of the CXTPDockingPaneContext class.
  2. //
  3. // This file is a part of the XTREME DOCKINGPANE MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include "Resource.h"
  24. #include "Common/XTPDrawHelpers.h"
  25. #include "Common/XTPResourceManager.h"
  26. #include "TabManager/XTPTabManager.h"
  28. #include "XTPDockingPaneContext.h"
  29. #include "XTPDockingPane.h"
  30. #include "XTPDockingPaneManager.h"
  31. #include "XTPDockingPaneTabbedContainer.h"
  32. #include "XTPDockingPaneSplitterContainer.h"
  33. #include "XTPDockingPaneMiniWnd.h"
  34. #include "XTPDockingPaneSidePanel.h"
  36. #ifdef _DEBUG
  37. #define new DEBUG_NEW
  38. #undef THIS_FILE
  39. static char THIS_FILE[] = __FILE__;
  40. #endif
  44. void AFX_CDECL CXTPDockingPaneContext::AdjustRectangle(CRect& rect, CPoint pt)
  45. {
  46. int nXOffset = (pt.x < rect.left) ? (pt.x - rect.left - 6) :
  47. (pt.x > rect.right) ? (pt.x - rect.right + 6) : 0;
  48. int nYOffset = (pt.y < rect.top) ? (pt.y - rect.top - 6) :
  49. (pt.y > rect.bottom) ? (pt.y - rect.bottom + 6) : 0;
  50. rect.OffsetRect(nXOffset, nYOffset);
  51. }
  53. void AFX_CDECL CXTPDockingPaneContext::AdjustCursor(CPoint& pt)
  54. {
  55. CRect rc = XTPMultiMonitor()->GetWorkArea(pt);
  56. if (pt.x < rc.left) pt.x = rc.left;
  57. if (pt.x > rc.right) pt.x = rc.right;
  58. if (pt.y < rc.top) pt.y = rc.top;
  59. if (pt.y > rc.bottom) pt.y = rc.bottom;
  60. }
  62. typedef BOOL (WINAPI *PFNSETLAYEREDWINDOWATTRIBUTES) (HWND hwnd, COLORREF crKey, BYTE bAlpha, DWORD dwFlags);
  64. #ifndef LWA_ALPHA
  65. #define LWA_ALPHA               0x00000002
  66. #endif
  68. #ifndef WS_EX_LAYERED
  69. #define WS_EX_LAYERED           0x00080000
  70. #endif
  72. /////////////////////////////////////////////////////////////////////////////
  73. // CXTPDockingPaneContextAlphaWnd
  75. CXTPDockingPaneContextAlphaWnd::CXTPDockingPaneContextAlphaWnd()
  76. {
  77. }
  79. CXTPDockingPaneContextAlphaWnd::~CXTPDockingPaneContextAlphaWnd()
  80. {
  81. }
  84. BEGIN_MESSAGE_MAP(CXTPDockingPaneContextAlphaWnd, CWnd)
  85. //{{AFX_MSG_MAP(CXTPDockingPaneContextAlphaWnd)
  86. ON_WM_ERASEBKGND()
  87. ON_WM_PAINT()
  88. //}}AFX_MSG_MAP
  89. END_MESSAGE_MAP()
  92. /////////////////////////////////////////////////////////////////////////////
  93. // CXTPDockingPaneContextAlphaWnd message handlers
  95. BOOL CXTPDockingPaneContextAlphaWnd::OnEraseBkgnd(CDC* /*pDC*/)
  96. {
  97. return TRUE;
  98. }
  100. void CXTPDockingPaneContextAlphaWnd::OnPaint()
  101. {
  102. CPaintDC dc(this); // device context for painting
  104. CRect rc;
  105. GetClientRect(&rc);
  107. dc.FillSolidRect(rc, GetSysColor(COLOR_HIGHLIGHT));
  108. }
  110. //////////////////////////////////////////////////////////////////////////
  111. // CXTPDockingPaneContextStickerWnd
  113. CXTPDockingPaneContextStickerWnd::CXTPDockingPaneContextStickerWnd(CXTPDockingPaneContext* pContext)
  114. : m_pContext(pContext)
  115. {
  116. m_typeSticker = m_selectedSticker = xtpPaneStickerNone;
  117. }
  119. CXTPDockingPaneContextStickerWnd::~CXTPDockingPaneContextStickerWnd()
  120. {
  121. }
  124. BEGIN_MESSAGE_MAP(CXTPDockingPaneContextStickerWnd, CWnd)
  125. //{{AFX_MSG_MAP(CXTPDockingPaneContextStickerWnd)
  126. ON_WM_ERASEBKGND()
  127. ON_WM_PAINT()
  128. //}}AFX_MSG_MAP
  129. END_MESSAGE_MAP()
  132. /////////////////////////////////////////////////////////////////////////////
  133. // CXTPDockingPaneContextAlphaWnd message handlers
  135. BOOL CXTPDockingPaneContextStickerWnd::OnEraseBkgnd(CDC* /*pDC*/)
  136. {
  137. return TRUE;
  138. }
  140. struct CXTPDockingPaneContextStickerWnd::SPRITEINFO
  141. {
  142. SPRITEINFO(int x, int y, int left, int top, int cx, int cy)
  143. {
  144. ptDest = CPoint(x, y);
  145. rcSrc.SetRect(left, top, left + cx, top + cy);
  146. }
  147. CPoint ptDest;
  148. CRect rcSrc;
  149. };
  151. #define SPRITE_STICKER_TOP              0
  152. #define SPRITE_STICKER_LEFT             1
  153. #define SPRITE_STICKER_BOTTOM           2
  154. #define SPRITE_STICKER_RIGHT            3
  155. #define SPRITE_STICKER_TOP_SELECTED     4
  156. #define SPRITE_STICKER_LEFT_SELECTED    5
  157. #define SPRITE_STICKER_BOTTOM_SELECTED  6
  158. #define SPRITE_STICKER_RIGHT_SELECTED   7
  160. #define SPRITE_STICKER_CENTER           8
  161. #define SPRITE_STICKER_CENTER_SELECTED  9
  162. #define SPRITE_STICKER_CLIENT           10
  164. static CXTPDockingPaneContextStickerWnd::SPRITEINFO arrSpritesStyckerWidbey[] =
  165. {
  166. CXTPDockingPaneContextStickerWnd::SPRITEINFO(25, 0, 0, 0, 43, 30),
  167. CXTPDockingPaneContextStickerWnd::SPRITEINFO(0, 25, 30, 33, 30, 43),
  168. CXTPDockingPaneContextStickerWnd::SPRITEINFO(25, 63, 43, 0, 43, 30),
  169. CXTPDockingPaneContextStickerWnd::SPRITEINFO(63, 25, 0, 33, 30, 43),
  170. CXTPDockingPaneContextStickerWnd::SPRITEINFO(25, 0, 0, 76, 43, 30),
  171. CXTPDockingPaneContextStickerWnd::SPRITEINFO(0, 25, 90, 33, 30, 43),
  172. CXTPDockingPaneContextStickerWnd::SPRITEINFO(25, 63, 43, 76, 43, 30),
  173. CXTPDockingPaneContextStickerWnd::SPRITEINFO(63, 25, 60, 33, 30, 43),
  174. CXTPDockingPaneContextStickerWnd::SPRITEINFO(30, 30, 86, 0, 33, 33),
  175. CXTPDockingPaneContextStickerWnd::SPRITEINFO(30, 30, 86, 76, 33, 33),
  176. CXTPDockingPaneContextStickerWnd::SPRITEINFO(25, 25, 0, 0, 43, 43),
  177. };
  179. static CXTPDockingPaneContextStickerWnd::SPRITEINFO arrSpritesStyckerVisualStudio2005[] =
  180. {
  181. CXTPDockingPaneContextStickerWnd::SPRITEINFO(30, 0, 61, 29, 29, 30),
  182. CXTPDockingPaneContextStickerWnd::SPRITEINFO(0, 30, 90, 30, 30, 29),
  183. CXTPDockingPaneContextStickerWnd::SPRITEINFO(30, 59, 91, 0, 29, 30),
  184. CXTPDockingPaneContextStickerWnd::SPRITEINFO(60, 30, 62, 0, 30, 29),
  185. CXTPDockingPaneContextStickerWnd::SPRITEINFO(30, 0, 61, 29 + 61, 29, 30),
  186. CXTPDockingPaneContextStickerWnd::SPRITEINFO(0, 30, 90, 30 + 61, 30, 29),
  187. CXTPDockingPaneContextStickerWnd::SPRITEINFO(30, 59, 91, 0 + 61, 29, 30),
  188. CXTPDockingPaneContextStickerWnd::SPRITEINFO(60, 30, 62, 0 + 61, 30, 29),
  190. CXTPDockingPaneContextStickerWnd::SPRITEINFO(30, 30, 120, 82, 28, 29),
  191. CXTPDockingPaneContextStickerWnd::SPRITEINFO(24, 24, 120, 41, 41, 41),
  192. CXTPDockingPaneContextStickerWnd::SPRITEINFO(24, 24, 120, 0, 41, 41),
  194. CXTPDockingPaneContextStickerWnd::SPRITEINFO(0, 0, 0, 29, 29, 32),
  195. CXTPDockingPaneContextStickerWnd::SPRITEINFO(0, 0, 29, 32, 32, 29),
  196. CXTPDockingPaneContextStickerWnd::SPRITEINFO(0, 0, 32, 0, 29, 32),
  197. CXTPDockingPaneContextStickerWnd::SPRITEINFO(0, 0, 0, 0, 32, 29),
  198. CXTPDockingPaneContextStickerWnd::SPRITEINFO(0, 0, 0, 29 + 61, 29, 32),
  199. CXTPDockingPaneContextStickerWnd::SPRITEINFO(0, 0, 29, 32 + 61, 32, 29),
  200. CXTPDockingPaneContextStickerWnd::SPRITEINFO(0, 0, 32, 0 + 61, 29, 32),
  201. CXTPDockingPaneContextStickerWnd::SPRITEINFO(0, 0, 0, 0 + 61, 32, 29),
  203. };
  206. void CXTPDockingPaneContextStickerWnd::DrawTransparent(CDC* pDC , const CPoint& ptDest, const CSize& sz, CBitmap* pBitmap)
  207. {
  208. CImageList il;
  209. il.Create(sz.cx, sz.cy, ILC_COLOR24 | ILC_MASK, 0, 1);
  210. il.Add(pBitmap, RGB(0, 0xFF, 0));
  212. il.Draw(pDC, 0, ptDest, ILD_NORMAL);
  213. }
  215. void CXTPDockingPaneContextStickerWnd::DrawSprite(CDC* pDC, UINT nID, SPRITEINFO* pSpriteInfo, BOOL bClientBitmap)
  216. {
  217. CBitmap bmp;
  218. VERIFY(XTPResourceManager()->LoadBitmap(&bmp, nID));
  220. CSize sz(pSpriteInfo->rcSrc.Width(), pSpriteInfo->rcSrc.Height());
  222. CBitmap bmpSprite;
  223. bmpSprite.CreateCompatibleBitmap(pDC, sz.cx, sz.cy);
  225. if (bmpSprite.GetSafeHandle())
  226. {
  227. CXTPCompatibleDC dcSprite(pDC, &bmpSprite);
  228. CXTPCompatibleDC dc(pDC, &bmp);
  229. dcSprite.BitBlt(0, 0, sz.cx, sz.cy, &dc, pSpriteInfo->rcSrc.left, pSpriteInfo->rcSrc.top, SRCCOPY);
  230. }
  232. CPoint ptDest = bClientBitmap ? pSpriteInfo->ptDest : CPoint(0, 0);
  234. DrawTransparent(pDC, ptDest, sz, &bmpSprite);
  235. }
  238. void CXTPDockingPaneContextStickerWnd::OnDraw(CDC* pDC)
  239. {
  240. XTPCurrentSystemTheme theme = XTPColorManager()->GetCurrentSystemTheme();
  241. BOOL bClient = (m_typeSticker & xtpPaneStickerClient) == xtpPaneStickerClient;
  243. if (m_pContext->GetStickerStyle() == xtpPaneStickerStyleWhidbey)
  244. {
  245. UINT nIDBitmap = theme == xtpSystemThemeOlive ? XTP_IDB_DOCKINGPANE_STICKERS_OLIVE :
  246. theme == xtpSystemThemeSilver ? XTP_IDB_DOCKINGPANE_STICKERS_SILVER : XTP_IDB_DOCKINGPANE_STICKERS_BLUE;
  248. SPRITEINFO* sprites = arrSpritesStyckerWidbey;
  250. if (bClient)
  251. DrawSprite(pDC, XTP_IDB_DOCKINGPANE_STICKER_CLIENT, &sprites[SPRITE_STICKER_CLIENT]);
  252. if (m_typeSticker & xtpPaneStickerTop)
  253. DrawSprite(pDC, nIDBitmap, &sprites[m_selectedSticker == xtpPaneStickerTop ? SPRITE_STICKER_TOP_SELECTED : SPRITE_STICKER_TOP], bClient);
  254. if (m_typeSticker & xtpPaneStickerLeft)
  255. DrawSprite(pDC, nIDBitmap, &sprites[m_selectedSticker == xtpPaneStickerLeft ? SPRITE_STICKER_LEFT_SELECTED : SPRITE_STICKER_LEFT], bClient);
  256. if (m_typeSticker & xtpPaneStickerBottom)
  257. DrawSprite(pDC, nIDBitmap, &sprites[m_selectedSticker == xtpPaneStickerBottom ? SPRITE_STICKER_BOTTOM_SELECTED : SPRITE_STICKER_BOTTOM], bClient);
  258. if (m_typeSticker & xtpPaneStickerRight)
  259. DrawSprite(pDC, nIDBitmap, &sprites[m_selectedSticker == xtpPaneStickerRight ? SPRITE_STICKER_RIGHT_SELECTED : SPRITE_STICKER_RIGHT], bClient);
  260. if (m_typeSticker & xtpPaneStickerCenter)
  261. DrawSprite(pDC, nIDBitmap, &sprites[m_selectedSticker == xtpPaneStickerCenter ? SPRITE_STICKER_CENTER_SELECTED : SPRITE_STICKER_CENTER]);
  262. }
  263. else
  264. {
  265. SPRITEINFO* sprites = arrSpritesStyckerVisualStudio2005;
  266. int nClientSprite = bClient ? 0 : 11;
  268. if (bClient)
  269. DrawSprite(pDC, XTP_IDB_DOCKINGPANE_STICKERS_2005, &sprites[m_selectedSticker == xtpPaneStickerCenter ? SPRITE_STICKER_CENTER_SELECTED : SPRITE_STICKER_CLIENT]);
  270. if (m_typeSticker & xtpPaneStickerTop)
  271. DrawSprite(pDC, XTP_IDB_DOCKINGPANE_STICKERS_2005, &sprites[nClientSprite + (m_selectedSticker == xtpPaneStickerTop ? SPRITE_STICKER_TOP_SELECTED : SPRITE_STICKER_TOP)], bClient);
  272. if (m_typeSticker & xtpPaneStickerLeft)
  273. DrawSprite(pDC, XTP_IDB_DOCKINGPANE_STICKERS_2005, &sprites[nClientSprite + (m_selectedSticker == xtpPaneStickerLeft ? SPRITE_STICKER_LEFT_SELECTED : SPRITE_STICKER_LEFT)], bClient);
  274. if (m_typeSticker & xtpPaneStickerBottom)
  275. DrawSprite(pDC, XTP_IDB_DOCKINGPANE_STICKERS_2005, &sprites[nClientSprite + (m_selectedSticker == xtpPaneStickerBottom ? SPRITE_STICKER_BOTTOM_SELECTED : SPRITE_STICKER_BOTTOM)], bClient);
  276. if (m_typeSticker & xtpPaneStickerRight)
  277. DrawSprite(pDC, XTP_IDB_DOCKINGPANE_STICKERS_2005, &sprites[nClientSprite + (m_selectedSticker == xtpPaneStickerRight ? SPRITE_STICKER_RIGHT_SELECTED : SPRITE_STICKER_RIGHT)], bClient);
  278. if (m_typeSticker & xtpPaneStickerCenter)
  279. DrawSprite(pDC, XTP_IDB_DOCKINGPANE_STICKERS_2005, &sprites[SPRITE_STICKER_CENTER]);
  280. }
  281. }
  284. void CXTPDockingPaneContextStickerWnd::OnPaint()
  285. {
  286. CPaintDC dcPaint(this); // device context for painting
  287. CXTPBufferDC dc(dcPaint, CXTPClientRect(this));
  289. OnDraw(&dc);
  290. }
  292. XTPDockingPaneStickerType CXTPDockingPaneContextStickerWnd::HitTest(CPoint pt)
  293. {
  294. CXTPClientRect rc(this);
  295. ScreenToClient(&pt);
  297. if (!rc.PtInRect(pt))
  298. return xtpPaneStickerNone;
  300. CClientDC dcClient(this);
  302. CBitmap bmp;
  303. bmp.CreateCompatibleBitmap(&dcClient, rc.Width(), rc.Height());
  305. CXTPCompatibleDC dc(&dcClient, &bmp);
  306. dc.FillSolidRect(rc, 0);
  308. UINT nIDBitmap = m_pContext->GetStickerStyle() == xtpPaneStickerStyleVisualStudio2005 ?
  309. XTP_IDB_DOCKINGPANE_STICKERS_2005 : XTP_IDB_DOCKINGPANE_STICKERS_BLUE;
  310. UINT nIDBitmapClient = m_pContext->GetStickerStyle() == xtpPaneStickerStyleVisualStudio2005 ?
  311. XTP_IDB_DOCKINGPANE_STICKERS_2005 : XTP_IDB_DOCKINGPANE_STICKER_CLIENT;
  313. BOOL bClient = (m_typeSticker & xtpPaneStickerClient) == xtpPaneStickerClient;
  315. SPRITEINFO* sprites = m_pContext->GetStickerStyle() == xtpPaneStickerStyleWhidbey ?
  316. arrSpritesStyckerWidbey : arrSpritesStyckerVisualStudio2005;
  318. if (m_typeSticker & xtpPaneStickerTop)
  319. {
  320. DrawSprite(&dc, nIDBitmap, &sprites[SPRITE_STICKER_TOP], bClient);
  321. if (dc.GetPixel(pt) != 0)
  322. return xtpPaneStickerTop;
  323. }
  324. if (m_typeSticker & xtpPaneStickerLeft)
  325. {
  326. DrawSprite(&dc, nIDBitmap, &sprites[SPRITE_STICKER_LEFT], bClient);
  327. if (dc.GetPixel(pt) != 0)
  328. return xtpPaneStickerLeft;
  329. }
  330. if (m_typeSticker & xtpPaneStickerBottom)
  331. {
  332. DrawSprite(&dc, nIDBitmap, &sprites[SPRITE_STICKER_BOTTOM], bClient);
  333. if (dc.GetPixel(pt) != 0)
  334. return xtpPaneStickerBottom;
  335. }
  336. if (m_typeSticker & xtpPaneStickerRight)
  337. {
  338. DrawSprite(&dc, nIDBitmap, &sprites[SPRITE_STICKER_RIGHT], bClient);
  339. if (dc.GetPixel(pt) != 0)
  340. return xtpPaneStickerRight;
  341. }
  342. if (m_typeSticker & xtpPaneStickerCenter)
  343. {
  344. DrawSprite(&dc, nIDBitmapClient, &sprites[SPRITE_STICKER_CLIENT]);
  345. if (dc.GetPixel(pt) != 0)
  346. return xtpPaneStickerCenter;
  347. }
  349. return xtpPaneStickerNone;
  350. }
  352. //////////////////////////////////////////////////////////////////////////
  353. // CXTPDockingPaneContext
  355. CXTPDockingPaneContext::CXTPDockingPaneContext()
  356. {
  357. m_bUseAlphaContext = FALSE;
  358. m_bUseDockingStickers = FALSE;
  359. m_bDragKeyboard = FALSE;
  361. m_pStickerPane = NULL;
  362. m_pLastStickerPane = NULL;
  363. m_pManager = NULL;
  364. m_pPane = NULL;
  365. m_pContainer = NULL;
  366. m_bAttachLast = FALSE;
  367. m_bSideDock = FALSE;
  368. m_bAttach = FALSE;
  369. m_bFloatable = TRUE;
  370. m_bDockable = TRUE;
  371. m_bDitherLast = FALSE;
  372. m_containDirection = (XTPDockingPaneDirection)-1;
  373. m_pDC = NULL;
  375. m_pfnSetLayeredWindowAttributes = NULL;
  377. HMODULE hLib = GetModuleHandle(_T("USER32"));
  378. if (hLib)
  379. {
  380. m_pfnSetLayeredWindowAttributes = (PVOID) ::GetProcAddress(hLib, "SetLayeredWindowAttributes");
  381. }
  383. m_bResetDC = FALSE;
  384. }
  386. CXTPDockingPaneContext::~CXTPDockingPaneContext()
  387. {
  389. }
  391. void CXTPDockingPaneContext::Drag(CXTPDockingPaneBase* pPane, CPoint point)
  392. {
  393. CRect rcPane = pPane->GetPaneWindowRect();
  395. CWnd* pSite = pPane->GetDockingSite();
  396. if (pSite && (pPane->GetType() == xtpPaneTypeDockingPane || pPane->GetType() == xtpPaneTypeTabbedContainer)
  397. && !pSite->IsKindOf(RUNTIME_CLASS(CXTPDockingPaneMiniWnd)))
  398. {
  399. CXTPDockingPane* pActivePane = pPane->GetType() == xtpPaneTypeTabbedContainer ?
  400. ((CXTPDockingPaneTabbedContainer*)pPane)->GetSelected() : (CXTPDockingPane*)pPane;
  402. if (pActivePane)
  403. {
  404. CXTPDockingPaneTabbedContainer* pHolder = (CXTPDockingPaneTabbedContainer*)m_pManager->_GetHolder(pActivePane, TRUE);
  405. pSite = pHolder ? pHolder->GetDockingSite() : NULL;
  407. if (pSite && pSite->IsKindOf(RUNTIME_CLASS(CXTPDockingPaneMiniWnd)))
  408. {
  409. CRect rcFloating = ((CXTPDockingPaneMiniWnd*)pSite)->GetPaneWindowRect();
  411. rcPane.right = rcPane.left + rcFloating.Width();
  412. rcPane.bottom = rcPane.top + rcFloating.Height();
  413. }
  414. }
  415. }
  417. Drag(pPane, point, rcPane);
  418. }
  420. void CXTPDockingPaneContext::Drag(CXTPDockingPaneBase* pPane, CPoint pt, CRect rect)
  421. {
  422. m_bDragKeyboard = (pt == CPoint(-1, -1));
  424. if (m_bDragKeyboard)
  425. {
  426. pt.x = rect.CenterPoint().x;
  427. pt.y = rect.top + 15;
  428. SetCursorPos(pt.x, pt.y);
  429. }
  431. m_ptSticky = m_ptLast = pt;
  433. AdjustRectangle(rect, pt);
  435. m_pPane = pPane;
  436. m_rectDragFrameScreen = m_rectDragFrame = rect;
  437. m_pDC = 0;
  438. m_pContainer = 0;
  439. m_bAttach = m_bAttachLast = FALSE;
  440. m_bFloatable = TRUE;
  441. m_bDockable = TRUE;
  442. m_bSideDock = FALSE;
  444. m_bUseAlphaContext = m_pManager->IsAlphaDockingContext() && (m_pfnSetLayeredWindowAttributes != NULL);
  445. m_bUseDockingStickers = m_pManager->IsShowDockingContextStickers() && m_bUseAlphaContext;
  448. CXTPDockingPaneBaseList lst;
  449. pPane->FindPane(xtpPaneTypeDockingPane, &lst);
  450. POSITION pos = lst.GetHeadPosition();
  451. while (pos)
  452. {
  453. CXTPDockingPane* pListPane = (CXTPDockingPane*)lst.GetNext(pos);
  455. if (m_pManager->NotifyAction(xtpPaneActionFloating, pListPane))
  456. m_bFloatable = FALSE;
  458. if (pListPane->GetOptions() & xtpPaneNoFloatable)
  459. m_bFloatable = FALSE;
  461. if (pListPane->GetOptions() & xtpPaneNoDockable)
  462. m_bDockable = FALSE;
  463. }
  465. if (m_pManager->m_bShowSizeCursorWhileDragging)
  466. {
  467. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZEALL));
  468. }
  471. InitLoop();
  473. Track();
  474. }
  477. void CXTPDockingPaneContext::InitLoop()
  478. {
  479. m_rectLast.SetRectEmpty();
  480. m_sizeLast.cx = m_sizeLast.cy = 0;
  481. m_bDitherLast = FALSE;
  482. m_rectStickerPane.SetRectEmpty();
  483. m_pStickerPane = NULL;
  484. m_pLastStickerPane = NULL;
  485. m_bResetDC = FALSE;
  487. if (!m_bUseAlphaContext)
  488. {
  489. // handle pending WM_PAINT messages
  490. MSG msg;
  491. while (::PeekMessage(&msg, NULL, WM_PAINT, WM_PAINT, PM_NOREMOVE))
  492. {
  493. if (!GetMessage(&msg, NULL, WM_PAINT, WM_PAINT))
  494. return;
  495. DispatchMessage(&msg);
  496. }
  498. // lock window update while dragging
  499. ASSERT(m_pDC == NULL);
  500. CWnd* pWnd = CWnd::GetDesktopWindow();
  501. if (pWnd->LockWindowUpdate())
  502. m_pDC = pWnd->GetDCEx(NULL, DCX_WINDOW | DCX_CACHE | DCX_LOCKWINDOWUPDATE);
  503. else
  504. m_pDC = pWnd->GetDCEx(NULL, DCX_WINDOW | DCX_CACHE);
  505. ASSERT(m_pDC != NULL);
  506. }
  507. }
  508. void CXTPDockingPaneContext::CancelLoop()
  509. {
  510. ReleaseCapture();
  512. if (m_bUseAlphaContext)
  513. {
  514. m_wndContext.DestroyWindow();
  515. m_wndAttachedTab.DestroyWindow();
  517. DestroyDockingStickers();
  519. POSITION pos = m_rgnStickers.GetStartPosition();
  520. while (pos)
  521. {
  522. UINT nKey;
  523. CRgn* pRgn;
  524. m_rgnStickers.GetNextAssoc(pos, nKey, pRgn);
  525. delete pRgn;
  526. }
  527. m_rgnStickers.RemoveAll();
  529. }
  530. else
  531. {
  532. DrawFocusRect(TRUE);    // gets rid of focus rect
  534. CWnd* pWnd = CWnd::GetDesktopWindow();
  535. pWnd->UnlockWindowUpdate();
  536. if (m_pDC != NULL)
  537. {
  538. pWnd->ReleaseDC(m_pDC);
  539. m_pDC = NULL;
  540. }
  541. }
  542. }
  544. void CXTPDockingPaneContext::_CreateRectangleRgn(CRgn& rgnResult, CRect rc)
  545. {
  546. CRgn rgnOutside, rgnInside;
  547. rgnOutside.CreateRectRgnIndirect(&rc);
  548. CRect rect = rc;
  549. rect.DeflateRect(4, 4);
  550. rect.IntersectRect(rect, rc);
  551. rgnInside.CreateRectRgnIndirect(rect);
  552. rgnResult.CreateRectRgn(0, 0, 0, 0);
  553. rgnResult.CombineRgn(&rgnOutside, &rgnInside, RGN_XOR);
  554. }
  556. void CXTPDockingPaneContext::_CreateRgn(CRgn& rgnResult, CRect rc, BOOL bTabbedRgn, BOOL bRemove)
  557. {
  558. if (bRemove)
  559. {
  560. rgnResult.CreateRectRgn(0, 0, 0, 0);
  561. return;
  562. }
  564. if (bTabbedRgn)
  565. {
  566. CSize szTab(min(50, rc.Width() - 5), min(20, rc.Height() / 2));
  567. CRect rcIntersect, rcTop(rc.left, rc.top, rc.right, rc.bottom - szTab.cy),
  568. rcBottom(rc.left + 5, rc.bottom - szTab.cy - 4, rc.left + 5 + szTab.cx, rc.bottom);
  570. CRgn rgnTop, rgnBottom, rgnIntersect;
  572. rcIntersect.IntersectRect(rcTop, rcBottom);
  573. rcIntersect.DeflateRect(4, 0);
  575. _CreateRectangleRgn(rgnTop, rcTop);
  576. _CreateRectangleRgn(rgnBottom, rcBottom);
  577. _CreateRectangleRgn(rgnIntersect, rcIntersect);
  579. rgnResult.CreateRectRgn(0, 0, 0, 0);
  580. rgnResult.CombineRgn(&rgnBottom, &rgnTop, RGN_OR);
  581. rgnResult.CombineRgn(&rgnResult, &rgnIntersect, RGN_XOR);
  582. }
  583. else
  584. {
  585. _CreateRectangleRgn(rgnResult, rc);
  586. }
  587. }
  589. void CXTPDockingPaneContext::DrawFocusRect(BOOL bRemoveRect)
  590. {
  591. if (m_pManager->m_bShowContentsWhileDragging && m_pContainer == NULL &&
  592. m_bFloatable && !m_bAttach && !m_rectDragFrame.IsRectEmpty())
  593. {
  594. CRect rect = m_rectDragFrame;
  596. m_wndAttachedTab.DestroyWindow();
  597. m_wndContext.DestroyWindow();
  599. if (!m_bUseAlphaContext && !m_bResetDC)
  600. {
  601. ASSERT(m_pDC != NULL);
  602. // determine new rect and size
  604. rect.SetRectEmpty();
  606. // first, determine the update region and select it
  607. CRgn rgnNew, rgnLast, rgnUpdate;
  609. _CreateRgn(rgnNew, rect, m_bAttach, TRUE);
  610. _CreateRgn(rgnLast, m_rectLast, m_bAttachLast);
  612. rgnUpdate.CreateRectRgn(0, 0, 0, 0);
  613. rgnUpdate.CombineRgn(&rgnLast, &rgnNew, RGN_XOR);
  615. // draw into the update/new region
  616. m_pDC->SelectClipRgn(&rgnUpdate);
  617. m_pDC->GetClipBox(&rect);
  618. CBrush* pBrushOld = m_pDC->SelectObject(CDC::GetHalftoneBrush());
  619. m_pDC->PatBlt(rect.left, rect.top, rect.Width(), rect.Height(), PATINVERT);
  620. // cleanup DC
  622. if (pBrushOld != NULL)
  623. m_pDC->SelectObject(pBrushOld);
  625. m_pDC->SelectClipRgn(NULL);
  627. CWnd* pWnd = CWnd::GetDesktopWindow();
  628. pWnd->UnlockWindowUpdate();
  629. if (m_pDC != NULL)
  630. {
  631. pWnd->ReleaseDC(m_pDC);
  632. m_pDC = NULL;
  633. }
  634. m_bResetDC = TRUE;
  635. }
  637. if (m_pPane->GetType() == xtpPaneTypeSplitterContainer)
  638. {
  639. if (m_rectDragFrame != m_rectLast)
  640. {
  641. m_pPane->GetDockingSite()->MoveWindow(m_rectDragFrame);
  642. }
  643. }
  644. else if (!bRemoveRect)
  645. {
  646. XTPDockingPaneAction actionNotify = xtpPaneActionFloated;
  648. CXTPDockingPaneBaseList lst;
  649. m_pPane->FindPane(xtpPaneTypeDockingPane, &lst);
  651. if (m_rectDragFrame.top < 0)
  652. m_rectDragFrame.OffsetRect(0, -m_rectDragFrame.top);
  654. CXTPDockingPaneMiniWnd* pMiniWnd = m_pManager->FloatPane(m_pPane, m_rectDragFrame);
  656. m_pManager->RecalcFrameLayout(m_pPane);
  657. SAFE_CALLPTR(pMiniWnd, RecalcLayout());
  659. m_pPane = pMiniWnd->GetTopPane();
  661. POSITION pos = lst.GetHeadPosition();
  662. while (pos)
  663. {
  664. CXTPDockingPane* pPane = (CXTPDockingPane*)lst.GetNext(pos);
  665. m_pManager->NotifyAction(actionNotify, pPane);
  666. }
  668. AfxGetThread()->PumpMessage();
  669. AfxGetThread()->OnIdle(0);
  670. }
  672. m_rectLast = rect;
  673. m_bAttachLast = FALSE;
  675. return;
  676. }
  678. if (m_bResetDC)
  679. {
  680. ASSERT(m_pDC == NULL);
  681. ASSERT(m_bUseAlphaContext == FALSE);
  683. // handle pending WM_PAINT messages
  684. MSG msg;
  685. while (::PeekMessage(&msg, NULL, WM_PAINT, WM_PAINT, PM_NOREMOVE))
  686. {
  687. if (!GetMessage(&msg, NULL, WM_PAINT, WM_PAINT))
  688. return;
  689. DispatchMessage(&msg);
  690. }
  692. // lock window update while dragging
  693. CWnd* pWnd = CWnd::GetDesktopWindow();
  694. if (pWnd->LockWindowUpdate())
  695. m_pDC = pWnd->GetDCEx(NULL, DCX_WINDOW | DCX_CACHE | DCX_LOCKWINDOWUPDATE);
  696. else
  697. m_pDC = pWnd->GetDCEx(NULL, DCX_WINDOW | DCX_CACHE);
  698. ASSERT(m_pDC != NULL);
  699. m_bResetDC = FALSE;
  701. m_sizeLast.cx = m_sizeLast.cy = 0;
  702. m_bDitherLast = FALSE;
  703. m_rectLast.SetRectEmpty();
  704. }
  706. if (m_bUseAlphaContext)
  707. {
  708. ASSERT(bRemoveRect == FALSE);
  710. CRect rect = (m_pContainer == 0) ? m_rectDragFrame : m_rectContainer;
  712. m_rectLast = rect;
  714. if (!m_bFloatable && m_pContainer == 0)
  715. {
  716. rect.SetRectEmpty();
  717. }
  719. if (m_bAttach != m_bAttachLast)
  720. {
  721. m_bAttachLast = m_bAttach;
  722. if (m_bAttach)
  723. CreateContextWindow(&m_wndAttachedTab);
  724. else
  725. m_wndAttachedTab.DestroyWindow();
  726. }
  728. if (m_bAttach)
  729. {
  730. CSize szTab(min(50, rect.Width() - 5), min(20, rect.Height() / 2));
  731. CRect rcTab;
  733. if (m_pManager->GetPaintManager()->GetTabPaintManager()->GetPosition() == xtpTabPositionTop
  734. && m_pContainer && m_pContainer->GetType() == xtpPaneTypeTabbedContainer)
  735. {
  736. if (((CXTPDockingPaneTabbedContainer*)m_pContainer)->IsTitleVisible())
  737. {
  738. rect.top += m_pManager->GetPaintManager()->GetCaptionHeight() + 3;
  739. }
  741. rect.top += szTab.cy;
  742. rcTab = CRect(rect.left + 5, rect.top - szTab.cy, rect.left + 5 + szTab.cx, rect.top);
  743. }
  744. else
  745. {
  746. rect.bottom -= szTab.cy;
  747. rcTab = CRect(rect.left + 5, rect.bottom, rect.left + 5 + szTab.cx, rect.bottom + szTab.cy);
  748. }
  750. m_wndAttachedTab.SetWindowPos(0, rcTab.left, rcTab.top, rcTab.Width(), rcTab.Height(), SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
  751. }
  753. if (m_wndContext.GetSafeHwnd() == 0 || CXTPWindowRect(&m_wndContext).Size() != rect.Size())
  754. {
  755. m_wndContext.DestroyWindow();
  756. CreateContextWindow(&m_wndContext);
  757. }
  759. m_wndContext.SetWindowPos(0, rect.left, rect.top, rect.Width(), rect.Height(), SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
  760. }
  761. else
  762. {
  763. ASSERT(m_pDC != NULL);
  764. // determine new rect and size
  765. CRect rect = (m_pContainer == 0) ? m_rectDragFrame : m_rectContainer;
  767. if (!m_bFloatable && m_pContainer == 0)
  768. rect.SetRectEmpty();
  770. // first, determine the update region and select it
  771. CRgn rgnNew, rgnLast, rgnUpdate;
  773. _CreateRgn(rgnNew, rect, m_bAttach, bRemoveRect);
  774. _CreateRgn(rgnLast, m_rectLast, m_bAttachLast);
  776. rgnUpdate.CreateRectRgn(0, 0, 0, 0);
  777. rgnUpdate.CombineRgn(&rgnLast, &rgnNew, RGN_XOR);
  779. m_rectLast = rect;
  780. m_bAttachLast = m_bAttach;
  782. // draw into the update/new region
  783. m_pDC->SelectClipRgn(&rgnUpdate);
  784. m_pDC->GetClipBox(&rect);
  785. CBrush* pBrushOld = m_pDC->SelectObject(CDC::GetHalftoneBrush());
  786. m_pDC->PatBlt(rect.left, rect.top, rect.Width(), rect.Height(), PATINVERT);
  787. // cleanup DC
  789. if (pBrushOld != NULL)
  790. m_pDC->SelectObject(pBrushOld);
  792. m_pDC->SelectClipRgn(NULL);
  793. }
  794. }
  796. BOOL CXTPDockingPaneContext::CanSideDock(CXTPDockingPaneBase* pPane, CRect rcFrame)
  797. {
  798. CRect rc = pPane->GetPaneWindowRect();
  799. rc.DeflateRect(m_pManager->GetSideDockingMargin());
  801. int dSize = 10;
  803. if (rc.Height() == 0 || rc.Width() == 0 || rcFrame.Height() == 0 || rcFrame.Width() == 0)
  804. return FALSE;
  806. if (!CRect().IntersectRect(rc, rcFrame))
  807. return FALSE;
  809. m_rectContainer.SetRectEmpty();
  811. if (abs(rcFrame.top - rc.top) < dSize)
  812. {
  813. m_containDirection = xtpPaneDockTop;
  814. m_rectContainer = CRect(rcFrame.left, rc.top, rcFrame.right, rc.top + rcFrame.Height());
  816. dSize = abs(rcFrame.top - rc.top);
  817. }
  819. if (abs(rc.bottom - rcFrame.bottom) < dSize)
  820. {
  821. m_containDirection = xtpPaneDockBottom;
  822. m_rectContainer = CRect(rcFrame.left, rc.bottom - rcFrame.Height(), rcFrame.right, rc.bottom);
  824. dSize = abs(rc.bottom - rcFrame.bottom);
  825. }
  827. if (abs(rcFrame.left - rc.left) < dSize)
  828. {
  829. m_containDirection = xtpPaneDockLeft;
  830. m_rectContainer = CRect(rc.left, rcFrame.top, rc.left + rcFrame.Width(), rcFrame.bottom);
  832. dSize = abs(rcFrame.left - rc.left);
  833. }
  835. if (abs(rc.right - rcFrame.right) < dSize)
  836. {
  837. m_containDirection = xtpPaneDockRight;
  838. m_rectContainer = CRect(rc.right - rcFrame.Width(), rcFrame.top, rc.right, rcFrame.bottom);
  839. }
  841. if (!m_rectContainer.IsRectEmpty())
  842. {
  843. if (!IsAllowDockingTo(pPane, m_containDirection))
  844. return FALSE;
  846. m_pContainer = pPane;
  847. return TRUE;
  848. }
  850. return FALSE;
  851. }
  853. BOOL CXTPDockingPaneContext::CanDock(CRect rc, CPoint pt, CXTPDockingPaneBase* pPane, BOOL bInside)
  854. {
  855. double dSize = 20.0;
  857. double dRatio = 1.0;
  859. if (bInside && !m_bFloatable)
  860. {
  861. if (rc.Width() > 1 && rc.Height() > 1) dRatio = (double)rc.Height() / (double)rc.Width();
  862. dSize = 32000.0;
  863. }
  865. if (rc.Height() == 0 || rc.Width() == 0)
  866. return FALSE;
  868. if (bInside && !rc.PtInRect(pt))
  869. return FALSE;
  871. if (!bInside && !CRect(rc.left - 20, rc.top - 20, rc.right + 20, rc.bottom + 20).PtInRect(pt))
  872. return FALSE;
  874. int nInside = bInside ? 1 : -1;
  875. BOOL bFound = FALSE;
  878. if ((double)abs(pt.y - rc.top) < dSize && nInside * (pt.y - rc.top) >= 0)
  879. {
  880. m_containDirection = xtpPaneDockTop;
  881. dSize = (double)abs(pt.y - rc.top);
  882. bFound = TRUE;
  883. }
  885. if ((double)abs(rc.bottom - pt.y) < dSize && nInside * (rc.bottom - pt.y) >= 0)
  886. {
  887. m_containDirection = xtpPaneDockBottom;
  888. dSize = (double)abs(rc.bottom - pt.y);
  889. bFound = TRUE;
  890. }
  892. if ((double)abs(pt.x - rc.left) * dRatio < dSize && nInside * (pt.x - rc.left) >= 0)
  893. {
  894. m_containDirection = xtpPaneDockLeft;
  895. dSize = (double)abs(pt.x - rc.left) * dRatio;
  896. bFound = TRUE;
  897. }
  899. if ((double)abs(rc.right - pt.x) * dRatio < dSize && nInside * (rc.right- pt.x) >= 0)
  900. {
  901. m_containDirection = xtpPaneDockRight;
  902. bFound = TRUE;
  903. }
  905. if (bFound)
  906. {
  907. if (!IsAllowDockingTo(pPane, m_containDirection))
  908. return FALSE;
  910. m_rectContainer = m_pManager->_CalculateResultDockingRect(m_pPane, m_containDirection, pPane);
  911. m_pContainer = pPane;
  912. }
  913. return bFound;
  914. }
  916. BOOL CXTPDockingPaneContext::IsAllowDockingTo(CXTPDockingPaneBase* pPane, XTPDockingPaneDirection direction)
  917. {
  918. CXTPDockingPaneBaseList lst;
  919. m_pPane->FindPane(xtpPaneTypeDockingPane, &lst);
  920. POSITION pos = lst.GetHeadPosition();
  921. while (pos)
  922. {
  923. CXTPDockingPane* p = (CXTPDockingPane*)lst.GetNext(pos);
  925. if (m_pManager->NotifyAction(xtpPaneActionDocking, p, pPane, direction))
  926. {
  927. return FALSE;
  928. }
  929. }
  930. return TRUE;
  931. }
  933. BOOL CXTPDockingPaneContext::IsAllowAttachTo(CXTPDockingPaneBase* pPane)
  934. {
  936. CXTPDockingPaneBaseList lst;
  937. m_pPane->FindPane(xtpPaneTypeDockingPane, &lst);
  938. POSITION pos = lst.GetHeadPosition();
  939. while (pos)
  940. {
  941. CXTPDockingPane* p = (CXTPDockingPane*)lst.GetNext(pos);
  943. if (m_pManager->NotifyAction(xtpPaneActionAttaching, p, pPane))
  944. {
  945. return FALSE;
  946. }
  947. }
  948. return TRUE;
  949. }
  951. BOOL CXTPDockingPaneContext::IsBehind(CXTPDockingPaneBase* pPaneBase, CXTPDockingPaneBase* pPaneTest)
  952. {
  953. CWnd* pFrameBase = pPaneBase->GetDockingSite();
  954. if (!pFrameBase || !pFrameBase->IsKindOf(RUNTIME_CLASS(CXTPDockingPaneMiniWnd)))
  955. return TRUE;
  957. CWnd* pFrameTest = pPaneTest->GetDockingSite();
  958. if (!pFrameTest || !pFrameTest->IsKindOf(RUNTIME_CLASS(CXTPDockingPaneMiniWnd)))
  959. return FALSE;
  961. HWND hWndNext = ::GetWindow(pFrameBase->GetSafeHwnd(), GW_HWNDNEXT);
  963. while (hWndNext)
  964. {
  965. if (hWndNext == pFrameTest->GetSafeHwnd())
  966. return FALSE;
  968. hWndNext = ::GetWindow(hWndNext, GW_HWNDNEXT);
  969. }
  971. return TRUE;
  972. }
  974. void CXTPDockingPaneContext::FindContainer(CPoint pt)
  975. {
  976. CXTPDockingPaneInfoList* pList = &m_pManager->GetPaneList();
  978. CXTPDockingPaneBase* pFloatingPane = NULL;
  980. POSITION pos = pList->GetHeadPosition();
  981. while (pos)
  982. {
  983. CXTPDockingPane* pNextPane = pList->GetNext(pos);
  985. CXTPDockingPaneBase* pPane = pNextPane->GetContainer();
  986. if (pPane == NULL)
  987. continue;
  989. ASSERT(pPane->GetType() == xtpPaneTypeTabbedContainer);
  991. if (pPane->GetContainer() == 0 || pPane->GetContainer()->GetType() != xtpPaneTypeSplitterContainer)
  992. continue;
  994. if (! (::GetWindowLong(((CXTPDockingPaneTabbedContainer*)pPane)->GetSafeHwnd(), GWL_STYLE) & WS_VISIBLE))
  995. continue;
  997. if (m_pPane->ContainPane(pPane))
  998. continue;
  1000. CRect rcClient = pPane->GetPaneWindowRect();
  1002. if (rcClient.PtInRect(pt) && pNextPane->IsFloating())
  1003. {
  1004. if (pFloatingPane == NULL || IsBehind(pFloatingPane, pPane))
  1005. {
  1006. pFloatingPane = pPane;
  1007. }
  1008. }
  1009. }
  1011. pos = pList->GetHeadPosition();
  1012. while (pos)
  1013. {
  1014. CXTPDockingPane* pNextPane = pList->GetNext(pos);
  1015. if (pNextPane->GetOptions() & xtpPaneNoDockable)
  1016. continue;
  1018. CXTPDockingPaneBase* pPane = pNextPane->GetContainer();
  1019. if (pPane == NULL)
  1020. continue;
  1022. if (pFloatingPane != NULL && pFloatingPane != pPane)
  1023. continue;
  1025. ASSERT(pPane->GetType() == xtpPaneTypeTabbedContainer);
  1027. if (pPane->GetContainer() == 0 || (pPane->GetContainer()->GetType() != xtpPaneTypeSplitterContainer && pPane->GetContainer()->GetType() != xtpPaneTypeSidePanel))
  1028. continue;
  1030. if (! (::GetWindowLong(((CXTPDockingPaneTabbedContainer*)pPane)->GetSafeHwnd(), GWL_STYLE) & WS_VISIBLE))
  1031. continue;
  1033. CRect rcClient = m_rectContainer = pPane->GetPaneWindowRect();
  1035. if (m_pPane->ContainPane(pPane))
  1036. continue;
  1038. if (((CXTPDockingPaneTabbedContainer*)pPane)->CanAttach(rcClient, pt))
  1039. {
  1040. if (IsAllowAttachTo(pPane))
  1041. {
  1042. m_pContainer = pPane;
  1043. m_bAttach = TRUE;
  1044. m_pStickerPane = 0;
  1045. m_rectStickerPane.SetRectEmpty();
  1046. return;
  1047. }
  1048. else
  1049. {
  1050. rcClient = m_rectContainer;
  1051. }
  1052. }
  1053. if (pPane->GetContainer()->GetType() == xtpPaneTypeSidePanel)
  1054. continue;
  1056. if (m_bUseDockingStickers)
  1057. {
  1058. if (rcClient.PtInRect(pt))
  1059. {
  1060. if (m_pStickerPane == NULL || IsBehind(m_pStickerPane, pPane))
  1061. {
  1062. m_rectStickerPane = m_rectContainer;
  1063. m_pStickerPane = pPane;
  1064. }
  1065. }
  1066. }
  1067. else
  1068. {
  1069. if (CanDock(rcClient, pt, pPane))
  1070. return;
  1071. }
  1072. }
  1074. if (pFloatingPane)
  1075. return;
  1077. if (m_pManager->IsSideDockingEnabled())
  1078. {
  1079. if (CanSideDock(m_pManager->GetClientPane(), m_rectDragFrame))
  1080. {
  1081. m_bSideDock = TRUE;
  1082. return;
  1083. }
  1084. }
  1086. if (m_bUseDockingStickers)
  1087. {
  1088. if (m_pStickerPane)
  1089. {
  1090. return;
  1091. }
  1093. if (m_rectStickerPane.IsRectEmpty())
  1094. {
  1095. CXTPDockingPaneBase* pPane = m_pManager->GetClientPane();
  1096. if (pPane->GetPaneWindowRect().PtInRect(pt))
  1097. {
  1098. m_rectStickerPane = pPane->GetPaneWindowRect();
  1099. m_pStickerPane = pPane;
  1100. return;
  1101. }
  1103. pPane = m_pManager->GetTopPane();
  1104. if (pPane->GetPaneWindowRect().PtInRect(pt))
  1105. {
  1106. m_rectStickerPane = pPane->GetPaneWindowRect();
  1107. }
  1108. }
  1109. }
  1110. else
  1111. {
  1112. CXTPDockingPaneBase* pPane;
  1114. pPane = m_pManager->GetClientPane();
  1115. m_rectContainer = pPane->GetPaneWindowRect();
  1116. if (CanDock(pPane->GetPaneWindowRect(), pt, pPane))
  1117. return;
  1119. pPane = m_pManager->GetTopPane();
  1120. m_rectContainer = pPane->GetPaneWindowRect();
  1121. if (CanDock(pPane->GetPaneWindowRect(), pt, pPane, FALSE))
  1122. return;
  1123. }
  1124. }
  1126. void CXTPDockingPaneContext::EnsureVisible(CRect& rectDragFrame)
  1127. {
  1128. CRect rcWork = XTPMultiMonitor()->GetWorkArea(rectDragFrame);
  1129. int nGap = 10;
  1131. if (rcWork.bottom - rectDragFrame.top < nGap)
  1132. {
  1133. rectDragFrame.OffsetRect(0, rcWork.bottom - rectDragFrame.top - nGap);
  1134. }
  1135. if (rectDragFrame.bottom - rcWork.top < nGap)
  1136. {
  1137. rectDragFrame.OffsetRect(0, rcWork.top - rectDragFrame.bottom + nGap);
  1138. }
  1139. if (rcWork.right - rectDragFrame.left < nGap)
  1140. {
  1141. rectDragFrame.OffsetRect(rcWork.right - rectDragFrame.left - nGap, 0);
  1142. }
  1143. if (rectDragFrame.right - rcWork.left < nGap)
  1144. {
  1145. rectDragFrame.OffsetRect(rcWork.left - rectDragFrame.right + nGap, 0);
  1146. }
  1147. }
  1149. void CXTPDockingPaneContext::UpdateStickyFrame(CRect& rectDragFrame, CWnd* pHost)
  1150. {
  1151. int nGap = m_pManager->m_nStickyGap;
  1152. CXTPWindowRect rcWork(pHost);
  1154. if (rectDragFrame.bottom < rcWork.top - nGap || rectDragFrame.top > rcWork.bottom + nGap)
  1155. return;
  1157. if (rectDragFrame.right < rcWork.left - nGap || rectDragFrame.left > rcWork.right + nGap)
  1158. return;
  1160. if (abs(rcWork.bottom - rectDragFrame.top) < nGap)
  1161. {
  1162. rectDragFrame.OffsetRect(0, rcWork.bottom - rectDragFrame.top);
  1163. }
  1164. if (abs(rectDragFrame.bottom - rcWork.top) < nGap)
  1165. {
  1166. rectDragFrame.OffsetRect(0, rcWork.top - rectDragFrame.bottom);
  1167. }
  1168. if (abs(rcWork.left - rectDragFrame.right) < nGap)
  1169. {
  1170. rectDragFrame.OffsetRect(rcWork.left - rectDragFrame.right, 0);
  1171. }
  1172. if (abs(rectDragFrame.left - rcWork.right) < nGap)
  1173. {
  1174. rectDragFrame.OffsetRect(rcWork.right - rectDragFrame.left, 0);
  1175. }
  1176. if (abs(rectDragFrame.left - rcWork.left) < nGap)
  1177. {
  1178. rectDragFrame.OffsetRect(rcWork.left - rectDragFrame.left, 0);
  1179. }
  1180. if (abs(rectDragFrame.right - rcWork.right) < nGap)
  1181. {
  1182. rectDragFrame.OffsetRect(rcWork.right - rectDragFrame.right, 0);
  1183. }
  1184. if (abs(rectDragFrame.bottom - rcWork.bottom) < nGap)
  1185. {
  1186. rectDragFrame.OffsetRect(0, rcWork.bottom - rectDragFrame.bottom);
  1187. }
  1188. if (abs(rectDragFrame.top - rcWork.top) < nGap)
  1189. {
  1190. rectDragFrame.OffsetRect(0, rcWork.top - rectDragFrame.top);
  1191. }
  1192. }
  1194. void CXTPDockingPaneContext::UpdateStickyFrame(CRect& rectDragFrame)
  1195. {
  1196. CRect rcWork = XTPMultiMonitor()->GetWorkArea(rectDragFrame);
  1197. int nGap = m_pManager->m_nStickyGap;
  1199. if (abs(rcWork.top - rectDragFrame.top) < nGap)
  1200. {
  1201. rectDragFrame.OffsetRect(0, rcWork.top - rectDragFrame.top);
  1202. }
  1203. if (abs(rectDragFrame.bottom - rcWork.bottom) < nGap)
  1204. {
  1205. rectDragFrame.OffsetRect(0, rcWork.bottom - rectDragFrame.bottom);
  1206. }
  1207. if (abs(rcWork.right - rectDragFrame.right) < nGap)
  1208. {
  1209. rectDragFrame.OffsetRect(rcWork.right - rectDragFrame.right, 0);
  1210. }
  1211. if (abs(rectDragFrame.left - rcWork.left) < nGap)
  1212. {
  1213. rectDragFrame.OffsetRect(rcWork.left - rectDragFrame.left, 0);
  1214. }
  1216. if ((m_pManager->GetSite()->GetStyle() & (WS_MAXIMIZE | WS_MINIMIZE)) == 0)
  1217. UpdateStickyFrame(rectDragFrame, m_pManager->GetSite());
  1219. CXTPDockingPaneBaseList* pList = &m_pManager->GetPaneStack();
  1220. POSITION pos = pList->GetHeadPosition();
  1221. while (pos)
  1222. {
  1223. CXTPDockingPaneBase* pNextPane = pList->GetNext(pos);
  1224. if (pNextPane->GetType() != xtpPaneTypeMiniWnd)
  1225. continue;
  1227. CXTPDockingPaneMiniWnd* pWnd = (CXTPDockingPaneMiniWnd*)pNextPane;
  1228. if (pWnd->GetSafeHwnd() && pWnd->IsWindowVisible() && m_pPane->GetDockingSite() != pWnd)
  1229. {
  1230. UpdateStickyFrame(rectDragFrame, pWnd);
  1231. }
  1232. }
  1233. }
  1235. void CXTPDockingPaneContext::UpdateSizingStickyFrame(UINT nSide, CRect& rectDragFrame, CWnd* pHost)
  1236. {
  1237. int nGap = m_pManager->m_nStickyGap;
  1238. CXTPWindowRect rcWork(pHost);
  1240. if (rectDragFrame.bottom < rcWork.top - nGap || rectDragFrame.top > rcWork.bottom + nGap)
  1241. return;
  1243. if (rectDragFrame.right < rcWork.left - nGap || rectDragFrame.left > rcWork.right + nGap)
  1244. return;
  1246. if (abs(rectDragFrame.top - rcWork.bottom) < nGap && (nSide == WMSZ_TOP || nSide == WMSZ_TOPLEFT || nSide == WMSZ_TOPRIGHT))
  1247. {
  1248. rectDragFrame.top = rcWork.bottom;
  1249. }
  1250. if (abs(rectDragFrame.bottom - rcWork.top) < nGap && (nSide == WMSZ_BOTTOM || nSide == WMSZ_BOTTOMLEFT || nSide == WMSZ_BOTTOMRIGHT))
  1251. {
  1252. rectDragFrame.bottom = rcWork.top;
  1253. }
  1254. if (abs(rectDragFrame.left - rcWork.left) < nGap && (nSide == WMSZ_LEFT || nSide == WMSZ_TOPLEFT || nSide == WMSZ_BOTTOMLEFT))
  1255. {
  1256. rectDragFrame.left = rcWork.left;
  1257. }
  1258. if (abs(rectDragFrame.left - rcWork.right) < nGap && (nSide == WMSZ_LEFT || nSide == WMSZ_TOPLEFT || nSide == WMSZ_BOTTOMLEFT))
  1259. {
  1260. rectDragFrame.left = rcWork.right;
  1261. }
  1262. if (abs(rectDragFrame.right - rcWork.left) < nGap  && (nSide == WMSZ_RIGHT || nSide == WMSZ_TOPRIGHT|| nSide == WMSZ_BOTTOMRIGHT))
  1263. {
  1264. rectDragFrame.right = rcWork.left;
  1265. }
  1266. if (abs(rectDragFrame.right - rcWork.right) < nGap  && (nSide == WMSZ_RIGHT || nSide == WMSZ_TOPRIGHT|| nSide == WMSZ_BOTTOMRIGHT))
  1267. {
  1268. rectDragFrame.right = rcWork.right;
  1269. }
  1270. }
  1272. void CXTPDockingPaneContext::OnSizingFloatingFrame(CXTPDockingPaneMiniWnd* pMiniWnd, UINT nSide, LPRECT lpRect)
  1273. {
  1274. if (!m_pManager->IsStickyFloatingFrames())
  1275. return;
  1277. CRect rectDragFrame(lpRect);
  1279. if ((m_pManager->GetSite()->GetStyle() & (WS_MAXIMIZE | WS_MINIMIZE)) == 0)
  1280. UpdateSizingStickyFrame(nSide, rectDragFrame, m_pManager->GetSite());
  1282. CXTPDockingPaneBaseList* pList = &m_pManager->GetPaneStack();
  1283. POSITION pos = pList->GetHeadPosition();
  1284. while (pos)
  1285. {
  1286. CXTPDockingPaneBase* pNextPane = pList->GetNext(pos);
  1287. if (pNextPane->GetType() != xtpPaneTypeMiniWnd)
  1288. continue;
  1290. CXTPDockingPaneMiniWnd* pWnd = (CXTPDockingPaneMiniWnd*)pNextPane;
  1291. if (pWnd->GetSafeHwnd() && pWnd->IsWindowVisible() && pMiniWnd != pWnd)
  1292. {
  1293. UpdateSizingStickyFrame(nSide, rectDragFrame, pWnd);
  1294. }
  1295. }
  1297. *lpRect = rectDragFrame;
  1298. }
  1300. void CXTPDockingPaneContext::Move(CPoint pt)
  1301. {
  1302. CPoint ptOffset = pt - m_ptLast;
  1304. m_rectDragFrameScreen.OffsetRect(ptOffset);
  1306. if (CRect().IntersectRect(m_rectDragFrameScreen, XTPMultiMonitor()->GetWorkArea(m_rectDragFrame)))
  1307. {
  1308. m_rectDragFrame = m_rectDragFrameScreen;
  1309. }
  1311. EnsureVisible(m_rectDragFrame);
  1313. if (!m_rectDragFrame.IsRectEmpty() && m_pManager->m_bStickyFloatingFrames)
  1314. {
  1315. UpdateStickyFrame(m_rectDragFrame);
  1316. }
  1319. m_pContainer = 0;
  1320. m_bAttach = FALSE;
  1321. m_rectStickerPane.SetRectEmpty();
  1322. m_pStickerPane = NULL;
  1323. m_bSideDock = FALSE;
  1325. if (GetKeyState(VK_CONTROL) >= 0 && m_bDockable)
  1326. {
  1327. FindContainer(pt);
  1328. }
  1330. m_ptLast = pt;
  1332. if (m_bUseDockingStickers)
  1333. {
  1334. UpdateDockingStickers();
  1336. BOOL bFound = FALSE;
  1337. POSITION pos = m_lstStickers.GetTailPosition();
  1338. while (pos)
  1339. {
  1341. CXTPDockingPaneContextStickerWnd* pSticker = m_lstStickers.GetPrev(pos);
  1342. XTPDockingPaneStickerType selectedSticker = xtpPaneStickerNone;
  1344. if (!bFound)
  1345. {
  1346. XTPDockingPaneStickerType ht = pSticker->HitTest(pt);
  1347. if (ht != xtpPaneStickerNone)
  1348. {
  1349. if ((pSticker->m_typeSticker & xtpPaneStickerClient) == xtpPaneStickerClient)
  1350. {
  1351. m_pContainer = m_pStickerPane;
  1352. m_rectContainer = m_rectStickerPane;
  1353. }
  1354. else
  1355. {
  1356. m_pContainer = m_pManager->GetTopPane();
  1357. m_rectContainer = m_pContainer->GetPaneWindowRect();
  1358. }
  1360. switch (ht)
  1361. {
  1362. case xtpPaneStickerTop:
  1363. m_rectContainer.bottom = m_rectContainer.CenterPoint().y;
  1364. m_containDirection = xtpPaneDockTop;
  1365. break;
  1366. case xtpPaneStickerBottom:
  1367. m_rectContainer.top = m_rectContainer.CenterPoint().y;
  1368. m_containDirection = xtpPaneDockBottom;
  1369. break;
  1370. case xtpPaneStickerLeft:
  1371. m_rectContainer.right = m_rectContainer.CenterPoint().x;
  1372. m_containDirection = xtpPaneDockLeft;
  1373. break;
  1374. case xtpPaneStickerRight:
  1375. m_rectContainer.left = m_rectContainer.CenterPoint().x;
  1376. m_containDirection = xtpPaneDockRight;
  1377. break;
  1378. case xtpPaneStickerCenter:
  1379. m_bAttach = TRUE;
  1380. break;
  1381. }
  1383. BOOL bAllow = TRUE;
  1385. if ((ht != xtpPaneStickerCenter) && !IsAllowDockingTo(m_pContainer, m_containDirection))
  1386. {
  1387. m_pContainer = NULL;
  1388. bAllow = FALSE;
  1389. }
  1391. if ((ht == xtpPaneStickerCenter) && !IsAllowAttachTo(m_pContainer))
  1392. {
  1393. m_pContainer = NULL;
  1394. m_bAttach = FALSE;
  1395. bAllow = FALSE;
  1396. }
  1398. if (bAllow)
  1399. {
  1400. if (ht != xtpPaneStickerCenter)
  1401. m_rectContainer = m_pManager->_CalculateResultDockingRect(m_pPane, m_containDirection, m_pContainer);
  1403. selectedSticker = ht;
  1404. }
  1406. bFound = TRUE;
  1407. }
  1408. }
  1409. if (pSticker->m_selectedSticker != selectedSticker)
  1410. {
  1411. pSticker->m_selectedSticker = selectedSticker;
  1412. pSticker->Invalidate(FALSE);
  1413. }
  1414. }
  1415. }
  1418. DrawFocusRect();
  1419. }
  1421. void CXTPDockingPaneContext::Track()
  1422. {
  1423. // don't handle if capture already set
  1424. if (::GetCapture() != NULL)
  1425. return;
  1427. CWnd* pCapture = m_pManager->GetSite();
  1428. ASSERT(pCapture);
  1429. if (!pCapture)
  1430. return;
  1431. // set capture to the window which received this message
  1432. pCapture->SetCapture();
  1433. ASSERT(pCapture == CWnd::GetCapture());
  1435. BOOL bAccept = FALSE;
  1436. // get messages until capture lost or cancelled/accepted
  1437. while (CWnd::GetCapture() == pCapture)
  1438. {
  1439. MSG msg;
  1441. // handle pending WM_PAINT messages
  1442. while (::PeekMessage(&msg, NULL, WM_PAINT, WM_PAINT, PM_NOREMOVE))
  1443. {
  1444. if (!GetMessage(&msg, NULL, WM_PAINT, WM_PAINT))
  1445. return;
  1446. DispatchMessage(&msg);
  1447. continue;
  1448. }
  1451. if (!::GetMessage(&msg, NULL, 0, 0))
  1452. {
  1453. AfxPostQuitMessage((int)msg.wParam);
  1454. break;
  1455. }
  1457. if (msg.message == WM_LBUTTONUP)
  1458. {
  1459. bAccept = TRUE;
  1460. break;
  1461. }
  1462. else if (msg.message == WM_MOUSEMOVE)
  1463. {
  1464. CSize sz = m_ptSticky - CPoint(msg.pt);
  1465. if (abs(sz.cx) > 4 || abs(sz.cy) > 4)
  1466. {
  1467. Move(msg.pt);
  1468. m_ptSticky = CPoint(0, 0);
  1469. }
  1470. }
  1471. else if (msg.message == WM_KEYDOWN || msg.message == WM_KEYUP)
  1472. {
  1473. if (m_bDragKeyboard && msg.message == WM_KEYDOWN)
  1474. {
  1475. if (msg.wParam == VK_RETURN)
  1476. {
  1477. bAccept = TRUE;
  1478. break;
  1479. }
  1480. if (msg.wParam >= VK_LEFT && msg.wParam <= VK_DOWN)
  1481. {
  1482. CPoint pt(m_ptLast);
  1483. if (msg.wParam == VK_LEFT)
  1484. pt.x -= 10;
  1485. else if (msg.wParam == VK_RIGHT)
  1486. pt.x += 10;
  1487. else if (msg.wParam == VK_UP)
  1488. pt.y -= 10;
  1489. else if (msg.wParam == VK_DOWN)
  1490. pt.y += 10;
  1492. AdjustCursor(pt);
  1493. SetCursorPos(pt.x, pt.y);
  1494. Move(pt);
  1495. m_ptSticky = CPoint(0, 0);
  1496. }
  1497. }
  1498. if (msg.wParam == VK_CONTROL)
  1499. {
  1500. Move(m_ptLast);
  1501. m_ptSticky = CPoint(0, 0);
  1502. }
  1503. if (msg.wParam == VK_ESCAPE)
  1504. {
  1505. break;
  1506. }
  1507. }
  1508. else
  1509. DispatchMessage(&msg);
  1510. }
  1512. CancelLoop();
  1514. if (bAccept && m_ptSticky == CPoint(0, 0))
  1515. {
  1516. XTPDockingPaneAction actionNotify = xtpPaneActionFloated;
  1518. CXTPDockingPaneBaseList lst;
  1519. m_pPane->FindPane(xtpPaneTypeDockingPane, &lst);
  1521. if (m_bAttach)
  1522. {
  1523. ASSERT(m_pContainer->GetType() == xtpPaneTypeTabbedContainer);
  1524. m_pManager->AttachPane(m_pPane, m_pContainer);
  1525. actionNotify = xtpPaneActionAttached;
  1526. }
  1527. else if (m_bSideDock && m_pContainer && m_pContainer == m_pManager->GetClientPane())
  1528. {
  1529. CRect rectSide(m_rectContainer);
  1530. rectSide.OffsetRect(-m_pContainer->GetPaneWindowRect().TopLeft());
  1532. if (m_pPane->GetContainer() && m_pPane->GetContainer()->GetType() == xtpPaneTypeSidePanel)
  1533. ((CXTPDockingPaneSidePanel*)m_pPane->GetContainer())->MovePanel(m_containDirection, rectSide);
  1534. else
  1535. m_pManager->DockSidePane(m_pPane, m_containDirection, rectSide);
  1537. actionNotify = xtpPaneActionDocked;
  1538. }
  1539. else if (m_pContainer)
  1540. {
  1541. m_pManager->DockPane(m_pPane, m_pManager->GetRTLDirection(m_containDirection), m_pContainer);
  1542. m_pManager->EnsureVisible(m_pContainer);
  1543. actionNotify = xtpPaneActionDocked;
  1544. }
  1545. else if (m_bFloatable)
  1546. {
  1547. CRect rcWork = XTPMultiMonitor()->GetWorkArea(m_rectDragFrame);
  1549. if (m_rectDragFrame.top < rcWork.top)
  1550. m_rectDragFrame.OffsetRect(0, rcWork.top - m_rectDragFrame.top);
  1552. if (m_pPane->GetType() == xtpPaneTypeSplitterContainer)
  1553. m_pPane->GetDockingSite()->MoveWindow(m_rectDragFrame);
  1554. else
  1555. m_pManager->FloatPane(m_pPane, m_rectDragFrame);
  1556. }
  1557. else
  1558. {
  1559. bAccept = FALSE;
  1560. }
  1562. if (bAccept)
  1563. {
  1564. POSITION pos = lst.GetHeadPosition();
  1565. while (pos)
  1566. {
  1567. CXTPDockingPane* pPane = (CXTPDockingPane*)lst.GetNext(pos);
  1568. m_pManager->NotifyAction(actionNotify, pPane, m_pContainer, m_containDirection);
  1569. }
  1570. }
  1571. }
  1572. }
  1575. void CXTPDockingPaneContext::DestroyDockingStickers()
  1576. {
  1577. while (!m_lstStickers.IsEmpty())
  1578. {
  1579. CWnd* pWnd = m_lstStickers.RemoveHead();
  1580. pWnd->DestroyWindow();
  1581. delete pWnd;
  1582. }
  1583. }
  1585. void CXTPDockingPaneContext::IncludeRgnPart(CRgn* pRgn, int x1, int y, int x2)
  1586. {
  1587. if (x1 < x2)
  1588. {
  1589. CRgn rgnExclude;
  1590. rgnExclude.CreateRectRgn(x1, y, x2, y + 1);
  1591. pRgn->CombineRgn(pRgn, &rgnExclude, RGN_OR);
  1592. }
  1593. }
  1595. void CXTPDockingPaneContext::RegionFromBitmap(CRgn* pRgn, CDC* pDC, CRect rc)
  1596. {
  1597. CSize sz = rc.Size();
  1599. pRgn->CreateRectRgn(0, 0, 0, 0);
  1601. for (int y = 0; y < sz.cy; y++)
  1602. {
  1603. int nStart = 0, x = 0;
  1604. BOOL bTransparent = TRUE;
  1606. while (x < sz.cx)
  1607. {
  1608. BOOL bTransparentPixel = pDC->GetPixel(x, y) == 0;
  1610. if (bTransparent && !bTransparentPixel)
  1611. {
  1612. nStart = x;
  1613. bTransparent = FALSE;
  1614. }
  1615. else if (!bTransparent && bTransparentPixel)
  1616. {
  1617. IncludeRgnPart(pRgn, nStart, y, x);
  1618. bTransparent = TRUE;
  1619. }
  1620. x++;
  1621. }
  1622. if (!bTransparent)
  1623. {
  1624. IncludeRgnPart(pRgn, nStart, y, x);
  1625. }
  1626. }
  1627. }
  1629. CXTPDockingPaneContextStickerWnd* CXTPDockingPaneContext::CreateNewSticker(CRect rc, XTPDockingPaneStickerType typeSticker)
  1630. {
  1631. if (typeSticker == xtpPaneStickerNone || typeSticker == xtpPaneStickerClient)
  1632. return NULL;
  1634. CXTPDockingPaneContextStickerWnd* pWnd = new CXTPDockingPaneContextStickerWnd(this);
  1635. m_lstStickers.AddTail(pWnd);
  1637. pWnd->CreateEx(WS_EX_TOOLWINDOW, AfxRegisterWndClass(NULL, AfxGetApp()->LoadStandardCursor(IDC_ARROW)),
  1638. 0, WS_POPUP, CRect(0, 0, 0, 0), m_pManager->GetSite(), 0);
  1640. pWnd->m_typeSticker = typeSticker;
  1643. CRgn* pRgn = NULL;
  1644. if (!m_rgnStickers.Lookup(typeSticker, pRgn))
  1645. {
  1646. pRgn = new CRgn;
  1647. m_rgnStickers.SetAt(typeSticker, pRgn);
  1648. }
  1649. ASSERT(pRgn != NULL);
  1650. if (!pRgn)
  1651. return NULL;
  1653. if (!pRgn->GetSafeHandle())
  1654. {
  1655. CClientDC dcClient(pWnd);
  1656. CBitmap bmp;
  1657. bmp.CreateCompatibleBitmap(&dcClient, rc.Width(), rc.Height());
  1659. if (bmp.GetSafeHandle())
  1660. {
  1661. CXTPCompatibleDC dc(&dcClient, &bmp);
  1662. dc.FillSolidRect(rc, RGB(0, 0, 0));
  1663. pWnd->OnDraw(&dc);
  1665. RegionFromBitmap(pRgn, &dc, rc);
  1666. }
  1667. }
  1669. HRGN hRgn = ::CreateRectRgn(0, 0, 0, 0);
  1670. ::CombineRgn(hRgn, (HRGN)pRgn->GetSafeHandle(), NULL, RGN_COPY);
  1672. pWnd->SetWindowRgn(hRgn, FALSE);
  1673. pWnd->SetWindowPos(0, rc.left, rc.top, rc.Width(), rc.Height(), SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
  1675. return pWnd;
  1676. }
  1678. CSize CXTPDockingPaneContext::GetStickerSize(XTPDockingPaneStickerType type) const
  1679. {
  1680. if (GetStickerStyle() == xtpPaneStickerStyleVisualStudio2005)
  1681. {
  1682. if (type == xtpPaneStickerTop) return CSize(29, 32);
  1683. if (type == xtpPaneStickerLeft) return CSize(32, 29);
  1684. if (type == xtpPaneStickerBottom) return CSize(29, 32);
  1685. if (type == xtpPaneStickerRight) return CSize(32, 29);
  1686. return CSize(89, 89);
  1687. }
  1688. else
  1689. {
  1690. if (type == xtpPaneStickerTop) return CSize(43, 30);
  1691. if (type == xtpPaneStickerLeft) return CSize(30, 43);
  1692. if (type == xtpPaneStickerBottom) return CSize(43, 30);
  1693. if (type == xtpPaneStickerRight) return CSize(30, 43);
  1694. return CSize(93, 93);
  1695. }
  1696. }
  1698. XTPDockingContextStickerStyle CXTPDockingPaneContext::GetStickerStyle() const
  1699. {
  1700. return m_pManager->GetDockingContextStickerStyle();
  1702. }
  1704. void CXTPDockingPaneContext::UpdateDockingStickers()
  1705. {
  1706. if (m_rectStickerPane.IsRectEmpty())
  1707. {
  1708. m_pLastStickerPane = NULL;
  1709. DestroyDockingStickers();
  1710. return;
  1711. }
  1713. CSize sz(GetStickerSize(xtpPaneStickerClient));
  1714. CRect rc(m_rectStickerPane.CenterPoint(), sz);
  1715. rc.OffsetRect(- sz.cx / 2, - sz.cy / 2);
  1717. if (m_pLastStickerPane != m_pStickerPane || m_lstStickers.IsEmpty())
  1718. {
  1719. DestroyDockingStickers();
  1721. if (m_pStickerPane)
  1722. {
  1723. UINT allowStickers = xtpPaneStickerNone;
  1724. if (IsAllowDockingTo(m_pStickerPane, xtpPaneDockLeft)) allowStickers = allowStickers + xtpPaneStickerLeft;
  1725. if (IsAllowDockingTo(m_pStickerPane, xtpPaneDockRight)) allowStickers = allowStickers + xtpPaneStickerRight;
  1726. if (IsAllowDockingTo(m_pStickerPane, xtpPaneDockBottom)) allowStickers = allowStickers + xtpPaneStickerBottom;
  1727. if (IsAllowDockingTo(m_pStickerPane, xtpPaneDockTop)) allowStickers = allowStickers + xtpPaneStickerTop;
  1729. CreateNewSticker(rc, m_pStickerPane == m_pManager->GetClientPane() || !IsAllowAttachTo(m_pStickerPane) ? XTPDockingPaneStickerType(xtpPaneStickerClient + allowStickers) : XTPDockingPaneStickerType(xtpPaneStickerClient + allowStickers + xtpPaneStickerCenter));
  1730. }
  1732. CXTPDockingPaneBase* pTopPane = m_pManager->GetTopPane();
  1733. CRect rcWindow = pTopPane->GetPaneWindowRect();
  1735. if (IsAllowDockingTo(pTopPane, xtpPaneDockTop))
  1736. CreateNewSticker(CRect(CPoint(rcWindow.CenterPoint().x - GetStickerSize(xtpPaneStickerTop).cx / 2, rcWindow.top + 16), GetStickerSize(xtpPaneStickerTop)), xtpPaneStickerTop);
  1737. if (IsAllowDockingTo(pTopPane, xtpPaneDockLeft))
  1738. CreateNewSticker(CRect(CPoint(rcWindow.left + 16, rcWindow.CenterPoint().y - GetStickerSize(xtpPaneStickerLeft).cy/ 2), GetStickerSize(xtpPaneStickerLeft)), xtpPaneStickerLeft);
  1739. if (IsAllowDockingTo(pTopPane, xtpPaneDockBottom))
  1740. CreateNewSticker(CRect(CPoint(rcWindow.CenterPoint().x - GetStickerSize(xtpPaneStickerBottom).cx / 2, rcWindow.bottom - 16 - GetStickerSize(xtpPaneStickerBottom).cy), GetStickerSize(xtpPaneStickerBottom)), xtpPaneStickerBottom);
  1741. if (IsAllowDockingTo(pTopPane, xtpPaneDockRight))
  1742. CreateNewSticker(CRect(CPoint(rcWindow.right - GetStickerSize(xtpPaneStickerRight).cx - 16, rcWindow.CenterPoint().y - GetStickerSize(xtpPaneStickerRight).cy/ 2), GetStickerSize(xtpPaneStickerRight)), xtpPaneStickerRight);
  1744. m_pLastStickerPane = m_pStickerPane;
  1745. }
  1747. ASSERT(m_lstStickers.GetCount() < 6);
  1748. }
  1751. void CXTPDockingPaneContext::CreateContextWindow(CXTPDockingPaneContextAlphaWnd* pWnd)
  1752. {
  1753. ASSERT(m_bUseAlphaContext);
  1755. if (pWnd->GetSafeHwnd())
  1756. return;
  1758. pWnd->CreateEx(WS_EX_LAYERED | WS_EX_TOPMOST | WS_EX_TOOLWINDOW, AfxRegisterWndClass(NULL, AfxGetApp()->LoadStandardCursor(IDC_ARROW)),
  1759. 0, WS_POPUP, CRect(0, 0, 0, 0), m_pManager->GetSite(), 0);
  1761. if (m_pfnSetLayeredWindowAttributes)
  1762. {
  1763. ((PFNSETLAYEREDWINDOWATTRIBUTES)m_pfnSetLayeredWindowAttributes)
  1764. (pWnd->m_hWnd, 0, 100, LWA_ALPHA);
  1765. }
  1766. }