multicolorplotbtn.cpp

实时存储 "实时 "显示的功能.具体就是: 从机器的pci板子获得采集的数据,这些数据要实时保存到机器的阵列硬盘上 同时想在采集的过程中显示一下数据的波形. ////采集板的数据来到计算机内存

////////////////////////////////////  MulticolorPlotBtn.cpp  ////////////////////////////////////

#include "StdAfx.h"
#include ".\multicolorplotbtn.h"

#include "MemDC.h"


#define GRID_TIMER     1
//网格刷新速率
#define GRID_UPDATE_SPEED   50

typedef struct
{
 float fx ;
 float fy ;
} DATA_POINT ;
DATA_POINT * g_DataPoint ;


CMulticolorPlotBtn::CMulticolorPlotBtn()
: nPlotType(BAR)
, bfInit(false)
, nGridResolutionX(10)
, nGridResolutionY(10)
, nGridScrollSpeedX(-1)
, nGridScrollSpeedY(0)
, nPlotGranulatrity(2)
, nGridLineWidth(1)
, m_clrDarkBack(RGB(0,0,75))
, m_clrDarkLine(RGB(32,64,32))
, nPlotData(0)
, pfData(NULL)
, fLow(0.0)
, fHigh(100.0)
, fScaleY(1.0)
, m_clrCyanData(RGB(0,255,255))
, nGridStarPosX(0)
, nGridStarPosY(0)
, bLock(true)
, m_clrAxisScaleY(RGB(0,255,255))
, nShowFormatDataText(0)
, m_clrLinePen(RGB(0,255,0))
, nLineWidth(1)
{
 // 关键代码
 // 初始化关键代码的 C_S 结构
 InitializeCriticalSection ( & g_cs ) ;

 // 初始化标题
 _stprintf ( szTitls , _TEXT ( "%s" ) , _TEXT ( "" ) ) ;
 // 初始化单位
 _stprintf ( szUints , _TEXT ( "%s" ) , _TEXT ( "" ) ) ;
}

CMulticolorPlotBtn::~CMulticolorPlotBtn(void)
{
 if ( pfData )
 {
  delete [] pfData ;
 }

 // 释放关键代码
 DeleteCriticalSection ( & g_cs ) ;
}

BEGIN_MESSAGE_MAP(CMulticolorPlotBtn, CButton)
 ON_WM_TIMER()
END_MESSAGE_MAP()

void CMulticolorPlotBtn::PreSubclassWindow()
{
 // TODO: 在此添加专用代码和/或调用基类

 // 避免把该按钮当成下压式按钮
 ModifyStyle( 0 , BS_OWNERDRAW ) ;

 GetWindowRect ( & m_rect ) ;
 ScreenToClient ( & m_rect ) ;

 // 得到该控件的宽和高
 m_Size.cx = m_rect.right - m_rect.left ;
 m_Size.cy = m_rect.bottom - m_rect.top ;

 // 计算控件可容纳可见的数据点数
 nPlotData = m_Size.cx / nPlotGranulatrity ;

 // 设置控件上显示的文字的字体和大小
 m_SmallFont.CreateFont( -11 , 0 , 0 , 0 , FW_THIN , false , false , false , DEFAULT_CHARSET ,
  OUT_DEFAULT_divCIS , CLIP_DEFAULT_divCIS , DEFAULT_QUALITY , VARIABLE_PITCH , _TEXT( "Times New Roman" ) ) ;

 // 给实际数据分配内存
 pfData = new float [ nPlotData ] ;
 if ( pfData )
 {
  // 初始化数据为 0
  ZeroMemory ( pfData , sizeof ( pfData ) * nPlotData ) ;

  m_GridPen.CreatePen ( PS_SOLID , nGridLineWidth , m_clrDarkLine ) ;

  GetWindowRect ( & m_rect ) ;
  ScreenToClient ( & m_rect ) ;

  CRgn m_Rgn ;
  m_Rgn.CreateRoundRectRgn ( 0 , 0 , m_Size.cx , m_Size.cy , 10 , 10 ) ;

  SetWindowRgn ( ( HRGN ) m_Rgn , true ) ;

  SetTimer ( GRID_TIMER , GRID_UPDATE_SPEED , NULL ) ;
 }

 CButton::PreSubclassWindow();
}

