C++ CDC::Draw3dRect方法代码示例

void MenuEditorItem::PaintSeparator(CDC& dc, CRect& rect)
{
	// Draw separator

	CRect sep = rect;
	sep.bottom = sep.top + 2;
	dc.FillSolidRect(sep, 0xffffff);
	dc.Draw3dRect(sep,GetSysColor(COLOR_BTNFACE), GetSysColor(COLOR_BTNFACE));
	rect.OffsetRect(0, sep.Height()+1);
}

void CSizingControlBar::OnNcPaint()
{
    // get window DC that is clipped to the non-client area
    CWindowDC dc(this);

    CRect rcClient, rcBar;
    GetClientRect(rcClient);
    ClientToScreen(rcClient);
    GetWindowRect(rcBar);
    rcClient.OffsetRect(-rcBar.TopLeft());
    rcBar.OffsetRect(-rcBar.TopLeft());

    CDC mdc;
    mdc.CreateCompatibleDC(&dc);
    
    CBitmap bm;
    bm.CreateCompatibleBitmap(&dc, rcBar.Width(), rcBar.Height());
    CBitmap* pOldBm = mdc.SelectObject(&bm);

    // draw borders in non-client area
    CRect rcDraw = rcBar;
    DrawBorders(&mdc, rcDraw);

    // erase the NC background
#ifdef _WIN64
    mdc.FillRect(rcDraw, CBrush::FromHandle(
        (HBRUSH) GetClassLong(m_hWnd, GCLP_HBRBACKGROUND)));
#else
    mdc.FillRect(rcDraw, CBrush::FromHandle(
        (HBRUSH) GetClassLong(m_hWnd, GCL_HBRBACKGROUND)));
#endif

    if (m_dwSCBStyle & SCBS_SHOWEDGES)
    {
        CRect rcEdge; // paint the sizing edges
        for (int i = 0; i < 4; i++)
            if (GetEdgeRect(rcBar, GetEdgeHTCode(i), rcEdge))
                mdc.Draw3dRect(rcEdge, ::GetSysColor(COLOR_BTNHIGHLIGHT),
                    ::GetSysColor(COLOR_BTNSHADOW));
    }

    NcPaintGripper(&mdc, rcClient);

    // client area is not our bussiness :)
    dc.IntersectClipRect(rcBar);
    dc.ExcludeClipRect(rcClient);

    dc.BitBlt(0, 0, rcBar.Width(), rcBar.Height(), &mdc, 0, 0, SRCCOPY);

    ReleaseDC(&dc);

    mdc.SelectObject(pOldBm);
    bm.DeleteObject();
    mdc.DeleteDC();
}

void CChatWnd::OnDrawItem(int /*nIDCtl*/, LPDRAWITEMSTRUCT lpDrawItemStruct)
{
    CDC* pDC = CDC::FromHandle( lpDrawItemStruct->hDC );
    CRect rc( &lpDrawItemStruct->rcItem );

    Emoticons.Draw( pDC, lpDrawItemStruct->itemID - 1, rc.left + 8, rc.top + 3 );

    if ( lpDrawItemStruct->itemState & ODS_SELECTED )
    {
        pDC->Draw3dRect( &rc, CoolInterface.m_crHighlight, CoolInterface.m_crHighlight );
        rc.DeflateRect( 1, 1 );
        pDC->Draw3dRect( &rc, CoolInterface.m_crHighlight, CoolInterface.m_crHighlight );
    }
    else
    {
        pDC->Draw3dRect( &rc, CoolInterface.m_crWindow, CoolInterface.m_crWindow );
        rc.DeflateRect( 1, 1 );
        pDC->Draw3dRect( &rc, CoolInterface.m_crWindow, CoolInterface.m_crWindow );
    }
}

void CXTPHeaderCtrlThemeExplorer::OnDrawBackground(LPDRAWITEMSTRUCT lpDIS)
{
	CRect rcItem(lpDIS->rcItem);
	CDC* pDC = CDC::FromHandle(lpDIS->hDC);

	// fill background
	pDC->FillSolidRect(&rcItem, m_cr3DFace);
	rcItem.right += 2;

	// draw 3D borders.
	pDC->Draw3dRect(&rcItem, m_cr3DHighLight, m_cr3DShadow);
}

