scope.cpp

示例随机数产生方法

	//画竖线
	for(i=1;i<=3;i++)
	{
		pDC->MoveTo(m_rectCurve.left+i*m_rectCurve.Width()/4,m_rectCurve.top);
		pDC->LineTo(m_rectCurve.left+i*m_rectCurve.Width()/4,m_rectCurve.bottom);
	}
	pDC->SelectClipRgn(NULL);
	pDC->SelectObject(pOldPen);

}
void CScope::DrawTrack(CDC *pDC,BOOL bPressed)
{
	CPen *pOldPen;
	pDC->FillRect(&m_rectScroll,&m_PanelBrush);
	pOldPen = pDC->SelectObject(&m_PenDarkLine);
	pDC->MoveTo(m_rectScroll.left,m_rectScroll.top);
	pDC->LineTo(m_rectScroll.left,m_rectScroll.bottom);
	pDC->MoveTo(m_rectScroll.left,m_rectScroll.top);
	pDC->LineTo(m_rectScroll.right,m_rectScroll.top);

	pDC->SelectObject(&m_PenBrightLine);
	pDC->MoveTo(m_rectScroll.right,m_rectScroll.top);
	pDC->LineTo(m_rectScroll.right,m_rectScroll.bottom);
	pDC->MoveTo(m_rectScroll.left,m_rectScroll.bottom);
	pDC->LineTo(m_rectScroll.right,m_rectScroll.bottom);
	pDC->SelectObject(pOldPen);

	CBitmap *pBmp;
	CDC dcMem;
	BITMAP bm;
	m_bitmapTrack.GetObject(sizeof(BITMAP),&bm);
	dcMem.CreateCompatibleDC(pDC);
	pBmp = dcMem.SelectObject(&m_bitmapTrack);
	int nPosY = (int)(m_nBase/(double)m_nRange*(m_rectScroll.Height()-bm.bmHeight))+m_rectScroll.top;
	if(bPressed)
		pDC->BitBlt(m_rectScroll.left,nPosY,bm.bmWidth,bm.bmHeight,&dcMem,0,0,NOTSRCCOPY);
	else
		pDC->BitBlt(m_rectScroll.left,nPosY,bm.bmWidth,bm.bmHeight,&dcMem,0,0,SRCCOPY);
	dcMem.SelectObject(pBmp);
}
void CScope::DrawAxis(CDC *pDC)
{
	CFont *pOldFont;
	int i,nPosY;
	CString str;
	pOldFont = pDC->SelectObject(&m_FontAxis);
	pDC->SetTextColor(RGB(255,255,0));
	pDC->SetBkMode(TRANSPARENT);
	pDC->SetTextAlign(TA_RIGHT|TA_BASELINE);
	int nCenterY = m_rectCurve.top+(int)((double)m_nBase/(double)m_nRange*m_rectCurve.Height());
	nPosY = nCenterY;
	if(nPosY<=m_rectCurve.top+10)
		nPosY += 10;
	if(m_dDimY<1)
		pDC->TextOut(m_rectCurve.left-2,nPosY,CString("0.0"));
	else
		pDC->TextOut(m_rectCurve.left-2,nPosY,CString("0"));
	
	for(i=1;i<=4;i++)
	{
		nPosY = nCenterY+i*m_rectCurve.Height()/4;
		if(nPosY<=m_rectCurve.bottom)
		{
			if(m_dDimY<1)
				str.Format("%.1f",-i*m_dDimY);
			else if(m_dDimY<1000)
				str.Format("%.0f",-i*m_dDimY);
			else
				str.Format("%.0fK",-i*m_dDimY/1000);
			pDC->TextOut(m_rectCurve.left-2,nPosY,str);
		}
	}

	for(i=1;i<=4;i++)
	{
		nPosY = nCenterY-i*m_rectCurve.Height()/4;
		if(nPosY>=m_rectCurve.top)
		{
			if(nPosY<=m_rectCurve.top+10)
				nPosY += 10;
			if(m_dDimY<1)
				str.Format("%.1f",i*m_dDimY);
			else if(m_dDimY<1000)
				str.Format("%.0f",i*m_dDimY);
			else
				str.Format("%.0fK",i*m_dDimY/1000);
			pDC->TextOut(m_rectCurve.left-2,nPosY,str);
		}
	}
	//横坐标
	pDC->SetTextAlign(TA_LEFT|TA_TOP);
	pDC->TextOut(m_rectCurve.left,m_rectCurve.bottom+2,CString("0.0"));
	pDC->SetTextAlign(TA_CENTER|TA_TOP);
	for(i=1;i<=3;i++)
	{
		str.Format("%.1f",i*m_dDimT);
		pDC->TextOut(m_rectCurve.left+i*m_rectCurve.Width()/4,m_rectCurve.bottom+2,str);
	}
	pDC->SetTextAlign(TA_RIGHT|TA_TOP);
	str.Format("%.1f",4*m_dDimT);
	pDC->TextOut(m_rectCurve.right,m_rectCurve.bottom+2,str);
	pDC->SelectObject(&pOldFont);
}

