// GraphicView.cpp : implementation of the CGraphicView class
//

#include "stdafx.h"
#include "Graphic.h"
//#include "Pegrpapi.h"
#include "GraphicDoc.h"
#include "GraphicView.h"
#include "math.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#include "CoolControlsManager.h"
#define GetRandom(min,max) ((rand()%(int)(((max)+1)-(min)))+(min))

/////////////////////////////////////////////////////////////////////////////
// CGraphicView

IMPLEMENT_DYNCREATE(CGraphicView, CView)

BEGIN_MESSAGE_MAP(CGraphicView, CView)
//{{AFX_MSG_MAP(CGraphicView)
ON_COMMAND(ID_DRAW_BAR, OnDrawBar)
ON_WM_ERASEBKGND()
ON_COMMAND(ID_DRAW_LINE, OnDrawLine)
ON_COMMAND(ID_DRAW_PIE, OnDrawPie)
ON_COMMAND(ID_DRAW_SCATTER, OnDrawScatter)
ON_COMMAND(ID_DRAW_WHISKER, OnDrawWhisker)
ON_COMMAND(ID_DRAW_STACKED_BAR, OnDrawStackedBar)
ON_COMMAND(ID_DRAW_XY_LINE, OnDrawXyLine)
ON_WM_TIMER()
ON_COMMAND(ID_DRAW_3D_BAR, OnDraw3dBar)
ON_COMMAND(ID_DRAW_3D_STACKED_BAR, OnDraw3dStackedBar)
ON_COMMAND(ID_DRAW_3D_LINE, OnDraw3dLine)
ON_COMMAND(ID_DRAW_3D_PIE, OnDraw3dPie)
ON_COMMAND(ID_BK_LINE, OnBkLine)
ON_COMMAND(ID_BK_XY, OnBkXy)
ON_COMMAND(ID_BK_AREA, OnBkArea)
ON_COMMAND(ID_BK_BAR, OnBkBar)
ON_COMMAND(ID_BK_BAR_GROUP, OnBkBarGroup)
ON_COMMAND(ID_BK_PIE, OnBkPie)
ON_COMMAND(ID_BUTTON32781, OnButton32781)
ON_WM_SIZE()
ON_COMMAND(ID_DRAW_NEW, OnDrawNew)
ON_COMMAND(ID_DRAW_SILE, OnDrawSile)
ON_COMMAND(ID_REAL, OnReal)
ON_COMMAND(ID_DRAWGRAPH, OnDrawgraph)
//}}AFX_MSG_MAP
// Standard printing commands
ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CGraphicView construction/destruction

CGraphicView::CGraphicView()
{
	// TODO: add construction code here
	m_nRealTimeCounter = 0;
	m_nSinCounter = 0;
}

CGraphicView::~CGraphicView()
{
}

BOOL CGraphicView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs
	
	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CGraphicView drawing

void CGraphicView::OnDraw(CDC* pDC)
{
	CGraphicDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	// TODO: add draw code for native data here
}

/////////////////////////////////////////////////////////////////////////////
// CGraphicView printing

BOOL CGraphicView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return DoPreparePrinting(pInfo);
}

void CGraphicView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add extra initialization before printing
}

void CGraphicView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add cleanup after printing
}

/////////////////////////////////////////////////////////////////////////////
// CGraphicView diagnostics

#ifdef _DEBUG
void CGraphicView::AssertValid() const
{
	CView::AssertValid();
}

void CGraphicView::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

CGraphicDoc* CGraphicView::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CGraphicDoc)));
	return (CGraphicDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CGraphicView message handlers

void CGraphicView::OnInitialUpdate() 
{
	CView::OnInitialUpdate(); 
	AfxGetApp()->GetMainWnd()->SetWindowText(_T("曲线显示完整版 V1.0"));
	GetCtrlManager().InstallHook();//使所有控件浮动
	//	OnDraw3dStackedBar();
	// TODO: Add your specialized code here and/or call the base class
	
}

void CGraphicView::OnDrawBar() 
{
	if(m_hPE)
	{
//		PEdestroy(m_hPE);
		Invalidate();
	}
	if(m_hPE)
		m_hPE=NULL;
	//! Right button click to show popup menu. //
	//! Double Click to show customization dialog. //
	
	// This example builds upon the basic CreateSimpleGraph '000' example chart //
	CreateSimpleGraph();
	
	// Below tells object to automatically generate statistical
	// comparison subsets, object will actually have
	// 6 subsets when finished initializing.
//	int nArray[2];
//	nArray[0] = PEAS_AVGAP;
//	nArray[1] = PEAS_AVGPP; 
///	PEvset (m_hPE, PEP_naAUTOSTATSUBSETS, nArray, 2);
	
	// Other various properties //
// 	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, TRUE);
// 	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_DARK_LINE);
// 	PEnset(m_hPE, PEP_nLEGENDSTYLE, PELS_1_LINE_INSIDE_AXIS);
// 	PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_BAR);
// 	PEnset(m_hPE, PEP_bMARKDATAPOINTS, TRUE); 
	
} 

void CGraphicView::CreateSimpleGraph()
{ 
	//! Right button click to show popup menu. //
	//! Double Click to show customization dialog. //
	//! Left-Click and drag to draw zoom box. Use popup memu or 'z' to undo zoom. // 
	
	// Simple example show the basics of a graph object. //
	// Graph's generally only contain YData because we assume
	// data is plotted equally spaced left to right.
	m_canReal=FALSE;
	CRect rect;
	GetClientRect( rect ); 
//	m_hPE = PEcreate(PECONTROL_GRAPH, WS_CHILD|WS_VISIBLE, &rect, m_hWnd, 1001);
// 	if (m_hPE) 
// 	{
// 		// Prepare images in memory //
// //		PEnset(m_hPE, PEP_bPREPAREIMAGES, TRUE);
// 		
// 		// Pass Data //
// 	//	PEnset(m_hPE, PEP_nSUBSETS, 4);
// 	//	PEnset(m_hPE, PEP_nPOINTS, 12);
// 		
// 		float fY;
// 		for (int s=0; s<=3; s++)
// 		{
// 			for (int p=0; p<=11; p++)
// 			{
// 				fY = float((p + 1) * 50) + GetRandom(2, 250);
// 				PEvsetcellEx(m_hPE, PEP_faYDATA, s, p, &fY);
// 			}
// 		}
		
		// Set DataShadows to show 3D //
// /		PEnset(m_hPE, PEP_nDATASHADOWS, PEDS_SHADOWS);
// 		PEnset(m_hPE, PEP_nBORDERTYPES, PETAB_DROP_SHADOW);
// 		
// 		PEszset(m_hPE, PEP_szMAINTITLE, "历史线性统计曲线");
// 		PEszset(m_hPE, PEP_szSUBTITLE, "程序设计与实现--戚高"); 
// 		PEszset(m_hPE, PEP_szYAXISLABEL, "最大应用量");
// 		PEszset(m_hPE, PEP_szXAXISLABEL, "月份");
// 		PEnset(m_hPE, PEP_bFOCALRECT, FALSE);
// 		PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_BAR);//现实类型
// 		PEnset(m_hPE, PEP_nGRIDLINECONTROL, PEGLC_NONE);//是否有X,Y
// 		PEnset(m_hPE, PEP_bALLOWRIBBON, TRUE);
//// 		PEnset(m_hPE, PEP_nALLOWZOOMING, PEAZ_HORZANDVERT);
//		PEnset(m_hPE, PEP_nZOOMSTYLE, PEZS_RO2_NOT);
// 		
		// subset labels //
// 		PEvsetcell( m_hPE, PEP_szaSUBSETLABELS, 0, "长沙" );
// 		PEvsetcell( m_hPE, PEP_szaSUBSETLABELS, 1, "上海" );
// 		PEvsetcell( m_hPE, PEP_szaSUBSETLABELS, 2, "北京" );
// 		PEvsetcell( m_hPE, PEP_szaSUBSETLABELS, 3, "广州" );
// 		
// 		// point labels //
// 		PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 0, "一月" );
// 		PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 1, "二月" );
// 		PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 2, "三月" );
// 		PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 3, "四月" );
// 		PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 4, "五月" );
// 		PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 5, "六月" );
// 		PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 6, "七月" );
// 		PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 7, "八月" );
// 		PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 8, "九月" );
// 		PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 9, "十月" );
// 		PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 10, "十一月" );
// 		PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 11, "十二月" );
// 		
// 		// subset colors //
// 		DWORD dwArray[4] = { RGB(198,0,0), RGB( 0, 198, 198 ), RGB( 198,198,0 ), RGB( 0,198,0 ) };
// 		PEvsetEx(m_hPE, PEP_dwaSUBSETCOLORS, 0, 4, dwArray, 0);
// 		
// 		// subset line types //
// 		int nLineTypes[] = { PELT_MEDIUMSOLID, PELT_MEDIUMSOLID, 
// 			PELT_MEDIUMSOLID, PELT_MEDIUMSOLID, PELT_MEDIUMSOLID, 
// 			PELT_MEDIUMSOLID, PELT_MEDIUMSOLID, PELT_MEDIUMSOLID};
// 		PEvset(m_hPE, PEP_naSUBSETLINETYPES, nLineTypes, 8);
// 		
// 		// subset point types //
// 		int nPointTypes[] = { PEPT_DOTSOLID, PEPT_UPTRIANGLESOLID, 
// 			PEPT_SQUARESOLID, PEPT_DOWNTRIANGLESOLID, PEPT_DOT, 
// 			PEPT_UPTRIANGLE, PEPT_SQUARE, PEPT_DOWNTRIANGLE };
// 		PEvset(m_hPE, PEP_naSUBSETPOINTTYPES, nPointTypes, 8);
// 		
// 		// Allow stacked type graphs //
// 		PEnset(m_hPE, PEP_bNOSTACKEDDATA, FALSE);
// 		
// 		// Various other features //
// 		PEnset(m_hPE, PEP_bFIXEDFONTS, TRUE);
// 		PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, TRUE);
// 		PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_MEDIUM_LINE);
// 		PEnset(m_hPE, PEP_bSIMPLEPOINTLEGEND, TRUE);
// 		PEnset(m_hPE, PEP_bSIMPLELINELEGEND, TRUE);
// 		PEnset(m_hPE, PEP_nLEGENDSTYLE, PELS_1_LINE);
// 		PEnset(m_hPE, PEP_nGRAPHPLUSTABLE, PEGPT_BOTH);
// 		
// 		PEnset(m_hPE, PEP_nGRADIENTBARS, 8);
// 		PEnset(m_hPE, PEP_nTEXTSHADOWS, PETS_BOLD_TEXT);
// 		PEnset(m_hPE, PEP_bMAINTITLEBOLD, TRUE);
// 		PEnset(m_hPE, PEP_bSUBTITLEBOLD, TRUE);
// 		PEnset(m_hPE, PEP_bLABELBOLD, TRUE);
// 		PEnset(m_hPE, PEP_bLINESHADOWS, TRUE);
// 		PEnset(m_hPE, PEP_nFONTSIZE, PEFS_LARGE);
// 		
// 	}
}

BOOL CGraphicView::OnEraseBkgnd(CDC* pDC) 
{
	return TRUE;
}

void CGraphicView::OnDrawLine() 
{ 
	if(m_hPE)
	{
//		PEdestroy(m_hPE);
		Invalidate();
	}
	if(m_hPE)
		m_hPE=NULL;
	CreateSimpleGraph();  
	int nArray[2];
//	nArray[0] = PEAS_AVGAP;
//	nArray[1] = PEAS_AVGPP; 
//	PEvset (m_hPE, PEP_naAUTOSTATSUBSETS, nArray, 2); 
// 	nArray[0] = 4;  // fourth subset
// 	nArray[1] = 5;  // fifth subset
// 	PEvset(m_hPE, PEP_naRANDOMSUBSETSTOGRAPH, nArray, 2); 
// 	PEnset(m_hPE, PEP_nSCROLLINGSUBSETS, 1);
// 	PEnset(m_hPE, PEP_nTABLEWHAT, PETW_ALLSUBSETS); 
// 	PEnset(m_hPE, PEP_nGRAPHPLUSTABLE, PEGPT_BOTH);
// 	PEnset(m_hPE, PEP_nDATAPRECISION, 0);
// 	PEnset(m_hPE, PEP_nFONTSIZE, PEFS_LARGE); 
// 	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, TRUE);
// 	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_MEDIUM_NO_BORDER);
// 	PEnset(m_hPE, PEP_nLEGENDSTYLE, PELS_1_LINE_INSIDE_AXIS);
// 	PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_BAR);
// 	PEnset(m_hPE, PEP_nBESTFITDEGREE, PEBFD_4TH);
// 	PEnset(m_hPE, PEP_bMARKDATAPOINTS, TRUE);
// 	PEnset(m_hPE, PEP_nLEGENDSTYLE, PELS_1_LINE);  
}



void CGraphicView::OnDrawPie() 
{
	if(m_hPE)
	{
//		PEdestroy(m_hPE);
		Invalidate();
	}
	// This example builds upon the basic CreateSimpleGraph '000' example chart //
	CreateSimpleGraph();
	
	// Disable default scale //
////	PEnset(m_hPE, PEP_nSHOWYAXIS, PESA_EMPTY);
	
// 	// Generally, a custom y axis will need manual range control //
// 	PEnset(m_hPE, PEP_nMANUALSCALECONTROLY, PEMSC_MINMAX);
// 	
// 	double manminY = 0.0F;
// 	PEvset(m_hPE, PEP_fMANUALMINY, &manminY, 1);
// 	
// 	double manmaxY = 1000.0F;
// 	PEvset(m_hPE, PEP_fMANUALMAXY, &manmaxY, 1);
// 	
	// Create custom grid lines with HorzLineAnnotations //
// 	// Note that GridLineControl will control these annotations //
// 	double horzlineannot = 200.0F;
// 	PEvsetcell(m_hPE, PEP_faHORZLINEANNOTATION, 0, &horzlineannot);
// 	int horzlinetyp = PELAT_GRIDLINE;
// 	PEvsetcell(m_hPE, PEP_naHORZLINEANNOTATIONTYPE, 0, &horzlinetyp);
// 	PEvsetcell(m_hPE, PEP_szaHORZLINEANNOTATIONTEXT, 0, "|LLow Value");
// 	
// 	horzlineannot = 500.0F;
// 	PEvsetcell(m_hPE, PEP_faHORZLINEANNOTATION, 1, &horzlineannot);
// 	horzlinetyp = PELAT_GRIDLINE;
// 	PEvsetcell(m_hPE, PEP_naHORZLINEANNOTATIONTYPE, 1, &horzlinetyp);
// 	PEvsetcell(m_hPE, PEP_szaHORZLINEANNOTATIONTEXT, 1, "|LMedium Value");
// 	
// 	horzlineannot = 800.0F;
// 	PEvsetcell(m_hPE, PEP_faHORZLINEANNOTATION, 2, &horzlineannot);
// 	horzlinetyp = PELAT_GRIDLINE;
// 	PEvsetcell(m_hPE, PEP_naHORZLINEANNOTATIONTYPE, 2, &horzlinetyp);
// 	PEvsetcell(m_hPE, PEP_szaHORZLINEANNOTATIONTEXT, 2, "|LHigh Value");
// 	
// 	horzlineannot = 350.0F;
// 	PEvsetcell(m_hPE, PEP_faHORZLINEANNOTATION, 3, &horzlineannot);
// 	horzlinetyp = PELAT_GRIDTICK;
// 	PEvsetcell(m_hPE, PEP_naHORZLINEANNOTATIONTYPE, 3, &horzlinetyp);
// 	PEvsetcell(m_hPE, PEP_szaHORZLINEANNOTATIONTEXT, 3, "");
// 	
// 	horzlineannot = 650.0F;
// 	PEvsetcell(m_hPE, PEP_faHORZLINEANNOTATION, 4, &horzlineannot);
// 	horzlinetyp = PELAT_GRIDTICK;
// 	PEvsetcell(m_hPE, PEP_naHORZLINEANNOTATIONTYPE, 4, &horzlinetyp);
// 	PEvsetcell(m_hPE, PEP_szaHORZLINEANNOTATIONTEXT, 4, "");
// 	
// 	// Set LeftMargin to allocate space for line annotation text //
// 	// Use the longest string used in annotations.
// 	PEszset(m_hPE, PEP_szLEFTMARGIN, "Medium Value ");
// 	
// 	// Set this to see annotations //
// 	PEnset(m_hPE, PEP_bSHOWANNOTATIONS, TRUE);
// 	
// 	// Increase line annotation text size //
// 	PEnset(m_hPE, PEP_nLINEANNOTATIONTEXTSIZE, 100);
// 	
// 	// Put Grid In Front of Bars //
// 	PEnset(m_hPE, PEP_bGRIDINFRONT, TRUE);
// 	
// 	// Other various properties //
// 	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, TRUE);
// 	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_LIGHT_INSET);
	
}


void CGraphicView::OnDrawScatter() 
{ 
	if(m_hPE)
	{
//		PEdestroy(m_hPE);
		Invalidate();
	}
	CreateSimpleGraph(); 
	DWORD color; 
	for (int s=0;s<=3;s++)  //4-1
	{    
		for (int p=0;p<=11;p++)
		{
			switch(s)
			{    
			case 0:
				color = RGB(15 + ((p + 1) * 20), 0, 0);  
//				PEvsetcellEx(m_hPE, PEP_dwaPOINTCOLORS, s, p, &color);
				break;
			case 1:
				color = RGB(0, 15 + ((p + 1) * 20), 0);
			//	PEvsetcellEx(m_hPE, PEP_dwaPOINTCOLORS, s, p, &color);
				break;
			case 2:
				color =  RGB(0, 0, 15 + ((p + 1) * 20));
			///*	*/	PEvsetcellEx(m_hPE, PEP_dwaPOINTCOLORS, s, p, &color);
				break;
			case 3:
				color = RGB(0, 15 + ((p + 1) * 20), 15 + ((p + 1) * 20));
			//	PEvsetcellEx(m_hPE, PEP_dwaPOINTCOLORS, s, p, &color);
				break;
			default:
				break;
			}
		}
	} 
	color = RGB(198, 0, 0);
//	PEvsetcell(m_hPE, PEP_dwaSUBSETCOLORS, 0, &color); 
// 	color = RGB(0, 198, 0);
// 	PEvsetcell(m_hPE, PEP_dwaSUBSETCOLORS, 1, &color); 
// 	color = RGB(0, 0, 198);
// 	PEvsetcell(m_hPE, PEP_dwaSUBSETCOLORS, 2, &color); 
// 	color = RGB(0, 198, 198);
// 	PEvsetcell(m_hPE, PEP_dwaSUBSETCOLORS, 3, &color); 
// 	PEnset(m_hPE, PEP_nSCROLLINGSUBSETS, 1);
// 	PEnset(m_hPE, PEP_nTABLEWHAT, PETW_ALLSUBSETS);
// 	PEnset(m_hPE, PEP_nFONTSIZE, PEFS_LARGE); 
// 	PEnset(m_hPE, PEP_dwGRAPHBACKCOLOR, 1);
// 	PEnset(m_hPE, PEP_nGRAPHGRADIENTSTYLE, 0); 
// 	PEnset(m_hPE, PEP_dwSHADOWCOLOR, RGB(0, 0, 0)); 
// 	PEnset(m_hPE, PEP_nGRAPHPLUSTABLE, PEGPT_BOTH);
// 	PEnset(m_hPE, PEP_nDATAPRECISION, 0); 
// 	PEnset(m_hPE, PEP_nFORCEVERTICALPOINTS, PEFVP_SLANTED); 
// 	PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_BAR);
// 	PEnset(m_hPE, PEP_nBORDERTYPES, PETAB_NO_BORDER); 
}

void CGraphicView::OnDrawWhisker() 
{ 
	if(m_hPE)
	{
//		PEdestroy(m_hPE);
		Invalidate();
	}
	//! Try this... Right Click chart and change the Plotting Method to Horizontal Bar Stacked. //
	
	// This example builds upon the basic CreateSimpleGraph '000' example chart //
	CreateSimpleGraph();
	
// 	// Enable Stacked type charts //
// 	PEnset(m_hPE, PEP_bNOSTACKEDDATA, FALSE);
// 	
// 	// Set plotting method //
// 	PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_BARSTACKED);
// 	
// 	// Add a table //
// 	PEnset(m_hPE, PEP_nGRAPHPLUSTABLE, PEGPT_BOTH);
// 	PEnset(m_hPE, PEP_nDATAPRECISION, 2);
// 	
// 	PEnset(m_hPE, PEP_bALLOWHORZBARSTACKED, TRUE);
// 	
}


void CGraphicView::OnDrawStackedBar() 
{ 
	if(m_hPE)
	{
//		PEdestroy(m_hPE);
		Invalidate();
	}
	//! Right button click to show popup menu. //
	//! Double Click to show customization dialog. //
	//! Left-Click and drag to draw zoom box. Use popup memu or 'z' to undo zoom. // 
	
	// This example builds upon the basic CreateSimpleGraph '000' example chart //
	CreateSimpleGraph();
	
// 	// Now sub-divide subsets into 4 individual axes //
// 	// Each axis with one subset in each //
// 	int nArray[4] = {1,1,1,1};
// 	PEvset (m_hPE, PEP_naMULTIAXESSUBSETS, nArray, 4);
// 	
// 	// Set first axis parameters //
// 	PEnset(m_hPE, PEP_nWORKINGAXIS, 0);
// 	PEszset(m_hPE, PEP_szYAXISLABEL, "标度1");
// 	PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_BAR);
// 	
// 	// Set second axis parameters //
// 	PEnset(m_hPE, PEP_nWORKINGAXIS, 1);
// 	PEszset(m_hPE, PEP_szYAXISLABEL, "标度2");
// 	PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_BAR);
// 	
// 	// Set third axis parameters //
// 	PEnset(m_hPE, PEP_nWORKINGAXIS, 2);
// 	PEszset(m_hPE, PEP_szYAXISLABEL, "标度3");
// 	PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_BAR);
// 	
// 	// Set fourth axis parameters //
// 	PEnset(m_hPE, PEP_nWORKINGAXIS, 3);
// 	PEszset(m_hPE, PEP_szYAXISLABEL, "标度4");
// 	PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_BAR);
// 	
// 	// Reset WorkingAxis when done //
// 	PEnset(m_hPE, PEP_nWORKINGAXIS, 0);
// 	
// 	// Add Axis Separator //
// 	PEnset(m_hPE, PEP_nMULTIAXESSEPARATORS, PEMAS_THICKPLUSTICK);
// 	
// 	// Axis Sizing //
// 	PEnset(m_hPE, PEP_nMULTIAXESSIZING, TRUE);
// 	
// 	// Get rid of 3d stuff //
// 	PEnset(m_hPE, PEP_nDATASHADOWS, PEDS_NONE);
// 	
// 	// Other various properties //
// 	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, TRUE);
// 	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_DARK_NO_BORDER);
// 	PEnset(m_hPE, PEP_bMARKDATAPOINTS, TRUE);
// 	
}


void CGraphicView::OnDrawXyLine() 
{
	if(m_hPE)
	{
//		PEdestroy(m_hPE);
		Invalidate();
	}
	RECT rect;
	GetClientRect( &rect );
	
	m_canReal=TRUE; 
	m_Real=TRUE;
// 	
// 	char szSubsets[] = "电流\t电压\t频率\t";
// 	PEvset (m_hPE, PEP_szaSUBSETLABELS, szSubsets, 3);
// 
// 	// Set Various Other Properties ///
// 	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, TRUE);
// 	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_DARK_INSET);
// 	
// 	m_hPE = PEcreate(PECONTROL_GRAPH, WS_VISIBLE, &rect, m_hWnd, 1001);
// 	PEnset(m_hPE, PEP_bPREPAREIMAGES, TRUE);
// 	PEnset(m_hPE, PEP_bCACHEBMP, TRUE); 
// 	PEnset(m_hPE, PEP_nSUBSETS, 2);		// set number of subsets
// 	PEnset(m_hPE, PEP_nPOINTS, 200);	// number of data points	
// 	PEnset(m_hPE, PEP_nPOINTSTOGRAPH, 20);
// 	PEnset(m_hPE, PEP_nPOINTSTOGRAPHINIT, PEPTGI_LASTPOINTS);	   		
// 	PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_POINTSPLUSLINE);	  
// 	PEszset(m_hPE, PEP_szMAINTITLE, "实时曲线示例");
// 	PEszset(m_hPE, PEP_szSUBTITLE, "编程设计实现-戚高"); // no subtitle
// 	PEnset(m_hPE, PEP_nMANUALSCALECONTROLY, PEMSC_MINMAX);
// 	double manminY = 1.0F;
// 	PEvset(m_hPE, PEP_fMANUALMINY, &manminY, 1);
// 	double manmaxY = 100.0F;
// 	PEvset(m_hPE, PEP_fMANUALMAXY, &manmaxY, 1);
// 	PEszset(m_hPE, PEP_szMANUALMAXPOINTLABEL, "000.000" );
// 	PEszset(m_hPE, PEP_szMANUALMAXDATASTRING, "00:00:00xx");
// 	PEnset(m_hPE, PEP_bNOSTACKEDDATA, TRUE); 
// 	PEnset(m_hPE, PEP_bNORANDOMPOINTSTOGRAPH, TRUE);
// 	PEnset(m_hPE, PEP_bALLOWHISTOGRAM, FALSE);	
// 	PEnset(m_hPE, PEP_bFOCALRECT, FALSE);
// 	PEnset(m_hPE, PEP_nGRIDLINECONTROL, FALSE);
// 	PEnset(m_hPE, PEP_nDATAPRECISION, 1);									  
// 	PEszset(m_hPE, PEP_szaPOINTLABELS, "");
// 	float f1 = 0.0F;
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 0, 0, &f1);
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 0, 1, &f1);
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 0, 2, &f1);
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 0, 3, &f1);
// 	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, FALSE);
// 	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_LIGHT_SHADOW);
// 	PEnset(m_hPE, PEP_bFIXEDFONTS, TRUE);
// 	PEnset(m_hPE, PEP_nTEXTSHADOWS, PETS_BOLD_TEXT);
// 	PEnset(m_hPE, PEP_bMAINTITLEBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bSUBTITLEBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bLABELBOLD, TRUE);
//	PEnset(m_hPE, PEP_nFONTSIZE, PEFS_LARGE); 
}			


