C++ CPaintDC::BitBlt方法代码示例

void CDataView::Render2D(CPaintDC& dc)
{
	CRect updateRect = dc.m_ps.rcPaint;


	int w = updateRect.Width();
	int h = updateRect.Height();

	int tx = updateRect.left;
	int ty = updateRect.top;
	
	int sx = std::max(0, GetScrollPos(SB_HORZ)) + tx;
	int sy = std::max(0, GetScrollPos(SB_VERT)) + ty;

#if 1
	dc.StretchBlt(
		tx, ty, w, h,
		m_memDC, sx/m_scale, sy/m_scale, w/m_scale, h/m_scale,
		SRCCOPY
		);
#else
	dc.BitBlt(
		tx,
		ty,
		w,
		h,
		m_memDC,
		sx,
		sy,
		SRCCOPY
	);
#endif
}

void CUsbtestDlg::ShowWave(CPaintDC& dc, RECT& rc)
{
    if (!m_buffer)
        return;

    CDC memDC;  //定义内存DC
    CBitmap memBitmap;
    CBitmap* pOldBmp = NULL;

    memDC.CreateCompatibleDC(&dc);
    memBitmap.CreateCompatibleBitmap(&dc, rc.right, rc.bottom);
    pOldBmp = memDC.SelectObject(&memBitmap);
    memDC.BitBlt(rc.left, rc.top, rc.right, rc.bottom, &dc, 0, 0, SRCCOPY);

    RECT rect;
    rect.top = rc.top + 30;
    rect.bottom = rc.bottom - 30;
    rect.left = rc.left + 2;
    rect.right = rc.right - 2;

    unsigned char* waveData = m_buffer;
    int len = waveSize;

    double step = (double)(rect.right - rect.left) / len;
    double scale = (double)(rect.bottom - rect.top) / (double)255;

    memDC.MoveTo(rect.left, rect.bottom - waveData[0] * scale);

    for (int i = 1; i < len; i++)
    {
        memDC.LineTo(rect.left + i*step, rect.bottom - waveData[i] * scale);
    }

    char str[10];
    sprintf_s(str, 10, "%d", curNo);

    memDC.TextOut(0, 0, CString(str));


    dc.BitBlt(rc.left, rc.top, rc.right, rc.bottom, &memDC, 0, 0, SRCCOPY);
    memDC.SelectObject(pOldBmp);
    memDC.DeleteDC();
    memBitmap.DeleteObject();
}

void CChildView::OnPaint() 
{
  CPaintDC *dc;
  CDC *pdc;
  CRgn ur;
  ur.CreateRectRgn(0, 0, 0, 0);
  GetUpdateRgn(&ur);

  CRect cr;
  GetClientRect(&cr);
  if (theApp.m_bStarted && !theApp.m_map.IsEmpty()) {
//    pdc = &dc;
    m_MemDC.SelectClipRgn(&ur);
    pdc = &m_MemDC;

    theApp.m_map.DrawMap(*pdc, &cr, &ur);

    CRect r;
//    r = cr;
    ur.GetRgnBox(r);
//    r.InflateRect(1, 1);
    if (r.left < 0)
      r.left = 0;
    if (r.top < 0)
      r.top = 0;
  	dc = new CPaintDC(this); // device context for painting
    dc->BitBlt(r.left, r.top, r.Width(), r.Height(), &m_MemDC, r.left, r.top, SRCCOPY);
  }
  else {
  	dc = new CPaintDC(this); // device context for painting
    if (theApp.m_bStarted) {
      dc->SetTextAlign(TA_CENTER);
      CPoint cp = cr.CenterPoint();
      CString s;
      s.Format("There are no maps in '%s'", theApp.m_map.m_sMapsPath);
      dc->ExtTextOut(cp.x, cp.y - dc->GetOutputTextExtent("W").cy/2, ETO_OPAQUE, &cr, s, NULL);
    }
    else {
      dc->FillSolidRect(cr, 0);
    }
  }
  delete dc;
}

