/////////////////////////////////////////////////////////////////////////
// DEMOCODE.TXT //
//////////////////

The following is C and Basic source code which shows how the demo's graph 
examples are created.  ProEssentials are very property oriented.  Even
a straight DLL implementation just sets properties via DLL calls.  This
makes ProEssentials very easy to implement as well as maintain.  Being 
property oriented also makes your implementation less error prone and
generally more resistant towards unstability. 

int CDemo2View::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
    if (CView::OnCreate(lpCreateStruct) == -1)
        return -1;
    
    // Establish some size but not important since a WM_RESIZE will be used
    // to control size of control.
    CRect rect;
    rect.left = 0;
    rect.top = 0;
    rect.right = 200;
    rect.bottom = 200;
    
    CDemo2App* pApp = (CDemo2App*) AfxGetApp();

    int s, p, o;            
    float f1, f2;

    /////////////////////////////////////////////////////////////////
    // Business Graph //
    ////////////////////
    if (pApp->m_nNewType == 0) 
    {
        m_hPE = PEcreate(PECONTROL_GRAPH, WS_VISIBLE, &rect, m_hWnd, cnt + 100);
        if (m_hPE) 
        {
            cnt ++;
            SetGlobalPEStuff();
            
            // SET PROPERTIES DEFINING AMOUNT OF DATA //
            PEnset(m_hPE, PEP_nSUBSETS, 3);
            PEnset(m_hPE, PEP_nPOINTS, 100);
            
            PEszset(m_hPE, PEP_szMAINTITLE, "Unit Sales");
            PEszset(m_hPE, PEP_szSUBTITLE, "");

            // MAKE RANDOM DATA //
            srand( (unsigned)time( NULL ) );
            for (s = 0; s<3; s++)
            {
                for (p=0; p<100; p++)
                {
                    f1 = GetRandom(1, 20);
                    f2 = GetRandom(0, 1000);
                    f1 = f1 + (f2 / 1000);
                    o = (s * 100) + p;
                    PEvsetcell(m_hPE, PEP_faYDATA, o, &f1);
                }   
            }
            
            // SET VARIOUS PROPERTIES //
            PEnset(m_hPE, PEP_nPOINTSTOGRAPH, 12);
            PEnset(m_hPE, PEP_bNOSTACKEDDATA, FALSE);
            PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_BARSTACKED);

            srand( (unsigned)time( NULL ) );
            char szTmp[30];         
            int n = GetRandom(1, 30);
            for (s=0; s<4; s++)
            {
                strcpy(szTmp, m_States.GetAt(n + s));
                PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, s, szTmp);
            }
            
            for (p=0; p<100; p++)
            {
                if (p < m_MonYr.GetSize())
                { 
                    strcpy(szTmp, m_MonYr.GetAt(p));
                    PEvsetcell(m_hPE, PEP_szaPOINTLABELS, p, szTmp);
                }   
            }
            
            int AF[8] = {1, 2, 3, 6, 12, 24, 36, 48};
            PEvset(m_hPE, PEP_naALTFREQUENCIES, AF, 8);
            PEnset(m_hPE, PEP_nTARGETPOINTSTOTABLE, 13);
            PEnset(m_hPE, PEP_nFIRSTPTLABELOFFSET, 1);
            PEnset(m_hPE, PEP_bALLOWHORIZONTALBAR, TRUE);
            PEnset(m_hPE, PEP_bALLOWANNOTATIONCONTROL, TRUE);
            PEnset(m_hPE, PEP_bSHOWANNOTATIONS, TRUE);
            PEnset(m_hPE, PEP_nLINEANNOTATIONTEXTSIZE, 95);
            
            double HLA[2] = {45.0F, 5.0F};
            int HLAT[2] = {PELT_THICKSOLID, PELT_THICKSOLID};
            long HLAC[2] = {RGB(0, 0, 255), RGB(0, 0, 255)};
            PEvset(m_hPE, PEP_faHORZLINEANNOTATION, HLA, 2);
            PEvset(m_hPE, PEP_naHORZLINEANNOTATIONTYPE, HLAT, 2);
            PEvset(m_hPE, PEP_dwaHORZLINEANNOTATIONCOLOR, HLAC, 2);
            
            int LAT[2] = {PEGAT_MEDIUMSOLIDLINE};
            long LAC[2] = {RGB(0, 0, 255)};
            char LAText[] = "Control Limits\t";
            PEvset(m_hPE, PEP_naLEGENDANNOTATIONTYPE, LAT, 1);
            PEvset(m_hPE, PEP_dwaLEGENDANNOTATIONCOLOR, LAC, 1);
            PEvset(m_hPE, PEP_szaLEGENDANNOTATIONTEXT, LAText, 1);
            PEnset(m_hPE, PEP_nFONTSIZE, PEFS_LARGE);
            PEnset(m_hPE, PEP_nGRAPHPLUSTABLE, PEGPT_BOTH);
        }   
    }       

    /////////////////////////////////////////////////////////////////
    // Quality Control //
    /////////////////////
    if (pApp->m_nNewType == 1) 
    {
        m_hPE = PEcreate(PECONTROL_GRAPH, WS_VISIBLE, &rect, m_hWnd, cnt + 100);
        if (m_hPE) 
        {   
            cnt ++;
            SetGlobalPEStuff();
            
            // SET PROPERTIES DEFINING AMOUNT OF DATA //
            PEnset(m_hPE, PEP_nSUBSETS, 1);
            PEnset(m_hPE, PEP_nPOINTS, 10);
            
            // MAKE RANDOM DATA //
            srand( (unsigned)time( NULL ) );
            for (s = 0; s<1; s++)
            {
                for (p=0; p<10; p++)
                {
                    f1 = GetRandom(3, 40);
                    o = (s * 10) + p;
                    PEvsetcell(m_hPE, PEP_faYDATA, o, &f1);
                }   
            }
            
            // SET VARIOUS PROPERTIES //
            PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_BAR);
            PEnset(m_hPE, PEP_nPLOTTINGMETHODII, PEGPM_POINTSPLUSLINE);
            
            PEnset(m_hPE, PEP_nGRAPHPLUSTABLE, 2);

            srand( (unsigned)time( NULL ) );
            char szTmp[30];         
            char szTmp2[30];
            
            PEszset(m_hPE, PEP_szMAINTITLE, "Defects Quality Report");
            PEszset(m_hPE, PEP_szSUBTITLE, "");
            
            PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 0, "Defects");
            
            for (p=0; p<10; p++)
            {
                strcpy(szTmp, "P#");
                itoa(100 + GetRandom(1, 99), szTmp2, 10);
                strcat(szTmp, szTmp2);
                PEvsetcell(m_hPE, PEP_szaPOINTLABELS, p, szTmp);
            }
            
            PEnset(m_hPE, PEP_bALLOWHORIZONTALBAR, TRUE);
            PEnset(m_hPE, PEP_bALLOWANNOTATIONCONTROL, TRUE);
            PEnset(m_hPE, PEP_bSHOWANNOTATIONS, TRUE);
            PEnset(m_hPE, PEP_nLINEANNOTATIONTEXTSIZE, 95);
            PEnset(m_hPE, PEP_nGRIDLINECONTROL, PEGLC_NONE);
            
            double HLA[2] = {33.0F, 30.0F};
            int HLAT[2] = {PELT_THICKSOLID, PELT_MEDIUMSOLID};
            long HLAC[2] = {RGB(0, 0, 255), RGB(0, 0, 255)};
            char HLAText[] = "|cCritical Limit\t|cUpper Limit\t";
            PEvset(m_hPE, PEP_faHORZLINEANNOTATION, HLA, 2);
            PEvset(m_hPE, PEP_naHORZLINEANNOTATIONTYPE, HLAT, 2);
            PEvset(m_hPE, PEP_dwaHORZLINEANNOTATIONCOLOR, HLAC, 2);
            PEvset(m_hPE, PEP_szaHORZLINEANNOTATIONTEXT, HLAText, 2);
            
            int ASS[1] = {PEAS_PARETO_DEC};
            PEvset(m_hPE, PEP_naAUTOSTATSUBSETS, ASS, 1);
            PEnset(m_hPE, PEP_nFONTSIZE, PEFS_LARGE);
            PEnset(m_hPE, PEP_bALLOWHISTOGRAM, FALSE);
        }
    }       

    /////////////////////////////////////////////////////////////////
    // Technical //
    ///////////////
    if (pApp->m_nNewType == 2) 
    {
        m_hPE = PEcreate(PECONTROL_GRAPH, WS_VISIBLE, &rect, m_hWnd, cnt + 100);
        if (m_hPE) 
        {
            cnt ++;
            SetGlobalPEStuff();
            
            // SET PROPERTIES DEFINING AMOUNT OF DATA //
            PEnset(m_hPE, PEP_nSUBSETS, 1);
            PEnset(m_hPE, PEP_nPOINTS, 500);
            
            PEszset(m_hPE, PEP_szMAINTITLE, "Signal Strength");
            PEszset(m_hPE, PEP_szSUBTITLE, "");

            // MAKE RANDOM DATA //
            srand( (unsigned)time( NULL ) );
            for (s = 0; s<1; s++)
            {
                for (p=0; p<500; p++)
                {
                    f1 = GetRandom(1, 125);
                    f2 = GetRandom(0, 1000);
                    f1 = f1 + (f2 / 1000);
                    f2 = p * .061025F;
                    f1 = 1000.0F + f1 + (sin(f2) * 900.0F);
                    
                    o = (s * 500) + p;
                    PEvsetcell(m_hPE, PEP_faYDATA, o, &f1);
                }   
            }
            
            // SET VARIOUS PROPERTIES //
            PEnset(m_hPE, PEP_nPOINTSTOGRAPH, 125);
            PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_LINE);

            srand( (unsigned)time( NULL ) );
            char szTmp[30];         
            PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 0, "Output");
            PEszset(m_hPE, PEP_szXAXISLABEL, "Milliseconds");
            PEszset(m_hPE, PEP_szYAXISLABEL, "Voltage (mV)");
            
            int AF[8] = {1, 2, 5, 10, 20, 50, 100, 200};
            PEvset(m_hPE, PEP_naALTFREQUENCIES, AF, 8);
            PEnset(m_hPE, PEP_nFIRSTPTLABELOFFSET, 1);
            PEnset(m_hPE, PEP_bALLOWANNOTATIONCONTROL, TRUE);
            PEnset(m_hPE, PEP_bSHOWANNOTATIONS, TRUE);
            PEnset(m_hPE, PEP_bDATASHADOWS, FALSE);
            PEnset(m_hPE, PEP_nYAXISSCALECONTROL, PEAC_LOG);
            s = -1;
            PEvsetcell(m_hPE, PEP_naSUBSETSTOLEGEND, 0, &s);
            
            double GAX[15] = {70.0F, 93.0F, 70.0F, 
                            170.0F, 195.0F, 170.0F,
                            270.0F, 295.0F, 270.0F,
                            370.0F, 395.0F, 370.0F,     
                            470.0F, 495.0F, 470.0F};
            double GAY[15] = {280.0F, 115.0F, 280.0F,
                            280.0F, 115.0F, 280.0F,
                            280.0F, 115.0F, 280.0F,
                            280.0F, 115.0F, 280.0F,
                            280.0F, 115.0F, 280.0F};
            int GAT[15] = {PEGAT_TOPLEFT, PEGAT_BOTTOMRIGHT, PEGAT_ROUNDRECT_THICK,
                            PEGAT_TOPLEFT, PEGAT_BOTTOMRIGHT, PEGAT_ROUNDRECT_THICK,
                            PEGAT_TOPLEFT, PEGAT_BOTTOMRIGHT, PEGAT_ROUNDRECT_THICK,
                            PEGAT_TOPLEFT, PEGAT_BOTTOMRIGHT, PEGAT_ROUNDRECT_THICK,
                            PEGAT_TOPLEFT, PEGAT_BOTTOMRIGHT, PEGAT_ROUNDRECT_THICK};
            long GAC[15] = {0L, 0L, RGB(0, 0, 255),
                            0L, 0L, RGB(0, 0, 255),
                            0L, 0L, RGB(0, 0, 255),
                            0L, 0L, RGB(0, 0, 255),
                            0L, 0L, RGB(0, 0, 255)};
            PEvset(m_hPE, PEP_faGRAPHANNOTATIONX, GAX, 15);
            PEvset(m_hPE, PEP_faGRAPHANNOTATIONY, GAY, 15);
            PEvset(m_hPE, PEP_naGRAPHANNOTATIONTYPE, GAT, 15);
            PEvset(m_hPE, PEP_dwaGRAPHANNOTATIONCOLOR, GAC, 15);
            
            int LAT[2] = {PEGAT_MEDIUMSOLIDLINE};
            long LAC[2] = {RGB(0, 0, 255)};
            char LAText[] = "Unreliable\t";
            PEvset(m_hPE, PEP_naLEGENDANNOTATIONTYPE, LAT, 1);
            PEvset(m_hPE, PEP_dwaLEGENDANNOTATIONCOLOR, LAC, 1);
            PEvset(m_hPE, PEP_szaLEGENDANNOTATIONTEXT, LAText, 1);
            
            PEnset(m_hPE, PEP_nCURSORMODE, PECM_DATACROSS);
            PEnset(m_hPE, PEP_bMOUSECURSORCONTROL, TRUE);
            PEnset(m_hPE, PEP_nGRIDLINECONTROL, PEGLC_NONE);
            PEnset(m_hPE, PEP_bNEGATIVEFROMXAXIS, FALSE);
            
            PEnset(m_hPE, PEP_nMANUALSCALECONTROLY, PEMSC_MINMAX);
            double m = 50.0F; 
            PEvset(m_hPE, PEP_fMANUALMINY, &m, 0);
            m = 2500.0F;
            PEvset(m_hPE, PEP_fMANUALMAXY, &m, 0);
        }   
    }       

    /////////////////////////////////////////////////////////////////
    // Graph Real Time //
    /////////////////////
    if (pApp->m_nNewType == 3) 
    {
        m_hPE = PEcreate(PECONTROL_GRAPH, WS_VISIBLE, &rect, m_hWnd, cnt + 100);
        if (m_hPE) 
        {
            cnt ++;
            SetGlobalPEStuff();
            srand( (unsigned)time( NULL ) );
            
            // SET PROPERTIES DEFINING AMOUNT OF DATA //
            PEnset(m_hPE, PEP_nSUBSETS, 2);
            PEnset(m_hPE, PEP_nPOINTS, 200);
            
            PEszset(m_hPE, PEP_szMAINTITLE, "Real Time Historical Log");
            PEszset(m_hPE, PEP_szSUBTITLE, "");
            
            PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 0, "Input");
            PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 1, "Output");
            
            PEszset(m_hPE, PEP_szYAXISLABEL, "Pressure");
            PEszset(m_hPE, PEP_szRYAXISLABEL, "Pressure");
            
            PEnset(m_hPE, PEP_bDATASHADOWS, FALSE);
            PEnset(m_hPE, PEP_nPOINTSTOGRAPH, 25);
            PEnset(m_hPE, PEP_nPOINTSTOGRAPHINIT, PEPTGI_LASTPOINTS);
            PEnset(m_hPE, PEP_bNORANDOMPOINTSTOGRAPH, TRUE);
            PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_LINE);
            PEnset(m_hPE, PEP_bFORCERIGHTYAXIS, TRUE);
            PEnset(m_hPE, PEP_bFORCEVERTICALPOINTS, TRUE);
            
            PEvsetcell(m_hPE, PEP_szaPOINTLABELS, 199, " ");
            
            PEnset(m_hPE, PEP_nMANUALSCALECONTROLY, PEMSC_MINMAX);
            double m = 0.0F;
            PEvset(m_hPE, PEP_fMANUALMINY, &m, 0);
            m = 100.0F;
            PEvset(m_hPE, PEP_fMANUALMAXY, &m, 0);
            
            PEnset(m_hPE, PEP_nMANUALSCALECONTROLRY, PEMSC_MINMAX);
            m = 0.0F;
            PEvset(m_hPE, PEP_fMANUALMINRY, &m, 0);
            m = 100.0F;
            PEvset(m_hPE, PEP_fMANUALMAXRY, &m, 0);
            
            PEszset(m_hPE, PEP_szMANUALMAXPOINTLABEL, "##:##:##");
            PEszset(m_hPE, PEP_szMANUALMAXDATASTRING, "##.###");
            
            PEnset(m_hPE, PEP_bALLOWDATAHOTSPOTS, FALSE);
            PEnset(m_hPE, PEP_bALLOWSUBSETHOTSPOTS, FALSE);
            PEnset(m_hPE, PEP_bALLOWPOINTHOTSPOTS, FALSE);
            PEnset(m_hPE, PEP_bALLOWTABLEHOTSPOTS, FALSE);
            PEnset(m_hPE, PEP_nALLOWZOOMING, FALSE);
            PEnset(m_hPE, PEP_bALLOWHISTOGRAM, FALSE);
            PEnset(m_hPE, PEP_nGRIDLINECONTROL, PEGLC_YAXIS);
            
            // clear out first four default data points to start empty //
            f1 = 0.0F;
            PEvsetcell(m_hPE, PEP_faYDATA, 0, &f1);
            PEvsetcell(m_hPE, PEP_faYDATA, 1, &f1);
            PEvsetcell(m_hPE, PEP_faYDATA, 2, &f1);
            PEvsetcell(m_hPE, PEP_faYDATA, 3, &f1);
            
            // Set Timer for Real-Time //
            m_nTimerID = SetTimer(1, 666, NULL);
        }   
    }       

    /////////////////////////////////////////////////////////////////
    // Multiple Y Axes //
    /////////////////////
    if (pApp->m_nNewType == 100) 
    {
        m_hPE = PEcreate(PECONTROL_SGRAPH, WS_VISIBLE, &rect, m_hWnd, cnt + 100);
        if (m_hPE) 
        {
            cnt ++;
            SetGlobalPEStuff();
            srand( (unsigned)time( NULL ) );

            PEszset(m_hPE, PEP_szMAINTITLE, "Multiple Y Axis Example");
            PEszset(m_hPE, PEP_szSUBTITLE, "");
            
            PEnset(m_hPE, PEP_nSUBSETS, 12);
            PEnset(m_hPE, PEP_nPOINTS, 100);

            // MAKE RANDOM DATA //
            
            double dt;
            float d, f3, f4;
            TM tm;
            tm.nMonth = 1;
            tm.nDay = 1;
            tm.nYear = 95;
            tm.nHour = 9;
            tm.nMinute = 32;
            tm.nSecond = 15;
            PEcreateserialdate(&dt, &tm, 1);
            
            int i = 0;
            for (p = 0; p<100; p++)
            {
                f1 = 150.0F + (sin(p * .034F) * 60.0F) + GetRandom(1, 30) + (p / 2.0F);
                f2 = 10.0F + GetRandom(1, 10);
                f3 = 35.0F + GetRandom(1, 20);
                d = (float) (dt + (double) p);
                
                PEvsetcell(m_hPE, PEP_faXDATA, p, &d);
                f4 = f1 - f3;
                PEvsetcell(m_hPE, PEP_faYDATA, p,  &f4);
                
                PEvsetcell(m_hPE, PEP_faXDATA, p + 100, &d);
                f4 = f1 + f3;
                PEvsetcell(m_hPE, PEP_faYDATA, p + 100, &f4);

                PEvsetcell(m_hPE, PEP_faXDATA, p + 200, &d);
                f4 = f1 - f2;
                PEvsetcell(m_hPE, PEP_faYDATA, p + 200, &f4);
    
                PEvsetcell(m_hPE, PEP_faXDATA, p + 300, &d);
                f4 = f1 + f2;
                PEvsetcell(m_hPE, PEP_faYDATA, p + 300, &f4);

                PEvsetcell(m_hPE, PEP_faXDATA, p + 400, &d);
                f4 = 250.0F + (cos(p * .06F) * 70.0F) + GetRandom(1, 40) + (p / 2.0F);
                PEvsetcell(m_hPE, PEP_faYDATA, p + 400, &f4);
    
                PEvsetcell(m_hPE, PEP_faXDATA, p + 500, &d);
                f4 = -10.0F + GetRandom(1, 80);
                PEvsetcell(m_hPE, PEP_faYDATA, p + 500, &f4);
    
                PEvsetcell(m_hPE, PEP_faXDATA, p + 600, &d);
                f4 = -10.0F + GetRandom(1, 30);
                PEvsetcell(m_hPE, PEP_faYDATA, p + 600, &f4);

                PEvsetcell(m_hPE, PEP_faXDATA, p + 700, &d);
                f4 = -20.0F + GetRandom(1, 50);
                PEvsetcell(m_hPE, PEP_faYDATA, p + 700, &f4);
                
                PEvsetcell(m_hPE, PEP_faXDATA, p + 800, &d);
                f4 = -50.0F + (cos(p * .06F) * 70.0F) + GetRandom(1, 30) + p;
                PEvsetcell(m_hPE, PEP_faYDATA, p + 800, &f4);

                PEvsetcell(m_hPE, PEP_faXDATA, p + 900, &d);
                f4 = 100.0F + (sin(p * .15F) * 100.0F) + GetRandom(1, 20) + p;
                PEvsetcell(m_hPE, PEP_faYDATA, p + 900, &f4);
            }    

            for (s=10; s<12; s++)
            {
                for (p=0; p<100; p++)
                {
                    o = (s * 100) + p;
                    d = (float) (dt + (double) p);
                    PEvsetcell(m_hPE, PEP_faXDATA, o, &d);
                    f4 = 15.0F + GetRandom(1, 75) + (s * 100.0F);
                    PEvsetcell(m_hPE, PEP_faYDATA, o, &f4);
                }
            }

            // SET VARIOUS OTHER PROPERTIES //
            
            s = -1;
            PEvsetcell(m_hPE, PEP_naSUBSETSTOLEGEND, 0, &s);

            int slt[12] = {0,0,0,0,0,0,0,0,0,0,0,0};
            PEvset(m_hPE, PEP_naSUBSETLINETYPES, slt, 12);

            int mas[4] = {6,2,2,2};
            PEvset(m_hPE, PEP_naMULTIAXESSUBSETS, mas, 4);
            
            float map[4] = {.5F, .15F, .15F, .2F};
            PEvset(m_hPE, PEP_faMULTIAXESPROPORTIONS, map, 4);

            PEnset(m_hPE, PEP_bDATASHADOWS, FALSE);

            PEnset(m_hPE, PEP_nWORKINGAXIS, 0);
            PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_SPECIFICPLOTMODE);
            PEnset(m_hPE, PEP_nSPECIFICPLOTMODE, PESPM_BOXPLOT);
            PEnset(m_hPE, PEP_nRYAXISCOMPARISONSUBSETS, 2);
            PEszset(m_hPE, PEP_szYAXISLABEL, "Y Axis #1");
            PEszset(m_hPE, PEP_szRYAXISLABEL, "Y Axis #2");

            PEnset(m_hPE, PEP_nWORKINGAXIS, 1);
            PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_BAR);
            PEszset(m_hPE, PEP_szYAXISLABEL, "Y Axis #3");

            PEnset(m_hPE, PEP_nWORKINGAXIS, 2);
            PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_AREA);
            PEnset(m_hPE, PEP_nRYAXISCOMPARISONSUBSETS, 1);
            PEszset(m_hPE, PEP_szYAXISLABEL, "Y Axis #4");
            PEszset(m_hPE, PEP_szRYAXISLABEL, "Y Axis #5");

            PEnset(m_hPE, PEP_nWORKINGAXIS, 3);
            PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_AREA);
            PEszset(m_hPE, PEP_szYAXISLABEL, "Y Axis #5");
            PEszset(m_hPE, PEP_szRYAXISLABEL, "Y Axis #6");
            PEnset(m_hPE, PEP_nMANUALSCALECONTROLY, PEMSC_MIN);
            double m = 900.0F;
            PEvset(m_hPE, PEP_fMANUALMINY, &m, 0);

            PEnset(m_hPE, PEP_nWORKINGAXIS, 0);
            
            PEnset(m_hPE, PEP_nDATETIMEMODE, PEDTM_VB);
            PElset(m_hPE, PEP_dwGRAPHFORECOLOR, RGB(255,255,255));
            PElset(m_hPE, PEP_dwGRAPHBACKCOLOR, 0L);
            PEnset(m_hPE, PEP_nFONTSIZE, PEFS_MEDIUM);        
            PEnset(m_hPE, PEP_nCURSORPROMPTSTYLE, 3);
            PEnset(m_hPE, PEP_bSCROLLINGHORZZOOM, TRUE);
            PEnset(m_hPE, PEP_nALLOWDATALABELS, PEADL_NONE);
        }   
    }       

    /////////////////////////////////////////////////////////////////
    // Dual X Axes //
    /////////////////
    if (pApp->m_nNewType == 101) 
    {
        m_hPE = PEcreate(PECONTROL_SGRAPH, WS_VISIBLE, &rect, m_hWnd, cnt + 100);
        if (m_hPE) 
        {
            cnt ++;
            SetGlobalPEStuff();
            srand( (unsigned)time( NULL ) );
            
            PEszset(m_hPE, PEP_szMAINTITLE, "Dual X Axes Example");
            PEszset(m_hPE, PEP_szSUBTITLE, "");
            
            PEnset(m_hPE, PEP_nSUBSETS, 2);
            PEnset(m_hPE, PEP_nPOINTS, 500);
            
            // MAKE RANDOM DATA //

            for (p = 0; p<500; p++)
            {
                f1 = 1500.0F + (sin(p * .014F) * 600.0F) + GetRandom(1, 5) + (p / 2.0F);
                f2 = 1500.0F + (cos(p * .014F) * 1600.0F) + GetRandom(1, 5) + (p / 2.0F);
                PEvsetcell(m_hPE, PEP_faXDATA, p, &f1);
                PEvsetcell(m_hPE, PEP_faYDATA, p,  &f2);
            }
                
            for (p = 0; p<500; p++)
            {
                f1 = 150.0F + (sin(p * .014F) * 60.0F) + GetRandom(1, 5) + (p / 2.0F);
                f2 = 150.0F + (cos(p * .014F) * 160.0F) + GetRandom(1, 5) + (p / 2.0F);
                PEvsetcell(m_hPE, PEP_faXDATA, p + 500, &f1);
                PEvsetcell(m_hPE, PEP_faYDATA, p + 500,  &f2);
            }
            
            // SET VARIOUS OTHER PROPERTIES //
            
            PEszset(m_hPE, PEP_szaSUBSETLABELS, "Signal #1");
            PEszset(m_hPE, PEP_szaSUBSETLABELS, "Signal #2");
            
            int slt[2] = {0, 0};
            PEvset(m_hPE, PEP_naSUBSETLINETYPES, slt, 2);

            PEnset(m_hPE, PEP_nRYAXISCOMPARISONSUBSETS, 1);
            PEnset(m_hPE, PEP_nTXAXISCOMPARISONSUBSETS, 1);
            
            PElset(m_hPE, PEP_dwYAXISCOLOR, RGB(255, 0, 0));
            PElset(m_hPE, PEP_dwXAXISCOLOR, RGB(255, 0, 0));
            
            PElset(m_hPE, PEP_dwRYAXISCOLOR, RGB(0, 255, 0));
            PElset(m_hPE, PEP_dwTXAXISCOLOR, RGB(0, 255, 0));
            
            PEnset(m_hPE, PEP_bDATASHADOWS, FALSE);
            PEnset(m_hPE, PEP_bCURSORPROMPTTRACKING, TRUE);
            PEnset(m_hPE, PEP_nFONTSIZE, PEFS_MEDIUM);
            
            PElset(m_hPE, PEP_dwDESKCOLOR, 0L);
            PElset(m_hPE, PEP_dwTEXTCOLOR, RGB(0, 255, 255));
            PElset(m_hPE, PEP_dwGRAPHFORECOLOR, RGB(192, 192, 192));
            PElset(m_hPE, PEP_dwGRAPHBACKCOLOR, 0L);
            
            s = -1;
            PEvsetcell(m_hPE, PEP_naSUBSETSTOLEGEND, 0, &s);
            
            char bmt1[] = "Machine|Power|Temperature";
            char bmt2[] = "Main Drill|4554 Watts|1243.4 F";
            char bmt3[] = "Secondary Drill|2343 Watts|634.2 F";
            PEvsetcell(m_hPE, PEP_szaMULTIBOTTOMTITLES, 0, bmt3); 
            PEvsetcell(m_hPE, PEP_szaMULTIBOTTOMTITLES, 1, bmt2); 
            PEvsetcell(m_hPE, PEP_szaMULTIBOTTOMTITLES, 2, bmt1); 
            
            char smt1[] = "Plant|Shift|Time";
            char smt2[] = "Dallas|Second|08:23 pm";
            PEvsetcell(m_hPE, PEP_szaMULTISUBTITLES, 0, smt1); 
            PEvsetcell(m_hPE, PEP_szaMULTISUBTITLES, 1, smt2); 
            PEnset(m_hPE, PEP_nCURSORPROMPTSTYLE, 3);
            PEnset(m_hPE, PEP_nGRIDSTYLE, PEGS_DOT);
            PEnset(m_hPE, PEP_nGRIDLINECONTROL, PEGLC_NONE);
            PEnset(m_hPE, PEP_nCURSORMODE, PECM_DATACROSS);
            PEnset(m_hPE, PEP_bMOUSECURSORCONTROL, TRUE);
            PEnset(m_hPE, PEP_nALLOWDATALABELS, FALSE);
            
            double bw = 1.0F;
            PEvset(m_hPE, PEP_fBARWIDTH, &bw, 0);
        }   
    }       

    /////////////////////////////////////////////////////////////////
    // Log //
    /////////
    if (pApp->m_nNewType == 102) 
    {
        m_hPE = PEcreate(PECONTROL_SGRAPH, WS_VISIBLE, &rect, m_hWnd, cnt + 100);
        if (m_hPE) 
        {
            cnt ++;
            SetGlobalPEStuff(); 
            srand( (unsigned)time( NULL ) );

            PEszset(m_hPE, PEP_szMAINTITLE, "Log Example");
            PEszset(m_hPE, PEP_szSUBTITLE, "  ");
            
            PEnset(m_hPE, PEP_nSUBSETS, 2);
            PEnset(m_hPE, PEP_nPOINTS, 100);
            
            // MAKE RANDOM DATA //
            
            long b, g, r;
            b = RGB(0, 0, 255);
            g = RGB(0, 255, 0);
            r = RGB(255, 0, 0);
            PEvsetcell(m_hPE, PEP_dwaSUBSETCOLORS, 0, &b);
            
            for (p = 0; p<100; p++)
            {
                f1 = 90.0F + (p * 100);
                f2 = 500.0F + (cos(p * .044F) * 5600.0F) + GetRandom(1, 15) + (p * 90.0F);
                
                if (f2 <= 1050.0F)
                    PEvsetcell(m_hPE, PEP_dwaPOINTCOLORS, p, &r);
                else
                    PEvsetcell(m_hPE, PEP_dwaPOINTCOLORS, p, &b);   

                PEvsetcell(m_hPE, PEP_faXDATA, p, &f1);
                PEvsetcell(m_hPE, PEP_faYDATA, p, &f2);
            }
            
            for (p = 0; p<100; p++)
            {
                f1 = 70.0F + (p * 100);
                f2 = 900.0F + (cos(p * .084F) * 3600.0F) + GetRandom(1, 50) + (p * 90.0F);
                
                if (f2 <= 1050.0F)
                    PEvsetcell(m_hPE, PEP_dwaPOINTCOLORS, p+100, &r);
                else
                    PEvsetcell(m_hPE, PEP_dwaPOINTCOLORS, p+100, &g);  

                PEvsetcell(m_hPE, PEP_faXDATA, p+100, &f1);
                PEvsetcell(m_hPE, PEP_faYDATA, p+100, &f2);
            }
            
            // SET VARIOUS OTHER PROPERTIES //
            
            PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 0, "Signal #1");
            PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 1, "Signal #2");
            
            PEszset(m_hPE, PEP_szXAXISLABEL, "Voltage");
            PEszset(m_hPE, PEP_szYAXISLABEL, "Current");
            
            PEnset(m_hPE, PEP_nYAXISSCALECONTROL, PEAC_LOG);
            PEnset(m_hPE, PEP_nXAXISSCALECONTROL, PEAC_LOG);
            PEnset(m_hPE, PEP_bDATASHADOWS, FALSE);
            PEnset(m_hPE, PEP_bMARKDATAPOINTS, TRUE);
            
            PEnset(m_hPE, PEP_nMANUALSCALECONTROLX, PEMSC_MINMAX);
            double m = 50.0F;
            PEvset(m_hPE, PEP_fMANUALMINX, &m, 0);
            m = 13010.0F;
            PEvset(m_hPE, PEP_fMANUALMAXX, &m, 0);
            
            PEnset(m_hPE, PEP_nMANUALSCALECONTROLY, PEMSC_MINMAX);
            m = 390.0F;
            PEvset(m_hPE, PEP_fMANUALMINY, &m, 0);
            m = 12010.0F;
            PEvset(m_hPE, PEP_fMANUALMAXY, &m, 0);
            
            PElset(m_hPE, PEP_dwGRAPHFORECOLOR, RGB(0, 0, 0));
            PElset(m_hPE, PEP_dwGRAPHBACKCOLOR, RGB(128, 128, 128));
            PElset(m_hPE, PEP_dwSHADOWCOLOR, 0L);
            
            int slt[2] = {PELT_MEDIUMSOLID,PELT_MEDIUMSOLID};
            PEvset(m_hPE, PEP_naSUBSETLINETYPES, slt, 2);    
            PEnset(m_hPE, PEP_nCURSORPROMPTSTYLE, 3);
            
            PEnset(m_hPE, PEP_nCURSORMODE, PECM_DATASQUARE);
            PEnset(m_hPE, PEP_bMOUSECURSORCONTROL, TRUE);
            PEnset(m_hPE, PEP_bALLOWBAR, FALSE);
            
            double GAX[15] = {70.0F, 3570.0F, 90.0F, 6490.0F};
            double GAY[15] = {4536.0F, 524.0F, 6111.0F, 958.0F};
            int GAT[15] = {PEGAT_NOSYMBOL, PEGAT_NOSYMBOL, PEGAT_NOSYMBOL, PEGAT_NOSYMBOL};
            long GAC[15] = {RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255)};
            char GAText[] = "Initial Measurment\tTarget Measurment\tInitial Measurment\tTarget Measurment\t";
            PEvset(m_hPE, PEP_faGRAPHANNOTATIONX, GAX, 4);
            PEvset(m_hPE, PEP_faGRAPHANNOTATIONY, GAY, 4);
            PEvset(m_hPE, PEP_naGRAPHANNOTATIONTYPE, GAT, 4);
            PEvset(m_hPE, PEP_dwaGRAPHANNOTATIONCOLOR, GAC, 4);
            PEvset(m_hPE, PEP_szaGRAPHANNOTATIONTEXT, GAText, 4);
            PEnset(m_hPE, PEP_nGRAPHANNOTATIONTEXTSIZE, 90);
            PEnset(m_hPE, PEP_bSHOWANNOTATIONS, TRUE);
            PEnset(m_hPE, PEP_bALLOWANNOTATIONCONTROL, TRUE);
        }   
    }       
    
    /////////////////////////////////////////////////////////////////
    // Scientific real time //
    //////////////////////////
    if (pApp->m_nNewType == 103) 
    {
        m_hPE = PEcreate(PECONTROL_SGRAPH, WS_VISIBLE, &rect, m_hWnd, cnt + 100);
        if (m_hPE)
        {
            cnt ++;
            SetGlobalPEStuff();
            srand( (unsigned)time( NULL ) );
            
            // SET PROPERTIES DEFINING AMOUNT OF DATA //
            PEnset(m_hPE, PEP_nSUBSETS, 1);
            PEnset(m_hPE, PEP_nPOINTS, 250);
            
            PEszset(m_hPE, PEP_szMAINTITLE, "Real Time Example");
            PEszset(m_hPE, PEP_szSUBTITLE, "");
            
            PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 0, "Signal Input");
            
            PEszset(m_hPE, PEP_szYAXISLABEL, "Pressure");
            PEszset(m_hPE, PEP_szRYAXISLABEL, "Pressure");
            
            PEnset(m_hPE, PEP_bDATASHADOWS, FALSE);
            PEnset(m_hPE, PEP_bCURSORPROMPTTRACKING, FALSE);
            PEnset(m_hPE, PEP_bALLOWPOPUP, FALSE);
            PEnset(m_hPE, PEP_bNORANDOMPOINTSTOGRAPH, TRUE);
            PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_LINE);
            PEnset(m_hPE, PEP_bFORCERIGHTYAXIS, TRUE);
            
            PEnset(m_hPE, PEP_nMANUALSCALECONTROLY, PEMSC_MINMAX);
            double m = 0.0F;
            PEvset(m_hPE, PEP_fMANUALMINY, &m, 0);
            m = 100.0F;
            PEvset(m_hPE, PEP_fMANUALMAXY, &m, 0);
            
            PEnset(m_hPE, PEP_nMANUALSCALECONTROLRY, PEMSC_MINMAX);
            m = 0.0F;
            PEvset(m_hPE, PEP_fMANUALMINRY, &m, 0);
            m = 100.0F;
            PEvset(m_hPE, PEP_fMANUALMAXRY, &m, 0);
            
            PEnset(m_hPE, PEP_nMANUALSCALECONTROLX, PEMSC_MINMAX);
            m = 0.0F;
            PEvset(m_hPE, PEP_fMANUALMINX, &m, 0);
            m = 500.0F;
            PEvset(m_hPE, PEP_fMANUALMAXX, &m, 0);
            
            PEnset(m_hPE, PEP_bZOOMMODE, TRUE);
            m = 0.0F;
            PEvset(m_hPE, PEP_fZOOMMINX, &m, 0);
            m = 50.0F;
            PEvset(m_hPE, PEP_fZOOMMAXX, &m, 0);
            m = 0.0F;
            PEvset(m_hPE, PEP_fZOOMMINY, &m, 0);
            m = 100.0F;
            PEvset(m_hPE, PEP_fZOOMMAXY, &m, 0);
            
            f1 = 0;
            PEvsetcell(m_hPE, PEP_faXDATA, 0, &f1);
            PEvsetcell(m_hPE, PEP_faXDATA, 1, &f1);
            PEvsetcell(m_hPE, PEP_faXDATA, 2, &f1);
            PEvsetcell(m_hPE, PEP_faXDATA, 3, &f1);
            PEvsetcell(m_hPE, PEP_faYDATA, 0, &f1);
            PEvsetcell(m_hPE, PEP_faYDATA, 1, &f1);
            PEvsetcell(m_hPE, PEP_faYDATA, 2, &f1);
            PEvsetcell(m_hPE, PEP_faYDATA, 3, &f1);
            
            PEnset(m_hPE, PEP_bALLOWDATAHOTSPOTS, FALSE);
            PEnset(m_hPE, PEP_bALLOWSUBSETHOTSPOTS, FALSE);
            PEnset(m_hPE, PEP_nALLOWDATALABELS, PEADL_NONE);
            PEnset(m_hPE, PEP_nALLOWZOOMING, PEAZ_NONE);

            // Set Timer for Real-Time //
            m_nTimerID = SetTimer(1, 666, NULL);
        }   
    }       

    /////////////////////////////////////////////////////////////////
    // Polar //
    ///////////
    if (pApp->m_nNewType == 200) 
    {
        m_hPE = PEcreate(PECONTROL_PGRAPH, WS_VISIBLE, &rect, m_hWnd, cnt + 100);
        if (m_hPE) 
        {
            cnt ++;
            SetGlobalPEStuff();
            
            PEszset(m_hPE, PEP_szMAINTITLE, "Polar Example");
            PEszset(m_hPE, PEP_szSUBTITLE, "");
            
            PEnset(m_hPE, PEP_nSUBSETS, 2);
            PEnset(m_hPE, PEP_nPOINTS, 360);

            // MAKE RANDOM DATA //
            
            for (p = 0; p<360; p++)
            {
                f1 = (float) p;
                f2 = sin(p * 0.054F);

                PEvsetcell(m_hPE, PEP_faXDATA, p, &f1);
                PEvsetcell(m_hPE, PEP_faYDATA, p, &f2);
            }
            
            for (p = 0; p<360; p++)
            {
                f1 = (float) p;
                f2 = sin(p * 0.044F);

                PEvsetcell(m_hPE, PEP_faXDATA, p+360, &f1);
                PEvsetcell(m_hPE, PEP_faYDATA, p+360, &f2);
            }
            
            PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 0, "Signal #1");
            PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 1, "Signal #2");
            
            PEnset(m_hPE, PEP_bMARKDATAPOINTS, TRUE);
            PEnset(m_hPE, PEP_nCURSORPROMPTSTYLE, 3);
            
            int slt[2] = {PELT_THINSOLID, PELT_THINSOLID};
            PEvset(m_hPE, PEP_naSUBSETLINETYPES, slt, 2);
        }   
    }       

    /////////////////////////////////////////////////////////////////
    // Smith //
    ///////////
    if (pApp->m_nNewType == 201) 
    {
        m_hPE = PEcreate(PECONTROL_PGRAPH, WS_VISIBLE, &rect, m_hWnd, cnt + 100);
        if (m_hPE) 
        {   
            cnt ++;
            SetGlobalPEStuff();
            PEnset(m_hPE, PEP_bSMITHCHART, 1);

            PEszset(m_hPE, PEP_szMAINTITLE, "Smith Chart Example");
            PEszset(m_hPE, PEP_szSUBTITLE, " ");
            
            // Assigns no data, just shows default data //
            
            PEnset(m_hPE, PEP_nPLOTTINGMETHOD, PEGPM_POINTSPLUSLINE);
            PEnset(m_hPE, PEP_nCURSORPROMPTSTYLE, 3);
        }
    }       
    
    /////////////////////////////////////////////////////////////////
    // Pie //
    /////////
    if (pApp->m_nNewType == 202) 
    {
        m_hPE = PEcreate(PECONTROL_PIE, WS_VISIBLE, &rect, m_hWnd, cnt + 100);
        if (m_hPE) 
        {
            cnt ++;
            SetGlobalPEStuff();
            srand( (unsigned)time( NULL ) );
            
            PEszset(m_hPE, PEP_szMAINTITLE, "Produce Sales");
            PEszset(m_hPE, PEP_szSUBTITLE, "");
            
            PEnset(m_hPE, PEP_nSUBSETS, 4);
            PEnset(m_hPE, PEP_nPOINTS, 12);
            
            // MAKE RANDOM DATA //
            
            int n;          
            for (s=0; s<4; s++)
            {
                n = GetRandom(1, 12);
                for (p=0; p<12; p++)
                {
                    o = (s * 12) + p;
                    if (p == n)
                        f1 = (float) GetRandom(1, 5) + ((float) GetRandom(1, 100) / 100.0F);
                    else
                        f1 = (float) GetRandom(1, 100) + ((float) GetRandom(1, 100) / 100.0F);
                    PEvsetcell(m_hPE, PEP_faXDATA, o, &f1);
                }
            }
            
            PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 0, "Cherries");
            PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 1, "Apples");
            PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 2, "Oranges");
            PEvsetcell(m_hPE, PEP_szaSUBSETLABELS, 3, "Grapes");
             
            char szTmp[30];         
            n = GetRandom(1, 20);
            for (s=0; s<12; s++)
            {
                strcpy(szTmp, m_States.GetAt(n + s));
                PEvsetcell(m_hPE, PEP_szaPOINTLABELS, s, szTmp);
            }   
            
            PEnset(m_hPE, PEP_nFONTSIZE, PEFS_LARGE);
            PEnset(m_hPE, PEP_nGROUPINGPERCENT, 3);
            PEnset(m_hPE, PEP_nAUTOEXPLODE, PEAE_ALLSUBSETS);
        }   
    }       
    
    if (m_hPE)
    {
        // AFTER SETTING PROPERTIES, YOU MUST REINITIALIZE //
        PEreinitialize(m_hPE);
        PEresetimage(m_hPE, 0, 0);
    }   
    
    return 0;
}

