bcgpvisualmanagerxp.cpp

关于远程网络监视程序的源码

			pDC->FillRect (rectFace, pbrFace);
			
			pDC->SelectObject (&penDkGray);
			pDC->MoveTo (rectTab.right, rectTab.bottom);
			pDC->LineTo (rectTab.right, rectTab.top - 1);

			pDC->SelectObject (&penHiLight);

			pDC->LineTo (rectTab.right, rectTab.top);
			pDC->LineTo(rectTab.left, rectTab.top);
			pDC->LineTo(rectTab.left, rectTab.bottom);
		}
	}

	pDC->SelectObject (pOldPen);

	OnDrawTabContent (pDC, rectTab, iTab, bIsActive, pTabWnd,
		bIsActive ? globalData.clrBarText : m_clrInactiveTabText);
}
//***********************************************************************************
void CBCGPVisualManagerXP::OnEraseTabsArea (CDC* pDC, CRect rect, 
										 const CBCGPBaseTabWnd* pTabWnd)
{
	ASSERT_VALID (pDC);
	ASSERT_VALID (pTabWnd);

	if (pTabWnd->IsFlatTab ())
	{
		CBCGPVisualManager::OnEraseTabsArea (pDC, rect, pTabWnd);
		return;
	}

	pDC->FillRect (rect, &m_brTabBack);
}
//**************************************************************************************
COLORREF CBCGPVisualManagerXP::OnDrawControlBarCaption (CDC* pDC, CBCGPDockingControlBar* /*pBar*/, 
			BOOL bActive, CRect rectCaption, CRect /*rectButtons*/)
{
	ASSERT_VALID (pDC);

	CPen pen (PS_SOLID, 1, 
		bActive ? globalData.clrBarLight : globalData.clrBarShadow);
	CPen* pOldPen = pDC->SelectObject (&pen);

	CBrush* pOldBrush = (CBrush*) pDC->SelectObject (
		bActive ? &globalData.brActiveCaption : &globalData.brBarFace);

	if (bActive)
	{
		rectCaption.InflateRect (1, 0);
	}

	pDC->RoundRect (rectCaption, CPoint (2, 2));

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

    // get the text color
    COLORREF clrCptnText = bActive ?
        globalData.clrCaptionText :
        globalData.clrBarText;

	return clrCptnText;
}
//****************************************************************************************
void CBCGPVisualManagerXP::OnDrawCaptionButton (CDC* pDC, CBCGPCaptionButton* pButton, 
											BOOL bActive,
											BOOL bHorz, BOOL bMaximized, BOOL bDisabled,
											int nImageID /*= -1*/)
{
	ASSERT_VALID (pDC);
	ASSERT (pButton != NULL);

    CRect rc = pButton->GetRect ();

	if (pButton->m_bPushed && pButton->m_bFocused && !bDisabled) 
	{
		OnFillHighlightedArea (pDC, rc, &m_brHighlightDn, NULL);
		bActive = TRUE;
	}
	else if (pButton->m_bPushed || pButton->m_bFocused)
	{
		if (!bDisabled)
		{
			OnFillHighlightedArea (pDC, rc, &m_brHighlight, NULL);
		}

		bActive = FALSE;
	}

	CMenuImages::IMAGES_IDS id = (CMenuImages::IMAGES_IDS)-1;
	
	if (nImageID != -1)
	{
		id = (CMenuImages::IMAGES_IDS)nImageID;
	}
	else
	{
		switch (pButton->GetHit ())
		{
		case HTCLOSE:
		case HTCLOSE_BCG:
			id = CMenuImages::IdClose;
			break;

		case HTMINBUTTON:
			id = bHorz ? 
				bMaximized ? CMenuImages::IdArowLeft : CMenuImages::IdArowRight : 
				bMaximized ? CMenuImages::IdArowDown :  CMenuImages::IdArowUp;
			break;

		case HTMAXBUTTON:
			id = bMaximized ? CMenuImages::IdPinHorz : CMenuImages::IdPinVert;
			break;

		case HTLEFTBUTTON_BCG:
			id = CMenuImages::IdArowBack;
			break;

		case HTRIGHTBUTTON_BCG:
			id = CMenuImages::IdArowForward;
			break;

		case HTMENU_BCG:
			id = CMenuImages::IdArowDown;
			break;

		default:
			ASSERT(FALSE);
		}
	}

	if (id != (CMenuImages::IMAGES_IDS)-1)
	{
		CSize sizeImage = CMenuImages::Size ();
		CPoint ptImage (rc.left + (rc.Width () - sizeImage.cx) / 2,
						rc.top + (rc.Height () - sizeImage.cy) / 2);

		OnDrawCaptionButtonIcon (pDC, pButton, id, bActive, bDisabled, ptImage);
	}

	if ((pButton->m_bPushed || pButton->m_bFocused) && !bDisabled)
	{
		COLORREF clrDark = globalData.clrBarDkShadow;
		pDC->Draw3dRect (rc, clrDark, clrDark);
	}
}
//**********************************************************************************
void CBCGPVisualManagerXP::OnDrawCaptionButtonIcon (CDC* pDC, 
													CBCGPCaptionButton* pButton,
													CMenuImages::IMAGES_IDS id,
													BOOL bActive, BOOL bDisabled,
													CPoint ptImage)
{
	ASSERT_VALID (pDC);

	CMenuImages::IMAGE_STATE imageState;
	
	if (bDisabled)
	{
		imageState = CMenuImages::ImageGray;
	}
	else if (pButton->m_clrForeground == (COLORREF)-1)
	{
		imageState = bActive ? CMenuImages::ImageWhite : CMenuImages::ImageBlack;
	}
	else
	{
		if (GetRValue (pButton->m_clrForeground) > 192 &&
			GetGValue (pButton->m_clrForeground) > 192 &&
			GetBValue (pButton->m_clrForeground) > 192)
		{
			imageState = CMenuImages::ImageWhite;
		}
		else
		{
			imageState = CMenuImages::ImageBlack;
		}
	}

	CMenuImages::Draw (pDC, id, ptImage, imageState);
}
//********************************************************************************
COLORREF CBCGPVisualManagerXP::OnFillCommandsListBackground (CDC* pDC, CRect rect, BOOL bIsSelected)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pDC);

	COLORREF clrText;

	CBCGPToolBarImages* pCommonImages = CBCGPToolBar::GetImages ();
	
	int iImageWidth = CBCGPToolBar::GetMenuImageSize ().cx;
	if (pCommonImages != NULL)
	{
		iImageWidth = pCommonImages->GetImageSize ().cx;
	}

	iImageWidth += GetMenuImageMargin ();

	if (bIsSelected)
	{
		if (m_bEnableToolbarButtonFill)
		{
			rect.left = 0;
		}

		OnFillHighlightedArea (pDC, rect, &m_brHighlight, NULL);

		pDC->Draw3dRect (rect, m_clrMenuItemBorder, m_clrMenuItemBorder);

		// Now, we should define a menu text color...
		if (GetRValue (m_clrHighlight) > 128 &&
			GetGValue (m_clrHighlight) > 128 &&
			GetBValue (m_clrHighlight) > 128)
		{
			clrText = RGB (0, 0, 0);
		}
		else
		{
			clrText = RGB (255, 255, 255);
		}
	}
	else
	{
		pDC->FillRect (rect, &m_brMenuLight);

		CRect rectImages = rect;
		rectImages.right = rectImages.left + iImageWidth + MENU_IMAGE_MARGIN;

		pDC->FillRect (rectImages, &m_brBarBkgnd);

		clrText = globalData.clrBarText;
	}

	return clrText;
}
//**********************************************************************************
void CBCGPVisualManagerXP::OnDrawMenuArrowOnCustomizeList (CDC* pDC, 
	CRect rectCommand, BOOL bSelected)
{
	ASSERT_VALID (pDC);

	CRect rectTriangle = rectCommand;
	rectTriangle.left = rectTriangle.right - CMenuImages::Size ().cx;

	CPoint pointTriangle (
		rectTriangle.left + (rectTriangle.Width () - CMenuImages::Size ().cx) / 2,
		rectTriangle.top + (rectTriangle.Height () - CMenuImages::Size ().cy) / 2);

	CMenuImages::IMAGE_STATE state = CMenuImages::ImageBlack;
	COLORREF clrPen = RGB (0, 0, 0);

	if (GetRValue (m_clrHighlight) < 128 ||
		GetGValue (m_clrHighlight) < 128 ||
		GetBValue (m_clrHighlight) < 128)
	{
		state = CMenuImages::ImageWhite;
		clrPen = RGB (255, 255, 255);
	}

	CMenuImages::Draw (pDC, CMenuImages::IdArowRightLarge, pointTriangle, state);

	CPen penLine (PS_SOLID, 1, clrPen);
	CPen* pOldPen = pDC->SelectObject (&penLine);
	ASSERT (pOldPen != NULL);

	pDC->MoveTo (rectTriangle.left - 1, rectCommand.top + 2);
	pDC->LineTo (rectTriangle.left - 1, rectCommand.bottom - 2);

	pDC->SelectObject (pOldPen);
}
//***********************************************************************************
void CBCGPVisualManagerXP::OnDrawTearOffCaption (CDC* pDC, CRect rect, BOOL bIsActive)
{
	const int iBorderSize = 1;
	ASSERT_VALID (pDC);

	pDC->FillRect (rect, &m_brMenuLight);

	rect.DeflateRect (iBorderSize, 1);
	OnFillHighlightedArea (pDC, rect, bIsActive ? &m_brHighlight : &m_brBarBkgnd,
		NULL);
	
	// Draw gripper:
	int nGripperWidth = max (20, CBCGPToolBar::GetMenuImageSize ().cx * 2);

	CRect rectGripper = rect;
	rectGripper.DeflateRect ((rectGripper.Width () - nGripperWidth) / 2, 1);

	if (m_brGripperHorz.GetSafeHandle () == NULL)
	{
		CreateGripperBrush ();
	}

	COLORREF clrTextOld = pDC->SetTextColor (bIsActive ?
		globalData.clrBarDkShadow : globalData.clrBarShadow);
	COLORREF clrBkOld = pDC->SetBkColor (
		bIsActive ? m_clrHighlight : m_clrBarBkgnd);

	if (bIsActive)
	{
		rectGripper.DeflateRect (0, 1);
	}

	pDC->FillRect (rectGripper, &m_brGripperHorz);

	pDC->SetTextColor (clrTextOld);
	pDC->SetBkColor (clrBkOld);

	if (bIsActive)
	{
		pDC->Draw3dRect (rect, globalData.clrBarDkShadow, globalData.clrBarDkShadow);
	}
}
//***********************************************************************************
COLORREF CBCGPVisualManagerXP::OnFillCalendarBarNavigationRow (CDC* pDC, CRect rect)
{
	ASSERT_VALID (pDC);

	pDC->FillRect (rect, &m_brBarBkgnd);

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

	pDC->MoveTo (rect.left, rect.bottom);
	pDC->LineTo (rect.right, rect.bottom);

	pDC->SelectObject (pOldPen);
    
	return globalData.clrBarText;
}
//*************************************************************************************
void CBCGPVisualManagerXP::OnFillCalendarBarWeekColumn (CDC* pDC, CRect rect,
								  COLORREF& clrText, COLORREF& clrTextDisabled)
{
	ASSERT_VALID (pDC);

	pDC->FillRect (rect, &m_brBarBkgnd);

	clrText = globalData.clrBarText;
	clrTextDisabled = globalData.clrGrayedText;
}
//************************************************************************************
void CBCGPVisualManagerXP::CreateGripperBrush ()
{
	ASSERT (m_brGripperHorz.GetSafeHandle () == NULL);
	ASSERT (m_brGripperVert.GetSafeHandle () == NULL);

	WORD horzHatchBits [8] = { 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00 };

	CBitmap bmpGripperHorz;
	bmpGripperHorz.CreateBitmap (8, 8, 1, 1, horzHatchBits);

	m_brGripperHorz.CreatePatternBrush (&bmpGripperHorz);

	WORD vertHatchBits[8] = { 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA };

	CBitmap bmpGripperVert;
	bmpGripperVert.CreateBitmap (8, 8, 1, 1, vertHatchBits);

	m_brGripperVert.CreatePatternBrush (&bmpGripperVert);
}
//***********************************************************************************
void CBCGPVisualManagerXP::ExtendMenuButton (CBCGPToolbarMenuButton* pMenuButton,
											CRect& rect)
{
	ASSERT_VALID (pMenuButton);

	int nGrow = 4;

	CBCGPPopupMenu* pPopupMenu= pMenuButton->GetPopupMenu ();
	if (pPopupMenu != NULL && pPopupMenu->GetSafeHwnd () != NULL)
	{
		CRect rectMenu;
		pPopupMenu->GetWindowRect (rectMenu);

		switch (pPopupMenu->GetDropDirection ())
		{
		case CBCGPPopupMenu::DROP_DIRECTION_BOTTOM:
			if (rectMenu.Width () < rect.Width ())
			{
				nGrow = 1;
			}

			rect.bottom += nGrow;
			break;

		case CBCGPPopupMenu::DROP_DIRECTION_TOP:
			if (rectMenu.Width () < rect.Width ())
			{
				nGrow = 1;
			}

			rect.top -= nGrow;
			break;

		case CBCGPPopupMenu::DROP_DIRECTION_RIGHT:
			if (rectMenu.Height () < rect.Height ())
			{
				nGrow = 1;
			}

			rect.right += nGrow;
			break;

		case CBCGPPopupMenu::DROP_DIRECTION_LEFT:
			if (rectMenu.Height () < rect.Height ())
			{
				nGrow = 1;
			}

			rect.left -= nGrow;
			break;
		}
	}
}
//***********************************************************************************
void CBCGPVisualManagerXP::OnDrawMenuSystemButton (CDC* pDC, CRect rect, UINT uiSystemCommand, 
										UINT nStyle, BOOL bHighlight)
{
	ASSERT_VALID (pDC);

	BOOL bIsDisabled = (nStyle & TBBS_DISABLED);
	BOOL bIsPressed = (nStyle & TBBS_PRESSED);

	CMenuImages::IMAGES_IDS imageID;

	switch (uiSystemCommand)
	{
	case SC_CLOSE:
		imageID = CMenuImages::IdClose;
		break;

	case SC_MINIMIZE:
		imageID = CMenuImages::IdMinimize;
		break;

	case SC_RESTORE:
		imageID = CMenuImages::IdRestore;
		break;

	default:
		return;
	}

	if (bHighlight && !bIsDisabled)
	{
		OnFillHighlightedArea (pDC, rect, 
			bIsPressed ? &m_brHighlightDn : &m_brHighlight, NULL);

		COLORREF clrBorder = m_clrMenuItemBorder;
		pDC->Draw3dRect (rect, clrBorder, clrBorder);
	}

	CSize sizeImage = CMenuImages::Size ();
	CPoint ptImage = rect.TopLeft () + 
		CSize ((rect.Width () - sizeImage.cx) / 2, (rect.Height () - sizeImage.cy) / 2);
	CMenuImages::Draw (pDC, imageID, ptImage,
		bIsDisabled ? CMenuImages::ImageGray : bHighlight ? 
			CMenuImages::ImageWhite : CMenuImages::ImageBlack);
}
//********************************************************************************
void CBCGPVisualManagerXP::OnDrawStatusBarPaneBorder (CDC* pDC, CBCGPStatusBar* /*pBar*/,
					CRect rectPane, UINT /*uiID*/, UINT nStyle)
{
	if (!(nStyle & SBPS_NOBORDERS))
	{
		if (nStyle & SBPS_POPOUT)
		{
			CBCGPDrawManager dm (*pDC);
			dm.HighlightRect (rectPane);
		}

		// Draw pane border:
		pDC->Draw3dRect (rectPane, m_clrPaneBorder, m_clrPaneBorder);
	}
}
//**************************************************************************************
void CBCGPVisualManagerXP::OnDrawComboDropButton (CDC* pDC, CRect rect,
												BOOL bDisabled,
												BOOL bIsDropped,
												BOOL bIsHighlighted,
												CBCGPToolbarComboBoxButton* /*pButton*/)
{
	ASSERT_VALID(pDC);
	ASSERT_VALID (this);

	CPoint pointTriangle (
		rect.left + (rect.Width () - CMenuImages::Size ().cx) / 2 + 1,
		rect.top + (rect.Height () - CMenuImages::Size ().cy) / 2 + 1);

	if (bIsDropped || bIsHighlighted)
	{
		OnFillHighlightedArea (pDC, rect, 
			bIsDropped ? &m_brHighlightDn : &m_brHighlight,
			NULL);

		CPen pen (PS_SOLID, 1, m_clrMenuItemBorder);
		CPen* pOldPen = pDC->SelectObject (&pen);
		ASSERT (pOldPen != NULL);

		pDC->MoveTo (rect.left, rect.top);
		pDC->LineTo (rect.left, rect.bottom);

		pDC->SelectObject (pOldPen);
	}
	else
	{
		pDC->FillSolidRect (rect, globalData.clrBarFace);
		pDC->Draw3dRect (rect, globalData.clrBarWindow, globalData.clrBarWindow);
	}

	CMenuImages::Draw (pDC, CMenuImages::IdArowDown, pointTriangle,
		bDisabled ? CMenuImages::ImageGray : (bIsDropped && bIsHighlighted) ? 
			CMenuImages::ImageWhite : CMenuImages::ImageBlack);
}
//*************************************************************************************
void CBCGPVisualManagerXP::OnDrawComboBorder (CDC* pDC, CRect rect,
												BOOL /*bDisabled*/,
												BOOL bIsDropped,
												BOOL bIsHighlighted,