//------------------------------------------------------------------------//
BOOL CBCGPGlobalUtils::IsWndCanFloatMulti (CWnd* pWnd) const
{
CBCGPControlBar* pBar = NULL;
CBCGPMiniFrameWnd* pMiniFrame =
DYNAMIC_DOWNCAST (CBCGPMiniFrameWnd, pWnd);
if (pMiniFrame != NULL)
{
pBar = DYNAMIC_DOWNCAST (CBCGPControlBar, pMiniFrame->GetControlBar ());
}
else
{
pBar = DYNAMIC_DOWNCAST (CBCGPControlBar, pWnd);
}
if (pBar == NULL)
{
return FALSE;
}
if (pBar->IsTabbed ())
{
CWnd* pParentMiniFrame = pBar->GetParentMiniFrame ();
// tabbed bar that is floating in multi miniframe
if (pParentMiniFrame != NULL && pParentMiniFrame->IsKindOf (RUNTIME_CLASS (CBCGPMultiMiniFrameWnd)))
{
return TRUE;
}
}
return ((pBar->GetBarStyle () & CBRS_FLOAT_MULTI) != 0);
}
void CBCGPSmartDockingManager::Start (CWnd* pDockingWnd)
{
if (!m_bCreated)
{
return;
}
if (m_bStarted)
{
return;
}
ASSERT_VALID (pDockingWnd);
m_pDockingWnd = pDockingWnd;
m_wndPlaceMarker.SetDockingWnd (m_pDockingWnd);
m_nHiliteSideNo = CBCGPSmartDockingMarker::sdNONE;
m_dwEnabledAlignment = CBRS_ALIGN_ANY;
if (m_pDockingWnd != NULL)
{
CBCGPMiniFrameWnd* pMiniFrame = DYNAMIC_DOWNCAST (CBCGPMiniFrameWnd, m_pDockingWnd);
if (pMiniFrame != NULL)
{
CBCGPDockingControlBar* pFisrtBar =
DYNAMIC_DOWNCAST (CBCGPDockingControlBar, pMiniFrame->GetFirstVisibleBar ());
if (pFisrtBar != NULL)
{
m_dwEnabledAlignment = pFisrtBar->GetEnabledAlignment ();
}
}
}
CBCGPSmartDockingMarker::SDMarkerPlace i;
for (i = CBCGPSmartDockingMarker::sdLEFT; i <= CBCGPSmartDockingMarker::sdBOTTOM; ++reinterpret_cast<int&>(i))
{
m_arMarkers[i]->AdjustPos (&m_rcOuter);
if (((m_dwEnabledAlignment & CBRS_ALIGN_LEFT) != 0) && i == CBCGPSmartDockingMarker::sdLEFT ||
((m_dwEnabledAlignment & CBRS_ALIGN_RIGHT) != 0) && i == CBCGPSmartDockingMarker::sdRIGHT ||
((m_dwEnabledAlignment & CBRS_ALIGN_TOP) != 0) && i == CBCGPSmartDockingMarker::sdTOP ||
((m_dwEnabledAlignment & CBRS_ALIGN_BOTTOM) != 0) && i == CBCGPSmartDockingMarker::sdBOTTOM)
{
m_arMarkers[i]->Show (TRUE);
}
}
m_bShown = TRUE;
m_bCentralGroupShown = FALSE;
m_bStarted = TRUE;
}
//------------------------------------------------------------------------//
CBCGPDockManager* CBCGPGlobalUtils::GetDockManager (CWnd* pWnd)
{
if (pWnd == NULL)
{
return NULL;
}
ASSERT_VALID (pWnd);
if (pWnd->IsKindOf (RUNTIME_CLASS (CBCGPFrameWnd)))
{
return ((CBCGPFrameWnd*) pWnd)->GetDockManager ();
}
else if (pWnd->IsKindOf (RUNTIME_CLASS (CBCGPMDIFrameWnd)))
{
return ((CBCGPMDIFrameWnd*) pWnd)->GetDockManager ();
}
else if (pWnd->IsKindOf (RUNTIME_CLASS (CBCGPOleIPFrameWnd)))
{
return ((CBCGPOleIPFrameWnd*) pWnd)->GetDockManager ();
}
else if (pWnd->IsKindOf (RUNTIME_CLASS (CBCGPOleDocIPFrameWnd)))
{
return ((CBCGPOleDocIPFrameWnd*) pWnd)->GetDockManager ();
}
else if (pWnd->IsKindOf (RUNTIME_CLASS (CBCGPMDIChildWnd)))
{
return ((CBCGPMDIChildWnd*) pWnd)->GetDockManager ();
}
else if (pWnd->IsKindOf (RUNTIME_CLASS (CDialog)) ||
pWnd->IsKindOf (RUNTIME_CLASS (CPropertySheet)))
{
if (pWnd->GetSafeHwnd() == AfxGetMainWnd()->GetSafeHwnd())
{
m_bDialogApp = TRUE;
}
}
else if (pWnd->IsKindOf (RUNTIME_CLASS (CBCGPOleCntrFrameWnd)))
{
return ((CBCGPOleCntrFrameWnd*) pWnd)->GetDockManager ();
}
else if (pWnd->IsKindOf (RUNTIME_CLASS (CBCGPMiniFrameWnd)))
{
CBCGPMiniFrameWnd* pMiniFrameWnd = DYNAMIC_DOWNCAST (CBCGPMiniFrameWnd, pWnd);
ASSERT_VALID (pMiniFrameWnd);
CBCGPDockManager* pManager = pMiniFrameWnd->GetDockManager ();
return pManager != NULL ? pManager : GetDockManager (m_bUseMiniFrameParent ? pMiniFrameWnd->GetParent() : pWnd->GetParent ());
}
return NULL;
}
CBCGPOleCntrFrameWnd::~CBCGPOleCntrFrameWnd()
{
POSITION pos = NULL;
for (pos = m_dockManager.m_lstMiniFrames.GetHeadPosition (); pos != NULL;)
{
CBCGPMiniFrameWnd* pNextFrame = DYNAMIC_DOWNCAST (CBCGPMiniFrameWnd,
m_dockManager.m_lstMiniFrames.GetNext (pos));
if (pNextFrame != NULL)
{
pNextFrame->DestroyWindow ();
}
}
CList<HWND, HWND> lstChildren;
CWnd* pNextWnd = GetTopWindow ();
while (pNextWnd != NULL)
{
lstChildren.AddTail (pNextWnd->m_hWnd);
pNextWnd = pNextWnd->GetNextWindow ();
}
for (pos = lstChildren.GetHeadPosition (); pos != NULL;)
{
HWND hwndNext = lstChildren.GetNext (pos);
if (IsWindow (hwndNext) && ::GetParent (hwndNext) == m_hWnd)
{
::DestroyWindow (hwndNext);
}
}
const CObList& list = CBCGPToolBar::GetAllToolbars ();
CObList& gAllToolbars = const_cast<CObList&>(list);
for (pos = gAllToolbars.GetHeadPosition (); pos != NULL;)
{
POSITION posSave = pos;
CBCGPToolBar* pToolBar = (CBCGPToolBar*) gAllToolbars.GetNext (pos);
ASSERT (pToolBar != NULL);
if (CWnd::FromHandlePermanent (pToolBar->m_hWnd) == NULL)
{
gAllToolbars.RemoveAt (posSave);
}
}
}
//**************************************************************************************
BOOL CBCGPBaseTabbedBar::FloatControlBar (CRect rectFloat,
BCGP_DOCK_METHOD dockMethod,
bool bShow)
{
ASSERT_VALID (this);
ASSERT_VALID (m_pTabWnd);
if (!CBCGPDockingControlBar::FloatControlBar (rectFloat, dockMethod, bShow))
{
return FALSE;
}
CBCGPMiniFrameWnd* pParentFrame = GetParentMiniFrame ();
if (pParentFrame != NULL)
{
pParentFrame->SetIcon (m_pTabWnd->GetTabHicon (m_pTabWnd->GetActiveTab ()), FALSE);
}
return TRUE;
}
//*******************************************************************************
BOOL CBCGPBaseTabbedBar::RemoveControlBar (CWnd* pBar)
{
ASSERT_VALID (this);
ASSERT_VALID (pBar);
ASSERT_VALID (m_pTabWnd);
int nTabNumber = m_pTabWnd->GetTabFromHwnd (pBar->GetSafeHwnd ());
if (nTabNumber < 0 || nTabNumber >= m_pTabWnd->GetTabsNum ())
{
return FALSE;
}
m_pTabWnd->RemoveTab (nTabNumber);
if (m_pTabWnd->GetTabsNum () == 0)
{
if (AllowDestroyEmptyTabbedBar ())
{
if (IsDocked ())
{
UnDockControlBar ();
}
else
{
CBCGPMiniFrameWnd* pMiniFrame = GetParentMiniFrame ();
pMiniFrame->RemoveControlBar (this);
}
DestroyWindow ();
return FALSE;
}
else
{
m_pTabWnd->ShowWindow (SW_HIDE);
}
}
return TRUE;
}
//--------------------------------------------------------------------------------------//
void CBCGPDragFrameImpl::Init (CWnd* pDraggedWnd)
{
ASSERT_VALID (pDraggedWnd);
m_pDraggedWnd = pDraggedWnd;
CWnd* pDockSite = NULL;
if (m_pDraggedWnd->IsKindOf (RUNTIME_CLASS (CBCGPMiniFrameWnd)))
{
CBCGPMiniFrameWnd* pMiniFrame = DYNAMIC_DOWNCAST (CBCGPMiniFrameWnd, m_pDraggedWnd);
pDockSite = pMiniFrame->GetParent ();
}
else if (m_pDraggedWnd->IsKindOf (RUNTIME_CLASS (CBCGPControlBar)))
{
CBCGPControlBar* pBar =
DYNAMIC_DOWNCAST (CBCGPControlBar, m_pDraggedWnd);
ASSERT_VALID (pBar);
CBCGPMiniFrameWnd* pParentMiniFrame = pBar->GetParentMiniFrame ();
if (pParentMiniFrame != NULL)
{
pDockSite = pParentMiniFrame->GetParent ();
}
else
{
pDockSite = pBar->GetDockSite ();
}
}
m_pDockManager = globalUtils.GetDockManager (pDockSite);
if (globalUtils.m_bDialogApp)
{
return;
}
ASSERT(m_pDockManager != NULL);
}
//*****************************************************************************
void CBCGPRecentDockInfo::StoreDockInfo (CBCGPBarContainer* pRecentContainer,
CBCGPDockingControlBar* pTabbedBar)
{
ASSERT_VALID (this);
ASSERT_VALID (m_pBar);
ASSERT_KINDOF (CBCGPDockingControlBar, m_pBar); // get here only for docking bars
CBCGPDockingControlBar* pBar =
DYNAMIC_DOWNCAST (CBCGPDockingControlBar, m_pBar);
CBCGPSlider* pDefaultSlider = (pTabbedBar != NULL) ?
pTabbedBar->GetDefaultSlider () : pBar->GetDefaultSlider ();
CBCGPMiniFrameWnd* pMiniFrame = pBar->GetParentMiniFrame ();
if (pMiniFrame != NULL)
{
CBCGPMiniFrameWnd* pRecentMiniFrame =
DYNAMIC_DOWNCAST (CBCGPMiniFrameWnd,
CWnd::FromHandlePermanent (m_hRecentMiniFrame));
m_hRecentMiniFrame = pMiniFrame->GetSafeHwnd ();
m_recentMiniFrameInfo.StoreDockInfo (pRecentContainer, pBar, pTabbedBar);
pMiniFrame->ScreenToClient (m_recentMiniFrameInfo.m_rectDockedRect);
pMiniFrame->GetWindowRect (m_rectRecentFloatingRect);
if (pRecentMiniFrame != NULL)
{
pRecentMiniFrame->PostMessage (BCGPM_CHECKEMPTYMINIFRAME);
}
}
else if (pDefaultSlider != NULL)
{
m_recentSliderInfo.StoreDockInfo (pRecentContainer, pBar, pTabbedBar);
pBar->GetDockSite ()->ScreenToClient (m_recentSliderInfo.m_rectDockedRect);
m_hRecentDefaultSlider = pDefaultSlider->GetSafeHwnd ();
m_dwRecentAlignmentToFrame = pDefaultSlider->GetCurrentAlignment ();
}
else
{
m_hRecentMiniFrame = NULL;
m_recentMiniFrameInfo.StoreDockInfo (NULL, pBar);
}
}
//------------------------------------------------------------------------//
void CBCGPGlobalUtils::CalcExpectedDockedRect (CBCGPBarContainerManager& barContainerManager,
CWnd* pWndToDock, CPoint ptMouse,
CRect& rectResult, BOOL& bDrawTab,
CBCGPDockingControlBar** ppTargetBar)
{
ASSERT (ppTargetBar != NULL);
DWORD dwAlignment = CBRS_ALIGN_ANY;
BOOL bTabArea = FALSE;
BOOL bCaption = FALSE;
bDrawTab = FALSE;
*ppTargetBar = NULL;
rectResult.SetRectEmpty ();
if (GetKeyState (VK_CONTROL) < 0)
{
return;
}
if (!GetCBAndAlignFromPoint (barContainerManager, ptMouse,
ppTargetBar, dwAlignment, bTabArea, bCaption) ||
*ppTargetBar == NULL)
{
return;
}
CBCGPControlBar* pBar = NULL;
if (pWndToDock->IsKindOf (RUNTIME_CLASS (CBCGPMiniFrameWnd)))
{
CBCGPMiniFrameWnd* pMiniFrame =
DYNAMIC_DOWNCAST (CBCGPMiniFrameWnd, pWndToDock);
ASSERT_VALID (pMiniFrame);
pBar = DYNAMIC_DOWNCAST (CBCGPControlBar, pMiniFrame->GetFirstVisibleBar ());
}
else
{
pBar = DYNAMIC_DOWNCAST (CBCGPControlBar, pWndToDock);
}
if (*ppTargetBar != NULL)
{
DWORD dwTargetEnabledAlign = (*ppTargetBar)->GetEnabledAlignment ();
DWORD dwTargetCurrentAlign = (*ppTargetBar)->GetCurrentAlignment ();
BOOL bTargetBarIsFloating = ((*ppTargetBar)->GetParentMiniFrame () != NULL);
if (pBar != NULL)
{
if (pBar->GetEnabledAlignment () != dwTargetEnabledAlign && bTargetBarIsFloating ||
(pBar->GetEnabledAlignment () & dwTargetCurrentAlign) == 0 && !bTargetBarIsFloating)
{
return;
}
}
}
if (bTabArea || bCaption)
{
// can't make tab on miniframe
bDrawTab = ((*ppTargetBar) != NULL);
if (bDrawTab)
{
bDrawTab = (*ppTargetBar)->CanBeAttached () && CanBeAttached (pWndToDock) &&
pBar != NULL && ((*ppTargetBar)->GetEnabledAlignment () == pBar->GetEnabledAlignment ());
}
if (!bDrawTab)
{
return;
}
}
if ((*ppTargetBar) != NULL && (*ppTargetBar)->GetParentMiniFrame () != NULL &&
!IsWndCanFloatMulti (pWndToDock))
{
bDrawTab = FALSE;
return;
}
if ((*ppTargetBar) != NULL &&
pWndToDock->IsKindOf (RUNTIME_CLASS (CBCGPBaseControlBar)) &&
!(*ppTargetBar)->CanAcceptBar ((CBCGPBaseControlBar*) pWndToDock))
{
bDrawTab = FALSE;
return;
}
CRect rectOriginal;
(*ppTargetBar)->GetWindowRect (rectOriginal);
if ((*ppTargetBar) == pWndToDock ||
pWndToDock->IsKindOf (RUNTIME_CLASS (CBCGPMiniFrameWnd)) &&
(*ppTargetBar)->GetParentMiniFrame () == pWndToDock)
{
bDrawTab = FALSE;
return;
}
CRect rectInserted;
CRect rectSlider;
DWORD dwSliderStyle;
CSize sizeMinOriginal (0, 0);
CSize sizeMinInserted (0, 0);
pWndToDock->GetWindowRect (rectInserted);
if ((dwAlignment & pBar->GetEnabledAlignment ()) != 0 ||
CBCGPDockManager::m_bIgnoreEnabledAlignment)
{
barContainerManager.CalcRects (rectOriginal, rectInserted, rectSlider, dwSliderStyle,
dwAlignment, sizeMinOriginal, sizeMinInserted);
rectResult = rectInserted;
}
}
