bcgptaskspane.cpp

远程网络监视程序的源码

// BCGPTasksPane.cpp : implementation file
//

#include "stdafx.h"
#include "bcgcbpro.h"
#include "BCGPLocalResource.h"
#include "bcgprores.h"
#include "BCGPVisualManager.h"
#include "BCGPContextMenuManager.h"
#include "BCGPWorkspace.h"
#include "BCGPTasksPane.h"
#include "BCGPTaskPaneMiniFrameWnd.h"
#include "BCGPMultiMiniFrameWnd.h"
#include "RegPath.h"
#include "BCGPRegistry.h"
#include "BCGPToolbarMenuButton.h"

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

extern CBCGPWorkspace* g_pWorkspace;

static const CString strTasksPaneProfile	= _T("BCGPTasksPanes");
#define REG_SECTION_FMT						_T("%sBCGPTasksPane-%d")
#define REG_SECTION_FMT_EX					_T("%sBCGPTasksPane-%d%x")
#define REG_ENTRY_SETTINGS					_T("Settings")

#define ID_SCROLL_VERT	1

static const int iBorderSize = 1;
static const int iNavToolbarId = 1;
static const int iAnimTimerId =		ID_CHECK_AUTO_HIDE_CONDITION + 1;
static const int iScrollTimerId =	ID_CHECK_AUTO_HIDE_CONDITION + 2;

static inline BOOL IsSystemCommand (UINT uiCmd)
{
	return (uiCmd >= 0xF000 && uiCmd < 0xF1F0);
}

/////////////////////////////////////////////////////////////////////////////
// CBCGPTasksPane additional classes: CTasksPaneNavigateButton

class CTasksPaneNavigateButton : public CBCGPToolbarButton
{
	friend class CBCGPTasksPane;
	DECLARE_SERIAL(CTasksPaneNavigateButton)

protected:
    CTasksPaneNavigateButton(int iImage = -1)
		: CBCGPToolbarButton ()
	{
		m_iImage = iImage;
		m_bLocked = TRUE;
	}
	CTasksPaneNavigateButton (UINT uiID, int iImage, LPCTSTR lpszText = NULL)
		: CBCGPToolbarButton (uiID, iImage, lpszText, FALSE, TRUE)
	{
	}
};

IMPLEMENT_SERIAL(CTasksPaneNavigateButton, CBCGPToolbarButton, 1)

/////////////////////////////////////////////////////////////////////////////
// CTasksPaneMenuButton

class CTasksPaneMenuButton : public CBCGPToolbarMenuButton
{
	friend class CBCGPTasksPane;
	DECLARE_SERIAL(CTasksPaneMenuButton)

public:
	CTasksPaneMenuButton(HMENU hMenu = NULL) :
		CBCGPToolbarMenuButton ((UINT)-1, hMenu, -1)
	{
		m_pParentBar = NULL;
	}
	//***********************************************************************
	virtual HMENU CreateMenu () const
	{
		if (m_pParentBar == NULL)
		{
			return NULL;
		}

		ASSERT_VALID (m_pParentBar);

		return m_pParentBar->CreateMenu ();
	}
	//***********************************************************************
	virtual CBCGPPopupMenu* CreatePopupMenu ()
	{
		CBCGPPopupMenu* pMenu = CBCGPToolbarMenuButton::CreatePopupMenu ();
		if (pMenu == NULL)
		{
			ASSERT (FALSE);
			return NULL;
		}

		pMenu->SetRightAlign (TRUE);
		return pMenu;
	}
	//***********************************************************************
	virtual void OnChangeParentWnd (CWnd* pWndParent)
	{
		CBCGPToolbarMenuButton::OnChangeParentWnd (pWndParent);
		m_pParentBar = DYNAMIC_DOWNCAST (CBCGPTasksPane, pWndParent);
	}
	
// data:
	CBCGPTasksPane*	m_pParentBar;
};

IMPLEMENT_SERIAL(CTasksPaneMenuButton, CBCGPToolbarMenuButton, 1)


/////////////////////////////////////////////////////////////////////////////
// CTasksPaneToolBar

IMPLEMENT_SERIAL(CTasksPaneToolBar, CBCGPToolBar, 1)