void CMonitorWnd::DrawActivePage(BOOL bFlag)
{
	if(!m_pActivePage || m_PageList.GetCount() < 2)
	{
		return;
	}

	CRect rect;
	m_pActivePage->GetWindowRect(&rect);
	ScreenToClient(&rect);
	rect.InflateRect(1,1);

	if(bFlag)
	{
		CDC *pDC = GetDC();
		if(pDC == NULL)
		{
			return;
		}

		pDC->Draw3dRect(&rect,m_clrTopLeft, m_clrBottomRight);	

		ReleaseDC(pDC);
	}
	else
	{
		CDC *pDC = GetDC();
		if(pDC == NULL)
		{
			return;
		}

		pDC->Draw3dRect(&rect, MONITOR_BACK_COLOR, MONITOR_BACK_COLOR);	

		ReleaseDC(pDC);
	}
}

void CMonitorBarCtrl::DoPaint(CDC* pDC)
{
	CRect rcClient;
	GetClientRect( &rcClient );

	CSize size = rcClient.Size();
	CDC* pMemDC = CoolInterface.GetBuffer( *pDC, size );
	if ( Settings.General.LanguageRTL )
		SetLayout( pMemDC->m_hDC, 0 );

	if ( ! CoolInterface.DrawWatermark( pMemDC, &rcClient, &m_bmWatermark ) )
		pMemDC->FillSolidRect( &rcClient, CoolInterface.m_crMidtone );

	if ( Skin.m_bBordersEnabled )
		DrawBorders( pMemDC, rcClient );
	else
		rcClient.DeflateRect( 2, 3, 2, 1 );

	for ( int nY = rcClient.top + 4 ; nY < rcClient.bottom - 4 ; nY += 2 )
	{
		pMemDC->Draw3dRect( rcClient.left + 3, nY, 4, 1,
			CoolInterface.m_crDisabled, CoolInterface.m_crDisabled );
	}

	DrawIconEx( pMemDC->GetSafeHdc(), rcClient.right - 16, rcClient.bottom - 16, m_hUpDown, 16, 16, 0, NULL, DI_NORMAL );

	m_pTxItem->SetHistory( rcClient.Width(), TRUE );
	m_pRxItem->SetHistory( rcClient.Width(), TRUE );

	CRect rcHistory( rcClient.left + 10, rcClient.top + 2, rcClient.right - 15, rcClient.bottom - 6 );
	PaintHistory( pMemDC, &rcHistory );

	CRect rcCurrent( rcClient.right - 7, rcClient.top + 2, rcClient.right - 2, rcClient.bottom - 6 );
	PaintCurrent( pMemDC, &rcCurrent, m_pRxItem );
	rcCurrent.OffsetRect( -6, 0 );
	PaintCurrent( pMemDC, &rcCurrent, m_pTxItem );

	m_rcTrack.SetRect( rcClient.left + 6, rcClient.bottom - 8, rcClient.right, rcClient.bottom - 2 );
	PaintTab( pMemDC );

	GetClientRect( &rcClient );
	pDC->BitBlt( rcClient.left, rcClient.top, rcClient.Width(), rcClient.Height(),
		pMemDC, 0, 0, SRCCOPY );
	if ( Settings.General.LanguageRTL )
		SetLayout( pMemDC->m_hDC, LAYOUT_RTL );
}

void CDownloadMonitorDlg::DoPaint(CDC& dc)
{
	CRect rc;

	m_wndProgress.GetWindowRect( &rc );
	ScreenToClient( &rc );

	DrawProgressBar( &dc, &rc );

	m_wndGraph.GetWindowRect( &rc );
	ScreenToClient( &rc );

	dc.Draw3dRect( &rc, 0, 0 );
	rc.DeflateRect( 1, 1 );

	m_pGraph->BufferedPaint( &dc, &rc );
}

BOOL CColorEdit::OnEraseBkgnd(CDC* pDC)
{
	CDC* pdcParent = GetParent()->GetDC();

	ui::CClientRect rcThisClient(this);
	ui::CWindowRect rcThisWindow(this);
	if (rcThisClient.Width() == rcThisWindow.Width())
	{
		rcThisWindow.InflateRect(2, 2);
	}

	GetParent()->ScreenToClient(rcThisWindow);
	pdcParent->Draw3dRect(rcThisWindow, m_crBorder, m_crBorder);
	ReleaseDC(pdcParent);

	return TRUE;
}