void CScope::OnLButtonUp(UINT nFlags, CPoint point) 
{
	CClientDC dc(this);
	ReleaseCapture();
	m_bPressed = FALSE;
	DrawTrack(&dc,m_bPressed);
	CStatic::OnLButtonUp(nFlags, point);
}

void CScope::OnLButtonDown(UINT nFlags, CPoint point) 
{
	
	if(m_rgnYPlus.PtInRegion(point))
	{
		if(m_dDimY>=1&&m_dDimY<10)
			m_dDimY+=1;
		if(m_dDimY>=10&&m_dDimY<100)
			m_dDimY+=10;
		if(m_dDimY>=100&&m_dDimY<1000)
			m_dDimY+=100;
		if(m_dDimY>=1000)
			m_dDimY+=1000;
		Invalidate();
	}
	if(m_rgnYMinus.PtInRegion(point))
	{
		if(m_dDimY>1&&m_dDimY<=10)
			m_dDimY-=1;
		if(m_dDimY>10&&m_dDimY<=100)
			m_dDimY-=10;
		if(m_dDimY>100&&m_dDimY<=1000)
			m_dDimY-=100;
		if(m_dDimY>1000)
			m_dDimY-=1000;
		if(m_dDimY<=1)
			m_dDimY=max(m_dDimY-0.1,0.1);
		Invalidate();
	}

	if(m_rgnTPlus.PtInRegion(point))
	{
		m_dDimT+=0.1;
		Invalidate();
	}
	if(m_rgnTMinus.PtInRegion(point))
	{
		m_dDimT=max(m_dDimT-0.1,0.1);
		Invalidate();
	}
	if(m_rectScroll.PtInRect(point))
	{
		SetCapture();
		m_bPressed = TRUE;
		m_nBase = (int)(((point.y-m_rectScroll.top+m_rectScroll.Height()/m_nRange/2)/(double)m_rectScroll.Height())*m_nRange);
		Invalidate();
	}
	CStatic::OnLButtonDown(nFlags, point);
}