void CMulticolorPlotBtn::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
{

 // TODO:  添加您的代码以绘制指定项
 ASSERT( lpDrawItemStruct != NULL ) ;

 CDC * pDC   = CDC::FromHandle( lpDrawItemStruct -> hDC ) ;

 // 创建内存 DC
 CMemDC * pMemDC = new CMemDC ( pDC ) ;

 // 得到控件大小
 RECT clipRect ;
 pMemDC->GetClipBox ( & clipRect ) ;

 if ( bfInit == false )
 {
  // 如果没有初始化，则初始化画刷
  CBitmap m_Bmp ;

  // 如果控件大小有效
  if ( clipRect.right - clipRect.left > 1 )
  {
   // 根据数据点分辨率创建内存位图
   m_Bmp.CreateCompatibleBitmap( pMemDC ,nPlotGranulatrity , m_Size.cy ) ;

   CBitmap * pOldBmp = pMemDC->SelectObject( & m_Bmp ) ;

   CSize m_BmpSize = m_Bmp.GetBitmapDimension () ;  

   // 根据不同的曲线分别绘制
   if ( nPlotType == BAR )    
   {
    double factor = 255.0 / ( float ) m_Size.cy ;

    BYTE r , g , b ;

    for ( int x = 0 ; x < m_Size.cy ; x ++ )
    {
     g = ( BYTE ) ( 255 - factor * x ) ;
     r = ( BYTE ) ( factor * x ) ;
     b = ( BYTE ) 64 ;

     pMemDC->SetPixelV ( 0 , x , RGB ( r , g , b ) ) ;
     pMemDC->SetPixelV ( 1 , x , RGB ( r , g , b ) ) ;
    }
   }
   else if ( nPlotType == LINE )
   {
   }
   else
   {
   }

   pMemDC->SelectObject ( pOldBmp ) ;

   // 生成位图画刷
   m_clrBrush.CreatePatternBrush ( & m_Bmp ) ;


   bfInit = true ;
  }
 }

 if ( bfInit )
 {
  // 填充背景色
  pMemDC->FillSolidRect ( & clipRect , m_clrDarkBack ) ;

  CFont * pOldFont ;

  //
  CPoint orgBrushOrigin = pMemDC->GetBrushOrg () ;

  // 画网格
  int nGridLinesX = m_Size.cx / nGridResolutionX ;
  int nGridLinesY = m_Size.cy / nGridResolutionY ;

  // 选择画笔
  CPen * pOldPen = pMemDC->SelectObject ( & m_GridPen ) ;

  // 创建垂直线
  for ( int x = 0 ; x <= nGridLinesX ; x ++ )
  {
   pMemDC->MoveTo ( x * nGridResolutionX + nGridStarPosX , 0   );
   pMemDC->LineTo ( x * nGridResolutionX + nGridStarPosX , m_Size.cy );
  }
  // 添加水平线
  for ( int y = 0 ; y <= nGridLinesY ; y ++ )
  {
   pMemDC->MoveTo ( 0   , nGridStarPosY + m_Size.cy - y * nGridResolutionY - 2 ) ;
   pMemDC->LineTo ( m_Size.cx , nGridStarPosY + m_Size.cy - y * nGridResolutionY - 2 ) ;
  }
  // 控制网格正确移动
  nGridStarPosX += nGridScrollSpeedX ;
  nGridStarPosY += nGridScrollSpeedY ;

  if ( nGridStarPosX < 0     ) nGridStarPosX = nGridResolutionX ;
  if ( nGridStarPosX > nGridResolutionX ) nGridStarPosX = 0 ;
  if ( nGridStarPosY < 0     ) nGridStarPosY = nGridResolutionY ;
  if ( nGridStarPosY > nGridResolutionY ) nGridStarPosY = 0 ;

  // 还原网格画笔
  pMemDC->SelectObject ( pOldPen ) ;

  // 用关键代码同步和SetData
  EnterCriticalSection ( & g_cs ) ;

  // 画数据
  float fx , fy ;
  if ( nPlotType == BAR )
  {
   RECT rFill ;

   for ( int nData = 0 ; nData < nPlotData ; nData ++ )
   {
    fx = ( float ) ( m_rect.left + nData * nPlotGranulatrity ) ;
    fy = fabs ( ( float ) ( m_rect.bottom - ( ( ( ( pfData[nData] - fLow ) / ( fHigh - fLow ) ) * m_Size.cy ) ) ) ) ;

    rFill.bottom = ( LONG ) m_rect.bottom ;
    rFill.top  = ( LONG ) fy ;
    rFill.left  = ( LONG ) fx ;
    rFill.right  = ( LONG ) ( fx + nPlotGranulatrity ) ;

    pMemDC->SetBrushOrg ( ( int ) fx , m_rect.bottom ) ;

    // 用初始化画刷时生成的渐变位图画刷填充矩形
    pMemDC->FillRect ( & rFill , & m_clrBrush ) ;
    // 画数据点处的颜色
    pMemDC->SetPixelV ( ( int ) fx , ( int ) fy , m_clrCyanData  ) ;

   }
  }
  else if ( nPlotType == LINE )
  {
   CPoint * g_DataPoint = new CPoint [nPlotData] ;

   // 创建曲线画笔
   CPen m_Pen ;
   m_Pen.CreatePen ( PS_SOLID , nLineWidth , m_clrLinePen ) ;
   CPen * m_pOldPen = pMemDC->SelectObject ( & m_Pen ) ;

   for ( int nData = 0 ; nData < nPlotData ; nData ++ )
   {
    g_DataPoint[nData].x  =  ( LONG ) ( m_rect.left + nData * nPlotGranulatrity ) ;
    g_DataPoint[nData].y  =  ( LONG ) fabs ( ( float ) ( m_rect.bottom - ( ( ( ( pfData[nData] - fLow ) / ( fHigh - fLow ) ) * m_Size.cy ) ) ) ) ;
   }

   pMemDC->Polyline ( g_DataPoint , nPlotData ) ;

   pMemDC->SelectObject ( m_pOldPen ) ;

   delete [] g_DataPoint ;


  }
  else
  {
  }


  // 绘制Y轴刻度
  TCHAR szAxisScaleYMax [MAX_PATH * sizeof ( TCHAR ) + 1] ;
  TCHAR szAxisScaleYMin [MAX_PATH * sizeof ( TCHAR ) + 1] ;
  TCHAR szAxisScaleY   [MAX_PATH * sizeof ( TCHAR ) + 1] ;

  ZeroMemory ( & szAxisScaleYMax  , sizeof ( szAxisScaleYMax ) ) ;
  ZeroMemory ( & szAxisScaleYMin  , sizeof ( szAxisScaleYMin ) ) ;
  ZeroMemory ( & szAxisScaleY   , sizeof ( szAxisScaleY  ) ) ;

  COLORREF clrText = pMemDC->GetTextColor () ;
  int nBkMode = pMemDC->GetBkMode () ;
  pMemDC->SetTextColor ( m_clrAxisScaleY ) ;
  pMemDC->SetBkMode ( TRANSPARENT ) ;

  pOldFont = pMemDC->SelectObject ( & m_SmallFont ) ;

  // 如果要求现实Y轴刻度数字
  switch ( nShowFormatDataText )
  {
  case 0 :    // 不显示
   {
   } break ;
  case 1 :    // 仅显示标题
   {
    _stprintf ( szAxisScaleYMax , _TEXT ( "%s" ) , szTitls ) ;

    pMemDC->TextOut ( 0 ,     0 , szAxisScaleYMax ) ;
   } break ;
  case 2 :    // 显示标题和流量比例
   {
    _stprintf ( szAxisScaleYMax , _TEXT ( "%s %8.1f %s / %8.1f" ) , szTitls , pfData [ nPlotData - 1 ] , szUints , fHigh ) ;

    pMemDC->TextOut ( 0 ,     0 , szAxisScaleYMax ) ;
   } break ;
  case 3 :    // 显示最大最小值
   {
    // 格式化最大值和标题及单位
    _stprintf ( szAxisScaleYMax , _TEXT ( "%s %8.1f %s / %8.1f" ) , szTitls , pfData [ nPlotData - 1 ] , szUints , fHigh ) ;
    // 格式化最小值
    _stprintf ( szAxisScaleYMin , _TEXT ( "%8.1f" ) , fLow ) ;

    pMemDC->TextOut ( 0 ,     0 , szAxisScaleYMax ) ;
    pMemDC->TextOut ( 0 , m_Size.cy - 10 , szAxisScaleYMin ) ;
   } break ;
  case 4 :    // 显示全部
   {
    // 格式化最大值和标题及单位
    _stprintf ( szAxisScaleYMax , _TEXT ( "%s %8.1f %s / %8.1f" ) , szTitls , pfData [ nPlotData - 1 ] , szUints , fHigh ) ;
    // 格式化最小值
    _stprintf ( szAxisScaleYMin , _TEXT ( "%8.1f" ) , fLow ) ;
    // 格式化中值
    _stprintf ( szAxisScaleY , _TEXT ( "%8.1f" ) , ( ( fHigh - fLow ) / 2.0 + fLow ) ) ;
    

    // 绘制Y轴刻度
    pMemDC->TextOut ( 0 ,     0 , szAxisScaleYMax ) ;
    pMemDC->TextOut ( 0 , m_Size.cy - 10 , szAxisScaleYMin ) ;
    pMemDC->TextOut ( 0 , m_Size.cy /  2 , szAxisScaleY  ) ;
   } break ;
 
  }

  pMemDC->SetTextColor ( clrText ) ;
  pMemDC->SetBkMode ( nBkMode ) ;
  pMemDC->SelectObject ( pOldFont ) ;

  // 离开关键代码
  LeaveCriticalSection ( & g_cs ) ;

  pMemDC->SetBrushOrg ( orgBrushOrigin.x , orgBrushOrigin.y ) ;
 }

 delete pMemDC ;

 ReleaseDC ( pDC ) ;
}


void CMulticolorPlotBtn::OnTimer(UINT nIDEvent)
{
 // TODO: 在此添加消息处理程序代码和/或调用默认值
 switch ( nIDEvent )
 {
 case GRID_TIMER :
  {
  } break ;
 }

 Invalidate ( false ) ;

 CButton::OnTimer(nIDEvent);
}

// BAR 颜色

void CMulticolorPlotBtn::SetBarColor ( COLORREF clrUp , COLORREF clrDown , bool bfRfastness ,
           bool bfGfastness , bool bfBfastness )
{
}

// 设置数据
void CMulticolorPlotBtn::SetData ( float fData )
{
 // 用关键代码同步
 EnterCriticalSection ( & g_cs ) ;

 for ( int n = 0 ; n < nPlotData - 1 ; n ++ )
 {
  pfData [ n ] = pfData [ n + 1 ] ;
 }

 pfData [ nPlotData - 1 ] = fData ;

 if ( bLock )       // 锁定比例范围
 {
 }
 else
 {
  // 保存最小值
  if ( fLow > fData )
  {
   fLow = fData ;
  }
  // 保存最大值
  if ( fHigh < fData )
  {
   fHigh = fData ;
  }
 }

 // 离开关键代码
 LeaveCriticalSection ( & g_cs ) ;
}

// 锁定数据显示范围
void CMulticolorPlotBtn::LockRang ( bool bfLock )
{
 bLock = bfLock ;
}

void CMulticolorPlotBtn::LockRang ( float fMin , float fMax )
{
 fLow = fMin ;
 fHigh = fMax ;

 LockRang ( true ) ;
}

////////////////////////////////////  end ////////////////////////////////////

/////////////////////////////  MemDC.h  ///////////////////////////////////////////////////

#if !defined(AFX_MEMDC_H__CA1D3541_7235_11D1_ABBA_00A0243D1382__INCLUDED_)
#define AFX_MEMDC_H__CA1D3541_7235_11D1_ABBA_00A0243D1382__INCLUDED_

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000

//////////////////////////////////////////////////
// CMemDC 实现一个内存DC

class CMemDC : public CDC
{
private:
    CBitmap  m_bitmap;      // 实际的bitmap
    CBitmap* m_pOldBitmap;  // 原先在CMemDC中的位图
    CDC*     m_pDC;         // 保存从构造函数中传来的CDC
    CRect    m_rect;        // 画的矩形区域
    BOOL     m_bMemDC;      // 如果CDC是一个内存DC，则为TRUE

public:

    CMemDC(CDC* pDC) : CDC()
    {
        ASSERT(pDC != NULL);

        m_pDC = pDC;
        m_pOldBitmap = NULL;
        m_bMemDC = !pDC->IsPrinting();//判断是否是一个内存DC
             
        if (m_bMemDC)    // 创建一个内存DC
        {
            pDC->GetClipBox(&m_rect);
            CreateCompatibleDC(pDC);
            m_bitmap.CreateCompatibleBitmap(pDC, m_rect.Width(), m_rect.Height());
            m_pOldBitmap = SelectObject(&m_bitmap);
            SetWindowOrg(m_rect.left, m_rect.top);
        }
        else  // 这不是一个内存DC，我们只拷贝相关的DC部分以备打印
        {
            m_bPrinting = pDC->m_bPrinting;
            m_hDC       = pDC->m_hDC;
            m_hAttribDC = pDC->m_hAttribDC;
        }
    }
  
    ~CMemDC()
    {
        if (m_bMemDC)
        {   
            // 拷贝实际的位图到屏幕上
            m_pDC->BitBlt(m_rect.left, m_rect.top, m_rect.Width(), m_rect.Height(),
                          this, m_rect.left, m_rect.top, SRCCOPY);
            //装入原始的位图
            SelectObject(m_pOldBitmap);
        }
  else
  {
            m_hDC = m_hAttribDC = NULL;
        }
    }

    // 允许作为指针
    CMemDC* operator->() {return this;}
    operator CMemDC*() {return this;}

};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio will insert additional declarations immediately before the divvious line.

#endif // !defined(AFX_MEMDC_H__CA1D3541_7235_11D1_ABBA_00A0243D1382__INCLUDED_)

////////////////////////////////////  end ////////////////////////////////////