void ComicStripPicture::OnPaint()
{
   CRect rect;
   GetClientRect(&rect);
	CPaintDC dc(this);
	CDC* pDC = &dc;
	CDC memDC;
	memDC.CreateCompatibleDC(pDC);
	CBitmap memZoomBitmap;
	memZoomBitmap.CreateCompatibleBitmap(pDC, rect.Width(), rect.Height());
	memDC.SelectObject(&memZoomBitmap);

   CDrawer::Draw(this, &memDC, m_pComicStripData);
   memDC.Draw3dRect(rect, RGB(0, 0, 0), RGB(0, 0, 0));
   pDC->BitBlt(0, 0, rect.Width(), rect.Height(), &memDC, 0, 0, SRCCOPY);
	memDC.DeleteDC();
	memZoomBitmap.DeleteObject();
}

void MenuEditorItem::PaintMenu(CDC& dc, CRect& rect)
{
	// draw this item

	dc.FillSolidRect(rect, 0xffffff);
	dc.Draw3dRect(rect,GetSysColor(COLOR_BTNFACE), GetSysColor(COLOR_BTNFACE));
	m_rect = rect;

	CRect temp = rect;
	
	if(pEditor->selected == this)
	{
		for(int x = temp.left; x < temp.right; x+=2)
		{
			dc.SetPixel(x,temp.top, 0);
			dc.SetPixel(x + 1- temp.Height()%2,temp.bottom-1, 0);
		}
		for(int y = temp.top; y < temp.bottom; y+=2)
		{
			dc.SetPixel(temp.left,y, 0);
			dc.SetPixel(temp.right-1,y +1- temp.Width()%2, 0);
		}
	}

	temp.DeflateRect(2,2);

	if(pEditor->selected == this)
		dc.FillSolidRect(temp, GetSysColor(COLOR_MENUHILIGHT));
	

	temp.left += 20;
	
	if(inserttext)
		dc.SetTextColor(GetSysColor(COLOR_GRAYTEXT));
	else if(pEditor->selected == this)
		dc.SetTextColor(GetSysColor(COLOR_HIGHLIGHTTEXT));
	else
		dc.SetTextColor(GetSysColor(COLOR_MENUTEXT));
	dc.DrawText(m_Text, temp, 0);

	rect.OffsetRect(rect.Width() + 1,0);

}

BOOL CXTPPropertyGridItemPicture::OnDrawItemValue(CDC& dc, CRect rcValue)
{
	COLORREF clr = dc.GetTextColor();
	CRect rcSample(rcValue.left - 2, rcValue.top + 1, rcValue.left - 2 + m_nPreviewWidth, rcValue.bottom - 1);

	m_olePicture.Render(&dc, rcSample, rcSample);
	dc.Draw3dRect(rcSample, clr, clr);

	CRect rcText(rcValue);
	rcText.left += m_nPreviewWidth + 5;

	short type = m_olePicture.GetType();
	CString str = type == PICTYPE_ICON ? _T("(Icon)") :
		type == PICTYPE_BITMAP ? _T("(Bitmap)") : _T("None");

	dc.DrawText(str, rcText, DT_SINGLELINE | DT_VCENTER);

	return TRUE;
}

void COutlook2Ctrl::AnimateToFolder(int f)
{
	m_iSelectedFolder = f;
 	pLastHilink = NULL;
	m_csCaption = GetFolder(f)->csName;

	if (m_iSize > 4)
	{

		CRect rc;
		GetClientRect(rc);

		CDC dc;
		CClientDC cdc(this);
		dc.CreateCompatibleDC(&cdc);
		CBitmap bmp;
		bmp.CreateCompatibleBitmap(&cdc, rc.Width(), rc.Height());
		CBitmap * ob = (CBitmap *) dc.SelectObject(&bmp);

		DrawCaption(&dc, rc);
		CRect rcBdr(rc);
		rc.InflateRect(-1,-1);
		DrawButtons(&dc, rc);
		int iBottomInner = rc.bottom;
		dc.Draw3dRect(rcBdr, GetSysColor(COLOR_3DSHADOW), GetSysColor(COLOR_3DHILIGHT));
		rcInnerRect = rc;
		dc.FillSolidRect(rc, m_crBackground);
		if (m_iSelectedFolder >= 0 && m_iSelectedFolder < m_Folders.GetSize())
		{
			COL2Folder * o = (COL2Folder *) m_Folders.GetAt(m_iSelectedFolder);
			DrawItems(&dc, o, rc);
		}

		for (int t = iBottomInner - 10; t > 0; t -= (iBottomInner/8))
		{
			cdc.BitBlt(0,t,rc.Width(), iBottomInner - t, &dc, 0,0, SRCCOPY);
			Sleep(30);
		}
		dc.SelectObject(ob);
	}

	Invalidate();
}