void CScope::OnMouseMove(UINT nFlags, CPoint point) 
{
	CClientDC dc(this);
	if(m_rgnYPlus.PtInRegion(point)&&m_nArrowIndex !=0)
	{
		m_nArrowIndex =0;
		DrawArrow(&dc,m_nArrowIndex,TRUE);
	}
	if(m_rgnYMinus.PtInRegion(point)&&m_nArrowIndex !=1)
	{
		m_nArrowIndex =1;
		DrawArrow(&dc,m_nArrowIndex,TRUE);
	}
	if(m_rgnTPlus.PtInRegion(point)&&m_nArrowIndex !=2)
	{
		m_nArrowIndex =2;
		DrawArrow(&dc,m_nArrowIndex,TRUE);
	}
	if(m_rgnTMinus.PtInRegion(point)&&m_nArrowIndex !=3)
	{
		m_nArrowIndex =3;
		DrawArrow(&dc,m_nArrowIndex,TRUE);
	}
	if(!m_rgnYPlus.PtInRegion(point)&&
		!m_rgnYMinus.PtInRegion(point)&&
		!m_rgnTPlus.PtInRegion(point)&&
		!m_rgnTMinus.PtInRegion(point)&&
		m_nArrowIndex!=-1)
	{
		DrawArrow(&dc,m_nArrowIndex,FALSE);
		m_nArrowIndex = -1;	
	}
	if(m_bPressed)
	{
		int newBase = (int)(((point.y-m_rectScroll.top+m_rectScroll.Height()/m_nRange/2)/(double)m_rectScroll.Height())*m_nRange);
		if(newBase<0)
			newBase =0;
		if(newBase>m_nRange)
			newBase =m_nRange;
		if(newBase !=m_nBase )
		{
			m_nBase = newBase;
			DrawCurvePanel(&dc);
			DrawCurvePanel(&dc);
			DrawGrid(&dc);
			DrawCurve(&dc);

			DrawAxis(&dc);
			DrawTrack(&dc,m_bPressed);
			DrawArrow(&dc,0,FALSE);
			DrawArrow(&dc,1,FALSE);
			DrawArrow(&dc,2,FALSE);
			DrawArrow(&dc,3,FALSE);
		}

	}

	CStatic::OnMouseMove(nFlags, point);
}
void CScope::DrawArrow(CDC *pDC,int nIndex,BOOL bLighted)
{
	CBrush brush1(RGB(192,192,192)),brush2(RGB(0,255,0));
	switch(nIndex)
	{
	case 0:
		if(bLighted)
			pDC->FillRgn(&m_rgnYPlus,&brush2);
		else
			pDC->FillRgn(&m_rgnYPlus,&brush1);
		break;
	case 1:
		if(bLighted)
			pDC->FillRgn(&m_rgnYMinus,&brush2);
		else
			pDC->FillRgn(&m_rgnYMinus,&brush1);
		break;
	case 2:
		if(bLighted)
			pDC->FillRgn(&m_rgnTPlus,&brush2);
		else
			pDC->FillRgn(&m_rgnTPlus,&brush1);
		break;
	case 3:
		if(bLighted)
			pDC->FillRgn(&m_rgnTMinus,&brush2);
		else
			pDC->FillRgn(&m_rgnTMinus,&brush1);
		break;

	}

}
void CScope::DrawCurve(CDC *pDC)
{
	m_bDrawing = TRUE;
	int nSize = m_TimeList.size();

	POINT *pPointArray =(POINT *) new POINT[nSize];
	int i;
	
	std::list<double>::iterator time_it = m_TimeList.begin();
	std::list<double>::iterator value_it = m_ValueList.begin();
	std::list<double>::iterator time_begin = time_it;
	for(i=0;i<nSize;i++)
	{
		pPointArray[i].x = ConvertTimeToAxisX(*time_it-*time_begin);
		pPointArray[i].y = ConvertValueToAxisY(*value_it);
		time_it++;
		value_it++;
	}
	m_bDrawing =FALSE;
	CPen *pOldPen = pDC->SelectObject(&m_PenCurve);
	pDC->SelectClipRgn(&m_rgnCurve);
	pDC->Polyline(pPointArray,nSize);
	pDC->SelectClipRgn(NULL);
	pDC->SelectObject(pOldPen);
	
	delete []pPointArray;


	
	 
}
void CScope::UpdateCurve()
{
	
	CClientDC dc(this);
	CRect rect;
	GetClientRect(&rect);
	CDC memDC;
	memDC.CreateCompatibleDC(&dc);
	CBitmap bitmap,*pOldBmp;
	bitmap.CreateCompatibleBitmap(&dc,rect.Width(),rect.Height());
	pOldBmp = memDC.SelectObject(&bitmap);
	DrawGrid(&memDC);
	DrawCurve(&memDC);
	dc.BitBlt(m_rectCurve.left,m_rectCurve.top,m_rectCurve.Width(),m_rectCurve.Height(),&memDC,m_rectCurve.left,m_rectCurve.top,SRCCOPY);
	memDC.SelectObject(pOldBmp);
}

UINT CScope::OnNcHitTest(CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
	
	return HTCLIENT;
}
void CScope::AddValue(double dTime,double dValue)
{
	if(m_bDrawing)
		return;

	m_TimeList.push_back(dTime);
	m_ValueList.push_back(dValue);
	std::list<double>::iterator start_it = m_TimeList.begin();
	std::list<double>::iterator end_it = m_TimeList.end();
	end_it--;
	double dStartTime = *start_it;
	double dEndTime = *(end_it);
	while(dEndTime-dStartTime>4*m_dDimT)
	{
		m_TimeList.pop_front();
		m_ValueList.pop_front();
		
		start_it = m_TimeList.begin();
		end_it = m_TimeList.end();
		end_it--;

		dStartTime = *start_it;
		dEndTime = *(end_it);
	}
}

inline int CScope::ConvertTimeToAxisX(double dTime)
{
	int nReturn;
	nReturn = m_rectCurve.left+dTime/(4.0*m_dDimT)*m_rectCurve.Width();
	return nReturn;
}
inline int CScope::ConvertValueToAxisY(double dValue)
{
	int nReturn;
	int nCenterY  = m_rectCurve.top+(int)(m_nBase/(double)m_nRange*m_rectCurve.Height());

	nReturn = nCenterY - dValue/(4.0*m_dDimY)*m_rectCurve.Height();
	return nReturn;
}
void CScope::SetValueString(CString strTitle,CString strUnit)
{
	m_strValueName = strTitle;
	m_strUnitName = strUnit;
	Invalidate();
}
void CScope::Clear()
{
	m_TimeList.clear();
	m_ValueList.clear();
	UpdateCurve();
//	SetValue(0.0);
}