void CTasksPaneToolBar::OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler)
{
	CBCGPToolBar::OnUpdateCmdUI (pTarget, bDisableIfNoHndler);

	CBCGPTasksPane*	pParentBar = DYNAMIC_DOWNCAST (CBCGPTasksPane, FromHandle (m_hWndOwner));
	if (pParentBar == NULL)
	{
		return;
	}
	ASSERT_VALID (pParentBar);

	// --------------------------
	// Update Navigation buttons:
	// --------------------------
	int i = 0;
	for (POSITION posBtn = m_Buttons.GetHeadPosition (); posBtn != NULL; i++)
	{
		CTasksPaneNavigateButton* pButton = 
			DYNAMIC_DOWNCAST (CTasksPaneNavigateButton, m_Buttons.GetNext(posBtn));
		if (pButton != NULL)
		{
			ASSERT_VALID (pButton);

			BOOL bEnable = TRUE;
			switch (pButton->GetImage ())
			{
			case 0: // back
				bEnable = pParentBar->IsBackButtonEnabled ();
				break;
			case 1: // forward
				bEnable = pParentBar->IsForwardButtonEnabled ();
				break;
			case 2: // home
				bEnable = TRUE;
				break;
			case 3: // close
				bEnable = pParentBar->CanBeClosed ();
				break;
			}

			pButton->m_nStyle &= ~TBBS_DISABLED;
			if (!bEnable)
			{
				pButton->m_nStyle |= TBBS_DISABLED;
			}
		}
	}

	Invalidate ();
	UpdateWindow ();
}
//******************************************************************************************
void CTasksPaneToolBar::AdjustLocations ()
{
	ASSERT_VALID(this);

	if (GetSafeHwnd () == NULL || !::IsWindow (m_hWnd))
	{
		return;
	}

	CBCGPToolBar::AdjustLocations ();

	//----------------------------------
	// Get menu button and close button:
	//----------------------------------
	CTasksPaneNavigateButton* pCloseBtn = NULL;
	CTasksPaneMenuButton* pMenuBtn = NULL;

	for (POSITION pos = m_Buttons.GetHeadPosition (); pos != NULL; )
	{
		CBCGPToolbarButton* pButton = (CBCGPToolbarButton*) m_Buttons.GetNext (pos);
		ASSERT_VALID (pButton);
		
		if (pButton->m_nStyle & TBBS_SEPARATOR)
		{
		}
		else
		{
			if (pButton->IsKindOf (RUNTIME_CLASS (CTasksPaneNavigateButton)))
			{
				if (pButton->GetImage () == 3)
				{
					pCloseBtn = DYNAMIC_DOWNCAST (CTasksPaneNavigateButton, pButton);
					ASSERT_VALID (pCloseBtn);
				}

			}
			else if (pButton->IsKindOf (RUNTIME_CLASS (CTasksPaneMenuButton)))
			{
				pMenuBtn = DYNAMIC_DOWNCAST (CTasksPaneMenuButton, pButton);
				ASSERT_VALID (pMenuBtn);
			}
		}
	}	

	CRect rectClient;
	GetClientRect (&rectClient);
	
	BOOL bShowCloseButton = FALSE;
	BOOL bStrechMenuButton = TRUE;

	if (pMenuBtn != NULL)
	{
		CRect rectMenuBtn = pMenuBtn->Rect ();
		int nMin = rectMenuBtn.left + rectMenuBtn.Height () * 3;
		int nMax = rectClient.right - 1;
		if (pCloseBtn != NULL && bShowCloseButton)
		{
			nMax = rectClient.right - 1 - rectMenuBtn.Height ();
		}

		// -------------------
		// Adjust menu button:
		// -------------------
		if (bStrechMenuButton)
		{
			rectMenuBtn.right = max (nMin, nMax);
			pMenuBtn->SetRect (rectMenuBtn);
		}

		// --------------------
		// Adjust close button:
		// --------------------
		if (pCloseBtn != NULL && bShowCloseButton)
		{
			CRect rectCloseBtn = pMenuBtn->Rect ();
			rectCloseBtn.left = rectMenuBtn.right;
			rectCloseBtn.right = rectMenuBtn.right + rectCloseBtn.Height ();

			if (rectCloseBtn.right < rectClient.right - 1)
			{
				rectCloseBtn.OffsetRect (rectClient.right - 1 - rectCloseBtn.right, 0);
			}

			pCloseBtn->SetRect (rectCloseBtn);
			pCloseBtn->Show (TRUE);
		}
		else if (pCloseBtn != NULL)
		{
			pCloseBtn->Show (FALSE);
		}
	}
	UpdateTooltips ();
}
//******************************************************************************************
void CTasksPaneToolBar::UpdateMenuButtonText (const CString& str)
{
	for (POSITION pos = m_Buttons.GetHeadPosition (); pos != NULL; )
	{
		CBCGPToolbarButton* pButton = (CBCGPToolbarButton*) m_Buttons.GetNext (pos);
		ASSERT_VALID (pButton);

		CTasksPaneMenuButton* pMenuBtn = DYNAMIC_DOWNCAST (CTasksPaneMenuButton, pButton);
		if (pMenuBtn != NULL)
		{
			ASSERT_VALID (pMenuBtn);

			pMenuBtn->m_strText = str;
		}
	}
}
//******************************************************************************************
BOOL CTasksPaneToolBar::OnUserToolTip (CBCGPToolbarButton* pButton, CString& strTTText) const
{
	ASSERT_VALID (pButton);

	if (pButton->IsKindOf (RUNTIME_CLASS (CTasksPaneMenuButton)))
	{
		CBCGPLocalResource locaRes;
		strTTText.LoadString (ID_BCGBARRES_TASKPANE_OTHER);
		return TRUE;
	}

	CTasksPaneNavigateButton* pNavButton = DYNAMIC_DOWNCAST (CTasksPaneNavigateButton, pButton);
	if (pNavButton != NULL)
	{
		ASSERT_VALID (pNavButton);
		strTTText = pNavButton->m_strText;
		return TRUE;
	}
		
	return CBCGPToolBar::OnUserToolTip (pButton, strTTText);
}
//********************************************************************************
void CTasksPaneToolBar::AdjustLayout ()
{
	CBCGPToolBar::AdjustLayout ();

	CBCGPTasksPane* pTaskPane = DYNAMIC_DOWNCAST (CBCGPTasksPane, GetParent ());
	if (pTaskPane != NULL)
	{
		pTaskPane->RecalcLayout (TRUE);
	}
}


/////////////////////////////////////////////////////////////////////////////
// CBCGPTasksPane

clock_t CBCGPTasksPane::m_nLastAnimTime = 0;
const int CBCGPTasksPane::m_iAnimTimerDuration = 30;
const int CBCGPTasksPane::m_iScrollTimerDuration = 80;

IMPLEMENT_SERIAL(CBCGPTasksPane, CBCGPDockingControlBar, VERSIONABLE_SCHEMA | 1)

CBCGPTasksPane::CBCGPTasksPane(): CBCGPDockingControlBar (), m_nMaxHistory (10)
{
	m_hFont = NULL;
	m_sizeIcon = CSize (0, 0);

	m_arrHistoryStack.Add (0);
	m_iActivePage = 0;
	m_pHotTask = NULL;
	m_pClickedTask = NULL;
	m_pHotGroupCaption = NULL;
	m_pClickedGroupCaption = NULL;
	m_bCanCollapse = TRUE;
	m_nVertScrollOffset = 0;
	m_nVertScrollTotal = 0;
	m_nVertScrollPage = 0;
	m_nRowHeight = 0;

	m_nVertMargin = -1;	// default, use Visual Manager's settings
	m_nHorzMargin = -1;
	m_nGroupVertOffset = -1;
	m_nGroupCaptionHeight = -1;
	m_nGroupCaptionHorzOffset = -1;
	m_nGroupCaptionVertOffset = -1;
	m_nTasksHorzOffset = -1;
	m_nTasksIconHorzOffset = -1;
	m_nTasksIconVertOffset = -1;

	m_rectTasks.SetRectEmpty ();

	m_bUseNavigationToolbar = FALSE;
	m_uiToolbarBmpRes = 0;
	m_sizeToolbarImage = CSize (0, 0);
	m_sizeToolbarButton = CSize (0, 0);
	m_rectToolbar.SetRectEmpty ();

	m_bUseScrollButtons = TRUE;
	m_rectScrollUp.SetRectEmpty ();
	m_rectScrollDn.SetRectEmpty ();
	m_iScrollBtnHeight = CMenuImages::Size ().cy + 2 * iBorderSize;
	m_iScrollMode = 0;
	
	m_bAnimationEnabled = TRUE;
	m_pAnimatedGroup = NULL;
	m_sizeAnim = CSize (0, 0);

	m_bMenuBtnPressed = FALSE;
}

CBCGPTasksPane::~CBCGPTasksPane()
{
	while (!m_lstTasksPanes.IsEmpty ())
	{
		delete m_lstTasksPanes.RemoveHead ();
	}
}

BEGIN_MESSAGE_MAP(CBCGPTasksPane, CBCGPDockingControlBar)
	//{{AFX_MSG_MAP(CBCGPTasksPane)
	ON_WM_CREATE()
	ON_WM_SIZE()
	ON_WM_SETTINGCHANGE()
	ON_WM_SETCURSOR()
	ON_WM_MOUSEMOVE()
	ON_WM_LBUTTONUP()
	ON_WM_CANCELMODE()
	ON_WM_LBUTTONDOWN()
	ON_WM_VSCROLL()
	ON_WM_PAINT()
	ON_WM_ERASEBKGND()
	ON_WM_DESTROY()
	ON_WM_TIMER()
	//}}AFX_MSG_MAP
	ON_MESSAGE(WM_SETFONT, OnSetFont)
	ON_MESSAGE(WM_GETFONT, OnGetFont)
	ON_NOTIFY_EX_RANGE(TTN_NEEDTEXT, 0, 0xFFFF, OnNeedTipText)
	ON_COMMAND(ID_BCGBARRES_TASKPANE_BACK, OnBack)
	ON_COMMAND(ID_BCGBARRES_TASKPANE_FORWARD, OnForward)
	ON_COMMAND(ID_BCGBARRES_TASKPANE_HOME, OnHome)
	ON_COMMAND(ID_BCGBARRES_TASKPANE_CLOSE, OnClose)
	ON_COMMAND(ID_BCGBARRES_TASKPANE_OTHER, OnOther)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CBCGPTasksPane message handlers

int CBCGPTasksPane::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CBCGPDockingControlBar::OnCreate(lpCreateStruct) == -1)
		return -1;
	
	//-----------------------------
	// Load Task Pane text strings:
	//-----------------------------
	CString strOther;
	CString strForward;
	CString strBack;

	{
		CBCGPLocalResource locaRes;
		strOther.LoadString (ID_BCGBARRES_TASKPANE_OTHER);
		strForward.LoadString (ID_BCGBARRES_TASKPANE_FORWARD);
		strBack.LoadString (ID_BCGBARRES_TASKPANE_BACK);
		m_strCaption.LoadString (IDS_BCGBARRES_TASKPANE);
	}

	// --------------------------------------------
	// Register tools for caption buttons tooltips:
	// --------------------------------------------
	for (int i = 1; i <= 3; i ++)
	{
		CRect rectDummy;
		rectDummy.SetRectEmpty ();

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

	// ------------------------------------
	// Add default page to m_lstTasksPanes:
	// ------------------------------------
	AddPage (m_strCaption);
	SetCaption (m_strCaption);

	// ---------------
	// Create toolbar:
	// ---------------
	if (!CreateNavigationToolbar ())
	{
		TRACE(_T("Can't create taskspane toolbar bar\n"));
		return FALSE;
	}

	CreateFonts ();

	if (globalData.m_hcurHand == NULL)
	{
		CBCGPLocalResource locaRes;
		globalData.m_hcurHand = AfxGetApp ()->LoadCursor (IDC_BCGBARRES_HAND);
	}

	CRect rectDummy;
	rectDummy.SetRectEmpty ();
	m_wndScrollVert.Create (WS_CHILD | WS_VISIBLE | SBS_VERT, rectDummy, this, ID_SCROLL_VERT);

	return 0;
}
//******************************************************************************************
void CBCGPTasksPane::OnSize(UINT nType, int cx, int cy) 
{
	CBCGPDockingControlBar::OnSize(nType, cx, cy);

	AdjustScroll ();
	ReposTasks ();

	RedrawWindow (NULL, NULL, RDW_INVALIDATE | RDW_ERASE);
}
//******************************************************************************************
int CBCGPTasksPane::ReposTasks (BOOL bCalcHeightOnly/* = FALSE*/)