void CDemo2View::SetGlobalPEStuff()
{
    PEnset(m_hPE, PEP_bPREPAREIMAGES, TRUE);
    PElset(m_hPE, PEP_dwDESKCOLOR, RGB(192, 192, 192));
    PEnset(m_hPE, PEP_nDATAPRECISION, 2);
    PEnset(m_hPE, PEP_nALLOWZOOMING, PEAZ_HORZANDVERT);
        
    DWORD c[32];
    c[0] = RGB(255, 0, 0);
    c[1] = RGB(0, 255, 0);
    c[2] = RGB(255, 255, 0);
    c[3] = RGB(0, 0, 255);
    c[4] = RGB(255, 0, 255);
    c[5] = RGB(0, 255, 255);
    c[6] = RGB(192, 192, 192);
    c[7] = RGB(255, 0, 0);
    c[8] = RGB(0, 255, 0);
    c[9] = RGB(255, 255, 0);
    c[10] = RGB(0, 0, 255);
    c[11] = RGB(255, 0, 255);
    c[12] = RGB(0, 255, 255);
    c[13] = RGB(192, 192, 192);
        
    PEvset(m_hPE, PEP_dwaSUBSETCOLORS, c, 14);
    PEnset(m_hPE, PEP_bCURSORPROMPTTRACKING, TRUE);
    PEnset(m_hPE, PEP_bFOCALRECT, FALSE);
        
    float f = .83F;
    PEvset(m_hPE, PEP_fFONTSIZEGLOBALCNTL, &f, 0);
    
    PEnset(m_hPE, PEP_bALLOWDATAHOTSPOTS, TRUE);
    PEnset(m_hPE, PEP_bALLOWSUBSETHOTSPOTS, TRUE);
    PEnset(m_hPE, PEP_bALLOWPOINTHOTSPOTS, TRUE);
    PEnset(m_hPE, PEP_bALLOWTABLEHOTSPOTS, TRUE);
}   

void CDemo2View::OnDestroy() 
{
    CView::OnDestroy();
    
    // Need to call PEdestroy once for every PEcreate //
    if (m_hPE) 
    {
        PEdestroy(m_hPE);
        cnt --;
        if (m_nTimerID) {KillTimer(m_nTimerID);}
    }
}

void CDemo2View::OnSize(UINT nType, int cx, int cy) 
{
    CView::OnSize(nType, cx, cy);
    
    if (m_hPE)
    {
        RECT r;
        ::GetClientRect(m_hWnd, &r);
        ::MoveWindow(m_hPE, 0, 0, r.right, r.bottom, FALSE);
    }
}

BOOL CDemo2View::OnCommand(WPARAM wp, LPARAM lp)
{
    HOTSPOTDATA HSData;
    
    switch (HIWORD(lp))
    {
        case PEWN_CLICKED:
            PEvget(m_hPE, PEP_structHOTSPOTDATA, &HSData);
            if (HSData.nHotSpotType == PEHS_SUBSET)
            {
                char szTmp[128];
                char szSubset[48];
                szTmp[0] = 0;
                strcat(szTmp, "You clicked subset ");
                sprintf(szSubset, "%i", HSData.w1);
                strcat(szTmp, szSubset);
                strcat(szTmp, ".  Subset label is ");
                PEvgetcell(m_hPE, PEP_szaSUBSETLABELS, (UINT) HSData.w1, szSubset);
                strcat(szTmp, szSubset);
                strcat(szTmp, ".");
                MessageBox(szTmp, "Subset Drill Down", MB_OK | MB_ICONINFORMATION);
            } 
            else if (HSData.nHotSpotType == PEHS_POINT)
            {
                if (PECONTROL_PIE != PEnget(m_hPE, PEP_nOBJECTTYPE))
                {
                    char szTmp[128];
                    char szSubset[48];
                    szTmp[0] = 0;
                    strcat(szTmp, "You clicked point ");
                    sprintf(szSubset, "%i", HSData.w1);
                    strcat(szTmp, szSubset);
                    strcat(szTmp, ".  Point label is ");
                    PEvgetcell(m_hPE, PEP_szaPOINTLABELS, (UINT) HSData.w1, szSubset);
                    strcat(szTmp, szSubset);
                    strcat(szTmp, ".");
                    MessageBox(szTmp, "Point Drill Down", MB_OK | MB_ICONINFORMATION);
                }    
                else
                 return CView::OnCommand(wp, lp);
            }
            else if ((HSData.nHotSpotType == PEHS_TABLE) || (HSData.nHotSpotType == PEHS_DATAPOINT))
            {
                UINT offset = ((int) HSData.w1 * (int) PEnget(m_hPE, PEP_nPOINTS)) + (int) HSData.w2;
                char    szTmp[128];
                char    szTmp2[48];
                float   fData;
                szTmp[0] = 0;
                strcat(szTmp, "You clicked subset ");
                sprintf(szTmp2, "%i", HSData.w1);
                strcat(szTmp, szTmp2);
                strcat(szTmp, ", point ");
                sprintf(szTmp2, "%i", HSData.w2);
                strcat(szTmp, szTmp2);
                strcat(szTmp, ".  The data value is equal to ");
                PEvgetcell(m_hPE, PEP_faYDATA, offset, (LPVOID) &fData);
                sprintf(szTmp2, "%.2f", fData);             
                strcat(szTmp, szTmp2);
                MessageBox(szTmp, "Table Drill Down", MB_OK | MB_ICONINFORMATION);
            }
            return TRUE;
    }
    
    return CView::OnCommand(wp, lp);
}

void CDemo2View::OnTimer(UINT nIDEvent) 
{
    if (PEnget(m_hPE, PEP_nOBJECTTYPE) == PECONTROL_GRAPH)
    {
        // Graph Real Time Feed //
        float r1, r2;
        float fNew[2];
    
        // make a point label with current time //
        CTime t = CTime::GetCurrentTime();
        CString ttext = t.Format("%I:%M:%S");
        PEvset(m_hPE, PEP_szaAPPENDPOINTLABELDATA, (void FAR*) (const char*) ttext, 1);
    
        // make some random data //
        r1 = (float) GetRandom(1, 25);
        r2 = (float) GetRandom(1000, 9999);
        fNew[0] = r1 + (r2 * .0001F);
        fNew[1] = fNew[0] * 4;
        PEvset(m_hPE, PEP_faAPPENDYDATA, &fNew[0], 1);
    }
    else
    {
        // Scientific Graph Real Time Feed //
        double m;
        float r1, r2, f;
        r1 = (float) 50.0F + (sin(m_nRealTimeCounter * .075F) * 30.0F) + GetRandom(1, 15);
        r2 = (float) GetRandom(1000, 9999);
        
        if (m_nRealTimeCounter >= 250)
        {
            m_nRealTimeCounter = 0;
            m = 0.0F;
            PEvset(m_hPE, PEP_fZOOMMINX, &m, 0);
            m = 50.0F;
            PEvset(m_hPE, PEP_fZOOMMAXX, &m, 0);
        }

        f = (float) m_nRealTimeCounter;
        PEvsetcell(m_hPE, PEP_faXDATA, m_nRealTimeCounter, &f);
        f = r1 + (r2 * .0001F);         
        PEvsetcell(m_hPE, PEP_faYDATA, m_nRealTimeCounter, &f);
        
        m_nRealTimeCounter ++;

        PEvget(m_hPE, PEP_fZOOMMAXX, &m);
        if (m_nRealTimeCounter > (int) m)
        {
            m += 25.0F;
            PEvset(m_hPE, PEP_fZOOMMAXX, &m, 0);
            m -= 50.0F; 
            PEvset(m_hPE, PEP_fZOOMMINX, &m, 0);
        }
        
        PEresetimage(m_hPE, 0, 0);
        ::InvalidateRect(m_hPE, NULL, FALSE);
    }
    CView::OnTimer(nIDEvent);
}





