📄 bcgpdockmanager.cpp
字号:
if (pControlBar->IsBarVisible ())
{
pControlBar->Slide (FALSE, !bImmediately);
}
}
}
//------------------------------------------------------------------------//
void CBCGPDockManager::AlignAutoHideBar (CBCGPSlider* pDefaultSlider, BOOL bIsVisible)
{
CRect rectSlider;
pDefaultSlider->GetWindowRect (rectSlider);
BOOL bHorz = pDefaultSlider->IsHorizontal ();
DWORD dwAlignment = pDefaultSlider->GetCurrentAlignment ();
if (bIsVisible)
{
CSize sizeRequered = pDefaultSlider->CalcFixedLayout (FALSE, bHorz);
if (bHorz)
{
dwAlignment & CBRS_ALIGN_TOP ? rectSlider.bottom = rectSlider.top + sizeRequered.cy :
rectSlider.top = rectSlider.bottom - sizeRequered.cy;
}
else
{
dwAlignment & CBRS_ALIGN_LEFT ? rectSlider.right = rectSlider.left + sizeRequered.cx :
rectSlider.left = rectSlider.right - sizeRequered.cx;
}
// m_rectOuterEdgeBounds - the area surrounded by dock bars
AlignByRect (m_rectOuterEdgeBounds, rectSlider, dwAlignment, bHorz, TRUE);
HDWP hdwp = NULL;
pDefaultSlider->GetParent ()->ClientToScreen (rectSlider);
pDefaultSlider->RepositionBars (rectSlider, hdwp);
}
else
{
// it can be nonvisible only when moved out of screen - adjust only width/height
CBCGPBaseControlBar* pControlBar = (CBCGPBaseControlBar*)
pDefaultSlider->GetFirstBar ();
CRect rectControlBar;
pControlBar->GetWindowRect (rectControlBar);
pDefaultSlider->GetParent ()->ScreenToClient (rectSlider);
pDefaultSlider->GetParent ()->ScreenToClient (rectControlBar);
if (bHorz)
{
rectSlider.left = rectControlBar.left = m_rectOuterEdgeBounds.left;
rectSlider.right = rectControlBar.right = m_rectOuterEdgeBounds.right;
}
else
{
rectSlider.top = rectControlBar.top = m_rectOuterEdgeBounds.top;
rectSlider.bottom = rectControlBar.bottom = m_rectOuterEdgeBounds.bottom;
}
CPoint ptOffset (0, 0);
// slider is not hidden completely - it is aligned by m_rectOuterEdgeBounds
switch (dwAlignment)
{
case CBRS_ALIGN_LEFT:
if (rectSlider.left != m_rectOuterEdgeBounds.left)
{
ptOffset.x = m_rectOuterEdgeBounds.left - rectSlider.left;
}
break;
case CBRS_ALIGN_RIGHT:
if (rectSlider.right != m_rectOuterEdgeBounds.right)
{
ptOffset.x = m_rectOuterEdgeBounds.right - rectSlider.right;
}
break;
case CBRS_ALIGN_TOP:
if (rectSlider.top != m_rectOuterEdgeBounds.top)
{
ptOffset.y = m_rectOuterEdgeBounds.top - rectSlider.top;
}
break;
case CBRS_ALIGN_BOTTOM:
if (rectSlider.bottom != m_rectOuterEdgeBounds.bottom)
{
ptOffset.y = m_rectOuterEdgeBounds.bottom - rectSlider.bottom;
}
break;
}
rectSlider.OffsetRect (ptOffset);
rectControlBar.OffsetRect (ptOffset);
pDefaultSlider->SetWindowPos (NULL, rectSlider.left, rectSlider.top,
rectSlider.Width (), rectSlider.Height (),
SWP_NOZORDER | SWP_NOACTIVATE);
pControlBar->SetWindowPos (NULL, rectControlBar.left, rectControlBar.top,
rectControlBar.Width (), rectControlBar.Height (),
SWP_NOZORDER | SWP_NOACTIVATE);
pControlBar->RecalcLayout ();
}
}
//------------------------------------------------------------------------//
void CBCGPDockManager::CalcExpectedDockedRect (CWnd* pWnd, CPoint ptMouse,
CRect& rectResult, BOOL& bDrawTab,
CBCGPDockingControlBar** ppTargetBar)
{
ASSERT_VALID (this);
rectResult.SetRectEmpty ();
if (GetKeyState (VK_CONTROL) < 0)
{
return;
}
BOOL bOuterEdge = FALSE;
DWORD dwAlignment = 0;
CBCGPMiniFrameWnd* pOtherMiniFrame = FrameFromPoint (ptMouse, NULL, TRUE);
if (pOtherMiniFrame != NULL)
{
pOtherMiniFrame->CalcExpectedDockedRect (pWnd, ptMouse, rectResult,
bDrawTab, ppTargetBar);
}
if (pOtherMiniFrame == NULL || rectResult.IsRectEmpty ())
{
CBCGPDockingControlBar* pBar =
DYNAMIC_DOWNCAST (CBCGPDockingControlBar,
ControlBarFromPoint (ptMouse, CBCGPDockManager::m_nDockSencitivity,
true, NULL, TRUE));
if (pBar != NULL && pBar->GetDefaultSlider () != NULL)
{
if (pWnd->IsKindOf (RUNTIME_CLASS (CBCGPMiniFrameWnd)))
{
CBCGPMiniFrameWnd* pMiniFrame =
DYNAMIC_DOWNCAST (CBCGPMiniFrameWnd, pWnd);
ASSERT_VALID (pMiniFrame);
if (!pBar->CanAcceptMiniFrame (pMiniFrame))
{
return;
}
}
CBCGPSlider* pDefaultSlider = pBar->GetDefaultSlider ();
ASSERT_VALID (pDefaultSlider);
pDefaultSlider->CalcExpectedDockedRect (pWnd, ptMouse, rectResult, bDrawTab,
ppTargetBar);
}
else
if (IsPointNearDockBar (ptMouse, dwAlignment, bOuterEdge))
{
*ppTargetBar = NULL;
if (pWnd->IsKindOf (RUNTIME_CLASS (CBCGPMiniFrameWnd)))
{
CBCGPMiniFrameWnd* pMiniFrame =
DYNAMIC_DOWNCAST (CBCGPMiniFrameWnd, pWnd);
ASSERT_VALID (pMiniFrame);
CBCGPControlBar* pBar =
DYNAMIC_DOWNCAST (CBCGPControlBar, pMiniFrame->GetControlBar ());
if (pBar != NULL && (pBar->GetEnabledAlignment () & dwAlignment) == 0)
{
return;
}
}
else if (pWnd->IsKindOf (RUNTIME_CLASS (CBCGPDockingControlBar)))
{
CBCGPDockingControlBar* pBar = DYNAMIC_DOWNCAST (CBCGPDockingControlBar, pWnd);
if ((pBar->GetEnabledAlignment () & dwAlignment) == 0)
{
return;
}
}
CRect rectWnd;
pWnd->GetWindowRect (rectWnd);
rectResult = bOuterEdge ? m_rectOuterEdgeBounds : m_rectClientAreaBounds;
switch (dwAlignment)
{
case CBRS_ALIGN_LEFT:
rectResult.right = rectResult.left + rectWnd.Width ();
break;
case CBRS_ALIGN_RIGHT:
rectResult.left = rectResult.right - rectWnd.Width ();
break;
case CBRS_ALIGN_TOP:
rectResult.bottom = rectResult.top + rectWnd.Height ();
break;
case CBRS_ALIGN_BOTTOM:
rectResult.top = rectResult.bottom - rectWnd.Height ();
break;
}
AdjustRectToClientArea (rectResult, dwAlignment);
m_pParentWnd->ClientToScreen (rectResult);
}
else
{
*ppTargetBar = NULL;
}
}
}
//-----------------------------------------------------------------------//
BOOL CBCGPDockManager::AdjustRectToClientArea (CRect& rectResult, DWORD dwAlignment)
{
BOOL bAdjusted = FALSE;
int nAllowedHeight = (int) (m_rectClientAreaBounds.Height () *
globalData.m_nCoveredMainWndClientAreaPercent / 100);
int nAllowedWidth = (int) (m_rectClientAreaBounds.Width () *
globalData.m_nCoveredMainWndClientAreaPercent / 100);
if (dwAlignment & CBRS_ORIENT_HORZ && rectResult.Height () >= nAllowedHeight)
{
if (dwAlignment & CBRS_ALIGN_TOP)
{
rectResult.bottom = rectResult.top + nAllowedHeight;
bAdjusted = TRUE;
}
else if (dwAlignment & CBRS_ALIGN_BOTTOM)
{
rectResult.top = rectResult.bottom - nAllowedHeight;
bAdjusted = TRUE;
}
}
else if (dwAlignment & CBRS_ORIENT_VERT &&
rectResult.Width () >= nAllowedWidth)
{
if (dwAlignment & CBRS_ALIGN_LEFT)
{
rectResult.right = rectResult.left + nAllowedWidth;
bAdjusted = TRUE;
}
else if (dwAlignment & CBRS_ALIGN_RIGHT)
{
rectResult.left = rectResult.right - nAllowedWidth;
bAdjusted = TRUE;
}
}
return bAdjusted;
}
//------------------------------------------------------------------------//
BOOL CBCGPDockManager::OnMoveMiniFrame (CWnd* pFrame)
{
ASSERT_VALID (this);
ASSERT_VALID (pFrame);
if (GetKeyState (VK_CONTROL) < 0)
{
return TRUE;
}
BOOL bResult = TRUE;
CBCGPMiniFrameWnd* pBCGMiniFrame = DYNAMIC_DOWNCAST (CBCGPMiniFrameWnd, pFrame);
if (pBCGMiniFrame != NULL)
{
CRect rect;
pFrame->GetWindowRect (rect);
int captionHeight = pBCGMiniFrame->GetCaptionHeight ();
CRect rectDelta (captionHeight, captionHeight, captionHeight, captionHeight);
globalUtils.AdjustRectToWorkArea (rect, &rectDelta);
pBCGMiniFrame->SetWindowPos (NULL, rect.left, rect.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
}
if (pBCGMiniFrame != NULL)
{
CPoint ptMouse;
GetCursorPos (&ptMouse);
CBCGPControlBar* pBar = DYNAMIC_DOWNCAST (CBCGPControlBar,
pBCGMiniFrame->GetControlBar ());
// first, check if there is any other miniframe around and whether
// it is possible to dock at this miniframe - but only if the
// current bar is docking control bar has style cbrs_float_multi
if ((pBar == NULL) ||
((pBar->GetBarStyle () & CBRS_FLOAT_MULTI) &&
pBar->IsKindOf (RUNTIME_CLASS (CBCGPDockingControlBar))))
{
CBCGPMiniFrameWnd* pOtherMiniFrame =
FrameFromPoint (ptMouse, pBCGMiniFrame, TRUE);
// dock only bars from miniframes that have the same parent main frame,
// otherwise it will create problems for dockmanagers
if (pOtherMiniFrame != NULL &&
pOtherMiniFrame->GetParent () == pBCGMiniFrame->GetParent ())
{
CBCGPMultiMiniFrameWnd* pMultiMiniFrame =
DYNAMIC_DOWNCAST (CBCGPMultiMiniFrameWnd, pOtherMiniFrame);
if (pMultiMiniFrame != NULL && m_pLastMultiMiniFrame == NULL)
{
m_clkLastTime = clock ();
m_pLastMultiMiniFrame = pMultiMiniFrame;
}
if (pMultiMiniFrame != NULL &&
m_pLastMultiMiniFrame == pMultiMiniFrame &&
clock () - m_clkLastTime > (int) g_nTimeOutBeforeDockingBarDock)
{
bResult = pMultiMiniFrame->DockFrame (pBCGMiniFrame,
DM_MOUSE);
m_clkLastTime = clock ();
m_pLastMultiMiniFrame = NULL;
return bResult;
}
return TRUE;
}
}
m_pLastMultiMiniFrame = NULL;
if (pBar != NULL)
{
if ((pBar->GetEnabledAlignment () & CBRS_ALIGN_ANY) == 0)
{
// docking was not enabled for this control bar
return TRUE;
}
// target control bar or dock bar
CBCGPBaseControlBar* pTargetBar = NULL;
BCGP_CS_STATUS status = pBar->
IsChangeState (CBCGPDockManager::m_nDockSencitivity, &pTargetBar);
if (pBar == pTargetBar)
{
status = CS_NOTHING;
}
if (pTargetBar != NULL || status == CS_DELAY_DOCK)
{
BOOL bDockBar = pTargetBar != NULL ?
pTargetBar->IsKindOf (RUNTIME_CLASS (CBCGPDockBar)) : FALSE;
BOOL bDockingBar = pTargetBar != NULL ?
pTargetBar->IsKindOf (RUNTIME_CLASS (CBCGPDockingControlBar)) : TRUE;
if (bDockBar || bDockingBar)
{
UINT uTimeOut = bDockBar ? g_nTimeOutBeforeToolBarDock :
g_nTimeOutBeforeDockingBarDock;
if (m_pLastTargetBar != pTargetBar || status != m_statusLast)
{
m_clkLastTime = clock ();
m_pLastTargetBar = pTargetBar;
m_statusLast = status;
pBCGMiniFrame->SetDockTimer (uTimeOut);
}
if (clock () - m_clkLastTime < (int) uTimeOut)
{
return TRUE;
}
}
}
m_pLastTargetBar = NULL;
m_clkLastTime = clock ();
m_statusLast = CS_NOTHING;
pBCGMiniFrame->KillDockTimer ();
if (status == CS_DOCK_IMMEDIATELY && pTargetBar != NULL)
{
// in the case docking was delayed we need always turn off predock state
// (usually it happens only for resizable control bars)
pBCGMiniFrame->SetPreDockState (PDS_NOTHING);
if (pBar->DockByMouse (pTargetBar))
{
return FALSE;
}
}
if (status == CS_DELAY_DOCK) // status returned by resizable control bar
{
bResult = pBCGMiniFrame->SetPreDockState (PDS_DOCK_REGULAR, pTargetBar);
}
else if (status == CS_DELAY_DOCK_TO_TAB)
{
bResult = pBCGMiniFrame->SetPreDockState (PDS_DOCK_TO_TAB, pTargetBar);
AdjustDockingLayout ();
}
else
{
bResult = pBCGMiniFrame->SetPreDockState (PDS_NOTHING, pTargetBar);
}
}
}
return bResult;
}
//------------------------------------------------------------------------//
// used for autohide to prevent wrong z-order when auto hide window is sliding
// in (collapsed)
//------------------------------------------------------------------------//
void CBCGPDockManager::BringBarsToTop (DWORD dwAlignment, BOOL bExcludeDockedBars)
{
dwAlignment &= CBRS_ALIGN_ANY;
for (POSITION pos = m_lstControlBars.GetTailPosition (); pos != NULL;)
{
CBCGPBaseControlBar* pBar =
(CBCGPBaseControlBar*) m_lstControlBars.GetPrev (pos);
ASSERT_VALID (pBar);
if (bExcludeDockedBars &&
(pBar->IsKindOf (RUNTIME_CLASS (CBCGPControlBar)) ||
pBar->IsKindOf (RUNTIME_CLASS (CBCGPSlider))))
{
continue;
}
// starting from first dockbar do not exclude anything (so, th stattus bar
// and so on will be on top)
bExcludeDockedBars = FALSE;
DWORD dwCurrAlignment = pBar->GetCurrentAlignment ();
if (dwCurrAlignment == dwAlignment || dwAlignment == 0)
{
pBar->BringWindowToTop ();
}
}
}
//------------------------------------------------------------------------//
void CBCGPDockManager::SetAutohideZOrder (CBCGPDockingControlBar* pAHDockingBar)
{
ASSERT_VALID (this);
ASSERT_VALID (pAHDockingBar);
DWORD dwAlignment = pAHDockingBar->GetCurrentAlignment ();
CBCGPSlider* pAHSlider = pAHDockingBar->GetDefaultSlider ();
for (POSITION pos = m_lstControlBars.GetTailPosition (); pos != NULL;)
{
CBCGPBaseControlBar* pBar =
(CBCGPBaseControlBar*) m_lstControlBars.GetPrev (pos);
ASSERT_VALID (pBar);
if (pBar == pAHSlider || pBar == pAHDockingBar)
{
continue;
}
if (pBar->IsKindOf (RUNTIME_CLASS (CBCGPControlBar)) &&
(pBar->GetCurrentAlignment () == dwAlignment))
{
pBar->SetWindowPos (pAHDockingBar, 0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
}
else if (pBar->IsKindOf (RUNTIME_CLASS (CBCGPSlider)))
{
pBar->SetWindowPos (&CWnd::wndBottom, 0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
}
}
pAHDockingBar->SetWindowPos (pAHSlider, 0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
}
//------------------------------------------------------------------------//
void CBCGPDockManager::RecalcLayout (BOOL bNotify)
{
if (m_bDisableRecalcLayout)
{
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -