bcgpdockingcontrolbar.cpp

远程网络监视程序的源码

// BCGPDockingControlBar.cpp : implementation file
//

#include "stdafx.h"

#include "BCGGlobals.h"
#include "BCGPGlobalUtils.h"
#include "BCGPFrameWnd.h"
#include "BCGPMDIFrameWnd.h"
#include "BCGPOleIPFrameWnd.h"
#include "BCGPMiniFrameWnd.h"
#include "BCGPMultiMiniFrameWnd.h"
#include "BCGPBaseControlBar.h"
#include "BCGPDockBarRow.h"
#include "BCGPTabbedControlBar.h"
#include "BCGPDrawManager.h"
#include "BCGPAutoHideButton.h"
#include "BCGPAutoHideToolBar.h"
#include "BCGPAutoHideDockBar.h"
#include "BCGPSlider.h"
#include "BCGPLocalResource.h"
#include "BCGProRes.h"
#include "BCGPDockingControlBar.h"
#include "BCGPBarContainerManager.h"
#include "BCGPOutlookBar.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

int  CBCGPDockingControlBar::m_nTimeOutBeforeAutoHide	= 700;
int  CBCGPDockingControlBar::m_nSlideDefaultTimeOut		= 1;
BOOL CBCGPDockingControlBar::m_bHideInAutoHideMode		= FALSE;
int  CBCGPDockingControlBar::m_nSlideSteps				= 12;


static int g_nCloseButtonMargin = 1;
static int g_nCaptionVertMargin = 2;
static int g_nCaptionHorzMargin = 2;

CSize CBCGPDockingControlBar::m_sizeDragSencitivity = CSize (GetSystemMetrics (SM_CXDRAG), 
															 GetSystemMetrics (SM_CYDRAG));

BOOL CBCGPDockingControlBar::m_bCaptionText = FALSE;
BOOL CBCGPDockingControlBar::m_bHideDisabledButtons = TRUE;
BOOL CBCGPDockingControlBar::m_bDisableAnimation = FALSE;

IMPLEMENT_SERIAL(CBCGPDockingControlBar, CBCGPControlBar, VERSIONABLE_SCHEMA | 2)

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CBCGPDockingControlBar::CBCGPDockingControlBar()
{
	m_bPrepareToFloat = false;	
	m_bReadyToFloat = false;

	m_pTabbedControlBarRTC = RUNTIME_CLASS (CBCGPTabbedControlBar);

	m_hDefaultSlider = NULL;
	m_cyGripper = 0;
	m_bHasGripper = FALSE;
	m_nBorderSize = 0;
	m_dwSCBStyle = 0;
	m_bMaximized = FALSE;
	m_bActive = FALSE;

	m_bEnableAutoHideAll = TRUE;

	m_bPinState = FALSE;
	m_nAutoHideConditionTimerID = 0;
	m_nSlideTimer = 0;
	m_nSlideStep = 0;
	m_nSlideDelta = 0;
	m_pAutoHideButton = NULL;
	m_pAutoHideBar = NULL;

	m_ahSlideMode = CBCGPDockManager::m_ahSlideModeGlobal;

	m_bIsSliding = FALSE;
	m_bIsHiding = FALSE;
	m_bIsResizing = FALSE;

	m_nLastPercent = 100;

	m_rectRedraw.SetRectEmpty ();
	m_rectRestored.SetRectEmpty ();

	m_nHot = HTNOWHERE;
	m_nHit = HTNOWHERE;
	m_bCaptionButtonsCaptured = FALSE;

	m_hRestoredDefaultSlider = NULL;
}

CBCGPDockingControlBar::~CBCGPDockingControlBar()
{
}

BEGIN_MESSAGE_MAP(CBCGPDockingControlBar, CBCGPControlBar)
	//{{AFX_MSG_MAP(CBCGPDockingControlBar)
	ON_WM_NCCALCSIZE()
	ON_WM_NCPAINT()
	ON_WM_NCHITTEST()
	ON_WM_PAINT()
	ON_WM_LBUTTONDOWN()
	ON_WM_MOUSEMOVE()
	ON_WM_LBUTTONUP()
	ON_WM_NCLBUTTONDOWN()
	ON_WM_CLOSE()
	ON_WM_CREATE()
	ON_WM_LBUTTONDBLCLK()
	ON_WM_DESTROY()
	ON_WM_NCMOUSEMOVE()
	ON_WM_CANCELMODE()
	ON_WM_TIMER()
	ON_WM_RBUTTONDOWN()
	ON_WM_SETTINGCHANGE()
	ON_WM_WINDOWPOSCHANGING()
	ON_WM_CONTEXTMENU()
	//}}AFX_MSG_MAP
	ON_MESSAGE(WM_SETTEXT, OnSetText)
	ON_NOTIFY_EX_RANGE(TTN_NEEDTEXT, 0, 0xFFFF, OnNeedTipText)
END_MESSAGE_MAP()

//***********************************************************************
BOOL CBCGPDockingControlBar::Create(LPCTSTR lpszCaption, 
									CWnd* pParentWnd, 
									const RECT& rect, 
									BOOL bHasGripper, 
									UINT nID, 
									DWORD dwStyle, 
									DWORD dwTabbedStyle,
									DWORD dwBCGStyle,
									CCreateContext* pContext)
{
	ASSERT_VALID (this);
	return CBCGPDockingControlBar::CreateEx (0, lpszCaption, pParentWnd, rect, 
											 bHasGripper, nID, dwStyle, dwTabbedStyle, 
											 dwBCGStyle, pContext);
}
//*****************************************************************************************
BOOL CBCGPDockingControlBar::Create(LPCTSTR lpszWindowName, 
									CWnd* pParentWnd,
									CSize sizeDefault, 
									BOOL bHasGripper,
									UINT nID, 
									DWORD dwStyle, 
									DWORD dwTabbedStyle, 
									DWORD dwBCGStyle)
{
	ASSERT_VALID (this);
	CRect rect (0, 0, sizeDefault.cx, sizeDefault.cy);
	return CBCGPDockingControlBar::CreateEx (0, lpszWindowName, pParentWnd, rect, 
											 bHasGripper, nID, dwStyle, dwTabbedStyle, 
											 dwBCGStyle, NULL);
}
//***********************************************************************
BOOL CBCGPDockingControlBar::CreateEx (DWORD dwStyleEx, 
									   LPCTSTR lpszCaption, 
									   CWnd* pParentWnd, 
									   const RECT& rect, 
									   BOOL bHasGripper, 
									   UINT nID, 
									   DWORD dwStyle, 
									   DWORD dwTabbedStyle, 
									   DWORD dwBCGStyle,
									   CCreateContext* pContext)
{
	ASSERT_VALID (this);

	if (dwStyle & CBRS_FLOAT_MULTI)
	{
		m_pMiniFrameRTC = RUNTIME_CLASS (CBCGPMultiMiniFrameWnd);
	}

	if (dwTabbedStyle & CBRS_BCGP_OUTLOOK_TABS)
	{
		m_pTabbedControlBarRTC = RUNTIME_CLASS (CBCGPOutlookBar);
	}
	else if (dwTabbedStyle & CBRS_BCGP_REGULAR_TABS)
	{
		m_pTabbedControlBarRTC = RUNTIME_CLASS (CBCGPTabbedControlBar);
	}

	if (dwStyle & WS_CAPTION || bHasGripper)
	{
		m_bHasGripper = bHasGripper = TRUE;
		dwStyle &= ~WS_CAPTION;
	}


	if (!CBCGPControlBar::CreateEx (dwStyleEx, NULL, dwStyle, rect, pParentWnd, nID, 
											 dwBCGStyle, pContext))
	{
		return FALSE;
	}
	
	m_rectRestored = rect;

	if (m_sizeDialog != CSize (0, 0))
	{
		m_rectRestored.right = m_rectRestored.left + m_sizeDialog.cx;
		m_rectRestored.bottom = m_rectRestored.top + m_sizeDialog.cy;
	}

	SetBarAlignment (dwStyle & CBRS_ALIGN_ANY);
	EnableGripper (bHasGripper);
	
	if (lpszCaption != NULL)
	{
		SetWindowText (lpszCaption);
	}

	return TRUE;
}
//***********************************************************************
void CBCGPDockingControlBar::EnableGripper (BOOL bEnable)
{
	if (bEnable && m_bHasGripper)
	{
		m_cyGripper = globalData.GetTextHeight () + g_nCaptionVertMargin * 2;
	}
	else
	{
		m_cyGripper = 0;
	}

	SetWindowPos (NULL, 0, 0, 0, 0, SWP_NOZORDER | SWP_NOMOVE | SWP_NOSIZE | 
									SWP_NOACTIVATE | SWP_FRAMECHANGED);
}
//***********************************************************************
int CBCGPDockingControlBar::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CBCGPControlBar::OnCreate(lpCreateStruct) == -1)
		return -1;

	SetCaptionButtons ();

	m_ToolTip.Create (NULL, TTS_ALWAYSTIP);
	m_ToolTip.Activate (TRUE);
	if(globalData.m_nMaxToolTipWidth != -1)
	{
		m_ToolTip.SetMaxTipWidth(globalData.m_nMaxToolTipWidth);
	}

	for (int i = 0; i < CBCGSIZINGCONTROLBAR_BUTTONS_NUM; i ++)
	{
		CBCGPLocalResource locaRes;

		CRect rectDummy;
		rectDummy.SetRectEmpty ();

		CString strTooltip;
		strTooltip.LoadString (i == 0 ? IDS_BCGBARRES_CLOSEBAR : IDS_BCGBARRES_AUTOHIDEBAR);

		m_ToolTip.AddTool (this, LPSTR_TEXTCALLBACK, &rectDummy, i + 1);
	}

	return 0;
}
//***********************************************************************
BOOL CBCGPDockingControlBar::IsDocked () const
{
	ASSERT_VALID (this);
	CBCGPMiniFrameWnd* pParent = GetParentMiniFrame ();
	
	if (pParent != NULL && pParent->GetControlBarCount () == 1)
	{
		return FALSE;
	}

	return TRUE;
}
//***********************************************************************
void CBCGPDockingControlBar::OnAfterDock  (CBCGPBaseControlBar* /*pBar*/, LPCRECT /*lpRect*/, BCGP_DOCK_METHOD /*dockMethod*/) 
{
	if (!CBCGPDockManager::m_bRestoringDockState)
	{
		SetFocus ();
	}
}
//***********************************************************************
void CBCGPDockingControlBar::OnBeforeChangeParent (CWnd* pWndNewParent, BOOL bDelay)
{
	ASSERT_VALID (this);

	// is being floated or tabbed
	if (pWndNewParent->IsKindOf (RUNTIME_CLASS (CBCGPMiniFrameWnd)) ||
		pWndNewParent->IsKindOf (RUNTIME_CLASS (CBCGPTabWnd)))
	{
		UnDockControlBar (bDelay);
	}

	CBCGPControlBar::OnBeforeChangeParent (pWndNewParent);
}//***********************************************************************
void CBCGPDockingControlBar::RemoveFromDefaultSlider ()
{
	ASSERT_VALID (this);

	if (m_hDefaultSlider != NULL)
	{
		// slider will be deleted here (by delete this) if it was a last
		// control bar registered with the slider
		SetDefaultSlider (NULL);
	}
}
//***********************************************************************
void CBCGPDockingControlBar::OnAfterChangeParent  (CWnd* pWndOldParent)
{
	ASSERT_VALID (this);
	CBCGPControlBar::OnAfterChangeParent (pWndOldParent);

	CBCGPMiniFrameWnd* pMiniFrameParent = GetParentMiniFrame ();
	if (pMiniFrameParent != NULL)
	{
		pMiniFrameParent->AddRemoveBarFromGlobalList (this, TRUE);
	}
}
//***********************************************************************
void CBCGPDockingControlBar::RecalcLayout ()
{
	ASSERT_VALID (this);

	CBCGPControlBar::RecalcLayout ();

	
}
//***********************************************************************
void CBCGPDockingControlBar::UpdateTooltips ()
{
    CRect rcBar;
    GetWindowRect(rcBar);
	ScreenToClient (rcBar);

	for (int i = 0; i < m_arrButtons.GetSize () && i < m_ToolTip.GetToolCount( ); i ++)
	{
		CBCGPCaptionButton* pbtn = m_arrButtons [i];
		ASSERT_VALID (pbtn);

		if (m_ToolTip.GetSafeHwnd () != NULL)
		{
			CRect rectTT = pbtn->GetRect ();
			rectTT.OffsetRect (rcBar.TopLeft());
			m_ToolTip.SetToolRect (this, i + 1, rectTT);
		}
	}
}
//***********************************************************************
void CBCGPDockingControlBar::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp) 
{
	ASSERT_VALID (this);
	CBCGPControlBar::OnNcCalcSize(bCalcValidRects, lpncsp);

	if (IsFloating ())
	{
		for (int i = 0; i < m_arrButtons.GetSize (); i ++)
		{
			CBCGPCaptionButton* pbtn = m_arrButtons [i];
			ASSERT_VALID (pbtn);

			pbtn->m_bHidden = TRUE;
		}

		return;
	}

	CRect rcClient = lpncsp->rgrc[0];
	rcClient.DeflateRect (0, m_cyGripper, 0, 0);

	// "hide" and "expand" buttons positioning:
	CSize sizeButton = CBCGPCaptionButton::GetSize ();
    CPoint ptOrgBtnRight = CPoint (rcClient.right - sizeButton.cx,
		rcClient.top - m_cyGripper - m_nBorderSize + (m_cyGripper - sizeButton.cy) / 2 - 1);
    CPoint ptOrgBtnLeft = CPoint (rcClient.left, ptOrgBtnRight.y);

	CRect rcBar;
    GetWindowRect(rcBar);
	ScreenToClient (rcBar);

	BOOL bHidePinBtn = TRUE;

	CWnd* pParentWnd = GetParent ();

	if (pParentWnd->IsKindOf (RUNTIME_CLASS (CBCGPMiniFrameWnd)))
	{
		pParentWnd = pParentWnd->GetParent ();
	}

	CBCGPSlider* pDefaultSlider = GetDefaultSlider ();

	CBCGPDockManager* pDockManager = globalUtils.GetDockManager (pParentWnd);
	if (pDockManager != NULL &&
		pDefaultSlider != NULL && 
		(pDefaultSlider->GetCurrentAlignment () & 
		 pDockManager->GetEnabledAutoHideAlignment ()) &&
		 CanAutoHide ())
	{
       bHidePinBtn = FALSE;
	}

	if (m_cyGripper > 0)
	{
		for (int i = 0; i < m_arrButtons.GetSize (); i ++)
		{
			CBCGPCaptionButton* pbtn = m_arrButtons [i];
			ASSERT_VALID (pbtn);

			UINT unHit = pbtn->GetHit ();

			BOOL bHide = FALSE;
			if (m_bHideDisabledButtons)
			{
				bHide = bHidePinBtn && unHit == HTMAXBUTTON || 
						!CanBeClosed () && unHit == HTCLOSE_BCG;
			}

			pbtn->m_bFocused = pbtn->m_bPushed = FALSE;

			if (pbtn->m_bLeftAlign)
			{
				pbtn->Move (ptOrgBtnLeft - CRect (lpncsp->rgrc[0]).TopLeft (), bHide);

				if (!bHide)
				{
					ptOrgBtnLeft.Offset (sizeButton.cx + 2, 0);
				}
			}
			else
			{
				pbtn->Move (ptOrgBtnRight - CRect (lpncsp->rgrc[0]).TopLeft (), bHide);

				if (!bHide)
				{
					ptOrgBtnRight.Offset (- sizeButton.cx - 2, 0);
				}
			}
		}

		// Hide left aligned buttons if there is no room for them:
		for (i = 0; i < m_arrButtons.GetSize (); i ++)
		{
			CBCGPCaptionButton* pbtn = m_arrButtons [i];
			ASSERT_VALID (pbtn);

			if (pbtn->m_bLeftAlign)
			{
				pbtn->m_bHidden = CRect (lpncsp->rgrc[0]).left + pbtn->GetRect ().left >= ptOrgBtnRight.x;
			}
		}
	}
	else
	{
		for (int i = 0; i < m_arrButtons.GetSize (); i ++)
		{
			CBCGPCaptionButton* pbtn = m_arrButtons [i];
			ASSERT_VALID (pbtn);

			pbtn->m_bHidden = TRUE;
		}
	}

	rcClient.right = max(rcClient.right, rcClient.left);
	rcClient.bottom = max(rcClient.bottom, rcClient.top);

    lpncsp->rgrc[0] = rcClient;
	
	UpdateTooltips ();
}
//***********************************************************************
void CBCGPDockingControlBar::OnNcPaint() 
{
	if (m_bMultiThreaded)
	{
		g_cs.Lock ();
	}

	ASSERT_VALID (this);
	
	// get window DC that is clipped to the non-client area
    CWindowDC dc(this);

	CRect rectUpd;
	GetUpdateRect (rectUpd);

    CRect rcClient, rcBar;
    GetClientRect(rcClient);
    ClientToScreen(rcClient);
    GetWindowRect(rcBar);

    rcClient.OffsetRect(-rcBar.TopLeft());
    rcBar.OffsetRect(-rcBar.TopLeft());

	if (rectUpd.top > rcClient.top)
	{
		if (m_bMultiThreaded)
		{
			g_cs.Unlock ();
		}

		return;
	}