void CPeraProcessDesignerView::OnDraw(CDC* pDC)
{
CPeraProcessDesignerDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
// TODO: add draw code for native data here
CRect rc;
GetWindowRect(&rc);
rc.MoveToXY(0,0);
CBCGPDrawManager dm (*pDC);
dm.DrawRect( rc, g_crBarBorderIn, g_crBarBorderOut );
if ( m_pViewData != NULL )
{
if ( m_pViewData->m_strFlag.CollateNoCase( viewflagModel ) == 0 )
{
//有时候结构树标题栏下边有条边线不绘制问题
if ( theApp.m_pBarJianmoTree != NULL
&& IsWindow( theApp.m_pBarJianmoTree->GetSafeHwnd() ) )
{
::PostMessage( theApp.m_pBarJianmoTree->GetSafeHwnd(), WM_NCPAINT, 0, 0 );
}
}
}
}
//*********************************************************************************************************
void CBCGPVisualManagerVS2008::OnEraseTabsArea (CDC* pDC, CRect rect,
const CBCGPBaseTabWnd* pTabWnd)
{
ASSERT_VALID (pDC);
ASSERT_VALID (pTabWnd);
if (globalData.m_nBitsPerPixel <= 8 || globalData.IsHighContastMode () ||
!pTabWnd->IsVS2005Style () ||
pTabWnd->IsDialogControl ())
{
CBCGPVisualManagerVS2005::OnEraseTabsArea (pDC, rect, pTabWnd);
return;
}
CFrameWnd* pMainFrame = BCGCBProGetTopLevelFrame (pTabWnd);
if (pMainFrame->GetSafeHwnd () != NULL)
{
CRect rectMain;
pMainFrame->GetClientRect (rectMain);
pMainFrame->MapWindowPoints ((CBCGPTabWnd*)pTabWnd, &rectMain);
rect.top = rectMain.top;
rect.left = rectMain.left;
rect.right = rect.left + globalData.m_rectVirtual.Width () + 10;
}
CBCGPDrawManager dm (*pDC);
dm.FillGradient (rect, m_clrBarGradientDark, m_clrBarGradientLight, FALSE, 0);
}
//**********************************************************************
void CBCGPToolTipCtrl::OnFillBackground (CDC* pDC, CRect rect, COLORREF& clrText, COLORREF& clrLine)
{
ASSERT_VALID (pDC);
if (m_Params.m_clrFill == (COLORREF)-1)
{
CBCGPVisualManager::GetInstance ()->OnFillToolTip (pDC, this, rect,
clrText, clrLine);
}
else
{
if (m_Params.m_clrFillGradient == (COLORREF)-1)
{
CBrush br (m_Params.m_clrFill);
pDC->FillRect (rect, &br);
}
else
{
CBCGPDrawManager dm (*pDC);
dm.FillGradient2 (rect,
m_Params.m_clrFillGradient, m_Params.m_clrFill,
m_Params.m_nGradientAngle == -1 ? 90 : m_Params.m_nGradientAngle);
}
}
}
//**********************************************************************************
void CToolPalette::DoPaint(CDC* pDC)
{
CRect rcClient;
GetClientRect(rcClient);
CBCGPMemDC bufferDC(*pDC, rcClient);
CBCGPToolBar::DoPaint (&bufferDC.GetDC());
CBCGPDrawManager dm (bufferDC.GetDC());
bool bHorizontal = (GetCurrentAlignment() & CBRS_ORIENT_HORZ) != 0; // Toolbar layout mode
EDisplayOptions edo = GetToolbarDisplayOptions();
if ((edo & eDisplaySizeControl) != 0 && !bHorizontal)
{
const int sizeControlHeight = m_imgCaption.GetParams().m_rectImage.Height();
CRect rcSizeControl = rcClient;
rcSizeControl.bottom = rcSizeControl.top + sizeControlHeight;
m_imgCaption.Draw(pDC, rcSizeControl, 1); // 1 is the index of border image
rcClient.top += sizeControlHeight;
}
if ((edo & eDisplayTitle) != 0)
{
CString title;
GetWindowText (title);
CRect rcTitle = rcClient;
if ((edo & eDisplayBorder) != 0)
{
const CRect& rectCorners = m_imgCaption.GetParams().m_rectCorners;
rcTitle.top += rectCorners.top;
}
rcTitle.top += 1;
rcTitle.bottom = rcTitle.top + m_nCaptionHeight;
dm.FillGradient2 (rcTitle, RGB(48, 112, 202), RGB(21, 57, 111), 305);
rcTitle.DeflateRect (1, 2, 1, 2);
CFont* pOldFont = bufferDC.GetDC().SelectObject(&m_fntTitle);
bufferDC.GetDC().SetBkMode(TRANSPARENT);
bufferDC.GetDC().SetTextColor(0xFFFFFF);
bufferDC.GetDC().DrawText (title, rcTitle,
DT_CENTER | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_END_ELLIPSIS);
bufferDC.GetDC().SelectObject (pOldFont);
}
if ((edo & eDisplayBorder) != 0)
{
m_imgCaption.DrawFrame (&bufferDC.GetDC(), rcClient, 0); // 0 is the index of border image
}
}
//*****************************************************************************************
void CBCGPMenuButton::OnDraw (CDC* pDC, const CRect& rect, UINT uiState)
{
ASSERT_VALID (pDC);
CBCGPDrawOnGlass dog (m_bOnGlass);
CSize sizeArrow = CBCGPMenuImages::Size ();
CRect rectParent = rect;
rectParent.right -= sizeArrow.cx + nImageHorzMargin;
CBCGPButton::OnDraw (pDC, rectParent, uiState);
CRect rectArrow = rect;
rectArrow.left = rectParent.right;
CBCGPMenuImages::Draw (pDC,
m_bRightArrow ? CBCGPMenuImages::IdArowRightLarge : CBCGPMenuImages::IdArowDownLarge,
rectArrow,
(uiState & ODS_DISABLED) ? CBCGPMenuImages::ImageGray :
CBCGPMenuImages::GetStateByColor((m_bVisualManagerStyle && !m_bDontSkin && m_clrText != (COLORREF)-1) ? m_clrText : globalData.clrBtnText, FALSE));
if (m_bDefaultClick)
{
//----------------
// Draw separator:
//----------------
CRect rectSeparator = rectArrow;
rectSeparator.right = rectSeparator.left + 2;
rectSeparator.DeflateRect (0, 2);
if (!m_bWinXPTheme || m_bDontUseWinXPTheme)
{
rectSeparator.left += m_sizePushOffset.cx;
rectSeparator.top += m_sizePushOffset.cy;
}
if (m_bOnGlass)
{
CBCGPDrawManager dm (*pDC);
dm.DrawLine (rectSeparator.left, rectSeparator.top, rectSeparator.left, rectSeparator.bottom,
globalData.clrBarDkShadow);
}
else if (m_bVisualManagerStyle && !m_bDontSkin)
{
pDC->Draw3dRect (rectSeparator, globalData.clrBarDkShadow, globalData.clrBarHilite);
}
else
{
pDC->Draw3dRect (rectSeparator, globalData.clrBtnDkShadow, globalData.clrBtnHilite);
}
}
}
//*************************************************************************************************
void CBCGPVisualManagerVS2008::OnHighlightMenuItem (CDC* pDC, CBCGPToolbarMenuButton* pButton,
CRect rect, COLORREF& clrText)
{
ASSERT_VALID (pDC);
ASSERT_VALID (pButton);
if (globalData.m_nBitsPerPixel <= 8 || globalData.IsHighContastMode ())
{
CBCGPVisualManagerVS2005::OnHighlightMenuItem (pDC, pButton, rect, clrText);
return;
}
const int nRoundSize = 3;
const BOOL bIsWinXPBlue = (GetStandardWinXPTheme () == WinXpTheme_Blue);
COLORREF clr1 = bIsWinXPBlue ? WINXPBLUE_GRADIENT_DARK : m_clrHighlightGradientDark;
COLORREF clr2 = bIsWinXPBlue ? WINXPBLUE_GRADIENT_LIGHT : m_clrHighlightGradientLight;
COLORREF clrBorder = bIsWinXPBlue ? WINXPBLUE_MENUITEM_BORDER : m_clrHighlightGradientDark;
if (m_bOSColors)
{
clr1 = m_clrHighlight;
clr2 = RGB (255, 255, 255);
clrBorder = m_clrHighlightDn;
}
if (DYNAMIC_DOWNCAST(CBCGPCustomizeMenuButton, pButton) == NULL)
{
rect.DeflateRect (2, 0);
}
CRgn rgn;
rgn.CreateRoundRectRgn (rect.left, rect.top, rect.right, rect.bottom, nRoundSize, nRoundSize);
pDC->SelectClipRgn (&rgn);
CBCGPDrawManager dm (*pDC);
dm.FillGradient (rect, clr1, clr2, TRUE);
pDC->SelectClipRgn (NULL);
CPen pen (PS_SOLID, 1, clrBorder);
CPen* pOldPen = pDC->SelectObject (&pen);
CBrush* pOldBrush = (CBrush*) pDC->SelectStockObject (NULL_BRUSH);
pDC->RoundRect (rect.left, rect.top, rect.right, rect.bottom, nRoundSize + 2, nRoundSize + 2);
pDC->SelectObject (pOldPen);
pDC->SelectObject (pOldBrush);
clrText = GetHighlightedMenuItemTextColor (pButton);
}
//*********************************************************************************************************
void CBCGPVisualManagerVS2008::OnDrawAutoHideButtonBorder (CDC* pDC, CRect rect, CRect rectBorderSize, CBCGPAutoHideButton* pButton)
{
ASSERT_VALID (pDC);
ASSERT_VALID (pButton);
if (globalData.m_nBitsPerPixel <= 8 || globalData.IsHighContastMode () ||
m_hThemeTab == NULL)
{
CBCGPVisualManagerVS2005::OnDrawAutoHideButtonBorder (pDC, rect, rectBorderSize, pButton);
return;
}
const int nState = pButton->IsHighlighted () ? TIS_HOT : TIS_NORMAL;
const DWORD dwAlign = (pButton->GetAlignment ()) & CBRS_ALIGN_ANY;
CBCGPDrawManager dm (*pDC);
switch (dwAlign)
{
case CBRS_ALIGN_LEFT:
case CBRS_ALIGN_RIGHT:
{
CRect rectTab (0, 0, rect.Height (), rect.Width ());
CDC dcMem;
dcMem.CreateCompatibleDC (pDC);
CBitmap bmpMem;
bmpMem.CreateCompatibleBitmap (pDC, rectTab.Width (), rectTab.Height ());
CBitmap* pBmpOld = (CBitmap*) dcMem.SelectObject (&bmpMem);
(*m_pfDrawThemeBackground) (m_hThemeTab, dcMem.GetSafeHdc(), TABP_TABITEM, nState, &rectTab, 0);
dm.DrawRotated (rect, dcMem, dwAlign == CBRS_ALIGN_LEFT);
dcMem.SelectObject (pBmpOld);
}
break;
case CBRS_ALIGN_TOP:
case CBRS_ALIGN_BOTTOM:
(*m_pfDrawThemeBackground) (m_hThemeTab, pDC->GetSafeHdc(), TABP_TABITEM, nState, &rect, 0);
if (dwAlign == CBRS_ALIGN_TOP)
{
dm.MirrorRect (rect, FALSE);
break;
}
}
}
//***********************************************************************************
void CBCGPVisualManagerVS2005::OnFillHighlightedArea (CDC* pDC, CRect rect,
CBrush* pBrush, CBCGPToolbarButton* pButton)
{
if (pButton != NULL &&
(m_CurrAppTheme == WinXpTheme_Blue || m_CurrAppTheme == WinXpTheme_Olive))
{
ASSERT_VALID (pButton);
CBCGPToolbarMenuButton* pMenuButton =
DYNAMIC_DOWNCAST (CBCGPToolbarMenuButton, pButton);
BOOL bIsPopupMenu = pMenuButton != NULL &&
pMenuButton->GetParentWnd () != NULL &&
pMenuButton->GetParentWnd ()->IsKindOf (RUNTIME_CLASS (CBCGPPopupMenuBar));
if (bIsPopupMenu &&
(pButton->m_nStyle & TBBS_CHECKED) &&
pBrush == &m_brHighlightDn)
{
if (CBCGPToolBarImages::m_bIsDrawOnGlass)
{
CBCGPDrawManager dm (*pDC);
dm.DrawRect (rect, m_clrBarBkgnd, (COLORREF)-1);
}
else
{
pDC->FillRect (rect, &m_brMenuItemCheckedHighlight);
}
return;
}
if (pMenuButton != NULL && !bIsPopupMenu && pMenuButton->IsDroppedDown ())
{
if (CBCGPToolBarImages::m_bIsDrawOnGlass)
{
CBCGPDrawManager dm (*pDC);
dm.DrawRect (rect, m_clrBarBkgnd, (COLORREF)-1);
}
else
{
pDC->FillRect (rect, &m_brMenuButtonDroppedDown);
}
return;
}
}
CBCGPVisualManager2003::OnFillHighlightedArea (pDC, rect, pBrush, pButton);
}
void CVisualManager::OnDrawSlider (CDC* pDC, CBCGPSlider* pSlider, CRect rect, BOOL bAutoHideMode)
{
if (!CanDrawImage ())
{
CBCGPWinXPVisualManager::OnDrawSlider (pDC, pSlider, rect, bAutoHideMode);
return;
}
ASSERT_VALID (pDC);
ASSERT_VALID (pSlider);
pDC->FillRect (rect, &globalData.brBarFace);
COLORREF clr1E = m_clrSlider[0];
COLORREF clr1S = m_clrSlider[1];
COLORREF clr2E = m_clrSlider[2];
COLORREF clr2S = m_clrSlider[3];
CBCGPDrawManager dm (*pDC);
if (pSlider->IsHorizontal ())
{
rect.top += rect.Height () / 2 - 2;
rect.bottom = rect.top + 3;
dm.Fill4ColorsGradient (rect, clr1S, clr1E, clr1E, clr1S, FALSE);
rect.DeflateRect (0, 1);
dm.Fill4ColorsGradient (rect, clr2S, clr2E, clr2E, clr2S, FALSE);
}
else
{
rect.left += rect.Width () / 2 - 2;
rect.right = rect.left + 3;
dm.Fill4ColorsGradient (rect, clr1E, clr1S, clr1S, clr1E, TRUE);
rect.DeflateRect (1, 0);
dm.Fill4ColorsGradient (rect, clr2E, clr2S, clr2S, clr2E, TRUE);
}
}
//*********************************************************************************************************
COLORREF CBCGPVisualManagerVS2008::OnDrawControlBarCaption (CDC* pDC, CBCGPDockingControlBar* pBar,
BOOL bActive, CRect rectCaption, CRect rectButtons)
{
ASSERT_VALID (pDC);
if (!m_bOSColors)
{
return CBCGPVisualManagerVS2005::OnDrawControlBarCaption (pDC, pBar,
bActive, rectCaption, rectButtons);
}
rectCaption.bottom++;
CBCGPDrawManager dm (*pDC);
dm.FillGradient (rectCaption,
bActive ? globalData.clrActiveCaptionGradient : globalData.clrInactiveCaptionGradient,
bActive ? globalData.clrActiveCaption : globalData.clrInactiveCaption,
TRUE);
return bActive ? globalData.clrCaptionText : globalData.clrInactiveCaptionText;
}
//*********************************************************************************************************
void CBCGPVisualManagerVS2008::OnEraseTabsButton (CDC* pDC, CRect rect,
CBCGPButton* pButton,
CBCGPBaseTabWnd* pBaseTab)
{
ASSERT_VALID (pDC);
ASSERT_VALID (pButton);
ASSERT_VALID (pBaseTab);
if (globalData.m_nBitsPerPixel <= 8 || globalData.IsHighContastMode () ||
!pBaseTab->IsVS2005Style () ||
pBaseTab->IsDialogControl () ||
pButton->IsPressed () || pButton->IsHighlighted ())
{
CBCGPVisualManagerVS2005::OnEraseTabsButton (pDC, rect, pButton, pBaseTab);
return;
}
CRgn rgn;
rgn.CreateRectRgnIndirect (rect);
pDC->SelectClipRgn (&rgn);
CFrameWnd* pMainFrame = BCGCBProGetTopLevelFrame (pButton);
if (pMainFrame->GetSafeHwnd () != NULL)
{
CRect rectMain;
pMainFrame->GetClientRect (rectMain);
pMainFrame->MapWindowPoints (pButton, &rectMain);
rect.top = rectMain.top;
rect.left = rectMain.left;
rect.right = rect.left + globalData.m_rectVirtual.Width () + 10;
}
CBCGPDrawManager dm (*pDC);
dm.FillGradient (rect, m_clrBarGradientDark, m_clrBarGradientLight, FALSE, 0);
pDC->SelectClipRgn (NULL);
}
//*********************************************************************************
void CBCGPVisualManagerVS2005::OnFillAutoHideButtonBackground (CDC* pDC, CRect rect, CBCGPAutoHideButton* pButton)
{
ASSERT_VALID (pDC);
ASSERT_VALID (pButton);
if (!m_bRoundedAutohideButtons)
{
return;
}
LPPOINT points;
int nPoints = CreateAutoHideButtonRegion (rect, pButton->GetAlignment (), points);
CRgn rgnClip;
rgnClip.CreatePolygonRgn (points, nPoints, WINDING);
pDC->SelectClipRgn (&rgnClip);
if (globalData.m_nBitsPerPixel <= 8 || globalData.IsHighContastMode ())
{
CBCGPVisualManager2003::OnFillAutoHideButtonBackground (pDC, rect, pButton);
}
else
{
BOOL bIsHorz =
((pButton->GetAlignment () & CBRS_ALIGN_ANY) == CBRS_ALIGN_LEFT ||
(pButton->GetAlignment () & CBRS_ALIGN_ANY) == CBRS_ALIGN_RIGHT);
CBCGPDrawManager dm (*pDC);
dm.FillGradient (rect,
m_clrBarGradientDark, m_clrBarGradientLight, !bIsHorz);
}
pDC->SelectClipRgn (NULL);
delete [] points;
}
//*********************************************************************************************************
void CBCGPVisualManagerVS2008::OnDrawTabResizeBar (CDC* pDC, CBCGPBaseTabWnd* pWndTab,
BOOL bIsVert, CRect rect,
CBrush* pbrFace, CPen* pPen)
{
ASSERT_VALID (pDC);
ASSERT_VALID (pbrFace);
ASSERT_VALID (pPen);
ASSERT_VALID (pWndTab);
if (globalData.m_nBitsPerPixel <= 8 || globalData.IsHighContastMode () || pWndTab->IsFlatTab ())
{
CBCGPVisualManagerVS2005::OnDrawTabResizeBar (pDC, pWndTab, bIsVert, rect, pbrFace, pPen);
return;
}
CRgn rgn;
rgn.CreateRectRgnIndirect (rect);
pDC->SelectClipRgn (&rgn);
CFrameWnd* pMainFrame = BCGCBProGetTopLevelFrame (pWndTab);
if (pMainFrame->GetSafeHwnd () != NULL)
{
CRect rectMain;
pMainFrame->GetClientRect (rectMain);
pMainFrame->MapWindowPoints (pWndTab, &rectMain);
rect.top = rectMain.top;
rect.left = rectMain.left;
rect.right = rect.left + globalData.m_rectVirtual.Width () + 10;
}
CBCGPDrawManager dm (*pDC);
dm.FillGradient (rect, m_clrBarGradientDark, m_clrBarGradientLight, FALSE, 0);
pDC->SelectClipRgn (NULL);
}
//*********************************************************************************
void CMacStyle::OnFillOutlookPageButton (CDC* pDC, const CRect& rect,
BOOL bIsHighlighted, BOOL bIsPressed,
COLORREF& clrText)
{
COLORREF clr1 = RGB (139, 139, 139);
COLORREF clr2 = RGB (233, 233, 233);
if (bIsPressed)
{
COLORREF clr = clr1;
clr1 = clr2;
clr2 = clr;
}
else if (bIsHighlighted)
{
clr1 = RGB (153, 153, 153);
clr2 = RGB (255, 255, 255);
}
CBCGPDrawManager dm (*pDC);
dm.FillGradient (rect, clr1, clr2, TRUE);
clrText = RGB (32, 32, 32);
}
//*********************************************************************************************************
void CBCGPVisualManagerVS2008::OnFillButtonInterior (CDC* pDC,
CBCGPToolbarButton* pButton, CRect rect, CBCGPVisualManager::BCGBUTTON_STATE state)
{
ASSERT_VALID (pDC);
ASSERT_VALID (pButton);
CBCGPToolbarMenuButton* pMenuButton =
DYNAMIC_DOWNCAST (CBCGPToolbarMenuButton, pButton);
BOOL bIsMenuBarButton = pMenuButton != NULL &&
pMenuButton->GetParentWnd () != NULL &&
pMenuButton->GetParentWnd ()->IsKindOf (RUNTIME_CLASS (CBCGPMenuBar));
if (bIsMenuBarButton)
{
rect.bottom -= 2;
}
if (!bIsMenuBarButton || !pMenuButton->IsDroppedDown ())
{
CBCGPVisualManagerVS2005::OnFillButtonInterior (pDC, pButton, rect, state);
return;
}
if (!m_bOSColors)
{
OnFillHighlightedArea (pDC, rect, &m_brBarBkgnd, pButton);
return;
}
COLORREF clr1 = CBCGPDrawManager::PixelAlpha (m_clrHighlight, 85);
COLORREF clr2 = RGB (255, 255, 255);
CBCGPDrawManager dm (*pDC);
dm.FillGradient (rect, clr1, clr2, TRUE);
}
//*****************************************************************************************
void CBCGPSpinButtonCtrl::OnDraw (CDC* pDC)
{
ASSERT_VALID (this);
ASSERT_VALID (pDC);
CRect rectClient;
GetClientRect (rectClient);
if (GetBuddy ()->GetSafeHwnd () != NULL && (m_bOnGlass || CBCGPToolBarImages::m_bIsDrawOnGlass || m_bVisualManagerStyle))
{
CRect rectBorder (0, 0, 0, 0);
if (GetStyle () & UDS_ALIGNRIGHT)
{
rectBorder = rectClient;
rectClient.DeflateRect (1, 1);
}
else if (GetStyle () & UDS_ALIGNLEFT)
{
rectBorder = rectClient;
rectClient.DeflateRect (1, 1);
}
if (!rectBorder.IsRectEmpty ())
{
visualManager->OnDrawControlBorder (
pDC, rectBorder, this, CBCGPToolBarImages::m_bIsDrawOnGlass || m_bOnGlass);
}
}
if (CBCGPToolBarImages::m_bIsDrawOnGlass || m_bOnGlass)
{
CBCGPDrawManager dm (*pDC);
dm.DrawRect (rectClient, globalData.clrWindow, (COLORREF)-1);
}
else
{
pDC->FillRect (rectClient, &globalData.brWindow);
}
int nState = 0;
if (m_bIsButtonPressedUp)
{
nState |= SPIN_PRESSEDUP;
}
if (m_bIsButtonPressedDown)
{
nState |= SPIN_PRESSEDDOWN;
}
if (m_bIsButtonHighligtedUp)
{
nState |= SPIN_HIGHLIGHTEDUP;
}
if (m_bIsButtonHighligtedDown)
{
nState |= SPIN_HIGHLIGHTEDDOWN;
}
if (!IsWindowEnabled ())
{
nState |= SPIN_DISABLED;
}
CBCGPDrawOnGlass dog (m_bOnGlass || CBCGPToolBarImages::m_bIsDrawOnGlass);
visualManager->OnDrawSpinButtons (
pDC, rectClient, nState, (GetStyle() & UDS_HORZ) == UDS_HORZ, this);
}
void CBackgndImageDlg::OnPaint()
{
CPaintDC dc(this); // device context for painting
if (m_Bitmap.GetSafeHandle () == NULL)
{
dc.FillSolidRect (m_rectPreview, ::GetSysColor (COLOR_3DFACE));
CString str = _T("No image to display");
dc.SetBkMode (TRANSPARENT);
dc.DrawText (str, m_rectPreview, DT_CENTER | DT_VCENTER | DT_WORDBREAK);
return;
}
BITMAP bmp;
m_Bitmap.GetBitmap (&bmp);
int cx = bmp.bmWidth;
int cy = bmp.bmHeight;
int cxdest;
int cydest;
CRect rectRest = m_rectPreview;
if (cx > cy)
{
cxdest = m_rectPreview.Width ();
cydest = cx > cxdest ?
m_rectPreview.Height () * cxdest / cx :
m_rectPreview.Height () * cx / cxdest;
rectRest.top += cydest;
}
else
{
cydest = m_rectPreview.Height ();
cxdest = cy > cydest ?
m_rectPreview.Width () * cydest / cy :
m_rectPreview.Width () * cy / cydest;
rectRest.left += cxdest;
}
dc.FillSolidRect (rectRest, ::GetSysColor (COLOR_3DFACE));
CDC dcMem;
dcMem.CreateCompatibleDC (&dc);
CBitmap* pBmpOld = dcMem.SelectObject (&m_Bitmap);
dc.StretchBlt (m_rectPreview.left, m_rectPreview.top, cxdest, cydest,
&dcMem, 0, 0, cx, cy, SRCCOPY);
dcMem.SelectObject (pBmpOld);
CBCGPDrawManager dm (dc);
dm.HighlightRect (CRect (m_rectPreview.TopLeft (), CSize (cxdest, cydest)),
m_iBright);
}
//**************************************************************************
void CBCGPComboBox::OnPaint()
{
#ifndef _BCGSUITE_
if (globalData.bIsWindows9x)
{
Default();
return;
}
#endif
if ((GetStyle () & 0x0003L) == CBS_SIMPLE)
{
Default ();
return;
}
if (!m_bVisualManagerStyle && !m_bOnGlass)
{
Default ();
return;
}
CPaintDC dc(this); // device context for painting
BYTE alpha = 0;
if (m_bOnGlass)
{
alpha = 255;
}
CBCGPMemDC memDC (dc, this, alpha);
CDC* pDC = &memDC.GetDC ();
CRect rectClient;
GetClientRect (rectClient);
CBCGPDrawManager dm (*pDC);
dm.DrawRect (rectClient, globalData.clrWindow, (COLORREF)-1);
SendMessage (WM_PRINTCLIENT, (WPARAM) pDC->GetSafeHdc (), (LPARAM) PRF_CLIENT);
const int cxDropDown = ::GetSystemMetrics (SM_CXVSCROLL) + 4;
m_rectBtn = rectClient;
m_rectBtn.left = m_rectBtn.right - cxDropDown;
m_rectBtn.DeflateRect (2, 2);
CBCGPDrawOnGlass dog (m_bOnGlass);
CBCGPToolbarComboBoxButton buttonDummy;
#ifndef _BCGSUITE_
buttonDummy.m_bIsCtrl = TRUE;
CBCGPVisualManager::GetInstance ()->OnDrawComboDropButton (
pDC, m_rectBtn, !IsWindowEnabled (), m_bIsDroppedDown,
m_bIsButtonHighlighted,
&buttonDummy);
#else
CMFCVisualManager::GetInstance ()->OnDrawComboDropButton (
pDC, m_rectBtn, !IsWindowEnabled (), m_bIsDroppedDown,
m_bIsButtonHighlighted,
&buttonDummy);
#endif
dm.DrawRect (rectClient, (COLORREF)-1, globalData.clrBarShadow);
rectClient.DeflateRect (1, 1);
dm.DrawRect (rectClient, (COLORREF)-1, globalData.clrWindow);
}
//*********************************************************************************************************
COLORREF CBCGPVisualManagerVS2008::OnFillCommandsListBackground (CDC* pDC, CRect rect, BOOL bIsSelected)
{
if (globalData.m_nBitsPerPixel <= 8 || globalData.IsHighContastMode ())
{
return CBCGPVisualManagerVS2005::OnFillCommandsListBackground (pDC, rect, bIsSelected);
}
ASSERT_VALID (this);
ASSERT_VALID (pDC);
rect.left = 0;
const BOOL bIsWinXPBlue = (GetStandardWinXPTheme () == WinXpTheme_Blue) || m_bOSColors;
if (bIsSelected)
{
COLORREF clr1 = bIsWinXPBlue ? WINXPBLUE_GRADIENT_DARK : m_clrHighlightGradientDark;
COLORREF clr2 = bIsWinXPBlue ? WINXPBLUE_GRADIENT_LIGHT : m_clrHighlightGradientLight;
COLORREF clrBorder = bIsWinXPBlue ? WINXPBLUE_MENUITEM_BORDER : m_clrHighlightGradientDark;
if (m_bOSColors)
{
clr1 = m_clrHighlight;
clr2 = RGB (255, 255, 255);
clrBorder = m_clrHighlightDn;
}
CBCGPDrawManager dm (*pDC);
dm.FillGradient (rect, clr1, clr2, TRUE);
pDC->Draw3dRect (rect, clrBorder, clrBorder);
CBCGPToolbarMenuButton dummy;
return GetHighlightedMenuItemTextColor (&dummy);
}
else
{
pDC->FillRect (rect, &m_brMenuLight);
int iImageWidth = CBCGPToolBar::GetMenuImageSize ().cx + GetMenuImageMargin ();
CRect rectImages = rect;
rectImages.right = rectImages.left + iImageWidth + MENU_IMAGE_MARGIN;
if (bIsWinXPBlue)
{
CBrush br (WINXPBLUE_MENU_GUTTER);
pDC->FillRect (rectImages, &br);
CPen* pOldPen = pDC->SelectObject (&m_penSeparator);
ASSERT (pOldPen != NULL);
pDC->MoveTo (rectImages.right, rectImages.top);
pDC->LineTo (rectImages.right, rectImages.bottom);
pDC->SelectObject (pOldPen);
}
else
{
CBCGPDrawManager dm (*pDC);
dm.FillGradient (rectImages, m_clrToolBarGradientLight, m_clrToolBarGradientDark, FALSE);
}
return globalData.clrBarText;
}
}
//*********************************************************************************************************
void CBCGPVisualManagerVS2008::OnDrawTab (CDC* pDC, CRect rectTab,
int iTab, BOOL bIsActive, const CBCGPBaseTabWnd* pTabWnd)
{
ASSERT_VALID (pTabWnd);
ASSERT_VALID (pDC);
const COLORREF clrTab = pTabWnd->GetTabBkColor (iTab);
const BOOL bIsHighlight = (iTab == pTabWnd->GetHighlightedTab ());
if (globalData.m_nBitsPerPixel <= 8 || globalData.IsHighContastMode () ||
pTabWnd->IsDialogControl () ||
pTabWnd->IsFlatTab () || pTabWnd->IsPointerStyle() ||
clrTab != (COLORREF)-1)
{
CBCGPVisualManagerVS2005::OnDrawTab (pDC, rectTab, iTab, bIsActive, pTabWnd);
return;
}
if ((bIsActive || bIsHighlight || m_bOSColors) && pTabWnd->IsVS2005Style ())
{
((CBCGPBaseTabWnd*)pTabWnd)->SetTabBkColor (iTab,
bIsActive ? m_clrHighlight :
bIsHighlight ? m_clrHighlightDnGradientDark : GetThemeColor (m_hThemeButton, 2));
CBCGPVisualManagerVS2005::OnDrawTab (pDC, rectTab, iTab, bIsActive, pTabWnd);
((CBCGPBaseTabWnd*)pTabWnd)->SetTabBkColor (iTab, clrTab);
return;
}
if (m_hThemeTab == NULL ||
pTabWnd->IsOneNoteStyle () || pTabWnd->IsVS2005Style () ||
pTabWnd->IsLeftRightRounded ())
{
CRect rectClip = rectTab;
rectClip.bottom -= 2;
CRgn rgn;
rgn.CreateRectRgnIndirect (&rectClip);
pDC->SelectClipRgn (&rgn);
CBCGPVisualManagerVS2005::OnDrawTab (pDC, rectTab, iTab, bIsActive, pTabWnd);
pDC->SelectClipRgn (NULL);
return;
}
int nState = TIS_NORMAL;
if (bIsActive)
{
nState = TIS_SELECTED;
}
else if (iTab == pTabWnd->GetHighlightedTab ())
{
nState = TIS_HOT;
}
rectTab.right += 2;
if (!bIsActive)
{
rectTab.bottom--;
}
else if (pTabWnd->GetLocation () == CBCGPBaseTabWnd::LOCATION_BOTTOM)
{
rectTab.top--;
rectTab.bottom++;
}
if (rectTab.Width () > 25) // DrawThemeBackground will draw < 25 width tab bad
{
CRect rectDraw = rectTab;
if (bIsActive && pTabWnd->GetLocation () == CBCGPBaseTabWnd::LOCATION_BOTTOM)
{
rectDraw.bottom++;
}
(*m_pfDrawThemeBackground) (m_hThemeTab, pDC->GetSafeHdc(), TABP_TABITEM, nState, &rectDraw, 0);
if (pTabWnd->GetLocation () == CBCGPBaseTabWnd::LOCATION_BOTTOM)
{
CBCGPDrawManager dm (*pDC);
dm.MirrorRect (rectTab, FALSE);
}
}
COLORREF clrTabText = globalData.clrWindowText;
if (pTabWnd->GetTabTextColor(iTab) != (COLORREF)-1)
{
clrTabText = pTabWnd->GetTabTextColor(iTab);
}
else
{
if (!bIsActive)
{
clrTabText = globalData.clrBtnDkShadow;
}
else if (m_pfGetThemeColor != NULL)
{
(*m_pfGetThemeColor) (m_hThemeTab, TABP_TABITEM, nState, TMT_TEXTCOLOR, &clrTabText);
}
}
COLORREF cltTextOld = pDC->SetTextColor (clrTabText);
rectTab.right -= 2;
OnDrawTabContent (pDC, rectTab, iTab, bIsActive, pTabWnd, (COLORREF)-1);
pDC->SetTextColor (cltTextOld);
}
void COptionsPropSheet::OnDrawPageHeader (CDC* pDC, int nPage, CRect rectHeader)
{
CSize sizeIcon = m_Icons.GetImageSize ();
CBCGPDrawManager dm (*pDC);
COLORREF clrBegin, clrFinish;
switch (CBCGPVisualManager2010::GetStyle())
{
case CBCGPVisualManager2010::VS2010_Blue:
clrBegin = RGB(207, 221, 238);
clrFinish = RGB(186, 202, 222);
break;
case CBCGPVisualManager2010::VS2010_Black:
clrBegin = RGB(131, 131, 131);
clrFinish = RGB(57, 57, 57);
break;
case CBCGPVisualManager2010::VS2010_Silver:
clrBegin = RGB(233, 237, 241);
clrFinish = RGB(200, 204, 209);
break;
}
dm.FillGradient (rectHeader, clrBegin, clrFinish);
rectHeader.bottom -= 10;
CRect rectIcon = rectHeader;
rectIcon.left += 20;
rectIcon.right = rectIcon.left + sizeIcon.cx;
m_Icons.DrawEx (pDC, rectIcon, nPage, CBCGPToolBarImages::ImageAlignHorzLeft, CBCGPToolBarImages::ImageAlignVertCenter);
CString strText;
BOOL bNameVaild;
switch (nPage)
{
case 0:
bNameVaild = strText.LoadString(IDS_STRING_CHANGEOPTIONS);
ASSERT(bNameVaild);
break;
case 1:
bNameVaild = strText.LoadString(IDS_STRING_CHANGEVISIT);
ASSERT(bNameVaild);
break;
case 2:
bNameVaild = strText.LoadString(IDS_STRING_LINKEUPDATE);
ASSERT(bNameVaild);
break;
}
CRect rectText = rectHeader;
rectText.left = rectIcon.right + 10;
rectText.right -= 20;
CFont* pOldFont = pDC->SelectObject (&globalData.fontBold);
pDC->SetBkMode (TRANSPARENT);
pDC->SetTextColor (globalData.clrBarText);
UINT uiFlags = DT_SINGLELINE | DT_VCENTER;
CRect rectTextCalc = rectText;
pDC->DrawText (strText, rectTextCalc, uiFlags | DT_CALCRECT);
if (rectTextCalc.right > rectText.right)
{
rectText.DeflateRect (0, 10);
uiFlags = DT_WORDBREAK;
}
pDC->DrawText (strText, rectText, uiFlags);
pDC->SelectObject (pOldFont);
}
//*****************************************************************************************
void CBCGPColorButton::OnDraw (CDC* pDC, const CRect& rect, UINT uiState)
{
ASSERT_VALID (pDC);
if (m_pPalette == NULL)
{
RebuildPalette (NULL);
}
CPalette* pCurPalette = pDC->SelectPalette (m_pPalette, FALSE);
pDC->RealizePalette();
CSize sizeArrow = CBCGPMenuImages::Size ();
CRect rectColor = rect;
rectColor.right -= sizeArrow.cx + nImageHorzMargin;
CRect rectArrow = rect;
rectArrow.left = rectColor.right;
COLORREF color = m_Color;
if (color == (COLORREF) -1) // Automatic
{
//---------------------------
// Draw automatic text label:
//---------------------------
color = m_ColorAutomatic;
if (!m_strAutoColorText.IsEmpty ())
{
rectColor.right = rectColor.left + rectColor.Height ();
CRect rectText = rect;
rectText.left = rectColor.right;
rectText.right = rectArrow.left;
CFont* pOldFont = SelectFont (pDC);
ASSERT(pOldFont != NULL);
pDC->SetBkMode (TRANSPARENT);
pDC->SetTextColor (globalData.clrBtnText);
UINT nFormat = DT_CENTER | DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS;
if (m_bOnGlass)
{
CBCGPVisualManager::GetInstance ()->DrawTextOnGlass (pDC,
m_strAutoColorText, rectText, nFormat, 0);
}
else
{
pDC->DrawText (m_strAutoColorText, rectText, nFormat);
}
pDC->SelectObject (pOldFont);
}
}
//----------------
// Draw color box:
//----------------
rectColor.DeflateRect (2, 2);
if (m_bOnGlass)
{
CBCGPDrawManager dm (*pDC);
dm.DrawRect (rectColor, (COLORREF)-1, globalData.clrBtnDkShadow);
}
else
{
pDC->Draw3dRect (rectColor, globalData.clrBtnHilite, globalData.clrBtnHilite);
rectColor.DeflateRect (1, 1);
pDC->Draw3dRect (rectColor, globalData.clrBtnDkShadow, globalData.clrBtnDkShadow);
}
rectColor.DeflateRect (1, 1);
if (color != (COLORREF)-1 && (uiState & ODS_DISABLED) == 0)
{
if (globalData.m_nBitsPerPixel == 8) // 256 colors
{
ASSERT_VALID (m_pPalette);
color = PALETTEINDEX (m_pPalette->GetNearestPaletteIndex (color));
}
if (m_bOnGlass)
{
CBCGPDrawManager dm (*pDC);
dm.DrawRect (rectColor, color, (COLORREF)-1);
}
else
{
CBrush br (color);
pDC->FillRect (rectColor, &br);
}
}
//----------------------
// Draw drop-down arrow:
//----------------------
CRect rectArrowWinXP = rectArrow;
rectArrowWinXP.DeflateRect (2, 2);
if (!m_bWinXPTheme || !CBCGPVisualManager::GetInstance ()->DrawComboDropButtonWinXP (
pDC, rectArrowWinXP,
(uiState & ODS_DISABLED), m_bPushed,
m_bHighlighted))
{
pDC->FillRect (rectArrow, &globalData.brBtnFace);
CBCGPMenuImages::Draw (pDC, CBCGPMenuImages::IdArowDownLarge, rectArrow,
(uiState & ODS_DISABLED) ? CBCGPMenuImages::ImageGray : CBCGPMenuImages::ImageBlack);
pDC->Draw3dRect (rectArrow, globalData.clrBtnLight, globalData.clrBtnDkShadow);
rectArrow.DeflateRect (1, 1);
pDC->Draw3dRect (rectArrow, globalData.clrBtnHilite, globalData.clrBtnShadow);
}
if (pCurPalette != NULL)
{
pDC->SelectPalette (pCurPalette, FALSE);
}
}
void CKofBCGPFontComboBox::OnPaint()
{
if ((GetStyle () & 0x0003L) == CBS_SIMPLE)
{
Default ();
return;
}
if (!m_bVisualManagerStyle && !m_bOnGlass)
{
Default ();
return;
}
CPaintDC dc(this); // device context for painting
BYTE alpha = 0;
if (m_bOnGlass)
{
alpha = 255;
}
CBCGPMemDC memDC (dc, this, alpha);
CDC* pDC = &memDC.GetDC ();
CRect rectClient;
GetClientRect (rectClient);
CBCGPDrawManager dm (*pDC);
dm.DrawRect (rectClient, globalData.clrWindow, (COLORREF)-1);
// 得注释掉这句话
// SendMessage (WM_PRINTCLIENT, (WPARAM) pDC->GetSafeHdc (), (LPARAM) PRF_CLIENT);
const int cxDropDown = ::GetSystemMetrics (SM_CXVSCROLL) + 4;
int nCurSel = GetCurSel();
if (CB_ERR != nCurSel)
{
if (m_Images.GetSafeHandle () == NULL)
{
CBCGPLocalResource locaRes;
m_Images.Create (IDB_BCGBARRES_FONT, nImageWidth, 0, RGB (255, 255, 255));
}
CFont fontSelected;
CFont* pOldFont = NULL;
CRect rc(rectClient);
rc.right -= cxDropDown;
CBCGPFontDesc* pDesc = (CBCGPFontDesc*)GetItemDataPtr(nCurSel);
if (pDesc != NULL)
{
if (pDesc->m_nType & (DEVICE_FONTTYPE | TRUETYPE_FONTTYPE))
{
CPoint ptImage (rc.left + 3, rc.top + (rc.Height () - nImageHeight) / 2);
m_Images.Draw (pDC, pDesc->GetImageIndex (), ptImage, ILD_NORMAL);
}
rc.left += nImageWidth + 9;
if (m_bDrawUsingFont && pDesc->m_nCharSet != SYMBOL_CHARSET)
{
LOGFONT lf;
globalData.fontRegular.GetLogFont (&lf);
lstrcpy (lf.lfFaceName, pDesc->m_strName);
if (pDesc->m_nCharSet != DEFAULT_CHARSET)
{
lf.lfCharSet = pDesc->m_nCharSet;
}
if (lf.lfHeight < 0)
{
lf.lfHeight -= 4;
}
else
{
lf.lfHeight += 4;
}
fontSelected.CreateFontIndirect (&lf);
pOldFont = pDC->SelectObject (&fontSelected);
}
}
CString strText;
GetLBText (nCurSel, strText);
pDC->DrawText (strText, rc, DT_SINGLELINE | DT_VCENTER);
if (pOldFont != NULL)
{
pDC->SelectObject (pOldFont);
}
}
m_rectBtn = rectClient;
m_rectBtn.left = m_rectBtn.right - cxDropDown;
m_rectBtn.DeflateRect (2, 2);
CBCGPDrawOnGlass dog (m_bOnGlass);
CKofBCGPToolbarComboBoxButton buttonDummy;
#ifndef _BCGSUITE_
buttonDummy.m_bIsCtrl = TRUE;
CBCGPVisualManager::GetInstance ()->OnDrawComboDropButton (
pDC, m_rectBtn, !IsWindowEnabled (), m_bIsDroppedDown,
m_bIsButtonHighlighted,
&buttonDummy);
#else
CMFCVisualManager::GetInstance ()->OnDrawComboDropButton (
pDC, m_rectBtn, !IsWindowEnabled (), m_bIsDroppedDown,
m_bIsButtonHighlighted,
&buttonDummy);
#endif
dm.DrawRect (rectClient, (COLORREF)-1, globalData.clrBarShadow);
rectClient.DeflateRect (1, 1);
dm.DrawRect (rectClient, (COLORREF)-1, globalData.clrWindow);
}
void CImageStyle::FillArea (CDC* pDC, CRect rect, const CWnd* pWnd, BOOL bIsFloating,
BOOL bNCArea)
{
if (m_bmpBack.GetSafeHandle () == NULL)
{
globalData.clrBtnText = m_clrText;
// Load background bitmap:
if (!m_bIsInternalImage)
{
HBITMAP hbmp = (HBITMAP) ::LoadImage (
AfxGetInstanceHandle (),
m_strImagePath,
IMAGE_BITMAP,
0, 0,
LR_LOADFROMFILE | LR_CREATEDIBSECTION);
VERIFY (hbmp != NULL);
m_bmpBack.Attach (hbmp);
}
else
{
m_bmpBack.LoadBitmap (IDB_BACKGROUND);
}
BITMAP bmp;
m_bmpBack.GetBitmap (&bmp);
m_sizeBmp = CSize (bmp.bmWidth, bmp.bmHeight);
}
int xOffset = rect.left;
int yOffset = rect.top;
if (!bIsFloating &&
!pWnd->IsKindOf (RUNTIME_CLASS (CBCGPPopupMenuBar)))
{
CRect rectMainFrame;
pWnd->GetTopLevelFrame ()->GetWindowRect (rectMainFrame);
pWnd->ScreenToClient (&rectMainFrame);
xOffset = rectMainFrame.left % m_sizeBmp.cx;
yOffset = rectMainFrame.top % m_sizeBmp.cy;
if (bNCArea)
{
CRect rectWindow;
pWnd->GetWindowRect (rectWindow);
pWnd->ScreenToClient (rectWindow);
CRect rectClientActual;
pWnd->GetClientRect (rectClientActual);
xOffset += rectClientActual.left - rectWindow.left;
yOffset += rectClientActual.top - rectWindow.top;
}
}
for (int x = xOffset; x < rect.right; x += m_sizeBmp.cx)
{
for (int y = yOffset; y < rect.bottom; y += m_sizeBmp.cy)
{
pDC->DrawState (CPoint (x, y), m_sizeBmp, &m_bmpBack, 0);
}
}
CBCGPDrawManager dm (*pDC);
dm.HighlightRect (rect, m_nHighlight);
}
//*****************************************************************************************
void CBCGPSliderCtrl::OnDraw(CDC* pDCIn)
{
CBCGPMemDC memDC (*pDCIn, this);
CDC* pDC = &memDC.GetDC ();
if (!CBCGPVisualManager::GetInstance ()->OnFillParentBarBackground (this, pDC))
{
globalData.DrawParentBackground (this, pDC, NULL);
}
DWORD dwStyle = GetStyle ();
BOOL bVert = (dwStyle & TBS_VERT);
BOOL bLeftTop = (dwStyle & TBS_BOTH) || (dwStyle & TBS_LEFT);
BOOL bRightBottom = (dwStyle & TBS_BOTH) || ((dwStyle & TBS_LEFT) == 0);
BOOL bIsFocused = GetSafeHwnd () == ::GetFocus ();
CRect rectChannel;
GetChannelRect (rectChannel);
if (bVert)
{
CRect rect = rectChannel;
rectChannel.left = rect.top;
rectChannel.right = rect.bottom;
rectChannel.top = rect.left;
rectChannel.bottom = rect.right;
}
CBCGPDrawOnGlass dog(m_bOnGlass);
CBCGPVisualManager::GetInstance ()->OnDrawSliderChannel (pDC, this, bVert, rectChannel, m_bOnGlass);
CRect rectThumb;
GetThumbRect (rectThumb);
int nTicSize = max(3, (bVert ? rectThumb.Height() : rectThumb.Width()) / 3);
int nTicOffset = 2;
int nNumTics = GetNumTics();
for (int i = 0; i < nNumTics; i++)
{
int nTicPos = GetTicPos(i);
if (nTicPos < 0)
{
if (i == nNumTics - 2)
{
if (bVert)
{
nTicPos = rectChannel.top + rectThumb.Height() / 2;
}
else
{
nTicPos = rectChannel.left + rectThumb.Width() / 2;
}
}
else if (i == nNumTics - 1)
{
if (bVert)
{
nTicPos = rectChannel.bottom - rectThumb.Height() / 2 - 1;
}
else
{
nTicPos = rectChannel.right - rectThumb.Width() / 2 - 1;
}
}
}
if (nTicPos >= 0)
{
CRect rectTic1(0, 0, 0, 0);
CRect rectTic2(0, 0, 0, 0);
if (bVert)
{
if (bLeftTop)
{
rectTic1 = CRect(rectThumb.left - nTicOffset - nTicSize, nTicPos, rectThumb.left - nTicOffset, nTicPos + 1);
}
if (bRightBottom)
{
rectTic2 = CRect(rectThumb.right + nTicOffset, nTicPos, rectThumb.right + nTicOffset + nTicSize, nTicPos + 1);
}
}
else
{
if (bLeftTop)
{
rectTic1 = CRect(nTicPos, rectThumb.top - nTicOffset - nTicSize, nTicPos + 1, rectThumb.top - nTicOffset);
}
if (bRightBottom)
{
rectTic2 = CRect(nTicPos, rectThumb.bottom + nTicOffset, nTicPos + 1, rectThumb.bottom + nTicOffset + nTicSize);
}
}
if (!rectTic1.IsRectEmpty())
{
CBCGPVisualManager::GetInstance ()->OnDrawSliderTic(pDC, this, rectTic1, bVert, TRUE, m_bOnGlass);
}
if (!rectTic2.IsRectEmpty())
{
CBCGPVisualManager::GetInstance ()->OnDrawSliderTic(pDC, this, rectTic2, bVert, FALSE, m_bOnGlass);
}
}
}
CBCGPVisualManager::GetInstance ()->OnDrawSliderThumb (
pDC, this, rectThumb, m_bIsThumbHighligted || bIsFocused,
m_bIsThumPressed, !IsWindowEnabled (),
bVert, bLeftTop, bRightBottom, m_bOnGlass);
if (bIsFocused && m_bDrawFocus)
{
CRect rectFocus;
GetClientRect (rectFocus);
if (m_bOnGlass)
{
CBCGPDrawManager dm (*pDC);
dm.DrawFocusRect(rectFocus);
}
else
{
pDC->DrawFocusRect (rectFocus);
}
}
}
//**************************************************************************************
COLORREF CBCGPVisualManagerVS2005::OnDrawControlBarCaption (CDC* pDC, CBCGPDockingControlBar* pBar,
BOOL bActive, CRect rectCaption, CRect rectButtons)
{
ASSERT_VALID (pDC);
if (globalData.m_nBitsPerPixel <= 8 || globalData.IsHighContastMode ())
{
return CBCGPVisualManagerXP::OnDrawControlBarCaption (pDC, pBar,
bActive, rectCaption, rectButtons);
}
rectCaption.bottom++;
COLORREF clrFill;
if (!bActive)
{
if (m_CurrAppTheme == WinXpTheme_Blue ||
m_CurrAppTheme == WinXpTheme_Olive ||
m_CurrAppTheme == WinXpTheme_Silver)
{
clrFill = CBCGPDrawManager::PixelAlpha (m_clrBarGradientDark, 87);
CBrush brFill (clrFill);
pDC->FillRect (rectCaption, &brFill);
pDC->Draw3dRect (rectCaption, globalData.clrBarShadow, globalData.clrBarShadow);
}
else
{
CBrush brFill (globalData.clrInactiveCaption);
pDC->FillRect (rectCaption, &brFill);
return globalData.clrInactiveCaptionText;
}
}
else
{
if (m_CurrAppTheme == WinXpTheme_Blue ||
m_CurrAppTheme == WinXpTheme_Olive ||
m_CurrAppTheme == WinXpTheme_Silver)
{
COLORREF clrLight =
CBCGPDrawManager::PixelAlpha (globalData.clrHilite, 130);
CBCGPDrawManager dm (*pDC);
dm.FillGradient (rectCaption, globalData.clrHilite, clrLight, TRUE);
return globalData.clrTextHilite;
}
else
{
pDC->FillRect (rectCaption, &globalData.brActiveCaption);
return globalData.clrCaptionText;
}
}
if (GetRValue (clrFill) <= 192 &&
GetGValue (clrFill) <= 192 &&
GetBValue (clrFill) <= 192)
{
return RGB (255, 255, 255);
}
else
{
return RGB (0, 0, 0);
}
}
void CLoginBarToolTipCtrl::OnPaint()
{
CPaintDC dc(this); // device context for painting
CRect rect;
GetClientRect (rect);
CBCGPToolTipParams params;
visualManagerMFC->GetToolTipParams (params);
if (params.m_clrFill == (COLORREF)-1)
{
::FillRect (dc.GetSafeHdc (), rect, ::GetSysColorBrush (COLOR_INFOBK));
}
else
{
if (params.m_clrFillGradient == (COLORREF)-1)
{
CBrush br (params.m_clrFill);
dc.FillRect (rect, &br);
}
else
{
CBCGPDrawManager dm (dc);
dm.FillGradient2 (rect,
params.m_clrFillGradient, params.m_clrFill,
params.m_nGradientAngle == -1 ? 90 : params.m_nGradientAngle);
}
}
COLORREF clrLine = params.m_clrBorder == (COLORREF)-1 ?
::GetSysColor (COLOR_INFOTEXT) : params.m_clrBorder;
COLORREF clrText = params.m_clrText == (COLORREF)-1 ?
::GetSysColor (COLOR_INFOTEXT) : params.m_clrText;
dc.Draw3dRect (rect, clrLine, clrLine);
CFont* pPrevFont = m_pFont == NULL ?
(CFont*) dc.SelectStockObject (DEFAULT_GUI_FONT) :
dc.SelectObject (m_pFont);
dc.SetBkMode (TRANSPARENT);
dc.SetTextColor(clrText);
if (m_strText.FindOneOf (_T("\n")) != -1) // multi-line tooltip
{
rect.DeflateRect (m_nTextMargin, m_nTextMargin);
if (rect.Height () < m_rectLast.Height ())
{
// center tooltip vertically
//rect.top += (m_rectLast.Height () - rect.Height ()) / 2;
}
//dc.DrawText (m_strText, rect, DT_LEFT | DT_WORDBREAK);
DrawTextML (dc, m_strText, rect);
}
else // single line tooltip
{
rect.DeflateRect (m_nTextMargin, 0);
dc.DrawText (m_strText, rect, DT_LEFT | DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX);
}
if (pPrevFont != NULL)
{
dc.SelectObject (pPrevFont);
}
}