///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
////////////////
// Basic Code //
////////////////

The following is pseudo basic source code showing what is needed to
generate the graphs shown in the demo.  This code is using the OCX 
interface, but Delphi VCL and VB3 VBX code is nearly identical except 
for some minor syntax differences.


    Dim f1 As Single
    Dim s, p, n As Integer

    '/////////////////////////////////////////////////////////////////
    '// Business Graph //
    '////////////////////
    
    '// SET PROPERTIES DEFINING AMOUNT OF DATA //
    PEGraph1.Subsets = 3
    PEGraph1.Points = 100

    PEGraph1.MainTitle = "Unit Sales"
    PEGraph1.SubTitle = ""

    '// MAKE RANDOM DATA //
    For s = 0 to 3
        For p = 0 to 99
            f1 = 1 + (Rnd * 20)
            PEGraph1.YData(s, p) = f1
        Next p
    Next s  

    '// SET VARIOUS PROPERTIES //
    PEGraph1.PointsToGraph = 12
    PEGraph1.NoStackedData = False
    PEGraph1.PlottingMethod = PEGPM_BARSTACKED
    
    For s = 0 to 3
        PEGraph1.SubsetLabels(s) = States(s)
    Next s
    
    For p = 0 to 99
        PEGraph1.PointLabels(p) = MonYear(p) 
    Next p
    
    PEGraph1.AltFrequencies(0) = 1
    PEGraph1.AltFrequencies(1) = 2
    PEGraph1.AltFrequencies(2) = 3
    PEGraph1.AltFrequencies(3) = 6
    PEGraph1.AltFrequencies(4) = 12
    PEGraph1.AltFrequencies(5) = 24
    PEGraph1.AltFrequencies(6) = 36
    PEGraph1.AltFrequencies(7) = 48
    
    PEGraph1.TargetPointsToTable = 13
    PEGraph1.FirstPtLabelOffset = 1
    PEGraph1.AllowHorizontalBar = True
    PEGraph1.AllowAnnotationControl = True
    PEGraph1.ShowAnnotations = True
    PEGraph1.LineAnnotationTextSize = 95
    
    PEGraph1.HorzLineAnnotation(0) = 45
    PEGraph1.HorzLineAnnotationType(0) = PELT_THICKSOLID
    PEGraph1.HorzLineAnnotationColor(0) = QBColor(10)
    PEGraph1.HorzLineAnnotation(1) = 5
    PEGraph1.HorzLineAnnotationType(1) = PELT_THICKSOLID
    PEGraph1.HorzLineAnnotationColor(1) = QBColor(10)
            
    PEGraph1.LegendAnnotationType(0) = PEGAT_MEDIUMSOLIDLINE
    PEGraph1.LegendAnnotationColor(0) = QBColor(10)
    PEGraph1.LegendAnnotationText(0) = "Control Limits"
    
    PEGraph1.FontSize = PEFS_LARGE
    PEGraph1.GraphPlusTable = PEGPT_BOTH

    '// AFTER SETTING PROPERTIES, YOU MUST REINITIALIZE //
    PEGraph1.PEactions = 0 



    '/////////////////////////////////////////////////////////////////
    '// Quality Control //
    '/////////////////////
    
    '// SET PROPERTIES DEFINING AMOUNT OF DATA //
    PEGraph1.Subsets = 1
    PEGraph1.Points = 10

    '// MAKE RANDOM DATA //
    For p = 0 to 9
        PEGraph1.YData(0, p) = 1 + (Rnd * 40)
    Next p
        
    '// SET VARIOUS PROPERTIES //
    PEGraph1.PlottingMethod = PEGPM_BAR
    PEGraph1.PlottingMethodII = PEGPM_POINTSPLUSLINE
    PEGraph1.GraphPlusTable = PEGPT_BOTH        
    PEGraph1.MainTitle = "Defects Quality Report"
    PEGraph1.SubTitle = ""
    PEGraph1.SubsetLabels(0) = "Defects"

    For p = 0 to 9
        PEGraph1.PointLabels(p) = "P#" + Str$(p+1)
    Next p  
            
    PEGraph1.AllowHorizontalBar = True
    PEGraph1.AllowAnnotationControl = True
    PEGraph1.ShowAnnotations = True
    PEGraph1.LineAnnotationTextSize = 95
    PEGraph1.GridLineControl = PEGLC_NONE
            
    PEGraph1.HorzLineAnnotation(0) = 33
    PEGraph1.HorzLineAnnotationType(0) = PELT_THICKSOLID
    PEGraph1.HorzLineAnnotationColor(0) = QBColor(10)
    PEGraph1.HorzLineAnnotationText(0) = "Critical Limit"

    PEGraph1.HorzLineAnnotation(1) = 30
    PEGraph1.HorzLineAnnotationType(1) = PELT_MEDIUMSOLID
    PEGraph1.HorzLineAnnotationColor(1) = QBColor(10)
    PEGraph1.HorzLineAnnotationText(1) = "Upper Limit"
    
    PEGraph1.AutoStatSubsets(0) = PEAS_PARETO_DEC
    
    PEGraph1.FontSize = PEFS_LARGE
    PEGraph1.AllowHistogram = False

    '// AFTER SETTING PROPERTIES, YOU MUST REINITIALIZE //
    PEGraph1.PEactions = 0 



    '/////////////////////////////////////////////////////////////////
    '// Technical //
    '///////////////

    '// SET PROPERTIES DEFINING AMOUNT OF DATA //
    PEGraph1.Subsets = 1
    PEGraph1.Points = 500

    PEGraph1.MainTitle = "Signal Strength"
    PEGraph1.SubTitle = ""
            
    '// MAKE RANDOM DATA //
    For P=0 to 499
        PEGraph1.YData(0, p) = 1 + (Rnd * 125)
    Next p  
            
    '// SET VARIOUS PROPERTIES //
    PEGraph1.PointsToGraph = 125
    PEGraph1.PlottingMethod = PEGPM_LINE
    PEGraph1.SubsetLabels(0) = "Output"
    PEGraph1.XAxisLabel = "Milliseconds"
    PEGraph1.YAxisLabel = "Voltage (mV)"

    PEGraph1.AltFrequencies(0) = 1
    PEGraph1.AltFrequencies(1) = 2
    PEGraph1.AltFrequencies(2) = 5
    PEGraph1.AltFrequencies(3) = 10
    PEGraph1.AltFrequencies(4) = 20
    PEGraph1.AltFrequencies(5) = 50
    PEGraph1.AltFrequencies(6) = 100
    PEGraph1.AltFrequencies(7) = 200
    
    PEGraph1.FirstPtLabelOffset = 1
    PEGraph1.AllowAnnotationControl = True
    PEGraph1.ShowAnnotations = True
    PEGraph1.DataShadows = False
    PEGraph1.YAxisScaleControl = PEAC_LOG
    
    PEGraph1.SubsetsToLegend(0) = -1
    
    PEGraph1.GraphAnnotationX(0) = 70
    PEGraph1.GraphAnnotationY(0) = 280
    PEGraph1.GraphAnnotationType(0) = PEGAT_TOPLEFT
    PEGraph1.GraphAnnotationColor(0) = QBColor(10)
    PEGraph1.GraphAnnotationX(1) = 93
    PEGraph1.GraphAnnotationY(1) = 115
    PEGraph1.GraphAnnotationType(1) = PEGAT_BOTTOMRIGHT
    PEGraph1.GraphAnnotationColor(1) = QBColor(10)
    PEGraph1.GraphAnnotationX(2) = 70
    PEGraph1.GraphAnnotationY(2) = 280
    PEGraph1.GraphAnnotationType(2) = PEGAT_ROUNDRECT_THICK
    PEGraph1.GraphAnnotationColor(2) = QBColor(10)

    PEGraph1.GraphAnnotationX(3) = 170
    PEGraph1.GraphAnnotationY(3) = 280
    PEGraph1.GraphAnnotationType(3) = PEGAT_TOPLEFT
    PEGraph1.GraphAnnotationColor(3) = QBColor(10)
    PEGraph1.GraphAnnotationX(4) = 195
    PEGraph1.GraphAnnotationY(4) = 115
    PEGraph1.GraphAnnotationType(4) = PEGAT_BOTTOMRIGHT
    PEGraph1.GraphAnnotationColor(4) = QBColor(10)
    PEGraph1.GraphAnnotationX(5) = 170
    PEGraph1.GraphAnnotationY(5) = 280
    PEGraph1.GraphAnnotationType(5) = PEGAT_ROUNDRECT_THICK
    PEGraph1.GraphAnnotationColor(5) = QBColor(10)

    PEGraph1.GraphAnnotationX(6) = 270
    PEGraph1.GraphAnnotationY(6) = 280
    PEGraph1.GraphAnnotationType(6) = PEGAT_TOPLEFT
    PEGraph1.GraphAnnotationColor(6) = QBColor(10)
    PEGraph1.GraphAnnotationX(7) = 295
    PEGraph1.GraphAnnotationY(7) = 115
    PEGraph1.GraphAnnotationType(7) = PEGAT_BOTTOMRIGHT
    PEGraph1.GraphAnnotationColor(7) = QBColor(10)
    PEGraph1.GraphAnnotationX(8) = 270
    PEGraph1.GraphAnnotationY(8) = 280
    PEGraph1.GraphAnnotationType(8) = PEGAT_ROUNDRECT_THICK
    PEGraph1.GraphAnnotationColor(8) = QBColor(10)

    PEGraph1.GraphAnnotationX(6) = 370
    PEGraph1.GraphAnnotationY(6) = 280
    PEGraph1.GraphAnnotationType(6) = PEGAT_TOPLEFT
    PEGraph1.GraphAnnotationColor(6) = QBColor(10)
    PEGraph1.GraphAnnotationX(7) = 395
    PEGraph1.GraphAnnotationY(7) = 115
    PEGraph1.GraphAnnotationType(7) = PEGAT_BOTTOMRIGHT
    PEGraph1.GraphAnnotationColor(7) = QBColor(10)
    PEGraph1.GraphAnnotationX(8) = 370
    PEGraph1.GraphAnnotationY(8) = 280
    PEGraph1.GraphAnnotationType(8) = PEGAT_ROUNDRECT_THICK
    PEGraph1.GraphAnnotationColor(8) = QBColor(10)

    PEGraph1.GraphAnnotationX(6) = 470
    PEGraph1.GraphAnnotationY(6) = 280
    PEGraph1.GraphAnnotationType(6) = PEGAT_TOPLEFT
    PEGraph1.GraphAnnotationColor(6) = QBColor(10)
    PEGraph1.GraphAnnotationX(7) = 495
    PEGraph1.GraphAnnotationY(7) = 115
    PEGraph1.GraphAnnotationType(7) = PEGAT_BOTTOMRIGHT
    PEGraph1.GraphAnnotationColor(7) = QBColor(10)
    PEGraph1.GraphAnnotationX(8) = 470
    PEGraph1.GraphAnnotationY(8) = 280
    PEGraph1.GraphAnnotationType(8) = PEGAT_ROUNDRECT_THICK
    PEGraph1.GraphAnnotationColor(8) = QBColor(10)

    PEGraph1.LegendAnnotationType(0) = PEGAT_MEDIUMSOLIDLINE
    PEGraph1.LegendAnnotationColor(0) = QBColor(10)
    PEGraph1.LegendAnnotationText(0) = "Test Area"
    
    PEGraph1.CursorMode = PECM_DATACROSS
    PEGraph1.MouseCursorControl = True
    PEGraph1.GridLineControl = PEGLC_NONE
    PEGraph1.NegativeFronXAxis = False
    
    PEGraph1.ManualScaleControlY = PEMSC_MINMAX
    PEGraph1.ManualMinY = 50.0
    PEGraph1.ManualMaxY = 2500

    '// AFTER SETTING PROPERTIES, YOU MUST REINITIALIZE //
    PEGraph1.PEactions = 0 



    '/////////////////////////////////////////////////////////////////
    '// Graph Real Time //
    '/////////////////////

    '// SET PROPERTIES DEFINING AMOUNT OF DATA //
    PEGraph1.Subsets = 2
    PEGraph1.Points = 200

    PEGraph1.MainTitle = "Real Time Historical Log"
    PEGraph1.SubTitle = ""
            
    PEGraph1.SubsetLabels(0) = "Input"
    PEGraph1.SubsetLabels(1) = "Output"
    
    PEGraph1.YAxisLabel = "Pressure"
    PEGraph1.RYAxisLabel = "Pressure"
    
    PEGraph1.DataShadows = False
    PEGraph1.PointsToGraph = 25
    PEGraph1.PointsToGraphInit = PEPTGI_LASTPOINTS
    PEGraph1.NoRandomPointsToGraph = True
    PEGraph1.PlottingMethod = PEGPM_LINE
    PEGraph1.ForceRightYAxis = True
    PEGraph1.ForceVerticalPoints = True
    
    '// Set last Point Label so memory is allocated and not virtual //
    '// This is needed since real-time will shift current data //
    PEGraph1.PointLabels(199) = " "
    
    PEGraph1.ManualScaleControlY = PEMSC_MINMAX
    PEGraph1.ManualMinY = 0
    PEGraph1.ManualMaxY = 100

    PEGraph1.ManualScaleControlRY = PEMSC_MINMAX
    PEGraph1.ManualMinRY = 0
    PEGraph1.ManualMaxRY = 100

    PEGraph1.ManualMaxPointLabel = "##:##:##"
    PEGraph1.ManualMaxDataString = "##.###"
    
    PEGraph1.AllowDataHotSpots = False
    PEGraph1.AllowSubsetHotSpots = False
    PEGraph1.AllowPointHotSpots = False
    PEGraph1.AllowTableHotSpots = False
    PEGraph1.AllowZooming = PEAZ_NONE
    PEGraph1.AllowHistogram = False
    PEGraph1.GridLineControl = PEGLC_YAXIS
            
    '// clear out first four default data points to start empty //
    PEGraph1.YData(0) = 0
    PEGraph1.YData(1) = 0
    PEGraph1.YData(2) = 0
    PEGraph1.YData(3) = 0

    '// AFTER SETTING PROPERTIES, YOU MUST REINITIALIZE //
    PEGraph1.PEactions = 0 



    '/////////////////////////////////////////////////////////////////
    '// Multiple Y Axes //
    '/////////////////////
    PESGraph1.MainTitle = "Multiple Y Axis Example"
    PESGraph1.SubTitle = ""
    
    PESGraph1.Subsets = 12
    PESGraph1.Points = 100

    '// MAKE RANDOM DATA //
            
    Dim dt As Double;
    Dim d, f1, f2, f3, f4 As Single
    dt = Now

    For p = 0 to 99
        f1 = 150 + (sin(p * .034) * 60) + (Rnd * 30) + (p / 2)
        f2 = 10 + (Rnd * 10)
        f3 = 35 + (Rnd * 20)
        d = dt + p  
        
        PESGraph1.XData(0, p) = d
        PESGraph1.YData(0, p) = f1 - f3
        PESGraph1.XData(1, p) = d
        PESGraph1.YData(1, p) = f1 + f3
        PESGraph1.XData(2, p) = d
        PESGraph1.YData(2, p) = f1 - f2
        PESGraph1.XData(3, p) = d
        PESGraph1.YData(3, p) = f1 + f2
        PESGraph1.XData(4, p) = d
        PESGraph1.YData(4, p) = 250 + (cos(p * .06) * 70) + (Rnd * 40) + (p / 2)
        PESGraph1.XData(5, p) = d
        PESGraph1.YData(5, p) = -10 + (Rnd * 80)
        PESGraph1.XData(6, p) = d
        PESGraph1.YData(6, p) = -10 + (Rnd * 30)
        PESGraph1.XData(7, p) = d
        PESGraph1.YData(7, p) = -20 + (Rnd * 50)
        PESGraph1.XData(8, p) = d
        PESGraph1.YData(8, p) = -50 + (cos(p * .06) * 70) + (Rnd * 30) + p
        PESGraph1.XData(9, p) = d
        PESGraph1.YData(9, p) = 100 + (sin(p * .15) * 100) + (Rnd * 20) + p
    Next p  

    For s = 10 to 11
        For p = 0 to 99
            d = dt + p
            PESGraph1.XData(s, p) = d
            PESGraph1.YData(s, p) = 15 + (Rnd * 75) + (s * 100)
        Next p
    Next s  

    '// SET VARIOUS OTHER PROPERTIES //
    
    PESGraph1.SubsetsToLegend(0) = -1
    
    For s = 0 to 11
        PESGraph1.SubsetLineTypes(s) = PELT_THINSOLID
    Next s  
    
    PESGraph1.MultiAxesSubsets(0) = 6
    PESGraph1.MultiAxesSubsets(1) = 2
    PESGraph1.MultiAxesSubsets(2) = 2
    PESGraph1.MultiAxesSubsets(3) = 2

    PESGraph1.MultiAxesProportions(0) = .5
    PESGraph1.MultiAxesProportions(1) = .15
    PESGraph1.MultiAxesProportions(2) = .15
    PESGraph1.MultiAxesProportions(3) = .2
    
    PESGraph1.DataShadows = False
    
    '// Set first (top) axis parameters //
    PESGraph1.WorkingAxis = 0
    PESGraph1.PlottingMethod = PESGPM_SPECIFICPLOTMODE
    PESGraph1.SpecificPlotMode = PESPM_BOXPLOT
    PESGraph1.RYAxisComparisonSubsets = 2
    PESGraph1.YAxisLabel = "Y Axis #1"
    PESGraph1.RYAxisLabel = "Y Axis #2"

    '// Set second axis parameters
    PESGraph1.WorkingAxis = 1
    PESGraph1.PlottingMethod = PESGPM_BAR
    PESGraph1.YAxisLabel = "Y Axis #3"

    '// Set third axis //
    PESGraph1.WorkingAxis = 2
    PESGraph1.PlottingMethod = PESGPM_AREA
    PESGraph1.RYAxisComparisonSubsets = 1
    PESGraph1.YAxisLabel = "Y Axis #4"
    PESGraph1.RYAxisLabel = "Y Axis #5"

    '// Set fourth axis //
    PESGraph1.WorkingAxis = 3
    PESGraph1.PlottingMethod = PESGPM_AREA
    PESGraph1.YAxisLabel = "Y Axis #5"
    PESGraph1.RYAxisLabel = "Y Axis #6"
    PESGraph1.ManualScaleControlY = PEMSC_MIN
    PESGraph1.ManualMinY = 900

    '// Always reset WorkingAxis to 0 //
    PESGraph1.WorkingAxis = 0
    
    PESGraph1.DateTimeMode = PEDTM_VB
    PESGraph1.GraphForeColor = QBColor(15)
    PESGraph1.GraphBackColor = 0
    
    PESGraph1.FontSize = PEFS_MEDIUM
    PESGraph1.CursorPromptStyle = 3
    PESGraph1.ScrollingHorzZoom = True
    PESGraph1.AllowDataLabels = PEADL_NONE

    '// AFTER SETTING PROPERTIES, YOU MUST REINITIALIZE //
    PESGraph1.PEactions = 0 


    '/////////////////////////////////////////////////////////////////
    '// Dual X Axes //
    '/////////////////
    
    PESGraph1.MainTitle = "Dual X Axes Example"
    PESGraph1.SubTitle = ""
    
    PESGraph1.Subsets = 2
    PESGraph1.Points = 500
            
    '// MAKE RANDOM DATA //
    
    For p = 0 to 499
        PESGraph1.XData(0, p) = 1500 + (sin(p * .014) * 600) + (Rnd * 5) + (p / 2)
        PESGraph1.YData(0, p) = 1500 + (cos(p * .014) * 1600) + (Rnd * 5) + (p / 2)
    Next p  
    
    For p = 0 to 499
        PESGraph1.XData(1, p) = 150 + (sin(p * .014) * 60) + (Rnd * 5) + (p / 2)
        PESGraph1.YData(1, p) = 150 + (cos(p * .014) * 160) + (Rnd * 5) + (p / 2)
    Next p  

    '// SET VARIOUS OTHER PROPERTIES //
    
    PESGraph1.SubsetLabels(0) = "Signal #1"
    PESGraph1.SubsetLabels(1) = "Signal #2"
    
    PESGraph1.SubsetLineTypes(0) = PELT_THINSOLID
    PESGraph1.SubsetLineTypes(1) = PELT_THINSOLID
    
    PESGraph1.RYAxisComparisonSubsets = 1
    PESGraph1.TXAxisComparisonSubsets = 1
    
    PESGraph1.YAxisColor = QBColor(12)
    PESGraph1.XAxisColor = QBColor(12)
    
    PESGraph1.RYAxisColor = QBColor(11)
    PESGraph1.TXAxisColor = QBColor(11)

    PESGraph1.DataShadows = False
    PESGraph1.CursorPromptTracking = True
    PESGraph1.FontSize = PEFS_MEDIUM
    
    PESGraph1.DeskColor = 0
    PESGraph1.TextColor = QBColor(14)
    PESGraph1.GraphForeColor = QBColor(9)
    PESGraph1.GraphBackColor = 0
    
    PESGraph1.SubsetsToLegend(0) = -1
    
    PESGraph1.MultiSubTitles(0) = "Machine|Power|Temperature"
    PESGraph1.MultiSubTitles(1) = "Main Drill|4554 Watts|1243.4 F"
    PESGraph1.MultiSubTitles(2) = "Secondary Drill|2343 Watts|634.2 F"
    
    PESGraph1.MultiBottomTitles(0) = "Plant|Shift|Time"
    PESGraph1.MultiBottomTitles(1) = "Dallas|Second|08:23 pm"
    
    PESGraph1.CursorPromptStyle = 3
    PESGraph1.GridStyle = PEGS_DOT
    PESGraph1.GridLineControl = PEGLC_NONE
    PESGraph1.CursorMode = PECM_DATACROSS
    PESGraph1.MouseCursorControl = True
    PESGraph1.AllowDataLabels =  False
    
    PESGraph1.BarWidth = 1

    '// AFTER SETTING PROPERTIES, YOU MUST REINITIALIZE //
    PESGraph1.PEactions = 0 



    '/////////////////////////////////////////////////////////////////
    '// Log //
    '/////////

    PESGraph1.MainTitle = "Log Example"
    PESGraph1.SubTitle = "  "
    PESGraph1.Subsets = 2
    PESGraph1.Points = 100
            
    '// MAKE RANDOM DATA //
            
    Dim b, g, r As Long
    b = QBColor(10)
    g = QBColor(11)
    r = QBColor(12)
    
    For p = 0 to 99
        f1 = 90 + (p * 100)
        f2 = 500 + (cos(p * .044) * 5600) + (Rnd * 15) + (p * 90)
                
        If f2 <= 1050 Then
            PESGraph1.PointColors(0, p) = r
        Else
            PESGraph1.PointColors(0, p) = b   
        End If  
            
        PESGraph1.XData(0, p) = f1
        PESGraph1.YData(0, p) = f2
    Next p    
            
    For p = 0 to 99
        f1 = 70 + (p * 100)
        f2 = 900 + (cos(p * .084) * 3600) + (Rnd * 50) + (p * 90)
        
        If f2 <= 1050.0F Then
            PESGraph1.PointColors(1, p) =  r
        Else
            PESGraph1.PointColors(1, p) = g
        End If  
        
        PESGraph1.XData(1, p) = f1
        PESGraph1.YData(1, p) = f2
    Next p  
            
    '// SET VARIOUS OTHER PROPERTIES //
    
    PESGraph1.SubsetLabels(0) = "Signal #1"
    PESGraph1.SubsetLabels(1) = "Signal #2"
    
    PESGraph1.XAxisLabel = "Voltage"
    PESGraph1.YAxisLabel = "Current"

    PESGraph1.YAxisScaleControl = PEAC_LOG
    PESGraph1.XAxisScaleControl = PEAC_LOG
    
    PESGraph1.DataShadows = False
    PESGraph1.MarkDataPoints = True
    
    PESGraph1.ManualScaleControlX = PEMSC_MINMAX
    PESGraph1.ManualMinX = 50
    PESGraph1.ManualMaxX = 13010
    
    PESGraph1.ManualScaleControlY = PEMSC_MINMAX
    PESGraph1.ManualMinY = 390
    PESGraph1.ManualMaxY = 12010
    
    PESGraph1.GraphForeColor = 0
    PESGraph1.GraphBackColor = QBColor(7)
    PESGraph1.ShadowColor = 0
    
    PESGraph1.SubsetLineTypes(0) = PELT_MEDIUMSOLID
    PESGraph1.SubsetLineTypes(1) = PELT_MEDIUMSOLID
    
    PESGraph1.CursorPromptStyle = 3
    PESGraph1.CursorMode = PECM_DATASQUARE
    PESGraph1.MouseCursorControl = True
    PESGraph1.AllowBar = False
    
    PESGraph1.GraphAnnotationX(0) = 70
    PESGraph1.GraphAnnotationY(0) = 4536
    PESGraph1.GraphAnnotationText(0) = Initial Measurment
    PESGraph1.GraphAnnotationType(0) = PEGAT_NOSYMBOL
    PESGraph1.GraphAnnotationColor(0) = QBColor(15)

    PESGraph1.GraphAnnotationX(1) = 3570
    PESGraph1.GraphAnnotationY(1) = 524
    PESGraph1.GraphAnnotationText(1) = Target Measurment
    PESGraph1.GraphAnnotationType(1) = PEGAT_NOSYMBOL
    PESGraph1.GraphAnnotationColor(1) = QBColor(15)

    PESGraph1.GraphAnnotationX(2) = 90
    PESGraph1.GraphAnnotationY(2) = 6111
    PESGraph1.GraphAnnotationText(2) = Initial Measurment
    PESGraph1.GraphAnnotationType(2) = PEGAT_NOSYMBOL
    PESGraph1.GraphAnnotationColor(2) = QBColor(15)

    PESGraph1.GraphAnnotationX(3) = 6490
    PESGraph1.GraphAnnotationY(3) = 958
    PESGraph1.GraphAnnotationText(3) = Target Measurment
    PESGraph1.GraphAnnotationType(3) = PEGAT_NOSYMBOL
    PESGraph1.GraphAnnotationColor(3) = QBColor(15)
        
    PESGraph1.GraphAnnotationTextSize = 90
    PESGraph1.ShowAnnotations = True
    PESGraph1.AllowAnnotationControl = True

    '// AFTER SETTING PROPERTIES, YOU MUST REINITIALIZE //
    PESGraph1.PEactions = 0 

    
    '/////////////////////////////////////////////////////////////////
    '// Scientific real time //
    '//////////////////////////

    '// SET PROPERTIES DEFINING AMOUNT OF DATA //
    PESGraph1.Subsets = 1
    PESGraph1.Points = 250
    
    PESGraph1.MainTitle = "Real Time Example"
    PESGraph1.SubTitle = ""
    
    PESGraph1.SubsetLabels(0) = "Signal Input"
    
    PESGraph1.YAxisLabel = "Pressure"
    PESGraph1.RYAxisLabel = "Pressure"

    PESGraph1.DataShadows = False
    PESGraph1.CursorPromptTracking = False
    PESGraph1.AllowPopup = False
    PESGraph1.NoRandomPointsToGraph = True
    PESGraph1.PlottingMethod = PESGPM_LINE
    
    PESGraph1.ForceRightYAxis = True
    
    PESGraph1.ManualScaleControlY = PEMSC_MINMAX
    PESGraph1.ManualMinY = 0
    PESGraph1.ManualMaxY = 100
            
    PESGraph1.ManualScaleControlRY = PEMSC_MINMAX
    PESGraph1.ManualMinRY = 0
    PESGraph1.ManualMaxRY = 100
            
    PESGraph1.ManualScaleControlX = PEMSC_MINMAX
    PESGraph1.ManualMinX = 0
    PESGraph1.ManualMaxX = 500
    
    '// Manual range is 0-500 but start out looking at 0-50 //
    PESGraph1.ZoomMode = True
    PESGraph1.ZoomMinX = 0
    PESGraph1.ZoomMaxX = 50
    PESGraph1.ZoomMinY = 0
    PESGraph1.ZoomMaxY = 100
    
    '// clear out default data to start with an empty graph //
    PESGraph1.XData(0) = 0
    PESGraph1.XData(1) = 0
    PESGraph1.XData(2) = 0
    PESGraph1.XData(3) = 0
    PESGraph1.YData(0) = 0
    PESGraph1.YData(1) = 0
    PESGraph1.YData(2) = 0
    PESGraph1.YData(3) = 0
    
    PESGraph1.AllowDataHotSpots = False
    PESGraph1.AllowSubsetHotSpots = False
    PESGraph1.AllowDataLabels = PEADL_NONE
    PESGraph1.AllowZooming = PEAZ_NONE

    '// AFTER SETTING PROPERTIES, YOU MUST REINITIALIZE //
    PESGraph1.PEactions = 0 

            


    '/////////////////////////////////////////////////////////////////
    '// Polar //
    '///////////
    
    PEPGraph1.MainTitle = "Polar Example"
    PEPGraph1.SubTitle = ""
    
    PEPGraph1.Subsets = 2
    PEPGraph1.Points = 360
    
    '// MAKE RANDOM DATA //
    
    For p = 0 to 359
        PEPGraph1.XData(0, p) = p
        PEPGraph1.YData(0, p) = sin(p * 0.054)
    Next p  
    
    For p = 0 to 359
        PEPGraph1.XData(1, p) = p
        PEPGraph1.YData(1, p) = sin(p * 0.044)
    Next p  
    
    PEPGraph1.SubsetLabels(0) = "Signal #1"
    PEPGraph1.SubsetLabels(1) = "Signal #2"
    
    PEPGraph1.MarkDataPoints = True
    PEPGraph1.CursorPromptStyle = 3
    
    PEPGraph1.SubsetLineTypes(0) = PELT_THINSOLID
    PEPGraph1.SubsetLineTypes(1) = PELT_THINSOLID

    '// AFTER SETTING PROPERTIES, YOU MUST REINITIALIZE //
    PEPGraph1.PEactions = 0 
    

    

    '/////////////////////////////////////////////////////////////////
    '// Smith //
    '///////////

    PEPGraph1.SmithChart = True
    
    PEPGraph1.MainTitle = "Smith Chart Example"
    PEPGraph1.SubTitle = " "
            
    '// Assigns no data, just shows default data //
    
    PEPGraph1.PlottingMethod = PEPGPM_POINTSPLUSLINE
    PEPGraph1.CursorPromptStyle = 3

    '// AFTER SETTING PROPERTIES, YOU MUST REINITIALIZE //
    PEPGraph1.PEactions = 0 


    
    '/////////////////////////////////////////////////////////////////
    '// Pie //
    '/////////
    
    PEPieChart1.MainTitle = "Produce Sales"
    PEPieChart1.SubTitle = ""
    
    PEPieChart1.Subsets = 4
    PEPieChart1.Points = 12        
            
    '// MAKE RANDOM DATA //
    
    For s = 0 to 3
        For p = 0 to 11
            PEPieChart1.XData(s, p) = 1 + (Rnd * 100) 
        Next p
    Next s  
            
    PEPieChart1.SubsetLabels(0) = "Cherries"
    PEPieChart1.SubsetLabels(1) = "Apples"
    PEPieChart1.SubsetLabels(2) = "Oranges"
    PEPiechart1.SubsetLabels(3) = "Grapes"
  
    For p = 0 to 11
        PEPieChart1.PointLabels(p) = States(p)
    Next p  
    
    PEPieChart1.FontSize = PEFS_LARGE
    PEPieChart1.GroupingPercent = 3
    PEPieChart1.AutoExplode = PEAE_ALLSUBSETS
    
    '// AFTER SETTING PROPERTIES, YOU MUST REINITIALIZE //
    PEPieChart1.PEactions = 0 
    

    '/////////////////////////////////////////////////////////////////
    '// Graph OnTimerEvent //
    '////////////////////////
    
    '// new point label //
    CurrentTime$ = Time$
    
    '// new YData //
    ReDim NewData(2) As Single
    NewData(0) = (Rnd * 20) + 2
    NewData(1) = (Rnd * 40) + 60
    
    '// transfer new point label //
    test% = PEvset(PEGraph1, PEP_szaAPPENDPOINTLABELDATA, ByVal CurrentTime$, 1)

    '// transfer new YData //
    '// this will also update and view new image //
    test% = PEvset(PEGraph1, PEP_faAPPENDYDATA, NewData(0), 1)


    '/////////////////////////////////////////////////////////////////
    '// Scientific Graph OnTimerEvent //
    '///////////////////////////////////
    
    Dim f1 As Single
    f1 = 50 + (sin(m_nRealTimeCounter * .075) * 30) + (Rnd * 15);
        
    '// This resets zoom location when reaching end of graph //
    If m_nRealTimeCounter >= 250 Then
        m_nRealTimeCounter = 0;
        PESGraph1.ZoomMinX = 0
        PESGraph1.ZoomMaxX = 50
    End If

    PESGraph1.XData(0, m_nRealTimeCounter, m_nRealTimeCounter)
    PESGraph1.YData(0, m_nRealTimeCounter, f1)
        
    m_nRealTimeCounter = m_nRealTimeCounter + 1

    If m_nRealTimeCounter > PESGraph1.ZoomMaxX Then
        PESGraph1.ZoomMaxX = PESGraph1.ZoomMaxX + 25
        PESGraph1.ZoomMinX = PESGraph1.ZoomMaxX - 50
    End If
        
    PEactions = 2  '// Calls PEresetimage
    PEactions = 3  '// Calls InvalidateRect






