bcgpvisualmanager2003.cpp

远程网络监视程序的源码

//*******************************************************************************
// COPYRIGHT NOTES
// ---------------
// 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.
//*******************************************************************************

// BCGPVisualManager2003.cpp: implementation of the CBCGPVisualManager2003 class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "multimon.h"
#include "bcgcbpro.h"
#include "BCGPVisualManager2003.h"
#include "BCGPDrawManager.h"
#include "BCGPPopupMenuBar.h"
#include "BCGPMenuBar.h"
#include "bcgglobals.h"
#include "BCGPToolbarMenuButton.h"
#include "CustomizeButton.h"
#include "MenuImages.h"
#include "BCGPCaptionBar.h"
#include "BCGPBaseTabWnd.h"
#include "BCGPColorBar.h"
#include "BCGPCalendarBar.h"
#include "BCGPTabWnd.h"
#include "BCGPTasksPane.h"
#include "BCGPStatusBar.h"
#include "BCGPAutoHideButton.h"
#include "BCGPHeaderCtrl.h"

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

IMPLEMENT_DYNCREATE(CBCGPVisualManager2003, CBCGPVisualManagerXP)

BOOL CBCGPVisualManager2003::m_bUseGlobalTheme = TRUE;
BOOL CBCGPVisualManager2003::m_bStatusBarOfficeXPLook = TRUE;

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