void CGraphicView::OnTimer(UINT nIDEvent) 
{ 
	CString ttext;  
	double newx2;
	float YData[250];
	double XData[250]; 
	double dx; 
	CTime t;
/////	TM petm; 
	if(m_canReal)
	{
		if(nIDEvent==2)
		{
			if(m_Real)
			{
				float newy = 50.0F + float(sin((double) m_nSinCounter * 0.075F) * 30.0F) + GetRandom(1, 15);
				float newy1,newy2;
				newy1 = 50.0F - float(sin((double) m_nSinCounter * 0.075F) * 30.0F) + GetRandom(1, 15);
				newy2 = 50.0F + float(sin((double) m_nSinCounter * 0.075F) * 30.0F) - GetRandom(1, 15);
				// Determine newx2 as current date and time in VB format //
				t = CTime::GetCurrentTime();
// /				petm.nDay = t.GetDay();
// 				petm.nMonth = t.GetMonth();
// 				petm.nYear = t.GetYear() - 1900;
// 				petm.nHour = t.GetHour();
// 				petm.nMinute = t.GetMinute();
// 				petm.nSecond = t.GetSecond();
// 				PEcreateserialdate(&newx2, &petm, PEDTM_VB);
				
				// Shift data when counter reaches end of data //
				if(m_nRealTimeCounter >= 1999)
				{
					memset(YData, 0, 250 * sizeof(float));
					memset(XData, 0, 250 * sizeof(double));
					// Shift Data by 250 data points, oldest 250 will be lost.
					m_nRealTimeCounter = m_nRealTimeCounter - 250;
// 					PEvset(m_hPE, PEP_faAPPENDYDATA, YData, 250);
// 					PEvset(m_hPE, PEP_faAPPENDXDATAII, XData, 250);
				}
				
				// Store new values at current index //
// 				PEvsetcellEx(m_hPE, PEP_faXDATAII, 0, m_nRealTimeCounter, &newx2);
// 				PEvsetcellEx(m_hPE, PEP_faYDATA, 0, m_nRealTimeCounter, &newy);
// 				
// 				// Store new values at current index //
// 				PEvsetcellEx(m_hPE, PEP_faXDATAII, 1, m_nRealTimeCounter, &newx2);
// 				PEvsetcellEx(m_hPE, PEP_faYDATA, 1, m_nRealTimeCounter, &newy1);
// 				
// 				// Store new values at current index //
// 				PEvsetcellEx(m_hPE, PEP_faXDATAII, 2, m_nRealTimeCounter, &newx2);
// 				PEvsetcellEx(m_hPE, PEP_faYDATA, 2, m_nRealTimeCounter, &newy2);
				
				// Increment index counter //
				m_nRealTimeCounter += 1;
				
				// SinCounter is only to produce sin wave data //
				m_nSinCounter += 1;
				if (m_nSinCounter > 30000) 
					m_nSinCounter = 1;
				
				// If current time is beyond zoom max, the re-adjust zoom max //
				if (newx2 > ZoomEnd)
				{
					ZoomEnd = ZoomEnd + ZoomSmallInterval;
					ZoomStart = ZoomEnd - ZoomInterval;
// 					PEvset(m_hPE, PEP_fZOOMMINX, &ZoomStart, 1);
// 					PEvset(m_hPE, PEP_fZOOMMAXX, &ZoomEnd, 1);
// 					
// 					PEvgetcellEx(m_hPE, PEP_faXDATAII, 0, 1, &dx);
// 					PEvset(m_hPE, PEP_fMANUALMINX, &dx, 1);
// 					PEvset(m_hPE, PEP_fMANUALMAXX, &ZoomEnd, 1);
				}
				
// 				// Update image and force paint //
// 				PEreinitialize( m_hPE );
// 				PEresetimage( m_hPE, 0, 0 );
				::InvalidateRect(m_hPE, NULL, FALSE);
			}
		}
		else
		{
			if(m_Real)
			{
				/*PEvset(m_hPE, PEP_szaAPPENDPOINTLABELDATA, NULL, 1);
				
				// make some random data //
				float r1,r2,fNew[2];
				r1 = (float) GetRandom(1, 20);
				r2 = (float) GetRandom(1, 100);
				
				fNew[0] = r1 + (r2 * .0001F);
				fNew[1] = fNew[0] * 4;
				PEvset(m_hPE, PEP_faAPPENDYDATA, &fNew[0], 1);*/
				///////////////////////////////////  
				float newy = 50.0F + float(sin((double) m_nSinCounter * 0.075F) * 30.0F) + GetRandom(1, 15);
				float newx = (float)m_nRealTimeCounter; 
				
// 				// Append new values  //
// 				PEvset(m_hPE, PEP_faAPPENDYDATA, &newy, 1);
// 				PEvset(m_hPE, PEP_faAPPENDXDATA, &newx, 1); 
// 				m_nRealTimeCounter = m_nRealTimeCounter + 1;
// 				
// 				// Switch to AutoScaling x axis after receiving 100 data points //
// 				if (m_nRealTimeCounter == 100)
// 					PEnset(m_hPE, PEP_nMANUALSCALECONTROLX, PEMSC_NONE);
// 				
				// SinCounter is only to produce sin wave data //
				m_nSinCounter = m_nSinCounter + 1;
				if (m_nSinCounter > 30000) 
					m_nSinCounter = 1;
				
				// Update image and force paint //
//				PEreinitialize( m_hPE );
	//			PEresetimage( m_hPE, 0, 0 );
				::InvalidateRect(m_hPE, NULL, FALSE);
			}
			else
			{
				////**********************************************
				float newy,newx;
				newy = 50.0F + float(sin((double) m_nSinCounter * 0.075F) * 30.0F) + GetRandom(1, 15);
				newx = float(m_nRealTimeCounter);
// 				
// 				// Update new data at current index //
// 				PEvsetcellEx(m_hPE, PEP_faYDATA, 0, m_nRealTimeCounter, &newy);
// 				PEvsetcellEx(m_hPE, PEP_faXDATA, 0, m_nRealTimeCounter, &newx);
// 				newy = 50.0F - float(sin((double) m_nSinCounter * 0.075F) * 30.0F) + GetRandom(1, 15);
// 				newx = float(m_nRealTimeCounter);
// 				PEvsetcellEx(m_hPE, PEP_faYDATA, 1, m_nRealTimeCounter, &newy);
// 				PEvsetcellEx(m_hPE, PEP_faXDATA, 1, m_nRealTimeCounter, &newx);
// 				newy = 50.0F + float(sin((double) m_nSinCounter * 0.075F) * 12.0F) - GetRandom(1, 15);
// 				newx = float(m_nRealTimeCounter);
// 				PEvsetcellEx(m_hPE, PEP_faYDATA, 2, m_nRealTimeCounter, &newy);
// 				PEvsetcellEx(m_hPE, PEP_faXDATA, 2, m_nRealTimeCounter, &newx);
				
// 				double dx;
// 				dx = (double) newx;
// 				PEvsetcell(m_hPE, PEP_faVERTLINEANNOTATION, 0, &dx);
// 				PEvsetcell(m_hPE, PEP_faVERTLINEANNOTATION, 2, &dx);
// 				PEvsetcell(m_hPE, PEP_faVERTLINEANNOTATION, 3, &dx);
// 				int lt = PELT_MEDIUMSOLID;
// 				PEvsetcell(m_hPE, PEP_naVERTLINEANNOTATIONTYPE, 0, &lt);
// 				COLORREF col;
// 				col = RGB(0,0,198);
// 				PEvsetcell(m_hPE, PEP_dwaVERTLINEANNOTATIONCOLOR, 0, &col);
// 				col = RGB(0,198,0);
// 				PEvsetcell(m_hPE, PEP_dwaVERTLINEANNOTATIONCOLOR, 1, &col);
// 				col = RGB(255,198,0);
// 				PEvsetcell(m_hPE, PEP_dwaVERTLINEANNOTATIONCOLOR, 2, &col);
// 				// Increment counter //
				m_nRealTimeCounter = m_nRealTimeCounter + 1;
				
				// Reset counter at end of data //
				if (m_nRealTimeCounter == 100)
					m_nRealTimeCounter = 0;
				
				// SinCounter is only to produce sin wave data //
				m_nSinCounter = m_nSinCounter + 1;
				if (m_nSinCounter > 30000) 
					m_nSinCounter = 1;
				
// 				// Update image and force paint //
// 				PEreinitialize( m_hPE );
// 				//	PEresetimage( m_hPE, 0, 0 );
// 				//	PEresetimage( m_hPE, 1, 0 );
// 				PEresetimage( m_hPE, 2, 0 );
				::InvalidateRect(m_hPE, NULL, FALSE);
			}
		}
	}
	CView::OnTimer(nIDEvent);
}