void CGraphStatic::DrawData(CPaintDC& dc)
{
	CRect rect;
	CDC memdc;
	CBitmap   bmp;
	CBitmap *pOldBMP;
	CPen DataPen,*pOldPen;

	if(m_TotalPoint ==0)
		return;

	this->GetClientRect(&rect);
	bmp.CreateCompatibleBitmap(&dc, rect.Width(),rect.Height());   	

	DataPen.CreatePen(PS_SOLID,2, RGB(15, 255, 235));


	//Create compatibledc
	if(!memdc.CreateCompatibleDC(&dc))  
	{  
		TRACE("Can't create compatibaleDC\n");
		::PostQuitMessage(0);  
	}   
	pOldPen=memdc.SelectObject(&DataPen);
	pOldBMP = memdc.SelectObject(&bmp);   

	memdc.BitBlt(0,   0,  rect.Width(),   rect.Height(),   &dc,   0,   0,   SRCCOPY);  	

	int xorg = m_LeftOffset;
	int yorg = rect.Height()-m_BottomOffset;


	TRACE("xorg = %d,yorg = %d\n",xorg,yorg);
	memdc.SetViewportOrg(xorg,yorg);

	for(int i = 0;i<m_TotalPoint;i++)
	{
		this->DrawPixcel(memdc,i,m_pData[i]);	
	}


//Draw the average line
	double x0,y0;
	x0 = 0;
	y0 = m_Average;
	GetPoint(x0,y0);
	memdc.MoveTo(round(x0),round(y0));

//	int old_mode = memdc.SetBkMode(TRANSPARENT);
	COLORREF old_bkcolor = memdc.SetBkColor(RGB(255,255,0));
	COLORREF old_color = memdc.SetTextColor(RGB(255,0,255));
	memdc.TextOut(round(x0 - (m_LeftOffset - 10)) ,round(y0 - 12),"Avg.Temp");
//	memdc.SetBkMode(old_mode);
	memdc.SetTextColor(old_color);
	memdc.SetBkColor(old_bkcolor);

//	x0 = m_TotalPoint;
    x0 = m_MaxPoint - 1;
	y0 = m_Average;
	GetPoint(x0,y0);
	memdc.LineTo(round(x0),round(y0));

	dc.BitBlt(0,0,  rect.Width(),   rect.Height(),   &memdc,   -xorg,   -yorg,   SRCCOPY);  	

	memdc.SelectObject(pOldBMP);
	memdc.SelectObject(pOldPen);
	memdc.DeleteDC();

}

//.........这里部分代码省略.........
	memdc.FillSolidRect(&rect,  RGB(255,255,255));   

	
	TRACE(" DataLoggerGraph l=%d,t=%d,r=%d,b=%d\n",rect.left,rect.top,rect.right,rect.bottom);

	//adjust the offset
	m_RightOffset +=  (rect.Width() - m_LeftOffset- m_RightOffset)%m_XGrid;
	m_BottomOffset += (rect.Height()-m_TopOffset - m_BottomOffset)%m_YGrid;

	m_xpixel = rect.Width()-m_LeftOffset- m_RightOffset;
	TRACE("There are %d pixel x size\n",m_xpixel);

	m_ypixel = rect.Height()-m_TopOffset - m_BottomOffset;
	TRACE("There are %d pixel y size\n",m_ypixel);


	GridPen.CreatePen(PS_DASHDOTDOT, 1, RGB(255, 25, 5));
	pOldPen=memdc.SelectObject(&GridPen);


	memdc.Rectangle(&rect);

//Draw the horizontal line
	int x_start = m_LeftOffset;
	int y_start = m_TopOffset;
	int x_end = rect.Width() - m_RightOffset;
	int y_end = y_start;

	CString str1;
	CRect rect1;

    CString csText;
    int degree ;
	for( int i = 0;i<m_YGrid + 1;i++)
	{

		rect1.left = x_start - 30;
		rect1.top = y_start - 10;
		rect1.right = x_start;
		rect1.bottom = y_start + 30;
        
        degree = int(m_Min + ((m_YGrid - i) * 1.0 * (m_Max - m_Min))/m_YGrid);
        
        csText.Format("%d",degree);
//		memdc.DrawText(pFDegree[i],&rect1,DT_LEFT);
		memdc.DrawText(csText,&rect1,DT_LEFT);
        
		memdc.MoveTo(x_start,y_start);
		memdc.LineTo(x_end,y_end);

		rect1.left = x_end + 5;
		rect1.top = y_end  - 10;
		rect1.right = rect1.left + 30;
		rect1.bottom = rect1.top + 30;
//		memdc.DrawText(pCDegree[i],&rect1,DT_LEFT);
        degree = int((degree - 32.0) * 5.0/9.0);
        csText.Format("%d",degree);

        memdc.DrawText(csText,&rect1,DT_LEFT);

		y_start += (rect.Height() - m_TopOffset - m_BottomOffset)/m_YGrid;
		y_end = y_start;


	}