CBCGPVisualManager2003::CBCGPVisualManager2003()
{
	m_bShadowHighlightedImage = FALSE;
	m_bFadeInactiveImage = FALSE;
	m_nMenuShadowDepth = 3;

	m_nVertMargin = 8;
	m_nHorzMargin = 8;
	m_nGroupVertOffset = 8;
	m_nGroupCaptionHeight = 18;
	m_nGroupCaptionHorzOffset = 3;
	m_nGroupCaptionVertOffset = 3;
	m_nTasksHorzOffset = 8;
	m_nTasksIconHorzOffset = 5;
	m_nTasksIconVertOffset = 4;
	m_bActiveCaptions = TRUE;
	
	OnUpdateSystemColors ();
}
//****************************************************************************************
CBCGPVisualManager2003::~CBCGPVisualManager2003()
{
}
//****************************************************************************************
void CBCGPVisualManager2003::DrawCustomizeButton (CDC* pDC, CRect rect, BOOL bIsHorz,
						  CBCGPVisualManager::BCGBUTTON_STATE state,
						  BOOL bIsCustomize, BOOL bIsMoreButtons)
{
	ASSERT_VALID (pDC);

    COLORREF clrDark = state == ButtonsIsRegular ?
		m_clrCustomizeButtonGradientDark : m_clrHighlightGradientDark;

	COLORREF clrLight = state == ButtonsIsRegular ?
		m_clrCustomizeButtonGradientLight : m_clrHighlightGradientLight;

	COLORREF clrLightShadow = CBCGPDrawManager::PixelAlpha (clrLight, 90);

	CPen penDark (PS_SOLID, 1, clrDark);
	CPen penLight (PS_SOLID, 1, clrLight);

	CPen* pOldPen = pDC->SelectObject (&penDark);
	ASSERT (pOldPen != NULL);

	const int nEllipse = 2;
	for (int i = 0; i < nEllipse; i++)
	{
		if (bIsHorz)
		{
			int x1 = rect.left + i;
			int x2 = rect.right - nEllipse + i;
			int y = rect.top + i;

			pDC->SelectObject (&penLight);

			pDC->MoveTo (x1, y);
			pDC->LineTo (x2, y);

			pDC->SetPixel (x1, y, clrLightShadow);
			pDC->SetPixel (x2, y, clrLightShadow);

			pDC->SelectObject (&penDark);

			y = rect.bottom - i - 1;

			pDC->MoveTo (x1, y);
			pDC->LineTo (x2, y);

			pDC->SetPixel (x1, y, clrLight);
			pDC->SetPixel (x2, y, clrLight);
		}
		else
		{
			int y1 = rect.top + i;
			int y2 = rect.bottom - nEllipse + i;
			int x = rect.left + i;

			pDC->SelectObject (&penDark);

			pDC->MoveTo (x, y1);
			pDC->LineTo (x, y2);

			pDC->SetPixel (x, y1, clrLight);
			pDC->SetPixel (x, y2, clrLight);

			pDC->SelectObject (&penLight);

			x = rect.right - i - 1;

			pDC->MoveTo (x, y1);
			pDC->LineTo (x, y2);

			pDC->SetPixel (x, y1, clrLightShadow);
			pDC->SetPixel (x, y1, clrLightShadow);
		}
	}

	pDC->SelectObject (pOldPen);

	if (bIsHorz)
	{
		rect.DeflateRect (0, nEllipse);
		rect.left += nEllipse;
	}
	else
	{
		rect.DeflateRect (nEllipse, 0);
		rect.top += nEllipse;
	}

	CBCGPDrawManager dm (*pDC);
	dm.FillGradient (rect, clrDark, clrLight, bIsHorz);

	//---------------------
	// Draw button content:
	//---------------------
	const int nMargin = GetToolBarCustomizeButtonMargin ();

	CSize sizeImage = CMenuImages::Size ();

	if (bIsCustomize)
	{
		//-----------------
		// Draw menu image:
		//-----------------
		CRect rectMenu = rect;
		if (bIsHorz)
		{
			rectMenu.top = rectMenu.bottom - sizeImage.cy - 2 * nMargin;
		}
		else
		{
			rectMenu.left = rectMenu.right - sizeImage.cx - 2 * nMargin;
		}

		rectMenu.DeflateRect (
			(rectMenu.Width () - sizeImage.cx) / 2,
			(rectMenu.Height () - sizeImage.cy) / 2);

		rectMenu.OffsetRect (1, 1);

		CMenuImages::IMAGES_IDS id = bIsHorz ? 
			CMenuImages::IdCustomizeArowDown : CMenuImages::IdCustomizeArowLeft;

		CMenuImages::Draw (	pDC, id, rectMenu.TopLeft (),
			CMenuImages::ImageWhite);

		rectMenu.OffsetRect (-1, -1);

		CMenuImages::Draw (	pDC, id, rectMenu.TopLeft ());
	}

	if (bIsMoreButtons)
	{
		//-------------------
		// Draw "more" image:
		//-------------------
		CRect rectMore = rect;
		if (bIsHorz)
		{
			rectMore.bottom = rectMore.top + sizeImage.cy + 2 * nMargin;
		}
		else
		{
			rectMore.right = rectMore.left + sizeImage.cx + 2 * nMargin;
		}

		rectMore.DeflateRect (
			(rectMore.Width () - sizeImage.cx) / 2,
			(rectMore.Height () - sizeImage.cy) / 2);

		CMenuImages::IMAGES_IDS id = 
			bIsHorz ? 
				CMenuImages::IdCustomizeMoreButtonsHorz : 
				CMenuImages::IdCustomizeMoreButtonsVert;

		rectMore.OffsetRect (1, 1);
		CMenuImages::Draw (pDC, id, rectMore.TopLeft (), CMenuImages::ImageWhite);

		rectMore.OffsetRect (0, -1);
		CMenuImages::Draw (pDC, id, rectMore.TopLeft ());
	}
}
//***********************************************************************************
void CBCGPVisualManager2003::OnFillBarBackground (CDC* pDC, CBCGPBaseControlBar* pBar,
								CRect rectClient, CRect rectClip,
								BOOL bNCArea)
{
	ASSERT_VALID(pBar);
	ASSERT_VALID(pDC);

	CRuntimeClass* pBarClass = pBar->GetRuntimeClass ();

	if (globalData.m_nBitsPerPixel <= 8 ||
		pBar->IsDialogControl () ||
		pBarClass->IsDerivedFrom (RUNTIME_CLASS (CBCGPColorBar)) ||
		pBarClass->IsDerivedFrom (RUNTIME_CLASS (CBCGPCalendarBar)))
	{
		CBCGPVisualManagerXP::OnFillBarBackground (pDC, pBar, rectClient, rectClip);
		return;
	}

	if (m_bStatusBarOfficeXPLook &&
		pBarClass->IsDerivedFrom (RUNTIME_CLASS (CBCGPStatusBar)))
	{
		pDC->FillRect (	rectClip.IsRectEmpty () ? rectClient : rectClip, 
						&globalData.brBtnFace);
		return;
	}

	if (rectClip.IsRectEmpty ())
	{
		rectClip = rectClient;
	}

	CBCGPDrawManager dm (*pDC);

    if (pBar->IsKindOf (RUNTIME_CLASS (CBCGPCaptionBar)))
	{
		dm.FillGradient (rectClient, 
			m_clrCaptionBarGradientDark, m_clrCaptionBarGradientLight, TRUE);
		return;
	}

    if (pBar->IsKindOf (RUNTIME_CLASS (CBCGPPopupMenuBar)))
	{
		pDC->FillRect (rectClip, &m_brMenuLight);

		BOOL bQuickMode = FALSE;

		CBCGPPopupMenuBar* pMenuBar = DYNAMIC_DOWNCAST (CBCGPPopupMenuBar, pBar);
		if (!pMenuBar->m_bDisableSideBarInXPMode)
		{
			CWnd* pWnd = pMenuBar->GetParent();

			if(pWnd != NULL && pWnd->IsKindOf(RUNTIME_CLASS(CBCGPPopupMenu)))
			{
				CBCGPPopupMenu* pMenu = DYNAMIC_DOWNCAST (CBCGPPopupMenu, pWnd);

				if(pMenu->IsCustomizePane())
				{
					bQuickMode = TRUE;
				}
			}

			CRect rectImages = rectClient;

			if (bQuickMode)
			{
				rectImages.right = rectImages.left + 2*CBCGPToolBar::GetMenuImageSize ().cx + 
							4 * GetMenuImageMargin () + 4;
			}
			else
			{
				rectImages.right = rectImages.left + CBCGPToolBar::GetMenuImageSize ().cx + 
							2 * GetMenuImageMargin () + 1;
			}

			dm.FillGradient (rectImages, m_clrToolBarGradientLight, m_clrToolBarGradientDark, FALSE);
		}

		return;
	}

	BOOL bIsHorz = (pBar->GetBarStyle () & CBRS_ORIENT_HORZ);
	BOOL bIsToolBar = pBar->IsKindOf (RUNTIME_CLASS (CBCGPToolBar)) &&
						!pBar->IsKindOf (RUNTIME_CLASS (CBCGPMenuBar));

	COLORREF clr1 = bIsHorz ? m_clrToolBarGradientDark : m_clrToolBarGradientVertLight;
	COLORREF clr2 = bIsHorz ? m_clrToolBarGradientLight : m_clrToolBarGradientVertDark;

	if (!bIsToolBar)
	{
		bIsHorz = FALSE;

		clr1 = m_clrBarGradientDark;
		clr2 = m_clrBarGradientLight;

		CRect rectScreen;

		MONITORINFO mi;
		mi.cbSize = sizeof (MONITORINFO);
		if (GetMonitorInfo (MonitorFromPoint (CPoint (rectClient.right, rectClient.top), 
			MONITOR_DEFAULTTONEAREST), &mi))
		{
			rectScreen = mi.rcWork;
		}
		else
		{
			::SystemParametersInfo (SPI_GETWORKAREA, 0, &rectScreen, 0);
		}

		rectClient.right = rectScreen.right;
	}

	BOOL bRoundedCorners = FALSE;

	CBCGPToolBar* pToolBar = DYNAMIC_DOWNCAST (CBCGPToolBar, pBar);
	if (bNCArea && pToolBar != NULL && pToolBar->IsDocked () &&
		!pToolBar->IsKindOf (RUNTIME_CLASS (CBCGPMenuBar)))
	{
		bRoundedCorners = TRUE;

		CBCGPBaseControlBar* pParentBar = DYNAMIC_DOWNCAST (CBCGPBaseControlBar,
			pBar->GetParent ());

		if (pParentBar != NULL)
		{
			CPoint pt (0, 0);
			pBar->MapWindowPoints (pParentBar, &pt, 1);
			pt = pDC->OffsetWindowOrg (pt.x, pt.y);

			CRect rectParent;
			pParentBar->GetClientRect (rectParent);

			OnFillBarBackground (pDC, pParentBar, rectParent, rectParent);

			pDC->SetWindowOrg(pt.x, pt.y);
		}

		CRect rectFill = rectClient;
		rectFill.DeflateRect (1, 0);

		dm.FillGradient (rectFill, clr1, clr2, bIsHorz);

		CRect rectLeft = rectClient;
		rectLeft.top ++;
		rectLeft.right = rectLeft.left + 1;

		dm.FillGradient (rectLeft, clr1, clr2, bIsHorz);

		CRect rectRight = rectClient;
		rectLeft.top ++;
		rectRight.left = rectRight.right - 1;

		dm.FillGradient (rectRight, clr1, clr2, bIsHorz);
	}
	else
	{
		CRect rectFill = rectClient;

		if (bIsToolBar && pBar->IsDocked ())
		{
			ASSERT_VALID (pToolBar);

			rectFill.left -= pToolBar->m_cxLeftBorder;
			rectFill.right += pToolBar->m_cxRightBorder;
			rectFill.top -= pToolBar->m_cyTopBorder;
			rectFill.bottom += pToolBar->m_cyBottomBorder;
		}

		dm.FillGradient (rectFill, clr1, clr2, bIsHorz);
	}

	if (bNCArea)
	{
		if (bRoundedCorners)
		{
			//------------------------
			// Draw bottom/right edge:
			//------------------------
			CPen pen (PS_SOLID, 1, m_clrToolBarBottomLine);
			CPen* pOldPen = pDC->SelectObject (&pen);
			ASSERT (pOldPen != NULL);

			CRect rectFill = rectClient;

			if (bIsHorz)
			{
				pDC->MoveTo (rectClient.left + 2, rectClient.bottom - 1);
				pDC->LineTo (rectClient.right - 1, rectClient.bottom - 1);

				rectFill.left = rectFill.right - 1;
				rectFill.DeflateRect (0, 1);
			}
			else
			{
				pDC->MoveTo (rectClient.right - 1, rectClient.top + 2);
				pDC->LineTo (rectClient.right - 1, rectClient.bottom - 1);

				rectFill.top = rectFill.bottom + 1;
				rectFill.DeflateRect (1, 0);
			}

			pDC->SelectObject (pOldPen);

			dm.FillGradient (rectFill, m_clrToolBarBottomLine, m_clrToolBarGradientDark, bIsHorz);