void CGraphicView::OnDraw3dBar() 
{ 
	if(m_hPE)
	{
//		PEdestroy(m_hPE);
		Invalidate();
	}
	//! This shows how to place extra text inside table and within an axis. //
	//! Maximize to allow room for textual data which is drawn as fixed font size. //
	// This example builds upon the basic CreateSimpleGraph '000' example chart //
	CreateSimpleGraph();
	
	// Create two y axes //
	int nMAS[] = {2, 2};
// 	PEvset(m_hPE, PEP_naMULTIAXESSUBSETS, nMAS, 2);
// 	
// 	// Construct a simple table annotation //
// 	PEnset(m_hPE, PEP_nWORKINGTABLE, 0);
// 	PEnset(m_hPE, PEP_nTAROWS, 6);
// 	PEnset(m_hPE, PEP_nTACOLUMNS, 12);  // 12 is same number as PEP_nPOINTS
	
	// Pass the table text //
	char szTmp[48];
	float fp;
	int r, c;
	DWORD dwColor;
	BOOL b = TRUE;
	
	for (r=0; r<6; r++)
	{
		if (b)
			dwColor = RGB(175,175,175);
		else
			dwColor = RGB(255,255,255);
		b = !b;
		
		for (c=0; c<12; c++)
		{
			fp = float(sin(0.03F * (double) c + 1.0F + r) * 500.0F) + (float) GetRandom(2, 50);
			sprintf(szTmp, "%.3f ", fp);
// 			PEvsetcellEx(m_hPE, PEP_szaTATEXT, r, c, szTmp);
// 			PEvsetcellEx(m_hPE, PEP_dwaTACOLOR, r, c, &dwColor);
		}
	}
	
// 	// Set Table Location //
// 	PEnset(m_hPE, PEP_nTALOCATION, PETAL_INSIDE_AXIS_1);
// 	PEnset(m_hPE, PEP_nTAAXISLOCATION, PETAAL_BOTTOM_TABLE_SPACED);
// 	
// 	// Other Table Related Properties ///
// 	PEnset(m_hPE, PEP_bSHOWTABLEANNOTATION, TRUE);
// 	PEnset(m_hPE, PEP_nTABORDER, PETAB_NO_BORDER);
// 	PEnset(m_hPE, PEP_dwTABACKCOLOR, 1);
// 	PEnset(m_hPE, PEP_dwTAFORECOLOR, 1);
// 	
// 	// Construct a second simple table annotation //
// 	PEnset(m_hPE, PEP_nWORKINGTABLE, 1); 
// 	PEnset(m_hPE, PEP_nTAROWS, 6);
// 	PEnset(m_hPE, PEP_nTACOLUMNS, 12);
	
	// Pass the table text //
	b = TRUE;
	for (r=0; r<6; r++)
	{
		if (b)
			dwColor = RGB(175,175,175);
		else
			dwColor = RGB(255,255,255);
		b = !b;
		
		for (c=0; c<12; c++)
		{
			fp = float(sin(0.03F * (double) c + 1.0F + (2 * r)) * 500.0F) + (float) GetRandom(2, 50);
			sprintf(szTmp, "%.3f ", fp);
// 			PEvsetcellEx(m_hPE, PEP_szaTATEXT, r, c, szTmp);
// 			PEvsetcellEx(m_hPE, PEP_dwaTACOLOR, r, c, &dwColor);
		}
	}
	
// 	// Set Table Location //
// 	PEnset(m_hPE, PEP_nTALOCATION, PETAL_INSIDE_AXIS);
// 	PEnset(m_hPE, PEP_nTAAXISLOCATION, PETAAL_BOTTOM_TABLE_SPACED);
// 	
// 	// Other Table Related Properties ///
// 	PEnset(m_hPE, PEP_bSHOWTABLEANNOTATION, TRUE);
// 	PEnset(m_hPE, PEP_nTABORDER, PETAB_NO_BORDER);
// 	PEnset(m_hPE, PEP_dwTABACKCOLOR, 1);
// 	PEnset(m_hPE, PEP_dwTAFORECOLOR, 1);
// 	
// 	// Construct a third simple table annotation //
// 	PEnset(m_hPE, PEP_nWORKINGTABLE, 2); 
// 	PEnset(m_hPE, PEP_nTAROWS, 2);
// 	PEnset(m_hPE, PEP_nTACOLUMNS, 13);
// 	
	// Pass the table text //
	for (r=0; r<2; r++)
	{
		for (c=1; c<13; c++)
		{
			fp = float(sin(0.03F * (double) c + 1.0F) * 500.0F) + (float) GetRandom(2, 50);
			sprintf(szTmp, "%.3f ", fp);
//			PEvsetcellEx(m_hPE, PEP_szaTATEXT, r, c, szTmp);
		}
	}
	
	// Set Table Location //
// 	PEnset(m_hPE, PEP_nTALOCATION, PETAL_INSIDE_TABLE);
// 	PEnset(m_hPE, PEP_nTAAXISLOCATION, PETAAL_TOP_TABLE_SPACED);
// 	
// 	// Other Table Related Properties ///
// 	PEnset(m_hPE, PEP_bSHOWTABLEANNOTATION, TRUE);
// 	PEnset(m_hPE, PEP_dwTABACKCOLOR, RGB(0,198,198));
// 	PEnset(m_hPE, PEP_bTAHEADERCOLUMN, TRUE);
// 	
// 	// Set Text for Header Column //
// 	strcpy(szTmp, "Table Annotation Line 1");
// 	PEvsetcellEx(m_hPE, PEP_szaTATEXT, 0, 0, szTmp);
// 	strcpy(szTmp, "Table Annotation Line 2");
// 	PEvsetcellEx(m_hPE, PEP_szaTATEXT, 1, 0, szTmp);
// 	
	// Done setting Table Annotations ///
	
// 	// Set Various Other Properties ///
// 	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, TRUE);
// 	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_DARK_SHADOW);
// 	PEnset(m_hPE, PEP_nDATAPRECISION, 0);
// 	PEnset(m_hPE, PEP_nGRAPHPLUSTABLE, PEGPT_BOTH);
// 	PEnset(m_hPE, PEP_nLEGENDSTYLE, PELS_1_LINE_INSIDE_AXIS);
// 	PEnset(m_hPE, PEP_nGRIDLINECONTROL, PEGLC_YAXIS);
// 	PEnset(m_hPE, PEP_bMARKDATAPOINTS, TRUE);
// 	PEnset(m_hPE, PEP_nFONTSIZE, PEFS_SMALL);
// 	PEnset(m_hPE, PEP_nDATASHADOWS, PEDS_SHADOWS);
// 	PEnset(m_hPE, PEP_bSHOWLEGEND, FALSE);
// 	
// 	PEnset(m_hPE, PEP_nWORKINGAXIS, 0);
// 	PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_BAR);
// 	PEnset(m_hPE, PEP_nRYAXISCOMPARISONSUBSETS, 1);
// 	PEnset(m_hPE, PEP_dwRYAXISCOLOR, RGB(0, 198,198));
// 	PEszset(m_hPE, PEP_szYAXISLABEL, "");
// 	PEszset(m_hPE, PEP_szRYAXISLABEL, "");
// 	
// 	PEnset(m_hPE, PEP_nWORKINGAXIS, 1);
// 	PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_BAR);
// 	PEnset(m_hPE, PEP_nRYAXISCOMPARISONSUBSETS, 1);
// 	PEnset(m_hPE, PEP_dwRYAXISCOLOR, RGB(0, 198,0));
// 	PEszset(m_hPE, PEP_szYAXISLABEL, "");
// 	PEszset(m_hPE, PEP_szRYAXISLABEL, "");
// 	
// 	DWORD dwArray[4] = { RGB(138,0,0), RGB(0, 198, 198), RGB(138,138,0), RGB(0,198,0) };
// 	PEvsetEx(m_hPE, PEP_dwaSUBSETCOLORS, 0, 4, dwArray, 0);
// 	
// 	PEnset(m_hPE, PEP_nSHOWTABLEANNOTATIONSMENU, PEMC_SHOW);
	
}



void CGraphicView::OnDraw3dStackedBar() 
{
	if(m_hPE)
	{
//		PEdestroy(m_hPE);
		Invalidate();
	}
	//! Chart fills 100 points and once 100 points have
	//! been passed, old data is over-written as more
	//! data is passed to chart.
	m_canReal=TRUE;
	m_Real=FALSE;
	RECT rect;
	GetClientRect( &rect ); 
	
	// Construct Object //
////	m_hPE = PEcreate(PECONTROL_SGRAPH, WS_VISIBLE, &rect, m_hWnd, 1001);
// 	
// 	PEnset(m_hPE, PEP_nSUBSETS, 3);
// 	PEnset(m_hPE, PEP_nPOINTS, 100);
// 	
// 	// Set Manual Y scale //
// 	PEnset(m_hPE, PEP_nMANUALSCALECONTROLY, PEMSC_MINMAX);
// 	double arg = 1.0F;//
// 	PEvset(m_hPE, PEP_fMANUALMINY, &arg, 1);
// 	arg = 100.0F;
// 	PEvset(m_hPE, PEP_fMANUALMAXY, &arg, 1);
// 	
// 	// Set Manual X scale //
// 	PEnset(m_hPE, PEP_nMANUALSCALECONTROLX, PEMSC_MINMAX);
// 	arg = 1.0F;
// 	PEvset(m_hPE, PEP_fMANUALMINX, &arg, 1);
// 	arg = 100.0F;
// 	PEvset(m_hPE, PEP_fMANUALMAXX, &arg, 1);
// 	
// 	// Show Annotations //
// 	PEnset(m_hPE, PEP_bSHOWANNOTATIONS, TRUE);
// 	
// 	// Clear out default data //
// 	float val = 0;
// 	PEvsetcellEx(m_hPE, PEP_faXDATA, 0, 0, &val);
// 	PEvsetcellEx(m_hPE, PEP_faXDATA, 0, 1, &val);
// 	PEvsetcellEx(m_hPE, PEP_faXDATA, 0, 2, &val);
// 	PEvsetcellEx(m_hPE, PEP_faXDATA, 0, 3, &val); 
// 	
// 	PEvsetcellEx(m_hPE, PEP_faXDATA, 1, 0, &val);
// 	PEvsetcellEx(m_hPE, PEP_faXDATA, 1, 1, &val);
// 	PEvsetcellEx(m_hPE, PEP_faXDATA, 1, 2, &val);
// 	PEvsetcellEx(m_hPE, PEP_faXDATA, 1, 3, &val);
// 	
// 	PEvsetcellEx(m_hPE, PEP_faXDATA, 2, 0, &val);
// 	PEvsetcellEx(m_hPE, PEP_faXDATA, 2, 1, &val);
// 	PEvsetcellEx(m_hPE, PEP_faXDATA, 2, 2, &val);
// 	PEvsetcellEx(m_hPE, PEP_faXDATA, 2, 3, &val);
// 	
// 	int nTmpStyle;
// 	nTmpStyle = PELT_THINSOLID;
// 	PEvsetcell(m_hPE, PEP_naSUBSETLINETYPES, 0, &nTmpStyle); 
// 	PEvsetcell(m_hPE, PEP_naSUBSETLINETYPES, 1, &nTmpStyle); 
// 	PEvsetcell(m_hPE, PEP_naSUBSETLINETYPES, 2, &nTmpStyle);
// 	//	PEvset(m_hPE, PEP_naSUBSETLINETYPES, PELT_THINSOLID, 0);
// 	
// 	char szSubsets[] = "电流\t电压\t频率\t";
// 	PEvset (m_hPE, PEP_szaSUBSETLABELS, szSubsets, 3);
// 	
// 	
// 	
// 	// Set Various Other Properties ///
// 	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, TRUE);
// 	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_DARK_LINE);
// 	
// 	PEszset(m_hPE, PEP_szMAINTITLE, "工业控制实时曲线示例");
// 	PEszset(m_hPE, PEP_szSUBTITLE, "编程设计实现--戚高");
// 	PEnset(m_hPE, PEP_bNORANDOMPOINTSTOEXPORT, TRUE);
// 	PEnset(m_hPE, PEP_bFOCALRECT, FALSE);
// 	PEnset(m_hPE, PEP_bALLOWBAR, FALSE);
// 	PEnset(m_hPE, PEP_bALLOWPOPUP, FALSE);
// 	PEnset(m_hPE, PEP_bPREPAREIMAGES, TRUE);
// 	PEnset(m_hPE, PEP_bCACHEBMP, TRUE);
// 	PEnset(m_hPE, PEP_bFIXEDFONTS, TRUE);
// 	
// 	DWORD col = RGB(0, 198, 198);
// 	PEvsetcell(m_hPE, PEP_dwaSUBSETCOLORS, 0, &col); 
// 	
// 	col = RGB(0,198,0);
// 	PEvsetcell(m_hPE, PEP_dwaSUBSETCOLORS, 1, &col);
// 	
// 	col = RGB(255,0,0);
// 	PEvsetcell(m_hPE, PEP_dwaSUBSETCOLORS, 2, &col);
// 	
// 	PEnset(m_hPE, PEP_nGRADIENTBARS, 8);
// 	PEnset(m_hPE, PEP_nTEXTSHADOWS, PETS_BOLD_TEXT);
// 	PEnset(m_hPE, PEP_bMAINTITLEBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bSUBTITLEBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bLABELBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bLINESHADOWS, TRUE);
// 	PEnset(m_hPE, PEP_nFONTSIZE, PEFS_LARGE);
// 	
// 	PEreinitialize(m_hPE);
// 	PEresetimage(m_hPE, 2, 0);
// 	::InvalidateRect(m_hPE, NULL, FALSE);
// 	
// 	//Initialize Counters and Timer 
// 	m_nRealTimeCounter = 1;
// 	m_nSinCounter = 1;
	SetTimer( 1, 100, NULL ); 
}