//Draw the vertical line

	x_start = m_LeftOffset;
	y_start = m_TopOffset;
	x_end = x_start;
	y_end = rect.Height() - m_BottomOffset;

	int xaxis_index;

	for(i = 0;i<m_XGrid + 1;i++)
	{
		memdc.MoveTo(x_start,y_start);
		memdc.LineTo(x_end,y_end);
		rect1.left = x_end - 5;
		rect1.top = y_end ;
		rect1.right = rect1.left + 30;
		rect1.bottom = rect1.top + 30;
		xaxis_index = GetXAxisCharsIndex();
		memdc.DrawText(XAXIS[xaxis_index][i],&rect1,DT_LEFT);
		x_start +=(rect.Width() - m_LeftOffset - m_RightOffset)/m_XGrid; 


		x_end = x_start;
	}

//	//Biblt the bitmap to orignal dc

	dc.BitBlt(0,   0,  rect.Width(),   rect.Height(),   &memdc,   0,   0,   SRCCOPY);  	
	memdc.SelectObject(pOldPen);

	memdc.SelectObject(pOldBMP);  

	memdc.DeleteDC();

}

//.........这里部分代码省略.........
	GetClientRect (rect);
	rect.DeflateRect (5, 5, 5, 5);

	if (pDoc->m_pStyle != NULL)
	{
		CCdCoverCreator2View* pView = (CCdCoverCreator2View*) pChild->GetActiveView ();
		if (pView == NULL)
			goto __end;

		int nHeight = (rect.Width () / 5) * 4;
		CRenderDC rdc (&dc, nHeight, pView->GetDocument ()->m_pStyle);

		m_y[Cover] = 5;
		m_y[Back] = m_y[Cover] + rdc.GetHeight (Cover) + 10;
		m_y[Inlay] = m_y[Back] + rdc.GetHeight (Back) + 10;
		m_y[Label] = m_y[Inlay] + rdc.GetHeight (Inlay) + 10;
		m_y[Booklet] = m_y[Label] + rdc.GetHeight (Label) + 10;

		if (m_bRedraw)
		{
			CLabelRenderer renderer (pDoc->m_pTracks, pDoc->m_pDataCDInfo,
				reinterpret_cast<CBackgroundInfo**> (&(pDoc->m_pBackground)),
				pDoc->m_listFloatingObjects, *(pDoc->m_pStyle));

			for (int i = 0; i < NUM_RENDER_TYPES - 1; i++)
			{
				if ((RenderType) i == Booklet)
					continue;

				CRect rectBmp (0, 0, rdc.GetWidth ((RenderType) i) + 5, /*nHeight*/(m_y[i + 1] - m_y[i]) + 5);

				m_Bitmap[i].DeleteObject ();
				m_Bitmap[i].CreateCompatibleBitmap (&dc, rectBmp.right, rectBmp.bottom);

				// render
				dcMem.SelectObject (&m_Bitmap[i]);
				dcMem.FillRect (rectBmp, &brush);

				renderer.Render (CRenderDC (&dcMem, nHeight, pDoc->m_pStyle), (RenderType) i, true);
			}

			m_bRedraw = false;
		}

		// draw the bitmaps
		int x[] = {
			(rect.Width () - rdc.GetWidth (Cover)) / 2 + 5,
			(rect.Width () - rdc.GetWidth (Back)) / 2 + 5,
			(rect.Width () - rdc.GetWidth (Inlay)) / 2 + 5,
			(rect.Width () - rdc.GetWidth (Label)) / 2 + 5,
			(rect.Width () - rdc.GetWidth (Cover)) / 2 + 5
		};

		dc.SetViewportOrg (x[Booklet], m_y[Booklet]);
		DrawBooklet (&dc, rdc.GetWidth (Cover), rdc.GetWidth (Cover) / 2, pDoc, pView->GetRenderType ());
		dc.SetViewportOrg (0, 0);

		CBrush* pOldBrush = dc.GetCurrentBrush ();

		for (int i = 0; i < NUM_RENDER_TYPES; i++)
		{
			CRect rectArea (rect.left, m_y[i], rect.right,
				m_y[i] + ((RenderType) i == Booklet ? rdc.GetWidth (Cover) / 2 : rdc.GetHeight ((RenderType) i)));

			if ((RenderType) i != Booklet)
			{
				dcMem.SelectObject (m_Bitmap[i]);

				if (pDoc->m_pStyle->m_bHasRenderType[i])
					dc.SelectStockObject (WHITE_BRUSH);
				else
				{
					dc.SetTextColor (RGB (0xff, 0xff, 0xff));
					dc.SetBkColor (RGB (0x7f, 0x7f, 0x7f));
					dc.SelectObject (dc.GetHalftoneBrush ());
				}

				//dc.BitBlt (x[i], m_y[i], rdc.GetWidth ((RenderType) i) + 5, /*nHeight*/(m_y[i + 1] - m_y[i]) + 5, &dcMem, 0, 0, MERGECOPY);
				dc.BitBlt (x[i], m_y[i], rectArea.Width (), rectArea.Height () + 4, &dcMem, 0, 0, MERGECOPY);
			}

			// marker
			Mark (&dc, rectArea, pView->GetRenderType () != (RenderType) i);
		}

		dc.SelectObject (pOldBrush);
	}