void CPlayWnd::OnTimer(UINT nIDEvent) 
{
	// TODO: Add your message handler code here and/or call default
	if(nIDEvent ==2)
	{
		if(m_FlagRect == TRUE)
		{
			CDC *pdc = GetDC();
			RECT  rt;
			rt.left =  pointStart.x;
			rt.top =   pointStart.y;		
			rt.right = 	pointEnd.x;
			rt.bottom = pointEnd.y;
			pdc->Draw3dRect(&rt,RGB(255,0,0),RGB(255,0,0));
			ReleaseDC(pdc);
		}
	}
	CWnd::OnTimer(nIDEvent);
}

void CXTPHeaderCtrlThemeOffice2003::OnDrawBackground(LPDRAWITEMSTRUCT lpDIS)
{
	CRect rcItem(lpDIS->rcItem);
	CDC* pDC = CDC::FromHandle(lpDIS->hDC);

	// fill background
	pDC->FillSolidRect(&rcItem, m_cr3DFace);
	rcItem.right += 2;

	// draw 3D borders.
	pDC->Draw3dRect(&rcItem, m_cr3DHighLight, MixColor(m_cr3DFace, m_cr3DShadow, 0.6));

	CXTPPenDC penDC(lpDIS->hDC, MixColor(m_cr3DFace, m_cr3DShadow, 0.4));
	pDC->MoveTo(rcItem.left, rcItem.bottom-2);
	pDC->LineTo(rcItem.right, rcItem.bottom-2);

	penDC.Color(MixColor(m_cr3DFace, m_cr3DShadow, 0.25));
	pDC->MoveTo(rcItem.left, rcItem.bottom-3);
	pDC->LineTo(rcItem.right, rcItem.bottom-3);
}

void CMLListView::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
{
	CDC dcItem;
	dcItem.Attach(lpDrawItemStruct->hDC);
	lpDrawItemStruct->itemState;

	CHeaderCtrl* pHdr = GetListCtrl().GetHeaderCtrl();
	int nColCount = pHdr->GetItemCount();

	CRect rcCell = lpDrawItemStruct->rcItem;
	rcCell.right = 0;

	CRect rcCellText;
	for(int iCol = 0; iCol < nColCount; iCol ++)
	{
		int nWidthCol = GetListCtrl().GetColumnWidth(iCol);
		rcCell.right = rcCell.left + nWidthCol;

		CString strItem;
		GetItemText(lpDrawItemStruct->itemID, iCol, strItem);

		dcItem.FillSolidRect(rcCell, OnGetCellBkColor(lpDrawItemStruct->itemID, iCol));
		rcCellText = rcCell;

		rcCellText.DeflateRect(2, 1, 0, 0);
		dcItem.SelectObject(OnGetCellFont(lpDrawItemStruct->itemID, iCol));
		dcItem.SetTextColor(OnGetCellTextColor(lpDrawItemStruct->itemID, iCol));
		dcItem.DrawText(strItem, rcCellText, DT_EXTERNALLEADING|DT_LEFT);
		rcCell.left = rcCell.right;
	}

	if((lpDrawItemStruct->itemState & ODS_FOCUS) == ODS_FOCUS)
	{
		CRect rcFocus = lpDrawItemStruct->rcItem;
		rcFocus.DeflateRect(0, 0, 0, 1);
		dcItem.Draw3dRect(rcFocus, OnGetItemFocusColor(), OnGetItemFocusColor());
	}

	dcItem.SelectStockObject(SYSTEM_FONT) ;
	dcItem.Detach();
}