void CGraphicView::OnDraw3dLine() 
{   
	if(m_hPE)
	{
//		PEdestroy(m_hPE);
		Invalidate();
	}
	m_canReal=FALSE; 
	RECT rect;
	GetClientRect( &rect );
	
	// Construct Object //
// 	m_hPE = PEcreate(PECONTROL_PGRAPH, WS_VISIBLE, &rect, m_hWnd, 1001);
// 	
// 	PEnset(m_hPE, PEP_nSUBSETS, 2);
// 	PEnset(m_hPE, PEP_nPOINTS, 360);
// 	
	int p;
	float f1, f2;
	for (p=0; p<360; p++)
	{
		f1 = (float) p;
		f2 = (float) 150 * (float)sin((double) p * 0.054F);
//		PEvsetcellEx(m_hPE, PEP_faXDATA, 0, p, &f1);
//		PEvsetcellEx(m_hPE, PEP_faYDATA, 0, p, &f2);
	}
	
	for (p=0; p<360; p++)
	{
		f1 = (float) p;
// 		f2 = (float) 150 * (float)sin(((double) p * 0.044F)) * 2;
// 		PEvsetcellEx(m_hPE, PEP_faXDATA, 1, p, &f1);
// 		PEvsetcellEx(m_hPE, PEP_faYDATA, 1, p, &f2);
	}
	
// 	PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_LINE);
// 	PEnset(m_hPE, PEP_nALLOWZOOMING, 1);
// 	PEszset(m_hPE, PEP_szMAINTITLE, "Polar Chart");
// 	PEszset(m_hPE, PEP_szSUBTITLE, ""); // no subtitle
// 	float ftmp = .9F;
// 	PEvset(m_hPE, PEP_fFONTSIZELEGENDCNTL, &ftmp, 1 );
// 	PEnset(m_hPE, PEP_bPREPAREIMAGES, TRUE);
// 	PEnset(m_hPE, PEP_bCACHEBMP, TRUE);
// 	PEnset(m_hPE, PEP_bFOCALRECT, FALSE);
// 	
// 	// Set line types
// 	int nTypes[] = { PELT_MEDIUMSOLID, PELT_MEDIUMSOLID };
// 	PEvset(m_hPE, PEP_naSUBSETLINETYPES, nTypes, 2);
// 	
// 	// Set point types
// 	int nPTypes[] = { PEPT_DOTSOLID, PEPT_PLUS };
// 	PEvset(m_hPE, PEP_naSUBSETPOINTTYPES, nTypes, 2);
// 	
// 	// subset colors
// 	DWORD dwArray[2] = { RGB(198,0,0), RGB(0, 198, 0) };
// 	PEvset( m_hPE, PEP_dwaSUBSETCOLORS, dwArray, 2);
// 	
// 	// subset labels
// 	PEvsetcell( m_hPE, PEP_szaSUBSETLABELS, 0, "Signal #1" );
// 	PEvsetcell( m_hPE, PEP_szaSUBSETLABELS, 1, "Signal #2" );
// 	
// 	double dnull = -99999.0F;
// 	PEvset(m_hPE, PEP_fNULLDATAVALUEX, &dnull, 1);
// 	PEvset(m_hPE, PEP_fNULLDATAVALUE, &dnull, 1);
// 	
// 	// Set Various other features //
// 	PEnset(m_hPE, PEP_bFIXEDFONTS, TRUE);
// 	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, TRUE);
// 	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_MEDIUM_NO_BORDER);
// 	PEnset(m_hPE, PEP_bSIMPLEPOINTLEGEND, TRUE);
// 	PEnset(m_hPE, PEP_bSIMPLELINELEGEND, TRUE);
// 	PEnset(m_hPE, PEP_nLEGENDSTYLE, PELS_1_LINE);
// 	PEnset(m_hPE, PEP_nZOOMSTYLE, PEZS_RO2_NOT);
// 	PEnset(m_hPE, PEP_nPOINTSIZE, PEPS_SMALL);
// 	
// 	PEnset(m_hPE, PEP_nTEXTSHADOWS, PETS_BOLD_TEXT);
// 	PEnset(m_hPE, PEP_bMAINTITLEBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bSUBTITLEBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bLABELBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bLINESHADOWS, TRUE);
// 	PEnset(m_hPE, PEP_nFONTSIZE, PEFS_LARGE);
// 	PEnset(m_hPE, PEP_nGRADIENTBARS, 8);
// 	PEnset(m_hPE, PEP_nDATASHADOWS, PEDS_SHADOWS);
// 	float f = 1.2F;
// 	PEvset(m_hPE, PEP_fFONTSIZEGNCNTL, &f, 1); 
// 	// Enable Smith Mode //
// 	PEnset(m_hPE, PEP_nSMITHCHART, PESC_SMITH);
// 	PEszset(m_hPE, PEP_szMAINTITLE, "Smith Chart");
// 	
// 	// Change the data to something more appropriate //
// 	PEnset(m_hPE, PEP_nSUBSETS, 2);
// 	PEnset(m_hPE, PEP_nPOINTS, 40);
// 	
// 	// Set first subset's data // 
// 	int s = 0;
// 	for (p=0; p<=39; p++)
// 	{
// 		f = (float) p * 0.1F;
// 		PEvsetcellEx(m_hPE, PEP_faXDATA, s, p, &f);
// 		f = (float) sin((double) p * 0.54F) * 0.2F;
// 		PEvsetcellEx(m_hPE, PEP_faYDATA, s, p, &f);
// 	}
// 	
// 	// Set second subset's data //
// 	s = 1;
// 	for (p=0; p<=39; p++)
// 	{
// 		f = (float) p * 0.5F;
// 		PEvsetcellEx(m_hPE, PEP_faXDATA, s, p, &f);
// 		f = (float) sin((double) p * 0.44F) * 0.5F;
// 		PEvsetcellEx(m_hPE, PEP_faYDATA, s, p, &f);
// 	}
// 	
// 	// Set Various other features //
// 	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, TRUE);
// 	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_DARK_SHADOW);
// 	
// 	// Add Some Padding on Right and Bottom //
// 	PEnset(m_hPE, PEP_nIMAGEADJUSTLEFT, 400);
// 	PEnset(m_hPE, PEP_nIMAGEADJUSTRIGHT, 400);
// 	PEnset(m_hPE, PEP_nIMAGEADJUSTBOTTOM, 400);
}




void CGraphicView::OnDraw3dPie() 
{  
	if(m_hPE)
	{
//		PEdestroy(m_hPE);
		Invalidate();
	}
	RECT rect;
	GetClientRect( &rect ); 
	m_canReal=FALSE;
// 	m_hPE = PEcreate(PECONTROL_PIE, WS_VISIBLE, &rect, m_hWnd, 1001);
// 	PEnset(m_hPE, PEP_nSUBSETS, 5);
// 	PEnset(m_hPE, PEP_nPOINTS, 12);
// 	int s,p;          
// 	for (s=0; s<5; s++)
// 	{
// 		for (p=0; p<12; p++)
// 		{
// 			float f1 = (float) GetRandom(1, 5) + ((float) GetRandom(1, 150) / 100.0F);
// 			PEvsetcellEx(m_hPE, PEP_faXDATA, s, p, &f1);
// 		}
// 	}
// 	float f1= 0.0F;
// 	PEvsetcellEx(m_hPE, PEP_faXDATA, 0, 3, &f1); 
// 	PEvsetcell( m_hPE, PEP_szaSUBSETLABELS, 0, "北京" );
// 	PEvsetcell( m_hPE, PEP_szaSUBSETLABELS, 1, "上海" );
// 	PEvsetcell( m_hPE, PEP_szaSUBSETLABELS, 2, "广州"  );
// 	PEvsetcell( m_hPE, PEP_szaSUBSETLABELS, 3, "长沙" );
// 	PEvsetcell( m_hPE, PEP_szaSUBSETLABELS, 4, "重庆" ); 
// 	PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 0, "一月"      );
// 	PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 1, "二月"   );
// 	PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 2, "三月");
// 	PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 3, "四月" );
// 	PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 4, "五月"   );
// 	PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 5, "六月"    );
// 	PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 6, "七月"       );
// 	PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 7, "八月"   );
// 	PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 8, "九月"    );
// 	PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 9, "十月"     );
// 	PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 10, "十一月"   );
// 	PEvsetcell( m_hPE, PEP_szaPOINTLABELS, 11, "十二月"    ); 
// 	DWORD c[12];
// 	c[0] = RGB(198, 0, 0);
// 	c[1] = RGB(0, 198, 0);
// 	c[2] = RGB(198, 198, 0);
// 	c[3] = RGB(0, 0, 198);
// 	c[4] = RGB(198, 0, 198);
// 	c[5] = RGB(0, 198, 198);
// 	c[6] = RGB(192, 192, 192);
// 	c[7] = RGB(148, 0, 0);
// 	c[8] = RGB(0, 148, 0);
// 	c[9] = RGB(148, 148, 0);
// 	c[10] = RGB(0, 148, 148);
// 	c[11] = RGB(122, 122, 122);
// 	PEvset(m_hPE, PEP_dwaSUBSETCOLORS, c, 12); 
// 	PEszset(m_hPE, PEP_szMAINTITLE, "3D PIE图表显示编程");
// 	PEszset(m_hPE, PEP_szSUBTITLE, "编程设计实现-戚高"); // no subtitle 
// 	PEnset(m_hPE, PEP_nDATAPRECISION, 1);				   
// 	PEnset(m_hPE, PEP_nGROUPINGPERCENT, 4);
// 	PEnset(m_hPE, PEP_nDATASHADOWS, PEDS_3D);					 
// 	PEnset(m_hPE, PEP_bDISABLE3DSHADOW, FALSE);
// 	PEnset(m_hPE, PEP_nAUTOEXPLODE, PEAE_ALLSUBSETS);
// 	PEnset(m_hPE, PEP_bFOCALRECT, FALSE);
// 	PEnset(m_hPE, PEP_bPREPAREIMAGES, TRUE);
// 	PEnset(m_hPE, PEP_bCACHEBMP, TRUE);
// 	PEnset(m_hPE, PEP_nFONTSIZE, PEFS_LARGE);
// 	PEnset(m_hPE, PEP_bFIXEDFONTS, TRUE); 
// 	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, TRUE);
// 	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_MEDIUM_NO_BORDER); 
// 	PEnset(m_hPE, PEP_nTEXTSHADOWS, PETS_BOLD_TEXT);
// 	PEnset(m_hPE, PEP_bMAINTITLEBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bSUBTITLEBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bLABELBOLD, TRUE);
// 	PEnset(m_hPE, PEP_nFONTSIZE, PEFS_LARGE); 
}


void CGraphicView::OnBkLine() 
{ 
	if(m_hPE)
	{
//		PEdestroy(m_hPE);
		Invalidate();
	}
	OnDraw3dPie(); 
	float f1 = 1; 
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 0, 3, &f1);
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 0, 5, &f1); 
// 	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, FALSE);
// 	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_MEDIUM_SHADOW); 
// 	PEnset(m_hPE, PEP_nIMAGEADJUSTLEFT, 400);
// 	PEnset(m_hPE, PEP_nIMAGEADJUSTRIGHT, 400);
// 	PEnset(m_hPE, PEP_nIMAGEADJUSTBOTTOM, 400);
// 	//***********************************************
// 	OnDraw3dPie();
// 	f1 = 1;
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 0, 3, &f1);
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 0, 5, &f1); 
// 	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, FALSE);
// 	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_MEDIUM_SHADOW); 
// 	PEnset(m_hPE, PEP_nIMAGEADJUSTLEFT, 400);
// 	PEnset(m_hPE, PEP_nIMAGEADJUSTRIGHT, 400);
// 	PEnset(m_hPE, PEP_nIMAGEADJUSTBOTTOM, 400); 
}


void CGraphicView::OnBkXy() 
{ 
	if(m_hPE)
	{
//		PEdestroy(m_hPE);
		Invalidate();
	}
	RECT rect;
	GetClientRect( &rect );
// 	
// 	// Construct Object //
// 	m_hPE = PEcreate(PECONTROL_PGRAPH, WS_VISIBLE, &rect, m_hWnd, 100);
// 	
// 	// Set to rose mode //	
// 	PEnset(m_hPE, PEP_nSMITHCHART, PESC_ROSE);  // Select Rose Plot Mode
// 	
// 	// Set titles //
// 	PEszset(m_hPE, PEP_szMAINTITLE, "Wind Rose Example");
// 	PEszset(m_hPE, PEP_szSUBTITLE, " ");
// 	
// 	// Set data //
// 	PEnset(m_hPE, PEP_nSUBSETS, 13);
// 	PEnset(m_hPE, PEP_nPOINTS, 16);
// 	
// 	float tempxdata[] =
// 	{ 
// 		90.0F, 	67.5F,	45.0F,	22.5F,	0.0F,	337.5F,	315.0F,	292.5F,	270.0F,	247.5F,	225.0F,	202.5F,	180.0F,	157.5F,	135.0F,	112.5F,
// 			90.0F, 	67.5F,	45.0F,	22.5F,	0.0F,	337.5F,	315.0F,	292.5F,	270.0F,	247.5F,	225.0F,	202.5F,	180.0F,	157.5F,	135.0F,	112.5F,
// 			90.0F, 	67.5F,	45.0F,	22.5F,	0.0F,	337.5F,	315.0F,	292.5F,	270.0F,	247.5F,	225.0F,	202.5F,	180.0F,	157.5F,	135.0F,	112.5F,
// 			90.0F, 	67.5F,	45.0F,	22.5F,	0.0F,	337.5F,	315.0F,	292.5F,	270.0F,	247.5F,	225.0F,	202.5F,	180.0F,	157.5F,	135.0F,	112.5F,
// 			90.0F, 	67.5F,	45.0F,	22.5F,	0.0F,	337.5F,	315.0F,	292.5F,	270.0F,	247.5F,	225.0F,	202.5F,	180.0F,	157.5F,	135.0F,	112.5F,
// 			90.0F, 	67.5F,	45.0F,	22.5F,	0.0F,	337.5F,	315.0F,	292.5F,	270.0F,	247.5F,	225.0F,	202.5F,	180.0F,	157.5F,	135.0F,	112.5F,
// 			90.0F, 	67.5F,	45.0F,	22.5F,	0.0F,	337.5F,	315.0F,	292.5F,	270.0F,	247.5F,	225.0F,	202.5F,	180.0F,	157.5F,	135.0F,	112.5F,
// 			90.0F, 	67.5F,	45.0F,	22.5F,	0.0F,	337.5F,	315.0F,	292.5F,	270.0F,	247.5F,	225.0F,	202.5F,	180.0F,	157.5F,	135.0F,	112.5F,
// 			90.0F, 	67.5F,	45.0F,	22.5F,	0.0F,	337.5F,	315.0F,	292.5F,	270.0F,	247.5F,	225.0F,	202.5F,	180.0F,	157.5F,	135.0F,	112.5F,
// 			90.0F, 	67.5F,	45.0F,	22.5F,	0.0F,	337.5F,	315.0F,	292.5F,	270.0F,	247.5F,	225.0F,	202.5F,	180.0F,	157.5F,	135.0F,	112.5F,
// 			90.0F, 	67.5F,	45.0F,	22.5F,	0.0F,	337.5F,	315.0F,	292.5F,	270.0F,	247.5F,	225.0F,	202.5F,	180.0F,	157.5F,	135.0F,	112.5F,
// 			90.0F, 	67.5F,	45.0F,	22.5F,	0.0F,	337.5F,	315.0F,	292.5F,	270.0F,	247.5F,	225.0F,	202.5F,	180.0F,	157.5F,	135.0F,	112.5F,
// 			90.0F, 	67.5F,	45.0F,	22.5F,	0.0F,	337.5F,	315.0F,	292.5F,	270.0F,	247.5F,	225.0F,	202.5F,	180.0F,	157.5F,	135.0F,	112.5F	};
// 		PEvset(m_hPE, PEP_faXDATA, tempxdata, 208);
// 		
// 		float tempydata[] = 
// 		{	.77F, .75F, .78F, .88F, 1.07F, .98F, .69F, .51F, .38F, .50F, .56F, .65F, .72F, .70F, .62F, .63F,
// 		1.04F, 1.72F, 2.68F, 4.76F, 4.58F, 2.59F, 1.29F, .99F, 1.19F, 1.77F, 2.34F, 2.89F, 2.05F, 1.31F, 1.16F, 1.08F,
// 		.43F, 1.05F, 3.41F, 7.40F, 5.97F, 1.48F, .30F, .39F, .73F, 1.68F, 3.53F, 2.73F, 1.24F, .55F, .25F, .27F,
// 		.20F, 1.07F, 3.71F, 4.49F, 2.08F, .23F, .10F, .11F, .29F, 1.16F, 2.32F, 1.26F, .54F, .18F, .09F, .22F,
// 		.05F, .48F, .66F, 1.31F, .26F, .01F, .02F, .04F, .14F, .33F, .75F, .46F, .18F, .05F, .07F, .03F,
// 		.04F, .10F, .07F, .02F, .02F, .02F, .01F, .01F, .01F, .05F, .12F, .09F, .04F, .02F, .03F, .04F,
// 		.01F, 0.0F, .01F, .01F,	0.0F, .01F,	.01F, .01F,	.01F, .01F,	.01F, .03F,	0.0F, 0.0F,	.02F, .01F,
// 		.01F, 0.0F, .01F, 0.0F,	.01F, 0.0F,	.01F, 0.0F,	0.0F, .01F,	0.0F, .01F,	.02F, .01F,	.01F, 0.0F,
// 		.01F, 0.0F, 0.0F, 0.0F,	0.0F, 0.0F,	0.0F, .01F,	0.0F, 0.0F,	0.0F, 0.1F,	0.0F, 0.0F,	0.0F, 0.0F,
// 		0.0F, 0.0F, .01F, 0.0F,	0.0F, 0.0F,	0.0F, .01F,	0.0F, 0.0F,	0.0F, 0.0F,	0.0F, 0.0F,	0.0F, 0.0F,
// 		0.0F, 0.0F, .01F, 0.0F,	0.0F, 0.0F,	0.0F, .01F,	0.0F, 0.0F,	0.0F, 0.0F,	0.0F, 0.0F,	0.0F, 0.0F,
// 		0.0F, 0.0F, .01F, 0.0F,	0.0F, 0.0F,	0.0F, 0.0F,	0.0F, 0.0F,	0.0F, 0.0F,	0.0F, 0.0F,	0.0F, 0.0F,
// 		0.0F, 0.0F, .01F, 0.0F,	0.0F, 0.0F,	0.0F, 0.0F,	0.0F, 0.0F,	0.0F,0.0F,	0.0F, 0.0F,	0.0F, 0.0F	};
// 		PEvset(m_hPE, PEP_faYDATA, tempydata, 208);
// 		
// 		char tempptlabels[] = "E\tENE\tNE\tNNE\tN\tNNW\tNW\tWNW\tW\tWSW\tSW\tSSW\tS\tSSE\tSE\tESE\t";
// 		char tempsslabels[] = "3.75\t6.25\t8.75\t11.25\t13.75\t16.25\t18.75\t21.25\t23.75\t26.25\t28.75\t31.25\t33.75\t";
// 		PEvset(m_hPE, PEP_szaPOINTLABELS, tempptlabels, 16);
// 		PEvset(m_hPE, PEP_szaSUBSETLABELS, tempsslabels, 13);
// 		
// 		// Manually control degree line frequency //
// 		PEnset(m_hPE, PEP_bMANUALXAXISTICKNLINE, TRUE);
// 		double d = 22.5F;
// 		PEvset(m_hPE, PEP_fMANUALXAXISLINE, &d, 1);
// 		PEvset(m_hPE, PEP_fMANUALXAXISTICK, &d, 1);
// 		
// 		// Make it so monochrome image is just black and white //
// 		DWORD bwc[2];
// 		bwc[0] = 0L;
// 		bwc[1] = RGB(255,255,255);
// 		PEvset(m_hPE, PEP_dwaSUBSETSHADES, bwc, 2);
// 		
// 		// Remove standard legend, rose has a special legend //
// 		int stl = -1;
// 		PEvset(m_hPE, PEP_naSUBSETSTOLEGEND, &stl, 1);
// 		
// 		// Set inner circle label //
// 		PEszset(m_hPE, PEP_szMANUALMAXDATASTRING, "1.25|1.1%");
// 		
// 		// Get rid of radius labels //
// 		PEnset(m_hPE, PEP_bGRIDINFRONT, FALSE);
// 		
// 		// Enable zooming //
// 		PEnset(m_hPE, PEP_nALLOWZOOMING, PEAZ_HORZANDVERT);
// 		PEnset(m_hPE, PEP_nZOOMSTYLE, PEZS_RO2_NOT);
// 		
// 		PEnset(m_hPE, PEP_bPREPAREIMAGES, TRUE);
// 		PEnset(m_hPE, PEP_bCACHEBMP, TRUE);
// 		PEnset(m_hPE, PEP_bFIXEDFONTS, TRUE);
// 		PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, FALSE);
// 		PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_MEDIUM_NO_BORDER);
// 		PEnset(m_hPE, PEP_bSIMPLEPOINTLEGEND, TRUE);
// 		PEnset(m_hPE, PEP_bSIMPLELINELEGEND, TRUE);
// 		PEnset(m_hPE, PEP_nLEGENDSTYLE, PELS_1_LINE);
// 		
// 		// Add Some Padding on Right and Bottom //
// 		PEnset(m_hPE, PEP_nIMAGEADJUSTLEFT, 400);
// 		PEnset(m_hPE, PEP_nIMAGEADJUSTRIGHT, 400);
// 		PEnset(m_hPE, PEP_nIMAGEADJUSTBOTTOM, 400);
// 		
// 		PEnset(m_hPE, PEP_nTEXTSHADOWS, PETS_BOLD_TEXT);
// 		PEnset(m_hPE, PEP_bMAINTITLEBOLD, TRUE);
// 		PEnset(m_hPE, PEP_bSUBTITLEBOLD, TRUE);
// 		PEnset(m_hPE, PEP_bLABELBOLD, TRUE);
// 		PEnset(m_hPE, PEP_bLINESHADOWS, TRUE);
// 		PEnset(m_hPE, PEP_nFONTSIZE, PEFS_LARGE);
// 		PEnset(m_hPE, PEP_nGRADIENTBARS, 8);
// 		PEnset(m_hPE, PEP_nDATASHADOWS, PEDS_SHADOWS);
// 		float f = 1.2F;
// 		PEvset(m_hPE, PEP_fFONTSIZEGNCNTL, &f, 1);
		
}