__end:

#ifdef PEROUTKA_FEDORISIN
	CBitmap* pOldBmp = (CBitmap*) dcMem.SelectObject (m_bmpLogo);
	dc.FillSolidRect (0, r.bottom - 32, 148, 32, RGB (0xff, 0xff, 0xff));
	dc.BitBlt ((148 - 80) / 2, r.bottom - 32, 80, 32, &dcMem, 0, 0, SRCCOPY);
//	dcMem.SelectObject (pOldBmp);
#endif

	dcMem.DeleteDC ();
	brush.DeleteObject ();
}

void CDataView::Render1D(CPaintDC& dc)
{
	if (m_values.size() == 0) {
		return;
	}
	const std::vector<double>& values = m_values;
	const DataSetting1D& dataSetting = dynamic_cast<const DataSetting1D&>(*m_pDataSetting);
	size_t dataCount = dataSetting.GetTotalBytes() / dataSetting.GetElementSize();
	
	double min = 0;
	double max = 0;
	if (dataSetting.viewAuto) {
		min = *std::min_element(values.begin(), values.begin()+dataCount);
		max = *std::max_element(values.begin(), values.begin()+dataCount);
	}else {
		min = EvalFormula(dataSetting.viewMinFormula);
		max = EvalFormula(dataSetting.viewMaxFormula);
	}
	
	CRect rect;
	GetClientRect(rect);
	rect.DeflateRect(60, 20, 20, 60);
	if (rect.bottom < 2 || rect.left < 2)
		return;
	
	double xa, xb, ya, yb;
	SolveSimultaneousLinearEquations<double>(
		0, rect.left,
		dataCount, rect.right,
		xa, xb
	);
	SolveSimultaneousLinearEquations<double>(
		min, rect.bottom,
		max, rect.top,
		ya, yb
	);
	
	typedef gl::fixed<8, unsigned char> ComponentT;
	typedef gl::Color4< gl::ColorBGRA<ComponentT> > ColorT;
	typedef gl::AdditiveColorBlender<ColorT, NumericT> ColorBlenderT;
	typedef gl::LineDrawer_Nelson<NumericT, ColorT, ColorBlenderT, SLOPE_CORR_TABLE_SIZE, FILTER_TABLE_SIZE> LineDrawerT;


	CRect updateRect = dc.m_ps.rcPaint;
	CRect unionRect;
	::UnionRect(unionRect, rect, updateRect);

	gl::Clipper<NumericT> clipper;
	clipper.SetClipRegion(unionRect.left, unionRect.top, unionRect.right, unionRect.bottom);

	gl::Buffer2D<ColorT>* pBuffer = (gl::Buffer2D<ColorT>*) gl::BuildBuffer2DFromBMP(m_bmi.bmiHeader, m_pBits);
	std::auto_ptr<gl::Buffer2D<ColorT> > autoDeleter(pBuffer);

	gl::Buffer2D_Fill(*pBuffer, ColorT(0));

	LineDrawerT ld(pBuffer);
	ld.SetFilterTable(g_filterTable);
	ld.SetSlopeCorrectionTable(g_slopeCorrTable);

	ColorT col(0.9,0.9,0.9);

	// frame
	ld.DrawLine(col, rect.left, rect.top, rect.right, rect.top);
	ld.DrawLine(col, rect.left, rect.bottom, rect.right, rect.bottom);
	ld.DrawLine(col, rect.left, rect.top, rect.left, rect.bottom);
	ld.DrawLine(col, rect.right, rect.top, rect.right, rect.bottom);

	// axis
	if (rect.bottom <= yb && yb <= rect.top) {
		ld.DrawLine(col, xb, yb, xa*dataCount+xb, yb);
	}
	
	// grid

	// lines
	double x1 = xb;
	double y1 = ya*values[0]+yb;
	for (size_t i=1; i<dataCount; ++i) {
		double x = xa*i+xb;
		double y = ya*values[i]+yb;
		double tx1 = x1;
		double ty1 = y1;
		double tx = x;
		double ty = y;
		int clipped = clipper.ClipLinePoint(&tx1, &ty1, &tx, &ty);
		if (clipped != -1)
			ld.DrawLine(col, tx1, ty1, tx, ty);
		x1 = x;
		y1 = y;
	}
	
	dc.BitBlt(
		updateRect.left,
		updateRect.top,
		updateRect.Width(),
		updateRect.Height(),
		m_memDC,
		updateRect.left,
		updateRect.top,
		SRCCOPY
//.........这里部分代码省略.........

////////////////////////////////////////////////////////////////////////////////
//#include "../../../code/image_proc/image/hsi.hpp"
bool
CColorAdjustDialog::DrawPreview(CPaintDC& dc, RECT* rect)
{
  if (!m_blit_tile || m_blit_tile->GetPixels() == NULL || rect == NULL) {
    return false;
  }
  /////////////////////////////////////////////////////////
  const int width  = m_blit_tile->GetWidth();
  const int height = m_blit_tile->GetHeight();
  int current_width = m_Width;
  if (current_width > width)
    current_width = width;
  int current_height = m_Height;
  if (current_height > height)
    current_height = height;
  BGRA* pixels = (BGRA*) m_blit_tile->GetPixels();
  for (int iy = 0; iy < current_height; iy++) {
    for (int ix = 0; ix < current_width; ix++) {
      pixels[iy * width + ix].red   = m_Pixels[iy * m_Width + ix].red;
      pixels[iy * width + ix].green = m_Pixels[iy * m_Width + ix].green;
      pixels[iy * width + ix].blue  = m_Pixels[iy * m_Width + ix].blue;
      pixels[iy * width + ix].alpha = m_Pixels[iy * m_Width + ix].alpha;
    }
  }
  /////////////////////////////////////////////////////////
  int red_value   = GetRedValue();
  int green_value = GetGreenValue();
  int blue_value  = GetBlueValue();
  int alpha_value = GetAlphaValue();
  int use_red   = ShouldUseRedChannel();
  int use_green = ShouldUseGreenChannel();
  int use_blue  = ShouldUseBlueChannel();
  int use_alpha = ShouldUseAlphaChannel();
  int method = 0;
  if (method == 0)
  {
    for (int iy = 0; iy < current_height; iy++) {
      for (int ix = 0; ix < current_width; ix++) {
        if (use_red)   pixels[iy * width + ix].red   += red_value;
        if (use_green) pixels[iy * width + ix].green += green_value;
        if (use_blue)  pixels[iy * width + ix].blue  += blue_value;
        if (use_alpha) pixels[iy * width + ix].alpha += alpha_value;
      }
    } 
  }
  /*
  else
  {
    double h_value = ((double)red_value   / (double)255.0) * ((double)2.0 * 3.14);
    double s_value = ((double)green_value / (double)255.0);
    double i_value = ((double)blue_value  / (double)255.0);
    for (int iy = 0; iy < current_height; iy++) {
      for (int ix = 0; ix < current_width; ix++) {
        double r = pixels[iy * width + ix].red   / 255.0;
        double g = pixels[iy * width + ix].green / 255.0;
        double b = pixels[iy * width + ix].blue  / 255.0;
        double h, s, i;
        RGBtoHSI(r, g, b, &h, &s, &i);
        if (use_red)   h += h_value;
        if (use_green) s += s_value;
        if (use_blue)  i += i_value;
        if (use_alpha) pixels[iy * width + ix].alpha += alpha_value;
        HSItoRGB(h, s, i, &r, &g, &b);
        pixels[iy * width + ix].red   = r * 255;
        pixels[iy * width + ix].green = g * 255;
        pixels[iy * width + ix].blue  = b * 255;
      }
    } 
  }
  */
  /////////////////////////////////////////////////////////
  dc.BitBlt(rect->left, rect->top, current_width, current_height, CDC::FromHandle(m_blit_tile->GetDC()), 0, 0, SRCCOPY);
  if (1) {
    rect->left += current_width;
    dc.FillRect(rect, CBrush::FromHandle((HBRUSH)GetStockObject(BLACK_BRUSH)));
    rect->left -= current_width;
    rect->top += current_height;
    dc.FillRect(rect, CBrush::FromHandle((HBRUSH)GetStockObject(BLACK_BRUSH)));
    rect->top -= current_height;
  }
  return true;
}