bcgptoolbarbutton.cpp

远程网络监视程序的源码

// BCGPToolbarButton.cpp: implementation of the CBCGPPToolbarButton class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "menuhash.h"
#include "BCGGlobals.h"
#include "BCGPCommandManager.h"
#include "BCGPVisualManager.h"  
#include "BCGPToolbarButton.h"
#include "BCGPToolBar.h"
#include "BCGPMDIFrameWnd.h"
#include "BCGPOleIPFrameWnd.h"
#include "BCGPFrameWnd.h"
#include "BCGPToolbarMenuButton.h"
#include "BCGPWorkspace.h"

extern CBCGPWorkspace* g_pWorkspace;


IMPLEMENT_SERIAL(CBCGPToolbarButton, CObject, VERSIONABLE_SCHEMA | 1)

CLIPFORMAT CBCGPToolbarButton::m_cFormat = 0;
CString	 CBCGPToolbarButton::m_strClipboardFormatName;
BOOL CBCGPToolbarButton::m_bWrapText = TRUE;

static const int nTextMargin = 3;
static const int nSeparatorWidth = 8;
static const CString strDummyAmpSeq = _T("\001\001");

CList<UINT, UINT> CBCGPToolbarButton::m_lstProtectedCommands;
BOOL CBCGPToolbarButton::m_bUpdateImages = TRUE;

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

CBCGPToolbarButton::CBCGPToolbarButton()
{
	Initialize ();
}
//*********************************************************************************
CBCGPToolbarButton::CBCGPToolbarButton(UINT uiID, int iImage, LPCTSTR lpszText, BOOL bUserButton,
									 BOOL bLocked)
{
	Initialize ();

	m_bLocked = bLocked;

	m_nID = uiID;
	m_bUserButton = bUserButton;
	SetImage (iImage);

	m_strText = (lpszText == NULL) ? _T("") : lpszText;

	if (m_nID != 0 && !m_bLocked)
	{
		if (m_bUserButton)
		{
			if (m_iUserImage != -1)
			{
				CMD_MGR.SetCmdImage (m_nID, m_iUserImage, TRUE);
			}
			else
			{
				m_iUserImage = CMD_MGR.GetCmdImage (m_nID, TRUE);
			}
		}
		else
		{
			if (m_iImage != -1)
			{
				CMD_MGR.SetCmdImage (m_nID, m_iImage, FALSE);
			}
			else
			{
				m_iImage = CMD_MGR.GetCmdImage (m_nID, FALSE);
			}
		}
	}
}
//*********************************************************************************
void CBCGPToolbarButton::Initialize ()
{
	m_nID = 0;
	m_nStyle = TBBS_BUTTON;
	m_iImage = -1;
	m_iUserImage = -1;
	m_bUserButton = FALSE;
	m_bDragFromCollection = FALSE;
	m_bText = FALSE;
	m_bImage = TRUE;
	m_bWrap = FALSE;
	m_bWholeText = TRUE;
	m_bLocked = FALSE;
	m_bIsHidden = FALSE;
	m_bTextBelow = FALSE;

	m_rect.SetRectEmpty ();
	m_sizeText = CSize (0, 0);
	m_bDisableFill = FALSE;
	m_bExtraSize = FALSE;
	m_bHorz = TRUE;
	m_bVisible = TRUE;
}
//*********************************************************************************
CBCGPToolbarButton::~CBCGPToolbarButton()
{
}
//*********************************************************************************
void CBCGPToolbarButton::CopyFrom (const CBCGPToolbarButton& src)
{
	m_nID			= src.m_nID;
	m_bLocked		= src.m_bLocked;
	m_bUserButton	= src.m_bUserButton;
	m_nStyle		= src.m_nStyle;
	SetImage (src.m_bUserButton ? src.m_iUserImage : src.m_iImage);
	m_strText		= src.m_strText;
	m_bText			= src.m_bText;
	m_bImage		= src.m_bImage;
	m_bWrap			= src.m_bWrap;
	m_strTextCustom	= src.m_strTextCustom;
	m_bVisible		= src.m_bVisible;
					
	m_bDragFromCollection = FALSE;
}					
//***************************************************************************************
void CBCGPToolbarButton::Serialize (CArchive& ar)
{
	CObject::Serialize (ar);

	if (ar.IsLoading ())
	{
		int iImage;

		ar >> m_nID;
		ar >> m_nStyle;	
		ar >> iImage;	
		ar >> m_strText;	
		ar >> m_bUserButton;
		ar >> m_bDragFromCollection;
		ar >> m_bText;
		ar >> m_bImage;

		if (g_menuHash.IsActive () ||
			(g_pWorkspace != NULL && 
		   (g_pWorkspace->GetDataVersionMajor () == 6 &&
				g_pWorkspace->GetDataVersionMinor () >= 41 ||
				g_pWorkspace->GetDataVersionMajor () >= 7  ||
				g_pWorkspace->GetDataVersionMajor () == -1 &&
				g_pWorkspace->GetDataVersionMinor () == -1)))
		{
			ar >> m_bVisible;
		}

		SetImage (iImage);
	}
	else
	{
		ar << m_nID;		
		ar << m_nStyle;	
		ar << GetImage ();
		ar << m_strText;
		ar << m_bUserButton;
		ar << m_bDragFromCollection;
		ar << m_bText;
		ar << m_bImage;

		if (g_menuHash.IsActive () ||
			(g_pWorkspace != NULL && 
		   (g_pWorkspace->GetDataVersionMajor () == 6 &&
				 g_pWorkspace->GetDataVersionMinor () >= 41 ||
				 g_pWorkspace->GetDataVersionMajor () >= 7 ||
				 g_pWorkspace->GetDataVersionMajor () == -1 &&
				 g_pWorkspace->GetDataVersionMinor () == -1)))
		{
			ar << m_bVisible;
		}
	}
}
//***************************************************************************************
CLIPFORMAT CBCGPToolbarButton::GetClipboardFormat ()
{
	if (m_cFormat == 0)	// Not registered yet
	{
		CString strFormat = m_strClipboardFormatName;

		if (strFormat.IsEmpty ())
		{
			strFormat.Format (_T("BCGToolbarButton%lx"), AfxGetInstanceHandle ());
						// Format should be unique per application
		}

		m_cFormat = (CLIPFORMAT)::RegisterClipboardFormat (strFormat);
		ASSERT (m_cFormat != NULL);
	}

	return m_cFormat;
}
//***************************************************************************************
CBCGPToolbarButton* CBCGPToolbarButton::CreateFromOleData  (COleDataObject* pDataObject)
{
	ASSERT (pDataObject != NULL);
	ASSERT (pDataObject->IsDataAvailable (CBCGPToolbarButton::m_cFormat));

	CBCGPToolbarButton* pButton = NULL;

	try
	{
		//-------------------------------------
		// Get file refering to clipboard data:
		//-------------------------------------
		CFile* pFile = pDataObject->GetFileData (GetClipboardFormat ());
		if (pFile == NULL)
		{
			return FALSE;
		}

		//-------------------------------------------------------
		// Connect the file to the archive and read the contents:
		//-------------------------------------------------------
		CArchive ar (pFile, CArchive::load);

		//----------------------------------------
		// First, read run-time class information:
		//----------------------------------------
		CRuntimeClass* pClass = ar.ReadClass ();
		ASSERT (pClass != NULL);

		if (pClass != NULL)
		{
			pButton = (CBCGPToolbarButton*) pClass->CreateObject ();
			ASSERT (pButton != NULL);

			if (pButton != NULL)
			{
				pButton->Serialize (ar);
			}
		}

		ar.Close ();
		delete pFile;

		return pButton;
	}
	catch (COleException* pEx)
	{
		TRACE(_T("CBCGPToolbarButton::CreateFromOleData. OLE exception: %x\r\n"),
			pEx->m_sc);
		pEx->Delete ();
	}
	catch (CArchiveException* pEx)
	{
		TRACE(_T("CBCGPToolbarButton::CreateFromOleData. Archive exception\r\n"));
		pEx->Delete ();
	}
	catch (CNotSupportedException *pEx)
	{
		TRACE(_T("CBCGPToolbarButton::CreateFromOleData. \"Not Supported\" exception\r\n"));
		pEx->Delete ();
	}

	if (pButton != NULL)
	{
		delete pButton;
	}

	return NULL;
}
//***************************************************************************************
void CBCGPToolbarButton::OnDraw (CDC* pDC, const CRect& rect, CBCGPToolBarImages* pImages,
								BOOL bHorz, BOOL bCustomizeMode, BOOL bHighlight,
								BOOL bDrawBorder, BOOL bGrayDisabledButtons)
{
	ASSERT_VALID (pDC);
	ASSERT_VALID (this);

	m_bHorz = bHorz;

	//----------------------
	// Fill button interior:
	//----------------------
	FillInterior (pDC, rect, bHighlight);

	BOOL bHot = bHighlight;
	CSize sizeImage = (pImages == NULL) ? CSize (0, 0) : pImages->GetImageSize (TRUE);

	CBCGPUserTool* pUserTool = NULL;
	if (g_pUserToolsManager != NULL && !m_bUserButton)
	{
		pUserTool = g_pUserToolsManager->FindTool (m_nID);
	}

	CRect rectInternal = rect;
	CSize sizeExtra = m_bExtraSize ?
		CBCGPVisualManager::GetInstance ()->GetButtonExtraBorder () : CSize (0, 0);
	rectInternal.DeflateRect (sizeExtra.cx / 2, sizeExtra.cy / 2);

	int x = rectInternal.left;
	int y = rectInternal.top;

	int iTextLen = 0;

	if (IsDrawText () && !(m_bTextBelow && bHorz))
	{
		CString strWithoutAmp = m_strText;
		strWithoutAmp.Replace (_T("&&"), strDummyAmpSeq);
		strWithoutAmp.Remove (_T('&'));
		strWithoutAmp.Replace (strDummyAmpSeq, _T("&"));

		iTextLen = pDC->GetTextExtent (strWithoutAmp).cx + 2 * nTextMargin;
	}

	int dx = 0;
	int dy = 0;

	if (m_bTextBelow && bHorz)
	{
		ASSERT (bHorz);

		dx = rectInternal.Width ();
		dy = sizeImage.cy + 2 * nTextMargin;
	}
	else
	{
		dx = bHorz ? rectInternal.Width () - iTextLen : rectInternal.Width ();
		dy = bHorz ? rectInternal.Height () : rectInternal.Height () - iTextLen;
	}

	// determine offset of bitmap (centered within button)
	CPoint ptImageOffset;
	ptImageOffset.x = (dx - sizeImage.cx) / 2;
	ptImageOffset.y = (dy - sizeImage.cy) / 2;

	CPoint ptTextOffset (nTextMargin, nTextMargin);

	if (IsDrawText () && !(m_bTextBelow && bHorz))
	{
		TEXTMETRIC tm;
		pDC->GetTextMetrics (&tm);

		if (bHorz)
		{
			ptTextOffset.y = (dy - tm.tmHeight - 1) / 2;
		}
		else
		{
			ptTextOffset.x = (dx - tm.tmHeight + 1) / 2;
		}
	}

	CPoint ptImageOffsetInButton (0, 0);
	BOOL bPressed = FALSE;

	BOOL bDrawImageShadow = 
		bHighlight && !bCustomizeMode &&
		!IsDroppedDown () &&
		CBCGPVisualManager::GetInstance ()->IsShadowHighlightedImage () &&
		((m_nStyle & TBBS_PRESSED) == 0) &&
		((m_nStyle & TBBS_CHECKED) == 0) &&
		((m_nStyle & TBBS_DISABLED) == 0);

	if ((m_nStyle & (TBBS_PRESSED | TBBS_CHECKED)) && !bCustomizeMode &&
		!CBCGPVisualManager::GetInstance ()->IsShadowHighlightedImage () &&
		CBCGPVisualManager::GetInstance ()->IsOffsetPressedButton ())
	{
		// pressed in or checked
		ptImageOffset.Offset (1, 1);
		bPressed = TRUE;

		ptTextOffset.y ++;

		if (bHorz)
		{
			ptTextOffset.x ++;
		}
		else
		{
			ptTextOffset.x --;
		}
	}

	BOOL bFadeImage = !bHighlight && CBCGPVisualManager::GetInstance ()->IsFadeInactiveImage ();
	BOOL bImageIsReady = FALSE;

	if ((m_nStyle & TBBS_PRESSED) || !(m_nStyle & TBBS_DISABLED) ||
		bCustomizeMode)
	{
		if (IsDrawImage () && pImages != NULL)
		{
			if (pUserTool != NULL)
			{
				pUserTool->DrawToolIcon (pDC,
					CRect (CPoint (x + ptImageOffset.x, y + ptImageOffset.y),
					sizeImage));
			}
			else
			{
				CPoint pt = ptImageOffset;

				if (bDrawImageShadow)
				{
					pImages->Draw (pDC, x + pt.x, 
										y + pt.y, GetImage (),
										FALSE, FALSE, FALSE, TRUE);
					pt.Offset (-1, -1);
				}

				pImages->Draw (pDC, x + pt.x, y + pt.y, GetImage (),
					FALSE, FALSE, FALSE, FALSE, bFadeImage);
			}
		}

		if (bCustomizeMode || m_nStyle & TBBS_PRESSED)
		{
			bImageIsReady = TRUE;
		}
	}

	BOOL bDisabled = (bCustomizeMode && !IsEditable ()) ||
		(!bCustomizeMode && (m_nStyle & TBBS_DISABLED));

	if (!bImageIsReady)
	{
		if (IsDrawImage () && pImages != NULL)
		{
			if (pUserTool != NULL)
			{
				pUserTool->DrawToolIcon (pDC,
					CRect (CPoint (x + ptImageOffset.x, y + ptImageOffset.y),
					sizeImage));
			}
			else
			{
				if (bDrawImageShadow)
				{
					pImages->Draw (pDC, x + ptImageOffset.x, 
										y + ptImageOffset.y, GetImage (),
										FALSE, FALSE, FALSE, TRUE);
					ptImageOffset.Offset (-1, -1);
				}

				pImages->Draw (pDC, x + ptImageOffset.x, y + ptImageOffset.y, GetImage (),
								FALSE, bDisabled && bGrayDisabledButtons,
								FALSE, FALSE, bFadeImage);
			}
		}
	}

	if ((m_bTextBelow && bHorz) || IsDrawText ())
	{
		//--------------------
		// Draw button's text:
		//--------------------
		CBCGPVisualManager::BCGBUTTON_STATE state = CBCGPVisualManager::ButtonsIsRegular;

		if (bHighlight)
		{
			state = CBCGPVisualManager::ButtonsIsHighlighted;
		}
		else if (m_nStyle & (TBBS_PRESSED | TBBS_CHECKED))
		{
			//-----------------------
			// Pressed in or checked:
			//-----------------------
			state = CBCGPVisualManager::ButtonsIsPressed;
		}

		COLORREF clrText = CBCGPVisualManager::GetInstance ()->GetToolbarButtonTextColor (
			this, state);

		pDC->SetTextColor (clrText);
		CString strText = m_strText;
		CRect rectText = rectInternal;
		UINT uiTextFormat = 0;

		if (m_bTextBelow && bHorz)
		{
			ASSERT (bHorz);

			ptTextOffset.y += sizeImage.cy + nTextMargin;
			uiTextFormat = DT_CENTER;

			if (m_bWrapText)
			{
				uiTextFormat |= DT_WORDBREAK;
			}

			rectText.left = (rectInternal.left + rectInternal.right - m_sizeText.cx) / 2 + ptTextOffset.x;
			rectText.right = (rectInternal.left + rectInternal.right + m_sizeText.cx) / 2;
		}
		else
		{
			if (IsDrawImage ())
			{
				if (bHorz)
				{
					ptTextOffset.x += nTextMargin + sizeImage.cx;
				}
				else
				{
					ptTextOffset.y += nTextMargin + sizeImage.cy;
				}
			}

			rectText.left = x + ptTextOffset.x + nTextMargin;
			uiTextFormat = DT_SINGLELINE;
		}

		if (bHorz)
		{
			rectText.top += ptTextOffset.y;

			if (m_bTextBelow && m_bExtraSize)
			{
				rectText.OffsetRect (0,
					CBCGPVisualManager::GetInstance ()->GetButtonExtraBorder ().cy / 2);
			}

			pDC->DrawText (strText, &rectText, uiTextFormat);
		}
		else
		{