void CGraphicView::OnBkArea() 
{ 
	if(m_hPE)
	{
//		PEdestroy(m_hPE);
		Invalidate();
	}
	// This example builds upon the basic CreateSimpleGraph '000' example chart //
	CreateSimpleGraph();
	
	/////////////////////////////////////////
	// Construct a simple table annotation //
	/////////////////////////////////////////
// 	PEnset(m_hPE, PEP_nWORKINGTABLE, 0);
// 	PEnset(m_hPE, PEP_nTAROWS, 1);
// 	PEnset(m_hPE, PEP_nTACOLUMNS, 2);
// 	PEnset(m_hPE, PEP_nTATEXTSIZE, 85);
// 	
// 	// Pass the table text //
// 	char szTmp[48];
// 	strcpy(szTmp, "Category 1");
// 	PEvsetcellEx(m_hPE, PEP_szaTATEXT, 0, 0, szTmp);
// 	strcpy(szTmp, "Category 2");
// 	PEvsetcellEx(m_hPE, PEP_szaTATEXT, 0, 1, szTmp);
// 	
// 	// Set column widths ///
// 	int nWidth = 28;
// 	PEvsetcell(m_hPE, PEP_naTACOLUMNWIDTH, 0, &nWidth);
// 	PEvsetcell(m_hPE, PEP_naTACOLUMNWIDTH, 1, &nWidth);
// 	
// 	PEnset(m_hPE, PEP_bSHOWTABLEANNOTATION, TRUE);
// 	
// 	PEnset(m_hPE, PEP_nTALOCATION, PETAL_INSIDE_AXIS_0);
// 	PEnset(m_hPE, PEP_nTAAXISLOCATION, PETAAL_TOP_LEFT);
// 	PEnset(m_hPE, PEP_nTABORDER, PETAB_SINGLE_LINE);
// 	PEnset(m_hPE, PEP_dwTABACKCOLOR, RGB(255,255,255));
// 	
// 	int nJust = PETAJ_CENTER;
// 	PEvsetcell(m_hPE, PEP_naTAJUSTIFICATION, 0, &nJust);
// 	PEvsetcell(m_hPE, PEP_naTAJUSTIFICATION, 1, &nJust);
// 	
// 	/////////////////////////////////////////
// 	// Construct a simple table annotation //
// 	/////////////////////////////////////////
// 	PEnset(m_hPE, PEP_nWORKINGTABLE, 1);
// 	PEnset(m_hPE, PEP_nTAROWS, 1);
// 	PEnset(m_hPE, PEP_nTACOLUMNS, 4);
// 	PEnset(m_hPE, PEP_nTATEXTSIZE, 85);
// 	
// 	strcpy(szTmp, "Sub Cat 1");
// 	PEvsetcellEx(m_hPE, PEP_szaTATEXT, 0, 0, szTmp);
// 	strcpy(szTmp, "Sub Cat 2");
// 	PEvsetcellEx(m_hPE, PEP_szaTATEXT, 0, 1, szTmp);
// 	strcpy(szTmp, "Sub Cat 3");
// 	PEvsetcellEx(m_hPE, PEP_szaTATEXT, 0, 2, szTmp);
// 	strcpy(szTmp, "Sub Cat 4");
// 	PEvsetcellEx(m_hPE, PEP_szaTATEXT, 0, 3, szTmp);
// 	
// 	nWidth = 14;
// 	PEvsetcell(m_hPE, PEP_naTACOLUMNWIDTH, 0, &nWidth);
// 	PEvsetcell(m_hPE, PEP_naTACOLUMNWIDTH, 1, &nWidth);
// 	PEvsetcell(m_hPE, PEP_naTACOLUMNWIDTH, 2, &nWidth);
// 	PEvsetcell(m_hPE, PEP_naTACOLUMNWIDTH, 3, &nWidth);
// 	
// 	nJust = PETAJ_CENTER;
// 	PEvsetcell(m_hPE, PEP_naTAJUSTIFICATION, 0, &nJust);
// 	PEvsetcell(m_hPE, PEP_naTAJUSTIFICATION, 1, &nJust);
// 	PEvsetcell(m_hPE, PEP_naTAJUSTIFICATION, 2, &nJust);
// 	PEvsetcell(m_hPE, PEP_naTAJUSTIFICATION, 3, &nJust);
// 	
// 	PEnset(m_hPE, PEP_dwTABACKCOLOR, RGB(240,240,240));
// 	PEnset(m_hPE, PEP_bSHOWTABLEANNOTATION, TRUE);
// 	
// 	PEnset(m_hPE, PEP_nTALOCATION, PETAL_INSIDE_AXIS_0);
// 	PEnset(m_hPE, PEP_nTAAXISLOCATION, PETAAL_TOP_LEFT + PETAAL_NEW_ROW);
// 	
// 	PEnset(m_hPE, PEP_nTABORDER, PETAB_SINGLE_LINE);
// 	
// 	/////////////////////////////////////////
// 	// Construct a simple table annotation //
// 	/////////////////////////////////////////
// 	PEnset(m_hPE, PEP_nWORKINGTABLE, 2);
// 	PEnset(m_hPE, PEP_nTAROWS, 4);
// 	PEnset(m_hPE, PEP_nTACOLUMNS, 8);
// 	PEnset(m_hPE, PEP_nTATEXTSIZE, 85);
// 	
// 	// Set Column Widths //
// 	nWidth = 7;
// 	PEvsetcell(m_hPE, PEP_naTACOLUMNWIDTH, 0, &nWidth);
// 	PEvsetcell(m_hPE, PEP_naTACOLUMNWIDTH, 1, &nWidth);
// 	PEvsetcell(m_hPE, PEP_naTACOLUMNWIDTH, 2, &nWidth);
// 	PEvsetcell(m_hPE, PEP_naTACOLUMNWIDTH, 3, &nWidth);
// 	PEvsetcell(m_hPE, PEP_naTACOLUMNWIDTH, 4, &nWidth);
// 	PEvsetcell(m_hPE, PEP_naTACOLUMNWIDTH, 5, &nWidth);
// 	PEvsetcell(m_hPE, PEP_naTACOLUMNWIDTH, 6, &nWidth);
// 	PEvsetcell(m_hPE, PEP_naTACOLUMNWIDTH, 7, &nWidth);
// 	
	// Pass the table text //
	float fp;
	int nTmp;
	for (int r=0; r<4; r++)
	{
		for (int c=0; c<8; c++)
		{
			fp = float(sin(0.3F * (double) c + 1) * 500.0F) + GetRandom(2, 50);
//			sprintf(szTmp, "%.2f ", fp);
//			PEvsetcellEx(m_hPE, PEP_szaTATEXT, r, c, szTmp);
			
			if (c > 5)
				nTmp = RGB(0, 148, 0);
			else if (c > 3)
				nTmp = RGB(148, 148, 0);
			else if (c > 1)
				nTmp = RGB(0, 148, 148);
			else
				nTmp = RGB(198, 0, 0);
			
//			PEvsetcellEx(m_hPE, PEP_dwaTACOLOR, r, c, &nTmp); 
			
	//		nJust = PETAJ_CENTER;
	//		PEvsetcellEx(m_hPE, PEP_naTAJUSTIFICATION, r, c, &nJust);
		}
	}
	
	// Other Table Related Properties ///
// 	PEnset(m_hPE, PEP_bSHOWTABLEANNOTATION, TRUE);
// 	
// 	PEnset(m_hPE, PEP_nTALOCATION, PETAL_INSIDE_AXIS_0);
// 	PEnset(m_hPE, PEP_nTAAXISLOCATION, PETAAL_TOP_LEFT + PETAAL_NEW_ROW + PETAAL_NEW_ROW);
// 	PEnset(m_hPE, PEP_nTABORDER, PETAB_SINGLE_LINE);
// 	PEnset(m_hPE, PEP_dwTABACKCOLOR, RGB(200, 200, 200));
// 	
// 	// Done setting Table Annotations ///
// 	
// 	// Set Various Other Properties ///
// 	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, TRUE);
// 	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_MEDIUM_SHADOW);
// 	PEnset(m_hPE, PEP_nGRIDLINECONTROL, PEGLC_BOTH);
// 	PEnset(m_hPE, PEP_nDATAPRECISION, 0);
// 	
// 	double f = 1.5F;
// 	PEvset(m_hPE, PEP_fAXISNUMBERSPACING, &f, 1);
	
}


void CGraphicView::OnBkBar() 
{ 
	if(m_hPE)
	{
//		PEdestroy(m_hPE);
		Invalidate();
	}
	// This example builds upon the basic CreateSimpleGraph '000' example chart //
	CreateSimpleGraph();
	
	// Construct a simple table annotation //
// 	PEnset(m_hPE, PEP_nWORKINGTABLE, 0);
// 	PEnset(m_hPE, PEP_nTAROWS, 4);
// 	PEnset(m_hPE, PEP_nTACOLUMNS, 7);
	
	// Pass the table text //
	char szTmp[48];
// 	PEvsetcellEx(m_hPE, PEP_szaTATEXT, 1, 0, "Row 2 ");
// 	PEvsetcellEx(m_hPE, PEP_szaTATEXT, 2, 0, "Row 3 ");
// 	PEvsetcellEx(m_hPE, PEP_szaTATEXT, 3, 0, "Row 4 ");
// 	
// 	PEvsetcellEx(m_hPE, PEP_szaTATEXT, 0, 1, "Column 2 ");
// 	PEvsetcellEx(m_hPE, PEP_szaTATEXT, 0, 2, "Column 3 ");
// 	PEvsetcellEx(m_hPE, PEP_szaTATEXT, 0, 3, "Column 4 ");
// 	PEvsetcellEx(m_hPE, PEP_szaTATEXT, 0, 4, "Column 5 ");
// 	PEvsetcellEx(m_hPE, PEP_szaTATEXT, 0, 5, "Column 6 ");
// 	PEvsetcellEx(m_hPE, PEP_szaTATEXT, 0, 6, "Column 7 ");
	
	float fp;
	int nTmp;
	for (int r=1; r<4; r++)
	{
		for (int c=1; c<7; c++)
		{
			fp = float(sin(0.3F * (double) c + 1) * 500.0F) + GetRandom(2, 50);
			sprintf(szTmp, "%.5f ", fp);
//			PEvsetcellEx(m_hPE, PEP_szaTATEXT, r, c, szTmp);
			nTmp = RGB(198, 0, 0);
	//		PEvsetcellEx(m_hPE, PEP_dwaTACOLOR, r, c, &nTmp); 
		}
	}
	
// 	// Other Table Related Properties ///
// 	PEnset(m_hPE, PEP_bSHOWTABLEANNOTATION, TRUE);
// 	PEnset(m_hPE, PEP_nTALOCATION, PETAL_INSIDE_TOP_LEFT);
// 	PEnset(m_hPE, PEP_dwTABACKCOLOR, RGB(255,255,255));
// 	PEnset(m_hPE, PEP_nTAHEADERROWS, 1);
// 	PEnset(m_hPE, PEP_bTAHEADERCOLUMN, TRUE);
// 	PEnset(m_hPE, PEP_nTATEXTSIZE, 85);
// 	
// 	// Construct a second simple table annotation //
// 	PEnset(m_hPE, PEP_nWORKINGTABLE, 1);  // Note WorkingTable goes to 1
// 	PEnset(m_hPE, PEP_nTAROWS, 15);
// 	PEnset(m_hPE, PEP_nTACOLUMNS, 2);
// 	
// 	// // Pass the table text //
// 	PEvsetcellEx(m_hPE, PEP_szaTATEXT, 0, 0, "");
// 	PEvsetcellEx(m_hPE, PEP_szaTATEXT, 0, 1, "Data");
// 	nTmp = PETAJ_CENTER;
// 	PEvsetcellEx(m_hPE, PEP_naTAJUSTIFICATION, 0, 0, &nTmp);
// 	PEvsetcellEx(m_hPE, PEP_naTAJUSTIFICATION, 0, 1, &nTmp);
	
	// First Column Text //
	for (r=1; r<15; r++)
	{
		sprintf(szTmp, "%2d", r);
//		PEvsetcellEx(m_hPE, PEP_szaTATEXT, r, 0, szTmp);
	}
	
	// // Second Column Text //
	for (r=1; r<15; r++)
	{
		fp = float(sin(0.3F * (double) r + 1) * 500.0F) + GetRandom(2, 50);
		sprintf(szTmp, "%.2f", fp);
//		PEvsetcellEx(m_hPE, PEP_szaTATEXT, r, 1, szTmp);
	}
	
	// Other Table Related Properties ///
// 	PEnset(m_hPE, PEP_bSHOWTABLEANNOTATION, TRUE);
// 	PEnset(m_hPE, PEP_nTALOCATION, PETAL_LEFT_CENTER);
// 	PEnset(m_hPE, PEP_dwTABACKCOLOR, RGB(255,255,255));
// 	PEnset(m_hPE, PEP_nTAHEADERROWS, 1);
// 	PEnset(m_hPE, PEP_bTAHEADERCOLUMN, TRUE);
// 	
// 	// Done setting Table Annotations ///
// 	
// 	// Set Various Other Properties ///
// 	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, TRUE);
// 	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_LIGHT_INSET);
// 	PEnset(m_hPE, PEP_nDATAPRECISION, 0);
// 	
}


void CGraphicView::OnBkBarGroup() 
{ 
	if(m_hPE)
	{
//		PEdestroy(m_hPE);
		Invalidate();
	}
	RECT rect;
	GetClientRect( &rect );
	m_canReal=FALSE;
	// Construct Object //
//	m_hPE = PEcreate(PECONTROL_SGRAPH, WS_VISIBLE, &rect, m_hWnd, 1000);
// 	
// 	PEnset(m_hPE, PEP_nSUBSETS, 4);
// 	PEnset(m_hPE, PEP_nPOINTS, 12);
	
	// Change Data to match example scales which are manually configured //
	for (int s=0; s<=3; s++)
	{
		for (int p=0; p<=11; p++)
		{
			float f;
			f =  (p + 1) * 10.0F;
//			PEvsetcellEx(m_hPE, PEP_faXDATA, s, p, &f);
			
			switch (s)
			{
			case 0:
				f = 0.01F + GetRandom(1, 4);
				break;
			case 1:
				f = 400.0F + GetRandom(1, 450);
				break;
			case 2:
				f = 0.01F + GetRandom(1, 25);
				break;
			case 3:
				f = 0.01F + GetRandom(1, 65);
				break;
			}
//			PEvsetcellEx(m_hPE, PEP_faYDATA, s, p, &f);
		}
	}
	
	// Now sub-divide subsets into 4 individual axes //
	// Each axis with one subset in each //
// 	int nArray[4] = {1,1,1,1};
// 	PEvset (m_hPE, PEP_naMULTIAXESSUBSETS, nArray, 4);
// 	
// 	// Create Overlapped Axes //
// 	int nOMA[3] = {1,1,2};
// 	PEvset (m_hPE, PEP_naOVERLAPMULTIAXES, nOMA, 3);
// 	
// 	// Set Proportions of Axes  //
// 	float fMAP[3] = {.2F, .5F, .3F};
// 	PEvset (m_hPE, PEP_faMULTIAXESPROPORTIONS, fMAP, 3);
// 	
// 	// Set up First axis parameters //  
// 	PEnset(m_hPE, PEP_nWORKINGAXIS, 0);
// 	PEnset(m_hPE, PEP_nMANUALSCALECONTROLY, PEMSC_MINMAX);
// 	double dMin = 0.0F;
// 	PEvset(m_hPE, PEP_fMANUALMINY, &dMin, 1);
// 	double dMax = 5.0F;
// 	PEvset(m_hPE, PEP_fMANUALMAXY, &dMax, 1);
// 	PEnset(m_hPE, PEP_bMANUALYAXISTICKNLINE, TRUE);
// 	double dLine = 2.5F;
// 	PEvset(m_hPE, PEP_fMANUALYAXISLINE, &dLine, 1);
// 	double dTick = 0.5F;
// 	PEvset(m_hPE, PEP_fMANUALYAXISTICK, &dTick, 1);
// 	PEnset(m_hPE, PEP_nSHOWTICKMARKY, PESTM_TICKS_HIDE); 
// 	PEszset(m_hPE, PEP_szYAXISLABEL, "NPSHR (feet)");
// 	PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_BAR);
// 	
// 	// Set up Second axis parameters //  
// 	PEnset(m_hPE, PEP_nWORKINGAXIS, 1);
// 	PEnset(m_hPE, PEP_nRYAXISCOMPARISONSUBSETS, 1);
// 	PEnset(m_hPE, PEP_nMANUALSCALECONTROLRY, PEMSC_MINMAX);
// 	dMin = 400.0F;
// 	PEvset(m_hPE, PEP_fMANUALMINRY, &dMin, 1);
// 	dMax = 900.0F;
// 	PEvset(m_hPE, PEP_fMANUALMAXRY, &dMax, 1);
// 	PEnset(m_hPE, PEP_bMANUALRYAXISTICKNLINE, TRUE);
// 	dLine = 100.0F;
// 	PEvset(m_hPE, PEP_fMANUALRYAXISLINE, &dLine, 1);
// 	dTick = 20.0F;
// 	PEvset(m_hPE, PEP_fMANUALRYAXISTICK, &dTick, 1);
// 	PEnset(m_hPE, PEP_nSHOWTICKMARKRY, PESTM_TICKS_HIDE); 
// 	PEszset(m_hPE, PEP_szRYAXISLABEL, "Total Head (feet)");
// 	PEnset(m_hPE, PEP_nPLOTTINGMETHODII, PEGPM_POINTSPLUSSPLINE);
// 	
// 	// Set up Third axis parameters //  
// 	PEnset(m_hPE, PEP_nWORKINGAXIS, 2);
// 	PEnset(m_hPE, PEP_nMANUALSCALECONTROLY, PEMSC_MINMAX);
// 	dMin = 0.0F;
// 	PEvset(m_hPE, PEP_fMANUALMINY, &dMin, 1);
// 	dMax = 30.0F;
// 	PEvset(m_hPE, PEP_fMANUALMAXY, &dMax, 1);
// 	PEnset(m_hPE, PEP_bMANUALYAXISTICKNLINE, TRUE);
// 	dLine = 10.0F;
// 	PEvset(m_hPE, PEP_fMANUALYAXISLINE, &dLine, 1);
// 	dTick = 2.0F;
// 	PEvset(m_hPE, PEP_fMANUALYAXISTICK, &dTick, 1);
// 	PEnset(m_hPE, PEP_nSHOWTICKMARKY, PESTM_TICKS_HIDE); 
// 	PEszset(m_hPE, PEP_szYAXISLABEL, "Efficiency (%)");
// 	PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_POINTSPLUSSPLINE);
// 	
// 	// Set up Fourth axis parameters //  
// 	PEnset(m_hPE, PEP_nWORKINGAXIS, 3);
// 	PEnset(m_hPE, PEP_nMANUALSCALECONTROLY, PEMSC_MINMAX);
// 	dMin = 0.0F;
// 	PEvset(m_hPE, PEP_fMANUALMINY, &dMin, 1);
// 	dMax = 75.0F;
// 	PEvset(m_hPE, PEP_fMANUALMAXY, &dMax, 1);
// 	PEnset(m_hPE, PEP_bMANUALYAXISTICKNLINE, TRUE);
// 	dLine = 25.0F;
// 	PEvset(m_hPE, PEP_fMANUALYAXISLINE, &dLine, 1);
// 	dTick = 5.0F;
// 	PEvset(m_hPE, PEP_fMANUALYAXISTICK, &dTick, 1);
// 	PEnset(m_hPE, PEP_nSHOWTICKMARKY, PESTM_TICKS_HIDE); 
// 	PEszset(m_hPE, PEP_szYAXISLABEL, "Power(HP)");
// 	PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_POINTSPLUSSPLINE);
// 	
// 	// Done Setting Y Axis Parameters, reset WorkingAxis //
// 	PEnset(m_hPE, PEP_nWORKINGAXIS, 0);
// 	
// 	// Set various other properties //
// 	PEnset(m_hPE, PEP_nGRIDLINECONTROL, PEGLC_BOTH);
// 	PEnset(m_hPE, PEP_nMULTIAXISSTYLE, PEMAS_GROUP_ALL_AXES);
// 	PEnset(m_hPE, PEP_nLEGENDSTYLE, PELS_1_LINE_INSIDE_OVERLAP);
// 	
// 	PEszset(m_hPE, PEP_szXAXISLABEL, "Flow (gpm)");
// 	
// 	PEnset(m_hPE, PEP_nBORDERTYPES, PETAB_SINGLE_LINE);
// 	PEnset(m_hPE, PEP_bFIXEDFONTS, TRUE);
// 	PEnset(m_hPE, PEP_nFONTSIZE, PEFS_MEDIUM); 
// 	PEszset(m_hPE, PEP_szMAINTITLE, "");
// 	PEszset(m_hPE, PEP_szSUBTITLE, "");
// 	PEszset(m_hPE, PEP_szSUBTITLEFONT, "Courier New");
// 	
// 	float fSize = 1.1F;
// 	PEvset(m_hPE, PEP_fFONTSIZEMSCNTL, &fSize, 1);
// 	PEvset(m_hPE, PEP_fFONTSIZEMBCNTL, &fSize, 1);
// 	
// 	
// 	PEvsetcell(m_hPE, PEP_szaMULTISUBTITLES, 0, "PUMP PREDICTED PERFORMANCE|Units: US Customary|Date: 06/07/2002");
// 	PEvsetcell(m_hPE, PEP_szaMULTISUBTITLES, 1, "Impeller Diameter (in): Max = 11.875, Rated = 11.72, Min =11.062||");
// 	
// 	PEvsetcell(m_hPE, PEP_szaMULTIBOTTOMTITLES, 1, "Customer:  Since fixed length courier font, you can create rows by number of spaces, ||");
// 	PEvsetcell(m_hPE, PEP_szaMULTIBOTTOMTITLES, 0, "Pump Model:  or, v5 has a table annotation feature which could be used to add text here. ||");
// 	
// 	PEnset(m_hPE, PEP_bYAXISONRIGHT, TRUE);
// 	
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 0, "NPSHR");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 1, "Head");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 2, "Efficiency");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 3, "Power");
// 	
// 	PEnset(m_hPE, PEP_nMULTIAXISSTYLEMENU, PEMC_SHOW);
// 	PEnset(m_hPE, PEP_nDATASHADOWS, PEDS_NONE);
// 	PEnset(m_hPE, PEP_nALLOWZOOMING, PEAZ_HORZANDVERT);
// 	PEnset(m_hPE, PEP_nZOOMSTYLE, PEZS_RO2_NOT);
// 	
// 	PEnset(m_hPE, PEP_bSIMPLELINELEGEND, TRUE);
// 	PEnset(m_hPE, PEP_bSIMPLEPOINTLEGEND, TRUE);
// 	
// 	DWORD dwArray[4] = { RGB(198,0,0), RGB( 0, 198, 198 ), RGB( 198,198,0 ), RGB( 0,198,0 ) };
// 	PEvset(m_hPE, PEP_dwaSUBSETCOLORS, dwArray, 4);
// 	
// 	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, TRUE);
// 	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_DARK_NO_BORDER);
// 	
// 	PEnset(m_hPE, PEP_nTEXTSHADOWS, PETS_BOLD_TEXT);
// 	PEnset(m_hPE, PEP_bMAINTITLEBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bSUBTITLEBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bLABELBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bLINESHADOWS, TRUE);
// 	PEnset(m_hPE, PEP_nFONTSIZE, PEFS_LARGE);
// 	PEnset(m_hPE, PEP_nGRADIENTBARS, 8);
// 	PEnset(m_hPE, PEP_nDATASHADOWS, PEDS_SHADOWS);
	
}




void CGraphicView::OnBkPie() 
{
	if(m_hPE)
	{
//		PEdestroy(m_hPE);
		Invalidate();
	}
	//! Double Click to start and stop Auto Rotation. //
	//! Click and drag scroll bar thumb tabs to quickly rotate. // 
	//! Right button click to show popup menu. //
	
	RECT rect;
	GetClientRect( &rect );
////	m_hPE = PEcreate(PECONTROL_3D, WS_VISIBLE, &rect, m_hWnd, 1001);
	
	// Non-Surface chart, set PolyMode //
//	PEnset(m_hPE, PEP_nPOLYMODE, PEPM_3DBAR);
	
	// Pass Data //
	double sMin, sMax;
	long Row, Col, o, s, e, nQ;
	long nStartRow, nEndRow, nStartCol, nEndCol, nTargetRows, nTargetCols;
	
	nStartRow = 216;
	nEndRow = 230;
	nTargetRows = nEndRow - nStartRow + 1;
	
	nStartCol = 156;
	nEndCol = 170;
	nTargetCols = nEndCol - nStartCol + 1;
	
	nQ = nTargetRows * nTargetCols;
	
	long* pElevData = NULL;
	float* pMyXData = NULL;    
	float* pMyYData = NULL;
	float* pMyZData = NULL;
	
	char szFile[] = "terrain.bin";
	FILE * pFile = NULL;
	pFile = fopen(szFile, "rb");
	
	if (pFile)
	{
		pElevData = new long[202500];
		// Transfer entire data file into memory //
		size_t cnt;
		e = 0;
		for (s = 0; s < 45; s++)
		{
			cnt = fread(&pElevData[e], sizeof(long), 4500, pFile);
			e += 4500;
		}
		fclose(pFile);
	}
	else
	{
		MessageBox("Data File [terrain.bin] not found in program directory.");
		return;
	}
	
	pMyXData = new float[nQ];
	pMyYData = new float[nQ];
	pMyZData = new float[nQ];
	
	long rowcounter, colcounter;
	BOOL foundtargetindex = FALSE;
	rowcounter = 0;
	colcounter = 0;
	
	sMax = -9999999.9F;
	sMin = 9999999.9F;
	for (Row=0; Row<450; Row++)
	{
		for (Col=0; Col<450; Col++)
		{
			foundtargetindex = FALSE;
			
			if (Row >= nStartRow && Row <= nEndRow) 
			{
				if (Col >= nStartCol && Col <= nEndCol)
				{
					foundtargetindex = TRUE;
					o = (rowcounter * nTargetRows) + colcounter;
					pMyXData[o] = (float) Col + 1;
					pMyZData[o] = (float) Row + 1;
					pMyYData[o] = pElevData[(Row * 450) + Col] * 0.1F;
				}
			}
			if (foundtargetindex) 
				colcounter++;
		}
		if (foundtargetindex)
			rowcounter++;
	}
	
//	PEnset(m_hPE, PEP_nSUBSETS, nTargetRows);
//	PEnset(m_hPE, PEP_nPOINTS, nTargetCols);
	
	// Perform the actual transfer of data //
//	PEvset(m_hPE, PEP_faXDATA, pMyXData, nQ);
//	PEvset(m_hPE, PEP_faYDATA, pMyYData, nQ);
//	PEvset(m_hPE, PEP_faZDATA, pMyZData, nQ);
	
	if (pElevData)
		delete pElevData;
	if (pMyXData)
		delete pMyXData;
	if (pMyYData)
		delete pMyYData;
	if (pMyZData)
		delete pMyZData;
	
	// Set Various Other Properties //
//	PEnset(m_hPE, PEP_bFIXEDFONTS, TRUE);
//	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, TRUE);
////	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_DARK_SHADOW);
	
	DWORD dwColor[] = {RGB(0, 148, 0), RGB(148, 0, 0), RGB(0, 0, 148),
		RGB(148, 148, 0), RGB(0, 148, 148),
		RGB(0, 182, 0), RGB(182, 0, 0), RGB(0, 0, 182),
		RGB(182, 182, 0), RGB(0, 182, 182),
		RGB(0, 198, 0), RGB(198, 0, 0), RGB(0, 0, 198),
		RGB(198, 198, 0), RGB(0, 198, 148)  };
///	PEvset(m_hPE, PEP_dwaSUBSETCOLORS, dwColor, 15);
	
	// Set subset labels for z axis**
////	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 0, "Row 1");
//	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 1, "Row 2");
//	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 2, "Row 3");
//	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 3, "Row 4");
//	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 4, "Row 5");
//	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 5, "Row 6");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 6, "Row 7");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 7, "Row 8");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 8, "Row 9");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 9, "Row 10");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 10, "Row 11");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 11, "Row 12");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 12, "Row 13");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 13, "Row 14");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 14, "Row 15");
	
	// Set point labels for x axis //
// 	PEvsetcell(m_hPE, PEP_szaPOINTLABELS, 0, "Col 1");
// 	PEvsetcell(m_hPE, PEP_szaPOINTLABELS, 1, "Col 2");
// 	PEvsetcell(m_hPE, PEP_szaPOINTLABELS, 2, "Col 3");
// 	PEvsetcell(m_hPE, PEP_szaPOINTLABELS, 3, "Col 4");
// 	PEvsetcell(m_hPE, PEP_szaPOINTLABELS, 4, "Col 5");
// 	PEvsetcell(m_hPE, PEP_szaPOINTLABELS, 5, "Col 6");
// 	PEvsetcell(m_hPE, PEP_szaPOINTLABELS, 6, "Col 7");
// 	PEvsetcell(m_hPE, PEP_szaPOINTLABELS, 7, "Col 8");
// 	PEvsetcell(m_hPE, PEP_szaPOINTLABELS, 8, "Col 9");
// 	PEvsetcell(m_hPE, PEP_szaPOINTLABELS, 9, "Col 10");
// 	PEvsetcell(m_hPE, PEP_szaPOINTLABELS, 10, "Col 11");
// 	PEvsetcell(m_hPE, PEP_szaPOINTLABELS, 11, "Col 12");
// 	PEvsetcell(m_hPE, PEP_szaPOINTLABELS, 12, "Col 13");
// 	PEvsetcell(m_hPE, PEP_szaPOINTLABELS, 13, "Col 14");
// 	PEvsetcell(m_hPE, PEP_szaPOINTLABELS, 14, "Col 15");
// 	
	// Set Titles //
//	PEszset(m_hPE, PEP_szMAINTITLE, "3D Bar");
//	PEszset(m_hPE, PEP_szSUBTITLE, "");
	
	// Set camera position //
//	PEnset(m_hPE, PEP_nVIEWINGHEIGHT, 15);
//	PEnset(m_hPE, PEP_nDEGREEOFROTATION, 314);
	
	// Set Plotting methods //
//	PEnset(m_hPE, PEP_nPLOTTINGMETHOD, 2);   // ' Shading
	
	// Full rotation detail //
//	PEnset(m_hPE, PEP_nROTATIONDETAIL, PERD_FULLDETAIL);
	
	// Set small font size //
//	PEnset(m_hPE, PEP_nFONTSIZE, PEFS_SMALL);
	
	// Prepare images in memory //
//	PEnset(m_hPE, PEP_bPREPAREIMAGES, TRUE);
// 	PEnset(m_hPE, PEP_bCACHEBMP, TRUE);
// 	PEnset(m_hPE, PEP_bFOCALRECT, FALSE);
// 	PEnset(m_hPE, PEP_bALLOWSTYLEPAGE, FALSE);
//	PEnset(m_hPE, PEP_nROTATIONINCREMENT, PERI_INCBY2);
	
// 	// Add Some Padding on Right and Bottom //
// 	PEnset(m_hPE, PEP_nIMAGEADJUSTLEFT, 400);
// 	PEnset(m_hPE, PEP_nIMAGEADJUSTRIGHT, 400);
// 	PEnset(m_hPE, PEP_nIMAGEADJUSTBOTTOM, 400);
	
//	PEnset(m_hPE, PEP_nTEXTSHADOWS, PETS_BOLD_TEXT);
// 	PEnset(m_hPE, PEP_bMAINTITLEBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bSUBTITLEBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bLABELBOLD, TRUE);
//	PEnset(m_hPE, PEP_nFONTSIZE, PEFS_LARGE);
//	PEnset(m_hPE, PEP_dwGRAPHFORECOLOR, RGB(192,192,192));
	
}



