📄 bcgpdockmanager.cpp
字号:
if (rectWnd.PtInRect (point))
{
return pNextBar;
}
}
}
return NULL;
}
//------------------------------------------------------------------------//
CBCGPBaseControlBar* CBCGPDockManager::ControlBarFromPoint (CPoint point,
int nSensitivity, DWORD& dwAlignment,
CRuntimeClass* pRTCBarType,
const CBCGPBaseControlBar* pBarToIgnore) const
{
ASSERT_VALID (this);
dwAlignment = 0;
CBCGPBaseControlBar* pBar = ControlBarFromPoint (point, nSensitivity, true,
NULL, FALSE, pBarToIgnore);
if (pBar != NULL)
{
if ((pRTCBarType == NULL || pBar->IsKindOf (pRTCBarType)))
{
if (!globalUtils.CheckAlignment (point, pBar, nSensitivity, FALSE, dwAlignment))
{
return NULL;
}
}
else
{
pBar = NULL;
}
}
return pBar;
}
//------------------------------------------------------------------------//
BCGP_CS_STATUS CBCGPDockManager::DetermineControlBarAndStatus (CPoint pt,
int nSencitivity,
DWORD dwEnabledAlignment,
CBCGPBaseControlBar** ppTargetBar,
const CBCGPBaseControlBar* pBarToIgnore,
const CBCGPBaseControlBar* pBarToDock)
{
ASSERT_VALID (pBarToDock);
// find the exact control bar first.
*ppTargetBar = ControlBarFromPoint (pt, nSencitivity, true,
RUNTIME_CLASS (CBCGPDockingControlBar), TRUE,
pBarToIgnore);
if (*ppTargetBar == NULL)
{
// find a miniframe from point and check it for a single bar
CBCGPMiniFrameWnd* pMiniFrame = FrameFromPoint (pt, NULL, TRUE);
if (pMiniFrame != NULL && pBarToDock->GetParentMiniFrame () != pMiniFrame)
{
// detect caption
UINT uiHitTest = pMiniFrame->HitTest (pt, TRUE);
if (uiHitTest == HTCAPTION && pMiniFrame->GetVisibleBarCount () == 1)
{
*ppTargetBar = DYNAMIC_DOWNCAST
(CBCGPBaseControlBar, pMiniFrame->GetFirstVisibleBar ());
return CS_DELAY_DOCK_TO_TAB;
}
}
}
// check this bar for caption and tab area
if (*ppTargetBar != NULL)
{
if ((*ppTargetBar)->GetParentMiniFrame () != NULL &&
(pBarToDock->GetBarStyle () & CBRS_FLOAT_MULTI) &&
((*ppTargetBar)->GetBarStyle () & CBRS_FLOAT_MULTI) ||
(*ppTargetBar)->GetParentMiniFrame () == NULL)
{
CBCGPDockingControlBar* pDockingBar =
DYNAMIC_DOWNCAST (CBCGPDockingControlBar, *ppTargetBar);
if (!pDockingBar->IsFloating () &&
(pDockingBar->GetCurrentAlignment () & dwEnabledAlignment) == 0)
{
return CS_NOTHING;
}
if (pDockingBar != NULL)
{
return pDockingBar->GetDockStatus (pt, nSencitivity);
}
}
}
*ppTargetBar = NULL;
// check whether the mouse cursor is at the outer edge of the dock bar
// or at the inner edge of the most inner control bar (on client area) and the
// bar is allowed to be docked at this side
BOOL bOuterEdge = FALSE;
DWORD dwAlignment = 0;
if (IsPointNearDockBar (pt, dwAlignment, bOuterEdge) &&
(dwAlignment & dwEnabledAlignment))
{
return CS_DELAY_DOCK;
}
return CS_NOTHING;
}
//------------------------------------------------------------------------//
CBCGPBaseControlBar* CBCGPDockManager::FindBarByID (UINT uBarID, BOOL bSearchMiniFrames)
{
ASSERT_VALID (this);
for (POSITION pos = m_lstAutoHideBars.GetHeadPosition (); pos != NULL;)
{
CBCGPBaseControlBar* pBar = (CBCGPBaseControlBar*)
m_lstAutoHideBars.GetNext (pos);
ASSERT_VALID (pBar);
if (pBar->IsKindOf (RUNTIME_CLASS (CBCGPSlider)))
{
CBCGPSlider* pSlider = DYNAMIC_DOWNCAST (CBCGPSlider, pBar);
// SLIDER CONTAINS ONLY ONE BAR IN AUTOHIDE MODE
pBar = (CBCGPBaseControlBar*) pSlider->GetFirstBar ();
}
if (pBar == NULL)
{
continue;
}
UINT uID = pBar->GetDlgCtrlID ();
if (uID == uBarID)
{
return pBar;
}
}
for (pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
{
CBCGPBaseControlBar* pBar = (CBCGPBaseControlBar*)
m_lstControlBars.GetNext (pos);
UINT uID = pBar->GetDlgCtrlID ();
if (uID == uBarID)
{
return pBar;
}
if (pBar->IsKindOf (RUNTIME_CLASS (CBCGPBaseTabbedBar)))
{
CBCGPBaseTabbedBar* pTabbedBar =
DYNAMIC_DOWNCAST (CBCGPBaseTabbedBar, pBar);
ASSERT_VALID (pTabbedBar);
CBCGPBaseControlBar* pControlBar = DYNAMIC_DOWNCAST (CBCGPBaseControlBar,
pTabbedBar->FindBarByID (uBarID));
if (pControlBar != NULL)
{
return pControlBar;
}
}
else if (pBar->IsKindOf (RUNTIME_CLASS (CBCGPDockBar)))
{
CBCGPDockBar* pDockBar = (CBCGPDockBar*) pBar;
ASSERT_VALID (pDockBar);
CBCGPControlBar* pBar = pDockBar->FindBarByID (uBarID);
if (pBar != NULL)
{
return DYNAMIC_DOWNCAST (CBCGPBaseControlBar, pBar);
}
}
else if (pBar->IsKindOf (RUNTIME_CLASS (CBCGPReBar)))
{
CBCGPReBar* pReBar = (CBCGPReBar*) pBar;
ASSERT_VALID (pReBar);
CBCGPBaseControlBar* pBar = DYNAMIC_DOWNCAST(CBCGPBaseControlBar,
pReBar->GetDlgItem (uBarID));
if (pBar != NULL)
{
return pBar;
}
}
}
if (bSearchMiniFrames)
{
for (pos = m_lstMiniFrames.GetHeadPosition (); pos != NULL;)
{
CBCGPMiniFrameWnd* pMiniFrame =
DYNAMIC_DOWNCAST (CBCGPMiniFrameWnd, m_lstMiniFrames.GetNext (pos));
if (pMiniFrame != NULL)
{
CBCGPBaseControlBar* pWnd =
DYNAMIC_DOWNCAST (CBCGPBaseControlBar, pMiniFrame->GetControlBar ());
if (pWnd != NULL && pWnd->GetDlgCtrlID () == (int) uBarID)
{
return pWnd;
}
}
}
return CBCGPMiniFrameWnd::FindFloatingBarByID (uBarID);
}
return NULL;
}
//------------------------------------------------------------------------//
CBCGPDockBar* CBCGPDockManager::FindDockBar (DWORD dwAlignment, BOOL bOuter)
{
for (POSITION pos = bOuter ? m_lstControlBars.GetHeadPosition () :
m_lstControlBars.GetTailPosition (); pos != NULL;)
{
CBCGPBaseControlBar* pBar = (CBCGPBaseControlBar*)
(bOuter ? m_lstControlBars.GetNext (pos) :
m_lstControlBars.GetPrev (pos));
ASSERT_VALID (pBar);
if (!pBar->IsKindOf (RUNTIME_CLASS (CBCGPDockBar)))
{
continue;
}
if (pBar->GetCurrentAlignment () == (dwAlignment & CBRS_ALIGN_ANY))
{
return DYNAMIC_DOWNCAST (CBCGPDockBar, pBar);
}
}
return NULL;
}
//------------------------------------------------------------------------//
void CBCGPDockManager::FixupVirtualRects ()
{
ASSERT_VALID (this);
for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
{
CBCGPDockBar* pBar = DYNAMIC_DOWNCAST (CBCGPDockBar,
m_lstControlBars.GetNext (pos));
if (pBar != NULL)
{
pBar->FixupVirtualRects ();
}
}
AdjustDockingLayout ();
}
//------------------------------------------------------------------------//
BOOL CBCGPDockManager::IsPointNearDockBar (CPoint point, DWORD& dwBarAlignment,
BOOL& bOuterEdge) const
{
ASSERT_VALID (this);
dwBarAlignment = 0;
// check the "outer" edge first - non resizable dock bars
CRect rectBounds = m_rectOuterEdgeBounds;
m_pParentWnd->ClientToScreen (rectBounds);
bOuterEdge = TRUE;
if (globalUtils.CheckAlignment (point, NULL, CBCGPDockManager::m_nDockSencitivity, bOuterEdge,
dwBarAlignment, m_dwEnabledDockBars, rectBounds))
{
return TRUE;
}
// check the innre edges - edges of the client area
rectBounds = m_rectClientAreaBounds;
m_pParentWnd->ClientToScreen (rectBounds);
bOuterEdge = FALSE;
return globalUtils.CheckAlignment (point, NULL, CBCGPDockManager::m_nDockSencitivity,
bOuterEdge, dwBarAlignment, m_dwEnabledDockBars, rectBounds);
}
//------------------------------------------------------------------------//
BOOL CBCGPDockManager::DockControlBarLeftOf (CBCGPControlBar* pBarToDock,
CBCGPControlBar* pTargetBar)
{
ASSERT_VALID (this);
ASSERT_VALID (pBarToDock);
ASSERT_VALID (pTargetBar);
if (pTargetBar->IsKindOf (RUNTIME_CLASS (CBCGPDockingControlBar)) &&
pBarToDock->IsKindOf (RUNTIME_CLASS (CBCGPDockingControlBar)))
{
}
else if (pTargetBar->IsKindOf (RUNTIME_CLASS (CBCGPToolBar)) &&
pBarToDock->IsKindOf (RUNTIME_CLASS (CBCGPToolBar)))
{
CBCGPDockBar* pDockBar = FindDockBarByControlBar (pTargetBar);
if (pDockBar != NULL)
{
pBarToDock->UnDockControlBar (TRUE);
BOOL bResult = pDockBar->DockControlBarLeftOf (pBarToDock, pTargetBar);
return bResult;
}
}
return FALSE;
}
//------------------------------------------------------------------------//
CBCGPDockBar* CBCGPDockManager::FindDockBarByControlBar (CBCGPControlBar* pTargetBar)
{
ASSERT_VALID (this);
ASSERT_VALID (pTargetBar);
UINT uID = pTargetBar->GetDlgCtrlID ();
for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
{
CBCGPDockBar* pBar = DYNAMIC_DOWNCAST (CBCGPDockBar,
m_lstControlBars.GetNext (pos));
if (pBar != NULL)
{
if (pBar->FindBarByID (uID) == pTargetBar)
{
return pBar;
}
}
}
return NULL;
}
//------------------------------------------------------------------------//
// Should be used for toolbars or (resizable) control bars that can be docked
// on a resizable DockBar
//------------------------------------------------------------------------//
void CBCGPDockManager::DockControlBar (CBCGPBaseControlBar* pBar, UINT nDockBarID,
LPCRECT lpRect)
{
ASSERT_VALID (this);
ASSERT_VALID (pBar);
if (m_lstControlBars.IsEmpty ())
{
return;
}
// if the bar can be
pBar->UnDockControlBar (TRUE);
if (!pBar->CanBeResized () && !pBar->CanFloat ())
{
AddControlBar (pBar);
return;
}
DWORD dwBarDockStyle = pBar->GetEnabledAlignment ();
if (pBar->IsResizable ())
{
// resazable control bars are docked to frame window (their dock site)
// directly
if (nDockBarID == 0)
{
pBar->DockToFrameWindow (pBar->GetCurrentAlignment (), lpRect);
}
else
{
for (int i = 0; i < 4; i++)
{
DWORD dwDockBarID = dwDockBarMap [i][0];
DWORD dwDockAlign = dwDockBarMap [i][1];
if ((nDockBarID == 0 || nDockBarID == dwDockBarID) &&
(dwDockAlign & dwBarDockStyle))
{
pBar->DockToFrameWindow (dwDockAlign, lpRect);
break;
}
}
}
}
else
{
for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
{
CBCGPBaseControlBar* pNextBar = (CBCGPBaseControlBar*)
m_lstControlBars.GetNext (pos);
ASSERT_VALID (pNextBar);
if (pNextBar->IsKindOf (RUNTIME_CLASS (CBCGPDockBar)))
{
CBCGPDockBar* pNextDockBar = (CBCGPDockBar*) pNextBar;
if ((nDockBarID == 0 || pNextDockBar->GetDockBarID () == nDockBarID) &&
pBar->CanBeDocked (pNextDockBar) && pNextDockBar->CanAcceptBar (pBar))
{
if (pBar->DockControlBar (pNextDockBar, lpRect, DM_RECT))
{
pBar->InvalidateRect (NULL);
break;
}
}
}
}
}
}
//------------------------------------------------------------------------//
CBCGPAutoHideToolBar* CBCGPDockManager::AutoHideBar (CBCGPDockingControlBar* pBar,
CBCGPAutoHideToolBar* pCurrAutoHideToolBar)
{
ASSERT_VALID (this);
ASSERT_VALID (pBar);
DWORD dwAlignment = pBar->GetCurrentAlignment ();
// create autohide toolbar and button - it's always inner dockbar
CBCGPAutoHideDockBar* pAutoHideDockBar =
DYNAMIC_DOWNCAST (CBCGPAutoHideDockBar, FindDockBar (dwAlignment, FALSE));
if (pAutoHideDockBar == NULL)
{
// no autohide allowed at this side
return NULL;
}
CBCGPAutoHideToolBar* pAutoHideToolBar = pCurrAutoHideToolBar;
if (pAutoHideToolBar == NULL)
{
pAutoHideToolBar = new CBCGPAutoHideToolBar;
DWORD dwBCGStyle = 0; // can't float...
if (!pAutoHideToolBar->Create (NULL, WS_VISIBLE | WS_CHILD, CRect (0, 0, 0, 0),
m_pParentWnd, 1, dwBCGStyle))
{
TRACE0 ("Failde to create autohide toolbar");
ASSERT (FALSE);
delete pAutoHideToolBar;
return NULL;
}
}
pAutoHideToolBar->EnableDocking (CBRS_ALIGN_ANY);
CBCGPSlider* pDefaultSlider = pBar->GetDefaultSlider ();
ASSERT_VALID (pDefaultSlider);
CBCGPAutoHideButton* pBtn =
pAutoHideToolBar->AddAutoHideWindow (pBar, dwAlignment);
ASSERT_VALID (pBtn);
// NULL indicates that there was a new toolbar created here
if (pCurrAutoHideToolBar == NULL)
{
if (!pAutoHideDockBar->IsBarVisible ())
{
pAutoHideDockBar->ShowWindow (SW_SHOW);
}
pAutoHideToolBar->DockControlBar (pAutoHideDockBar, NULL, DM_RECT);
}
// recalc. layout according to the newly added bar
AdjustDockingLayout ();
// register the slider with the manager
AddControlBar (pDefaultSlider, TRUE, TRUE);
AlignAutoHideBar (pDefaultSlider);
pBar->BringWindowToTop ();
pDefaultSlider->BringWindowToTop ();
return pAutoHideToolBar;
}
//------------------------------------------------------------------------//
void CBCGPDockManager::HideAutoHideBars (CBCGPDockingControlBar* pBarToExclude, BOOL bImmediately)
{
for (POSITION pos = m_lstAutoHideBars.GetHeadPosition (); pos != NULL;)
{
CBCGPSlider* pSlider = (CBCGPSlider*) m_lstAutoHideBars.GetNext (pos);
ASSERT_VALID (pSlider);
CBCGPDockingControlBar* pControlBar = (CBCGPDockingControlBar*)
pSlider->GetFirstBar ();
ASSERT_VALID (pControlBar);
if (pControlBar == pBarToExclude)
{
continue;
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -