bcgpcolorbar.cpp

远程网络监视程序的源码

// BCGColorBar.cpp : implementation file
// This is a part of the BCGControlBar Library
// Copyright (C) 1998-2000 BCGSoft Ltd.
// All rights reserved.
//
// This source code can be used, distributed or modified
// only under terms and conditions 
// of the accompanying license agreement.
//

#include "stdafx.h"

#ifndef BCG_NO_COLOR

#include <math.h>
#include "BCGCBPro.h"
#include "BCGPColorBar.h"
#include "BCGPColorMenuButton.h"
#include "BCGPPopupMenu.h"
#include "BCGPColorDialog.h"
#include "BCGPColorButton.h"
#include "trackmouse.h"
#include "BCGPVisualManager.h"
#include "BCGPPropList.h"

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

static const int SEPARATOR_SIZE = 2;

/////////////////////////////////////////////////////////////////////////////
// CColorButton

class CColorButton : public CBCGPToolbarButton  
{
	friend class CBCGPColorBar;
	friend class CBCGPColorMenuButton;

	DECLARE_SERIAL(CColorButton)

protected:
	CColorButton(COLORREF color = RGB (0, 0, 0), 
				BOOL bIsAutomatic = FALSE, BOOL bIsOther = FALSE,
				LPCTSTR lpszColorName = NULL, BOOL bHighlight = FALSE,
				BOOL bIsDocument = FALSE,
				BOOL bIsOtherColor = FALSE)
	{
		m_Color = color;
		m_bHighlight = bHighlight;
		m_strText = (lpszColorName == NULL) ? _T("") : lpszColorName;
		m_bIsAutomatic = bIsAutomatic;
		m_bIsOther = bIsOther;
		m_bIsLabel = FALSE;
		m_bIsDocument = bIsDocument;
		m_bIsOtherColor = bIsOtherColor;
		m_pParentBar = NULL;
	}

	CColorButton(LPCTSTR lpszColorName, BOOL bIsDocument = FALSE)
	{
		ASSERT (lpszColorName != NULL);

		m_Color = (COLORREF)-1;
		m_bHighlight = FALSE;
		m_strText = lpszColorName;
		m_bIsAutomatic = FALSE;
		m_bIsOther = FALSE;
		m_bIsLabel = TRUE;
		m_bIsDocument = bIsDocument;
		m_bIsOtherColor = FALSE;
		m_pParentBar = NULL;
	}

	virtual void OnDraw (CDC* pDC, const CRect& rect, CBCGPToolBarImages* pImages,
						BOOL bHorz = TRUE, BOOL bCustomizeMode = FALSE,
						BOOL bHighlight = FALSE,
						BOOL bDrawBorder = TRUE,
						BOOL bGrayDisabledButtons = TRUE);

	virtual BOOL OnToolHitTest(const CWnd* /*pWnd*/, TOOLINFO* pTI)
	{
		if (m_nStyle & TBBS_DISABLED)
		{
			return FALSE;
		}

		if (!CBCGPToolBar::GetShowTooltips ())
		{
			return FALSE;
		}

		ASSERT (pTI != NULL);

		CString str = m_strText;
		if (!m_bIsAutomatic && !m_bIsOther && !m_bIsLabel)
		{
			if (!CBCGPColorBar::m_ColorNames.Lookup (m_Color, str))
			{
				str.Format (_T("Hex={%02X,%02X,%02X}"), 
					GetRValue (m_Color), GetGValue (m_Color), GetBValue (m_Color));
			}
		}

		pTI->lpszText = (LPTSTR) ::calloc ((str.GetLength () + 1), sizeof (TCHAR));
		_tcscpy (pTI->lpszText, str);

		return TRUE;
	}

	virtual void OnChangeParentWnd (CWnd* pWndParent)
	{
		CBCGPToolbarButton::OnChangeParentWnd (pWndParent);
		m_pParentBar = DYNAMIC_DOWNCAST (CBCGPColorBar, pWndParent);
	}

	COLORREF		m_Color;
	BOOL			m_bHighlight;
	BOOL			m_bIsAutomatic;
	BOOL			m_bIsOther;
	BOOL			m_bIsLabel;
	BOOL			m_bIsDocument;
	BOOL			m_bIsOtherColor;
	CBCGPColorBar*	m_pParentBar;
};

IMPLEMENT_SERIAL(CColorButton, CBCGPToolbarButton, 1)

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

    CPalette* pOldPalette = NULL;

	if (m_pParentBar != NULL)
	{
		pOldPalette = m_pParentBar->SelectPalette (pDC);
	}

	BOOL bDisabled = (m_nStyle & TBBS_DISABLED);

	UINT nStyle = m_nStyle;

	if (m_bHighlight)
	{
		m_nStyle |= TBBS_CHECKED;
	}

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

	//--------------------
	// Draw button border:
	//--------------------
	if (!bDisabled && !m_bIsLabel && HaveHotBorder () && bDrawBorder && !bCustomizeMode)
	{
		if (m_nStyle & (TBBS_PRESSED | TBBS_CHECKED))
		{
			//-----------------------
			// Pressed in or checked:
			//-----------------------
			CBCGPVisualManager::GetInstance ()->OnDrawButtonBorder (
				pDC, this, rect, CBCGPVisualManager::ButtonsIsPressed);
		}
		else if (bHighlight &&
			!(m_nStyle & (TBBS_CHECKED | TBBS_INDETERMINATE)))
		{
			CBCGPVisualManager::GetInstance ()->OnDrawButtonBorder (
				pDC, this, rect, CBCGPVisualManager::ButtonsIsHighlighted);
		}
	}

	CRect rectFrame = rect;
	rectFrame.DeflateRect (afxData.cxBorder2, afxData.cyBorder2);

	if (m_bIsOther || m_bIsAutomatic || m_bIsLabel)
	{
		CRect rectText = rect;

		if (m_bIsAutomatic && m_Color != (COLORREF)-1)
		{
			CRect rectColor = rectFrame;
			rectColor.DeflateRect (afxData.cxBorder2 + 1, afxData.cyBorder2 + 1);
			rectColor.right = rectColor.left + rectColor.Height ();

			if (!bDisabled)
			{
				CBrush br (PALETTERGB(GetRValue (m_Color),
									GetGValue(m_Color), 
									GetBValue(m_Color)));
				CPen pen (PS_SOLID, 1, globalData.clrBarShadow);

				CBrush* pOldBrush = pDC->SelectObject (&br);
				CPen* pOldPen = pDC->SelectObject (&pen);
		
				pDC->Rectangle (rectColor);

				pDC->SelectObject (pOldPen);
				pDC->SelectObject (pOldBrush);
			}
			else
			{
				pDC->Draw3dRect (rectColor, globalData.clrBarHilite,
											globalData.clrBarShadow);
				rectColor.OffsetRect (1, 1);
				pDC->Draw3dRect (rectColor, globalData.clrBarShadow,
											globalData.clrBarHilite);
			}


			rectText.left = rectColor.right + afxData.cxBorder2;
		}

		//------------
		// Draw label:
		//------------
		pDC->SetTextColor ((m_nStyle & TBBS_DISABLED) && !m_bIsLabel ? 
			globalData.clrGrayedText :
			globalData.clrBarText);

		UINT nFormat = DT_SINGLELINE | DT_VCENTER | DT_END_ELLIPSIS;
		if (!m_bIsLabel)
		{
			nFormat |= DT_CENTER;
		}

		CFont* pCurrFont = NULL;
		if (!bHorz)
		{
			pCurrFont = pDC->SelectObject (&globalData.fontRegular);
			ASSERT (pCurrFont != NULL);
		}

		pDC->DrawText (m_strText, &rectText, nFormat);

		if (pCurrFont != NULL)
		{
			pDC->SelectObject (pCurrFont);
		}
	}
	else if (!bDisabled)
	{
		//----------------
		// Draw color box:
		//----------------
		CBrush br (PALETTERGB(GetRValue(m_Color),
                            GetGValue(m_Color), 
                            GetBValue(m_Color)));

		CBrush* pOldBrush = pDC->SelectObject(&br);
		CPen* pOldPen = (CPen*) pDC->SelectStockObject (NULL_PEN);
		
		pDC->Rectangle (rectFrame);

		pDC->SelectObject (pOldPen);
		pDC->SelectObject (pOldBrush);
	}

	//------------
	// Draw frame:
	//------------
	if (!m_bIsOther && !m_bIsLabel)
	{
		if (!bDisabled)
		{
			pDC->Draw3dRect (rectFrame, globalData.clrBarShadow,
										globalData.clrBarShadow);
		}
		else
		{
			pDC->Draw3dRect (rectFrame, globalData.clrBarHilite,
										globalData.clrBarShadow);
			rectFrame.OffsetRect (1, 1);
			pDC->Draw3dRect (rectFrame, globalData.clrBarShadow,
										globalData.clrBarHilite);
		}
	}

    if (pOldPalette != NULL)
	{
        pDC->SelectPalette (pOldPalette, FALSE);
	}

	m_nStyle = nStyle;
}

/////////////////////////////////////////////////////////////////////////////
// CBCGPColorBar

IMPLEMENT_SERIAL(CBCGPColorBar, CBCGPPopupMenuBar, 1)

CMap<COLORREF,COLORREF,CString, LPCTSTR> CBCGPColorBar::m_ColorNames;

CBCGPColorBar::CBCGPColorBar()
{
    m_nNumColumns = 0;
	m_nNumRowsHorz = 0;
	m_nNumColumnsVert = 0;
	m_BoxSize = CSize (0, 0);
	m_nRowHeight = 0;
	m_ColorSelected = (COLORREF) -1;
	m_ColorAutomatic = (COLORREF) -1;
	m_nCommandID = 0;
	m_bStdColorDlg = FALSE;
	m_bIsTearOff = TRUE;
	m_bShowDocColorsWhenDocked = FALSE;
	m_bLocked = TRUE;
	m_bIsEnabled = TRUE;
	m_pParentBtn = NULL;
	m_pWndPropList = NULL;
	m_nHorzOffset = m_nVertOffset = 0;
	m_bInternal = FALSE;
	m_nVertMargin = 4;
	m_nHorzMargin = 4;
}
//**************************************************************************************
CBCGPColorBar::CBCGPColorBar (const CArray<COLORREF, COLORREF>& colors,
				COLORREF color, 
				LPCTSTR lpszAutoColor,
				LPCTSTR lpszOtherColor,
				LPCTSTR lpszDocColors,
				CList<COLORREF,COLORREF>& lstDocColors,
				int nColumns,
				int	nRowsDockHorz,
				int	nColDockVert,
				COLORREF colorAutomatic,
				UINT nCommandID,
				CBCGPColorButton* pParentBtn) :
	m_ColorSelected (color),
	m_strAutoColor (lpszAutoColor = NULL ? _T("") : lpszAutoColor),
	m_strOtherColor (lpszOtherColor == NULL ? _T("") : lpszOtherColor),
	m_strDocColors (lpszDocColors == NULL ? _T("") : lpszDocColors),
	m_nNumColumns (nColumns),
	m_nNumRowsHorz (nRowsDockHorz),
	m_nNumColumnsVert (nColDockVert),
	m_ColorAutomatic (colorAutomatic),
	m_bIsTearOff (FALSE),
	m_bStdColorDlg (FALSE),
	m_nCommandID (nCommandID),
	m_pParentBtn (pParentBtn)
{
	m_pWndPropList = NULL;

	m_colors.SetSize (colors.GetSize ());

	for (int i = 0; i < colors.GetSize (); i++)
	{
		m_colors [i] = colors [i];
	}

	m_lstDocColors.AddTail (&lstDocColors);
	m_bLocked = TRUE;
	m_bIsEnabled = TRUE;
	m_bShowDocColorsWhenDocked = TRUE;

	if (m_pParentBtn != NULL)
	{
		m_bStdColorDlg = !m_pParentBtn->m_bAltColorDlg;
	}

	m_nHorzOffset = m_nVertOffset = 0;
	m_bInternal = FALSE;
	m_nVertMargin = 4;
	m_nHorzMargin = 4;
}
//**************************************************************************************
CBCGPColorBar::CBCGPColorBar (CBCGPColorBar& src, UINT uiCommandID) :
		m_ColorSelected (src.m_ColorSelected),
		m_strAutoColor (src.m_strAutoColor),
		m_strOtherColor (src.m_strOtherColor),
		m_strDocColors (src.m_strDocColors),
		m_ColorAutomatic (src.m_ColorAutomatic),
		m_nNumColumns (src.m_nNumColumns),
		m_nNumRowsHorz (src.m_nNumRowsHorz),
		m_nNumColumnsVert (src.m_nNumColumnsVert),
		m_bIsTearOff (TRUE),
		m_nCommandID (uiCommandID),
		m_bStdColorDlg (src.m_bStdColorDlg)
{
	m_colors.SetSize (src.m_colors.GetSize ());

	for (int i = 0; i < src.m_colors.GetSize (); i++)
	{
		m_colors [i] = src.m_colors [i];
	}

	m_lstDocColors.AddTail (&src.m_lstDocColors);
	m_bLocked = TRUE;
	m_bIsEnabled = TRUE;
	m_bShowDocColorsWhenDocked = FALSE;
	m_pParentBtn = NULL;
	m_pWndPropList = NULL;
	m_nHorzOffset = m_nVertOffset = 0;
	m_bInternal = FALSE;
	m_nVertMargin = 4;
	m_nHorzMargin = 4;
}
//**************************************************************************************
CBCGPColorBar::~CBCGPColorBar()
{
}
//*************************************************************************************
void CBCGPColorBar::AdjustLocations ()
{
	if (GetSafeHwnd () == NULL || !::IsWindow (m_hWnd))
	{
		return;
	}

	ASSERT_VALID(this);

	CRect rectClient;	// Client area rectangle
	GetClientRect (&rectClient);

	rectClient.DeflateRect (m_nHorzMargin + m_nHorzOffset, m_nVertMargin + m_nVertOffset);

	int x = rectClient.left;
	int y = rectClient.top;
	int i = 0;

	BOOL bPrevSeparator = FALSE;
	BOOL bIsOtherColor =	(m_strAutoColor.IsEmpty () || 
							m_ColorSelected != (COLORREF)-1);

	for (POSITION pos = m_Buttons.GetHeadPosition (); pos != NULL; i ++)
	{
		CRect rectButton (0, 0, 0, 0);

		CBCGPToolbarButton* pButton = (CBCGPToolbarButton*) m_Buttons.GetNext (pos);
		if (pButton->m_nStyle & TBBS_SEPARATOR)
		{
			if (bPrevSeparator)
			{
				rectButton.SetRectEmpty ();
			}
			else
			{
				if (x > rectClient.left)
				{
					// Next line
					x = rectClient.left;
					y += m_BoxSize.cy + m_nVertMargin;
				}

				rectButton = CRect (
					CPoint (x, y),
					CSize (rectClient.Width (), SEPARATOR_SIZE));

				y += SEPARATOR_SIZE + 2;
				x = rectClient.left;
			}

			bPrevSeparator = TRUE;
		}
		else
		{
			CColorButton* pColorButton = DYNAMIC_DOWNCAST (CColorButton, pButton);
			if (pColorButton == NULL)
			{
				continue;
			}

			ASSERT_VALID (pColorButton);

			if (pColorButton->m_bIsDocument &&
				!m_bShowDocColorsWhenDocked && !IsFloating ())
			{
				rectButton.SetRectEmpty ();
			}
			else if (pColorButton->m_bIsAutomatic || pColorButton->m_bIsOther ||
				pColorButton->m_bIsLabel)
			{
				if (x > rectClient.left)
				{
					// Next line
					x = rectClient.left;
					y += m_BoxSize.cy + m_nVertMargin;
				}

				if (pColorButton->m_bIsOther && bIsOtherColor)
				{
					rectButton = CRect (
						CPoint (x, y),
						CSize (rectClient.Width () - m_BoxSize.cx, 
								m_nRowHeight - m_nVertMargin / 2));
					x = rectButton.right;
					y += (rectButton.Height () - m_BoxSize.cy) / 2;
				}
				else
				{
					rectButton = CRect (
						CPoint (x, y),
						CSize (rectClient.Width (), m_nRowHeight - m_nVertMargin / 2));
					y += m_nRowHeight - m_nVertMargin / 2;
					x = rectClient.left;
				}

				if (pColorButton->m_bIsOther)
				{
					rectButton.DeflateRect (m_nHorzMargin / 2, m_nVertMargin / 2);
				}

				bPrevSeparator = FALSE;
			}
			else
			{
				if (x + m_BoxSize.cx > rectClient.right)
				{
					x = rectClient.left;
					y += m_BoxSize.cy;
				}

				if (pColorButton->m_bIsOtherColor && !bIsOtherColor)
				{
					rectButton.SetRectEmpty ();
				}
				else
				{
					rectButton = CRect (CPoint (x, y), m_BoxSize);
					x += m_BoxSize.cx;

					bPrevSeparator = FALSE;
				}

				if (pColorButton->m_Color == m_ColorSelected &&
					!pColorButton->m_bIsOtherColor)
				{
					bIsOtherColor = FALSE;
				}
			}
		}

		pButton->SetRect (rectButton);
	}

	UpdateTooltips ();
}
//***************************************************************************************
CSize CBCGPColorBar::CalcSize (BOOL bVertDock)
{
	CSize sizeGrid = GetColorGridSize (bVertDock);

	return CSize(
		sizeGrid.cx * m_BoxSize.cx + 2 * m_nVertMargin, 
		sizeGrid.cy * m_BoxSize.cy + GetExtraHeight (sizeGrid.cx) + 2 * m_nHorzMargin);
}
//*************************************************************************************
CSize CBCGPColorBar::GetColorGridSize (BOOL bVertDock) const
//
// Calculate number of columns and rows in the color grid
//
{
	int nNumColumns = 0;
	int nNumRows = 0;