void CGraphicView::OnButton32781() 
{ 
	if(m_hPE)
	{
//		PEdestroy(m_hPE);
		Invalidate();
	}
	//! Double Click to start and stop Auto Rotation. //
	//! Click and drag scroll bar thumb tabs to quickly rotate. // 
	//! Right button click to show popup menu. //
	
	RECT rect;
	GetClientRect( &rect );
////	m_hPE = PEcreate(PECONTROL_3D, WS_VISIBLE, &rect, m_hWnd, 1001);
	
	// Non-Surface chart, set PolyMode //
//	PEnset(m_hPE, PEP_nPOLYMODE, PEPM_SCATTER);
	
	// Set the amount of data //
//	PEnset(m_hPE, PEP_nSUBSETS, 10);
//	PEnset(m_hPE, PEP_nPOINTS, 50);
	
	// Pass data, First two subsets //
	float f, f2;
	for (int s=0; s<=1; s++)
	{
		for (int p=0; p<=49; p++)
		{
			f2 = 5.0F * (float)cos(p * .24);
//			PEvsetcellEx(m_hPE, PEP_faXDATA, s, p, &f2);
			
			if (s == 0)
				f = (35.0F * (float)cos(p * 0.22F)) + (10.0F * (float)sin((s * .1F) * .94F));
			else
				f = (35.0F * (float)cos(p * 0.08F)) + (10.0F * (float)cos((s * .25F) * .6F));
//			PEvsetcellEx(m_hPE, PEP_faYDATA, s, p, &f);
			
			f = 5.0F * (float)(sin(p * .08F));
//			PEvsetcellEx(m_hPE, PEP_faZDATA, s, p, &f);
		}
	}
	
	// Pass more data, Second two subsets //
	for (s=0; s<=1; s++)
	{
		for (int p=0; p<=49; p++)
		{
			f2 = 5.0F * (float)cos(p * .14);
			f2 += 20;
//			PEvsetcellEx(m_hPE, PEP_faXDATA, s + 2, p, &f2);
			
			if (s == 0)
				f = (35.0F * (float)cos(p * 0.2F)) + (10.0F * (float)sin((s * .1F) * .74F));
			else
				f = (35.0F * (float)cos(p * 0.1F)) + (10.0F * (float)cos((s * .25F) * .74F));
			f += 40;
//			PEvsetcellEx(m_hPE, PEP_faYDATA, s + 2, p, &f);
			
			f = 5.0F * (float)(sin(p * .16F));
			f += 20;
//			PEvsetcellEx(m_hPE, PEP_faZDATA, s + 2, p, &f);
		}
	}
	
	// Pass more data, Third two subsets //
	for (s=0; s<=1; s++)
	{
		for (int p=0; p<=49; p++)
		{
			f2 = 5.0F * (float)cos(p * .07);
			f2 -= 20;
//			PEvsetcellEx(m_hPE, PEP_faXDATA, s + 4, p, &f2);
			
			if (s == 0)
				f = (35.0F * (float)cos(p * 0.08F)) + (10.0F * (float)sin((s * .07F) * .64F));
			else
				f = (35.0F * (float)cos(p * 0.2F)) + (10.0F * (float)cos((s * .15F) * 1.94F));
			f += 40;
		//	PEvsetcellEx(m_hPE, PEP_faYDATA, s + 4, p, &f);
			
			f = 5.0F * (float)(sin(p * .09F));
			f += 20;
		//	PEvsetcellEx(m_hPE, PEP_faZDATA, s + 4, p, &f);
		}
	}
	
	// Pass more data, Fourth two subsets //
	for (s=0; s<=1; s++)
	{
		for (int p=0; p<=49; p++)
		{
			f2 = 5.0F * (float)cos(p * .12);
			f2 -= 20;
		//	PEvsetcellEx(m_hPE, PEP_faXDATA, s + 6, p, &f2);
			
			if (s == 0)
				f = (35.0F * (float)cos(p * 0.3F)) + (10.0F * (float)sin((s * .08F) * 1.74F));
			else
				f = (35.0F * (float)cos(p * 0.2F)) + (10.0F * (float)cos((s * .75F) * .774F));
			f -= 40;
		//	PEvsetcellEx(m_hPE, PEP_faYDATA, s + 6, p, &f);
			
			f = 5.0F * (float)(sin(p * .36F));
			f -= 20;
		//	PEvsetcellEx(m_hPE, PEP_faZDATA, s + 6, p, &f);
		}
	}
	
	// Pass more data, Fifth two subsets //
	for (s=0; s<=1; s++)
	{
		for (int p=0; p<=49; p++)
		{
			f2 = 5.0F * (float)cos(p * .14);
			f2 += 20;
//			PEvsetcellEx(m_hPE, PEP_faXDATA, s + 8, p, &f2);
			
			if (s == 0)
				f = (25.0F * (float)cos(p * 0.1F)) + (10.0F * (float)sin((s * .02F) * 3.74F));
			else
				f = (55.0F * (float)cos(p * 0.2F)) + (10.0F * (float)cos((s * .05F) * 5.74F));
			f += 40;
//			PEvsetcellEx(m_hPE, PEP_faYDATA, s + 8, p, &f);
			
			f = 5.0F * (float)(sin(p * .16F));
			f -= 20;
	//		PEvsetcellEx(m_hPE, PEP_faZDATA, s + 8, p, &f);
		}
	}
	
	// Set Various Other Properties //
//	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, FALSE);
//	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_DARK_INSET);
	
	DWORD dwColor[] = {RGB(198, 198, 0), RGB(0, 198, 198), RGB(0, 198, 0), RGB(198, 0, 0), RGB(0, 0, 198), 
		RGB(192,192,192), RGB(198, 0, 198), RGB(200, 198, 150), RGB(200, 200, 140), RGB(150, 0, 198)};
//	PEvset(m_hPE, PEP_dwaSUBSETCOLORS, dwColor, 10);
	
//	int nPTypes[] = {PEPT_PLUS, PEPT_PLUS, PEPT_PLUS, PEPT_PLUS, PEPT_PLUS, PEPT_PLUS, PEPT_PLUS, PEPT_PLUS, PEPT_PLUS, PEPT_PLUS};
//	PEvset(m_hPE, PEP_naSUBSETPOINTTYPES, nPTypes, 10);
	
	// Set subset labels and titles //
//	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 0, "Data 1");
//	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 1, "Data 2");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 2, "Data 3");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 3, "Data 4");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 4, "Data 5");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 5, "Data 6");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 6, "Data 7");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 7, "Data 8");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 8, "Data 9");
// 	PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 9, "Data 10");
// 	
//	PEszset(m_hPE, PEP_szMAINTITLE, "3D Scatter");
//	PEszset(m_hPE, PEP_szSUBTITLE, "");
	
	// Set camera position //
//	PEnset(m_hPE, PEP_nVIEWINGHEIGHT, 15);
//	PEnset(m_hPE, PEP_nDEGREEOFROTATION, 145);
	
	// Set Plotting methods //
//	PEnset(m_hPE, PEP_nPLOTTINGMETHOD, 0);   // ' Points
	
	// Set small font size //
//	PEnset(m_hPE, PEP_nFONTSIZE, PEFS_MEDIUM);
//	PEnset(m_hPE, PEP_bFIXEDFONTS, TRUE);
	
	// Set legend location //
//	PEnset(m_hPE, PEP_nLEGENDLOCATION, PELL_LEFT);
	
	// Prepare images in memory //
//	PEnset(m_hPE, PEP_bPREPAREIMAGES, TRUE);
//	PEnset(m_hPE, PEP_bFOCALRECT, FALSE);
//	PEnset(m_hPE, PEP_bCACHEBMP, TRUE);
	
//	PEnset(m_hPE, PEP_nROTATIONDETAIL, PERD_FULLDETAIL);
//	PEnset(m_hPE, PEP_nROTATIONSPEED, 50);
//	PEnset(m_hPE, PEP_nROTATIONINCREMENT, PERI_INCBY1);
//		PEnset(m_hPE, PEP_bAUTOROTATION, TRUE);
//	PEnset(m_hPE, PEP_bSHOWLEGEND, FALSE);
	
// 	// Add Some Padding around image //
// 	PEnset(m_hPE, PEP_nIMAGEADJUSTLEFT, 400);
// 	PEnset(m_hPE, PEP_nIMAGEADJUSTRIGHT, 400);
// 	PEnset(m_hPE, PEP_nIMAGEADJUSTBOTTOM, 400);
	
//	PEnset(m_hPE, PEP_nTEXTSHADOWS, PETS_BOLD_TEXT);
// 	PEnset(m_hPE, PEP_bMAINTITLEBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bSUBTITLEBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bLABELBOLD, TRUE);
// //	PEnset(m_hPE, PEP_nFONTSIZE, PEFS_LARGE);
// 	PEnset(m_hPE, PEP_dwGRAPHFORECOLOR, RGB(192,192,192));
	
}


void CGraphicView::OnSize(UINT nType, int cx, int cy) 
{
	CView::OnSize(nType, cx, cy);
	if(m_hPE)
//		PEdestroy(m_hPE);
	CreateSimpleGraph(); 
	// TODO: Add your message handler code here
	
}

void CGraphicView::OnDrawNew() 
{ 
	if(m_hPE)
//		PEdestroy(m_hPE);
	// This example builds upon the basic CreateSimpleGraph '000' example chart //
	CreateSimpleGraph();
	
	int nHatchType[4];
//	nHatchType[0] = PEHS_BDIAGONAL;
//	nHatchType[1] = PEHS_CROSS;
//	nHatchType[2] = PEHS_DIAGCROSS;
//	nHatchType[3] = PEHS_FDIAGONAL;
//	PEvset(m_hPE, PEP_naSUBSETHATCH, nHatchType, 4);
	
	// Set Other Various Properties ///
//	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, TRUE);
//	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_MEDIUM_INSET);
	
	// Enable Stacked type charts //
//	PEnset(m_hPE, PEP_bNOSTACKEDDATA, FALSE);
	
	// Set plotting method //
//	PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_BARSTACKED);
//	PEnset(m_hPE, PEP_dwHATCHBACKCOLOR, RGB(100,100,100));
//	PEnset(m_hPE, PEP_bDATASHADOWS, PEDS_SHADOWS); 
	
	// Add a table //
//	PEnset(m_hPE, PEP_nGRAPHPLUSTABLE, PEGPT_BOTH);
//	PEnset(m_hPE, PEP_nDATAPRECISION, 0);
}


void CGraphicView::OnDrawSile() 
{ 
	if(m_hPE)
//		PEdestroy(m_hPE);
	//! Cross-Hair inside chart is a cursor giving a datapoint the focus //
	//! Use arrow keys or mouse to move cursor to a new location //
	//! You must click the control to give it the focus before key strokes will work. //
	//! Right and Left arrow keys move cursor up and down points //
	//! Up and Down arrow keys move cursor up and down subsets //
	
	// This example builds upon the basic CreateSimpleSGraph '100' example chart //
	CreateSimpleSGraph();
	
	// Set up cursor //
//	PEnset(m_hPE, PEP_nCURSORMODE, PECM_DATACROSS);
	
	// Help see data points //
//	PEnset(m_hPE, PEP_bMARKDATAPOINTS, TRUE);
	
	// This will allow you to move cursor by clicking data point //
//	PEnset(m_hPE, PEP_bMOUSECURSORCONTROL, TRUE);
//	PEnset(m_hPE, PEP_bALLOWDATAHOTSPOTS, TRUE);
	
	// Cursor prompting in top left corner //
//	PEnset(m_hPE, PEP_bCURSORPROMPTTRACKING, TRUE);
//	PEnset(m_hPE, PEP_nCURSORPROMPTSTYLE, PECPS_XYVALUES);
//	PEnset(m_hPE, PEP_nCURSORPROMPTLOCATION, PECPL_TOP_RIGHT);
	
	// Disable Zooming //
//	PEnset(m_hPE, PEP_nALLOWZOOMING, PEAZ_NONE);
	
	// Other possible values for cursor mode are below, //
	// PECM_NOCURSOR = 0
	// PECM_POINT = 1
	// PECM_DATACROSS = 2
	// PECM_DATASQUARE = 3
	// PECM_FLOATINGY = 4
	// PECM_FLOATINGXY = 5
	
	// Uncomment to start cursor at different location //	
	// NOTE: You must reinitialize before setting cursor location //
	// PEreinitialize(m_hPE);
	// PEresetimage(m_hPE, 0, 0);
	// PEnset(m_hPE, PEP_nCURSORSUBSET, 0);
	// PEnset(m_hPE, PEP_nCURSORPOINT, 2);
	
	////////////////////////////////////////////////////////////////////////
	// Look in OnCommand handler to see how to respond to cursor movement //
	////////////////////////////////////////////////////////////////////////
	/*
	
	  else if ((m_nLastSelection == 105) && (HIWORD(wp) == PEWN_CURSORMOVE))
	  {
	  int nSubset, nPoint;
	  float xvalue, yvalue;
	  char buffer[64];
	  
		nSubset = PEnget(m_hPE, PEP_nCURSORSUBSET);
		nPoint = PEnget(m_hPE, PEP_nCURSORPOINT);
		
		  PEvgetcellEx(m_hPE, PEP_faXDATA, nSubset, nPoint, &xvalue);
		  PEvgetcellEx(m_hPE, PEP_faYDATA, nSubset, nPoint, &yvalue);
		  
			sprintf(buffer, "Cursor at %d,%d=(%.2f, %.2f)", nSubset, nPoint, xvalue, yvalue);
			
			  CWnd* pParent = GetParent()->GetParent();
			  if (pParent) {pParent->SetWindowText(buffer);}
			  
				pParent = AfxGetMainWnd();
				if (pParent) {pParent->SetWindowText("PEWN_CURSORMOVE");}
				
				  return TRUE;
				  }
	*/
	
	
}


void CGraphicView::CreateSimpleSGraph()
{
	
	if(m_hPE)
//		PEdestroy(m_hPE);
	
	m_Real=FALSE;
	m_canReal=FALSE;
	//! Right button click to show popup menu. //
	//! Double Click to show customization dialog. //
	//! Left-Click and drag to draw zoom box. Use popup memu or 'z' to undo zoom. // 
	
	// Simple example show the basics of a scientific graph object. //
	// Scientific Graph's contain both YData and XData and thus data
	// is not plotted equally spaced as the graph object does.
	
	RECT rect;
	GetClientRect( &rect );
////	m_hPE = PEcreate(PECONTROL_SGRAPH, WS_VISIBLE, &rect, m_hWnd, 1001);
	if( m_hPE )
	{
		float fY;
		float fX;
		
		// Set number of Subsets and Points //
///		PEnset(m_hPE, PEP_nSUBSETS, 4);	
	//	PEnset(m_hPE, PEP_nPOINTS, 12);	
		
		for( int s=0; s<=3; s++ )
		{
			for( int p=0; p<=11; p++ )
			{										  
				fX = ((float) (p+1)) * 100.0F;
		//		PEvsetcellEx (m_hPE, PEP_faXDATA, s, p, &fX);
				fY = ((float) (p+1) * 1.0F) + GetRandom(1, 250);
		//		PEvsetcellEx (m_hPE, PEP_faYDATA, s, p, &fY);
			}
		}
		
		// Set DataShadows to show shadows
//		PEnset(m_hPE, PEP_nDATASHADOWS, PEDS_SHADOWS);
		
//		PEszset(m_hPE, PEP_szMAINTITLE, "历史线性统计曲线");
// 		PEszset(m_hPE, PEP_szSUBTITLE, "程序设计与实现--戚高"); 
// 		PEszset(m_hPE, PEP_szYAXISLABEL, "最大应用量");
// 		PEszset(m_hPE, PEP_szXAXISLABEL, "月份");
// 		PEnset(m_hPE, PEP_bFOCALRECT, FALSE);
// 		PEnset(m_hPE, PEP_bPREPAREIMAGES, TRUE);
// 		PEnset(m_hPE, PEP_bCACHEBMP, TRUE);
//		PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_POINTSPLUSSPLINE);
//		PEnset(m_hPE, PEP_nGRIDLINECONTROL, PEGLC_NONE);
//		PEnset(m_hPE, PEP_nALLOWZOOMING, PEAZ_HORZANDVERT);
////		PEnset(m_hPE, PEP_nZOOMSTYLE, PEZS_RO2_NOT);
		
		// subset labels //
//		PEvsetcell( m_hPE, PEP_szaSUBSETLABELS, 0, "长沙" );
// 		PEvsetcell( m_hPE, PEP_szaSUBSETLABELS, 1, "上海" );
// 		PEvsetcell( m_hPE, PEP_szaSUBSETLABELS, 2, "北京" );
// 		PEvsetcell( m_hPE, PEP_szaSUBSETLABELS, 3, "广州" );
// 		
		// subset colors
		DWORD dwArray[4] = { RGB(198,0,0), RGB( 0, 198, 198 ), RGB( 198,198,0 ), RGB( 0,198,0 ) };
//		PEvsetEx( m_hPE, PEP_dwaSUBSETCOLORS, 0, 4, dwArray, 0 );
		
		// subset line types
//		int nLineTypes[] = { PELT_MEDIUMSOLID, PELT_MEDIUMSOLID, PELT_MEDIUMSOLID, PELT_MEDIUMSOLID };
//		PEvset(m_hPE, PEP_naSUBSETLINETYPES, nLineTypes, 4);
		
		// subset point types
////////		int nPointTypes[] = { PEPT_DOTSOLID, PEPT_UPTRIANGLESOLID, PEPT_SQUARESOLID, PEPT_DOWNTRIANGLESOLID };
//		PEvset(m_hPE, PEP_naSUBSETPOINTTYPES, nPointTypes, 4);
		
		// Version 4.0 Features //
// 		PEnset(m_hPE, PEP_bFIXEDFONTS, TRUE);
// 		PEnset(m_hPE, PEP_bSIMPLEPOINTLEGEND, TRUE);
// 		PEnset(m_hPE, PEP_bSIMPLELINELEGEND, TRUE);
// //		PEnset(m_hPE, PEP_nLEGENDSTYLE, PELS_1_LINE);
//		PEnset(m_hPE, PEP_nMULTIAXISSTYLE, PEMAS_SEPARATE_AXES);
		
		// Set Various Other Properties //
	//	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, TRUE);
//		PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_MEDIUM_NO_BORDER);
		
// 		PEnset(m_hPE, PEP_nGRADIENTBARS, 8);
// //		PEnset(m_hPE, PEP_nTEXTSHADOWS, PETS_BOLD_TEXT);
// 		PEnset(m_hPE, PEP_bMAINTITLEBOLD, TRUE);
// 		PEnset(m_hPE, PEP_bSUBTITLEBOLD, TRUE);
// 		PEnset(m_hPE, PEP_bLABELBOLD, TRUE);
// 		PEnset(m_hPE, PEP_bLINESHADOWS, TRUE);
// //		PEnset(m_hPE, PEP_nFONTSIZE, PEFS_LARGE);
// 		PEnset(m_hPE, PEP_bSCROLLINGHORZZOOM, TRUE);
		
		
	}
}



void CGraphicView::OnReal() 
{
	KillTimer(1);
	if(m_hPE)
//		PEdestroy(m_hPE);
	
	m_canReal=TRUE;
	m_Real=TRUE;
	
	//! Chart holds 2000 points.  Data is fed into
	//! data arrays at current data index.  Once 2000
	//! points have been passed, 250 are truncated as
	//! data is shifted to make room for 250 more data
	//! points.
	
	//! Depending upon ZoomMode property, this example with
	//! either show most current 3 minutes or all data in
	//! object.
	
	
	RECT rect;
	GetClientRect( &rect );
	
	// Construct Object //
//	m_hPE = PEcreate(PECONTROL_SGRAPH, WS_CHILD|WS_VISIBLE, &rect, m_hWnd, 1001);
	
// 	PEnset(m_hPE, PEP_nSUBSETS, 3);
// 	PEnset(m_hPE, PEP_nPOINTS, 2000);
	
//	PEnset(m_hPE, PEP_nDATETIMEMODE, PEDTM_VB);	// Date/Time Mode
//	PEnset(m_hPE, PEP_bUSINGXDATAII, TRUE);     // Using Double Precision XDataII
	
	// Some functional attributes            // 1440 is minutes in a day
	ZoomInterval = (3.0F / 1440.0F);         // 3 minute scale zoom interval
	ZoomSmallInterval = (0.5F / 1440.0F);    // 30 second scale adjustment
	
	// Determine current date and time in VB's format //
	CTime t = CTime::GetCurrentTime();
////	TM petm;
// 	petm.nDay = t.GetDay();
// 	petm.nMonth = t.GetMonth();
// 	petm.nYear = t.GetYear() - 1900;
// 	petm.nHour = t.GetHour();
// 	petm.nMinute = t.GetMinute();
// 	petm.nSecond = t.GetSecond();
// 	PEcreateserialdate(&StartTime, &petm, PEDTM_VB);
	
	// Extents to show all data points 
	double manmaxx;
//	PEnset(m_hPE, PEP_nMANUALSCALECONTROLX, PEMSC_MINMAX);
//	PEvset(m_hPE, PEP_fMANUALMINX, &StartTime, 1);
	manmaxx = StartTime + ZoomInterval;
//	PEvset(m_hPE, PEP_fMANUALMAXX, &manmaxx, 1);
	
//	PEnset(m_hPE, PEP_nMANUALSCALECONTROLY, PEMSC_MINMAX);
	double d = 1.0F;
//	PEvset(m_hPE, PEP_fMANUALMINY, &d, 1);
	d = 100.0F;
//	PEvset(m_hPE, PEP_fMANUALMAXY, &d, 1);
	
	// Set Zoomed partial Range of X Scale //
	ZoomStart = StartTime;
	ZoomEnd = ZoomStart + ZoomInterval;
	
// 	PEvset(m_hPE, PEP_fZOOMMINX, &ZoomStart, 1);
// 	PEvset(m_hPE, PEP_fZOOMMAXX, &ZoomEnd, 1);
// 	d = 1.0F;
// 	PEvset(m_hPE, PEP_fZOOMMINY, &d, 1);
// 	d = 100.0F;
// 	PEvset(m_hPE, PEP_fZOOMMAXY, &d, 1);
// 	
// //	PEnset(m_hPE, PEP_bZOOMMODE, TRUE);
	// If ZoomMode is True, you will see 3 minutes of data //
	// If ZoomMode is False, you will see all data in object //
	
	// Clear out default data '
	// No need to clear out XData since using XDataII '
	float f = 0.0F;
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 0, 0, &f);
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 0, 1, &f);
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 0, 2, &f);
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 0, 3, &f);
// 	
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 1, 0, &f);
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 1, 1, &f);
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 1, 2, &f);
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 1, 3, &f);
// 	
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 2, 0, &f);
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 2, 1, &f);
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 2, 2, &f);
// 	PEvsetcellEx(m_hPE, PEP_faYDATA, 2, 3, &f);
// 	
	// Show Annotations //
// 	PEnset(m_hPE, PEP_bSHOWANNOTATIONS, TRUE);
// 	
// 	// Set Various Other Properties ///
// 	PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, TRUE);
// //	PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_DARK_INSET);
// 	
// 	int nTmpStyle;
// //	nTmpStyle = PELT_THINSOLID;
// 	PEvsetcell(m_hPE, PEP_naSUBSETLINETYPES, 0, &nTmpStyle); 
// 	PEvsetcell(m_hPE, PEP_naSUBSETLINETYPES, 1, &nTmpStyle); 
// 	PEvsetcell(m_hPE, PEP_naSUBSETLINETYPES, 2, &nTmpStyle);
	// PEvset(m_hPE, PEP_naSUBSETLINETYPES, PELT_THINSOLID, 0);
	
	char szSubsets[] = "电流\t电压\t频率\t";
// 	PEvset (m_hPE, PEP_szaSUBSETLABELS, szSubsets, 3);
// 	
// 	PEszset(m_hPE, PEP_szMAINTITLE, "工业用实时曲线");
// 	PEszset(m_hPE, PEP_szSUBTITLE, "编程设计实现-戚高");
// 	PEnset(m_hPE, PEP_bNORANDOMPOINTSTOEXPORT, TRUE);
// 	PEnset(m_hPE, PEP_bFOCALRECT, FALSE);
// 	PEnset(m_hPE, PEP_bALLOWBAR, FALSE);
// 	PEnset(m_hPE, PEP_bALLOWPOPUP, FALSE);
// 	PEnset(m_hPE, PEP_bPREPAREIMAGES, TRUE);
// 	PEnset(m_hPE, PEP_bCACHEBMP, TRUE);
// 	PEnset(m_hPE, PEP_bFIXEDFONTS, TRUE);
	
	DWORD col = RGB(0, 198, 198);
// 	PEvsetcell(m_hPE, PEP_dwaSUBSETCOLORS, 0, &col); 
// 	
// 	col = RGB(0,198,0);
// 	PEvsetcell(m_hPE, PEP_dwaSUBSETCOLORS, 1, &col);
// 	
// 	col = RGB(255,0,0);
// 	PEvsetcell(m_hPE, PEP_dwaSUBSETCOLORS, 2, &col);
// 	
// 	PEnset(m_hPE, PEP_nGRADIENTBARS, 8);
// //	PEnset(m_hPE, PEP_nTEXTSHADOWS, PETS_BOLD_TEXT);
// 	PEnset(m_hPE, PEP_bMAINTITLEBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bSUBTITLEBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bLABELBOLD, TRUE);
// 	PEnset(m_hPE, PEP_bLINESHADOWS, TRUE);
// //	PEnset(m_hPE, PEP_nFONTSIZE, PEFS_LARGE);
// 	
// //	PEreinitialize(m_hPE);
//	PEresetimage(m_hPE, 0, 0);
	::InvalidateRect(m_hPE, NULL, FALSE);
	
	// Initialize Counters and Timer //
	m_nRealTimeCounter = 1;
	m_nSinCounter = 1;
	SetTimer( 2, 250, NULL ); 
}



void CGraphicView::OnDrawgraph() 
{  
	if(m_hPE)
	{
//		PEdestroy(m_hPE);
		Invalidate();
	}
	m_Real=TRUE;
	m_canReal=TRUE;
   //! Chart fills 100 points but x axis is initially
   //! manually scaled.  Once 100 point have been passed,
   //! the chart switches to autoscaling the x axis.

   RECT rect;
   GetClientRect( &rect );

   // Construct Object //
//   m_hPE = PEcreate(PECONTROL_SGRAPH, WS_VISIBLE, &rect, m_hWnd, 1001);

//    PEnset(m_hPE, PEP_nSUBSETS, 1);
//    PEnset(m_hPE, PEP_nPOINTS, 100);
// 
//    // Set Manual Y scale //
// //   PEnset(m_hPE, PEP_nMANUALSCALECONTROLY, PEMSC_MINMAX);
//    double arg = 1.0F;
//    PEvset(m_hPE, PEP_fMANUALMINY, &arg, 1);
//    arg = 100.0F;
//    PEvset(m_hPE, PEP_fMANUALMAXY, &arg, 1);
// 
//    // Set Manual X scale //
// //   PEnset(m_hPE, PEP_nMANUALSCALECONTROLX, PEMSC_MINMAX);
//    arg = 1.0F;
//    PEvset(m_hPE, PEP_fMANUALMINX, &arg, 1);
//    arg = 100;
//    PEvset(m_hPE, PEP_fMANUALMAXX, &arg, 1);
// 
//    // Clear out default data //
//    float val = 0;
//    PEvsetcellEx(m_hPE, PEP_faXDATA, 0, 0, &val);
//    PEvsetcellEx(m_hPE, PEP_faXDATA, 0, 1, &val);
//    PEvsetcellEx(m_hPE, PEP_faXDATA, 0, 2, &val);
//    PEvsetcellEx(m_hPE, PEP_faXDATA, 0, 3, &val);
// 
//    PEvsetcellEx(m_hPE, PEP_faYDATA, 0, 0, &val);
//    PEvsetcellEx(m_hPE, PEP_faYDATA, 0, 1, &val);
//    PEvsetcellEx(m_hPE, PEP_faYDATA, 0, 2, &val);
//    PEvsetcellEx(m_hPE, PEP_faYDATA, 0, 3, &val);
// 
//    PEvsetcellEx(m_hPE, PEP_faXDATA, 1, 0, &val);
//    PEvsetcellEx(m_hPE, PEP_faXDATA, 1, 1, &val);
//    PEvsetcellEx(m_hPE, PEP_faXDATA, 1, 2, &val);
//    PEvsetcellEx(m_hPE, PEP_faXDATA, 1, 3, &val);
// 
//    PEvsetcellEx(m_hPE, PEP_faYDATA, 1, 0, &val);
//    PEvsetcellEx(m_hPE, PEP_faYDATA, 1, 1, &val);
//    PEvsetcellEx(m_hPE, PEP_faYDATA, 1, 2, &val);
//    PEvsetcellEx(m_hPE, PEP_faYDATA, 1, 3, &val);
// 
//    PEvsetcellEx(m_hPE, PEP_faXDATA, 2, 0, &val);
//    PEvsetcellEx(m_hPE, PEP_faXDATA, 2, 1, &val);
//    PEvsetcellEx(m_hPE, PEP_faXDATA, 2, 2, &val);
//    PEvsetcellEx(m_hPE, PEP_faXDATA, 2, 3, &val);
// 
//    PEvsetcellEx(m_hPE, PEP_faYDATA, 2, 0, &val);
//    PEvsetcellEx(m_hPE, PEP_faYDATA, 2, 1, &val);
//    PEvsetcellEx(m_hPE, PEP_faYDATA, 2, 2, &val);
//    PEvsetcellEx(m_hPE, PEP_faYDATA, 2, 3, &val);
// 
//    int nTmpStyle;
// //   nTmpStyle = PELT_THINSOLID;
//    PEvsetcell(m_hPE, PEP_naSUBSETLINETYPES, 0, &nTmpStyle); 
//    PEvsetcell(m_hPE, PEP_naSUBSETLINETYPES, 1, &nTmpStyle); 
//    PEvsetcell(m_hPE, PEP_naSUBSETLINETYPES, 2, &nTmpStyle);
//    //	PEvset(m_hPE, PEP_naSUBSETLINETYPES, PELT_THINSOLID, 0);
//    
//    char szSubsets[] = "电流\t电压\t频率\t";
//    PEvset (m_hPE, PEP_szaSUBSETLABELS, szSubsets, 3);
//    
//    // Set Various Other Properties ///
//    PEnset(m_hPE, PEP_bBITMAPGRADIENTMODE, TRUE);
// //   PEnset(m_hPE, PEP_nQUICKSTYLE, PEQS_MEDIUM_INSET);
//    
//    PEszset(m_hPE, PEP_szMAINTITLE, "工业用实时曲线程序");
//    
//    PEszset(m_hPE, PEP_szSUBTITLE, "编程设计实现-戚高");
//    PEnset(m_hPE, PEP_bNORANDOMPOINTSTOEXPORT, TRUE);
//    PEnset(m_hPE, PEP_bFOCALRECT, FALSE);
//    PEnset(m_hPE, PEP_bALLOWBAR, FALSE);
//    PEnset(m_hPE, PEP_bALLOWPOPUP, FALSE);
//    PEnset(m_hPE, PEP_bPREPAREIMAGES, TRUE);
//    PEnset(m_hPE, PEP_bCACHEBMP, TRUE);
//    PEnset(m_hPE, PEP_bFIXEDFONTS, TRUE);
// 
//    DWORD col = RGB(255, 0, 0);
//    PEvsetcell(m_hPE, PEP_dwaSUBSETCOLORS, 0, &col); 
//    
//    col = RGB(0,198,0);
//    PEvsetcell(m_hPE, PEP_dwaSUBSETCOLORS, 1, &col);
//    
//    col = RGB(255,0,0);
//    PEvsetcell(m_hPE, PEP_dwaSUBSETCOLORS, 2, &col);
// //    
// //    PEnset(m_hPE, PEP_nGRADIENTBARS, 8);
// //    PEnset(m_hPE, PEP_nTEXTSHADOWS, PETS_BOLD_TEXT);
// //    PEnset(m_hPE, PEP_bMAINTITLEBOLD, TRUE);
// //    PEnset(m_hPE, PEP_bSUBTITLEBOLD, TRUE);
// //    PEnset(m_hPE, PEP_bLABELBOLD, TRUE);
// //    PEnset(m_hPE, PEP_bLINESHADOWS, TRUE);
// //    PEnset(m_hPE, PEP_nFONTSIZE, PEFS_LARGE);

//   PEreinitialize(m_hPE);
//   PEresetimage(m_hPE, 0, 0);

   // Initialize Counters and Timer 
   m_nRealTimeCounter = 1;
   m_nSinCounter = 1;
   SetTimer( 1, 100, NULL );
 
}