windows-xp/Source/XPSP1/NT/sdktools/perfmon/grafdisp.c

//==========================================================================//
//                                  Includes                                //
//==========================================================================//


#include <stdio.h>
#include "perfmon.h"
#include "grafdisp.h"      // external declarations for this file

#include "grafdata.h"      // for InsertGraph, et al.
#include "graph.h"
#include "legend.h"
#include "line.h"          // for LineCreatePen
#include "perfmops.h"      // for DoWindowDrag
#include "playback.h"      // for PlayingBackLog
#include "valuebar.h"
#include "utils.h"
#include "timeline.h"      // for IsTLineWindowUp & TLineRedraw
#include "counters.h"      // for CounterEntry

//==========================================================================//
//                                  Constants                               //
//==========================================================================//

// this macro is used in doing a simple DDA (Digital Differential Analyzer)
// * 10 + 5 is to make the result round up with .5
#define DDA_DISTRIBUTE(TotalTics, numOfData) \
   ((TotalTics * 10 / numOfData) + 5) / 10

HDC   hGraphDisplayDC ;
//=============================//
// GraphDisplay Class          //
//=============================//


TCHAR   szGraphDisplayWindowClass[] = TEXT("PerfChart") ;
#define dwGraphDisplayClassStyle    (CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | CS_OWNDC)
#define iGraphDisplayClassExtra     (0)
#define iGraphDisplayWindowExtra    (0)
#define dwGraphDisplayWindowStyle   (WS_CHILD | WS_VISIBLE)



//==========================================================================//
//                              Local Functions                             //
//==========================================================================//
BOOL UpdateTimeLine (HDC hDC, PGRAPHSTRUCT pGraph, BOOL getLastTimeLocation) ;

INT
ScaleAndInvertY (
                FLOAT ey,
                PLINESTRUCT pLineStruct,
                PGRAPHSTRUCT pGraph
                )
/*
   Effect:        Given data value ey, scale and fit the value to fit
                  within the graph data area of the window, considering
                  the scale set for the line and the current size of the
                  data rectangle.
*/
{
    INT     yGraphDataHeight,               // Height of graph area
    yInverted ;                     // Scaled & Inverted Y.
    FLOAT   eppd,
    eyScaled ;

    // Take care of any scaling now, at output time.
    ey *= pLineStruct->eScale ;

    // Calculate the Cy of the graph area.
    yGraphDataHeight = pGraph->rectData.bottom - pGraph->rectData.top ;

    // Calculate the pixels per data point.
    eppd = (FLOAT) ((FLOAT) yGraphDataHeight / (FLOAT) pGraph->gOptions.iVertMax) ;
    eyScaled = eppd * ey ;
    yInverted = (INT) (((FLOAT) yGraphDataHeight) - eyScaled) ;

    yInverted += pGraph->rectData.top ;

    // Clamp the range to fit with in the graph portion of the windows
    yInverted = PinInclusive (yInverted,
                              pGraph->rectData.top, pGraph->rectData.bottom) ;
    return (yInverted) ;
}


BOOL
DrawGrid (
         HDC hDC,
         PGRAPHSTRUCT pGraph,
         LPRECT lpRect,
         BOOL bForPaint
         )
/*
   Effect:        Draw the grid lines in the graph display window.
                  These grid lines are in the graph data area only,
                  which is indicated by pGraph->rectData.

   Called By:     OnPaint only.
*/
{
    int            iGrid, iLines ;
    int            xGrid, yGrid ;
    POINT          aPoints [4 * iGraphMaxTics] ;
    DWORD          aCounts [2 * iGraphMaxTics] ;
    HPEN           hPenPrevious ;
    int            bottomAdjust ;

    if (!pGraph->gOptions.bHorzGridChecked &&
        !pGraph->gOptions.bVertGridChecked)
        return (FALSE) ;


    hPenPrevious = SelectPen (hDC, IsPrinterDC (hDC) ?
                              GetStockObject (BLACK_PEN) : pGraph->hGridPen) ;

    iLines = 0 ;

    if (pGraph->gOptions.bHorzGridChecked) {
        for (iGrid = 1 ;
            iGrid < pGraph->yNumTics ;
            iGrid++) {
            yGrid = pGraph->ayTics[iGrid] + pGraph->rectData.top ;
            if (yGrid >= lpRect->top &&
                yGrid <= lpRect->bottom) {
                aPoints[2 * iLines].x = lpRect->left ;
                aPoints[2 * iLines].y = yGrid ;
                aPoints[2 * iLines + 1].x = lpRect->right ;
                aPoints[2 * iLines + 1].y = yGrid ;

                aCounts[iLines] = 2 ;
                iLines++ ;
            }
        }
    }

    if (pGraph->gOptions.bVertGridChecked) {
        bottomAdjust = lpRect->bottom + (bForPaint ? 1 : 0) ;
        for (iGrid = 1 ;
            iGrid < pGraph->xNumTics ;
            iGrid++) {
            xGrid = pGraph->axTics[iGrid] + pGraph->rectData.left ;
            if (xGrid >= lpRect->left &&
                xGrid <= lpRect->right) {
                aPoints[2 * iLines].x = xGrid ;
                aPoints[2 * iLines].y = lpRect->top ;
                aPoints[2 * iLines + 1].x = xGrid ;
                aPoints[2 * iLines + 1].y = bottomAdjust ;

                aCounts[iLines] = 2 ;
                iLines++ ;
            }
        }
    }

    if (iLines)
        PolyPolyline (hDC, aPoints, aCounts, iLines) ;

    SelectPen (hDC, hPenPrevious) ;

    return (TRUE) ;
}



BOOL
DrawBarChartData (
                 HDC hDC,
                 PGRAPHSTRUCT pGraph
                 )
{
    PLINESTRUCT pLineStruct ;
    PFLOAT      pDataPoints ;
    INT         nLegendItems,
    cx,
    cxBar,
    xDataPoint = 0,
                 y  = 0;
    RECT        rectBar ;
    RECT        rectBkgrnd ;
    HBRUSH      hOldBrush ;
    FLOAT       eValue ;
    PLINESTRUCT pCurrentLine ;

    // Determine how many items are in the legend.

    nLegendItems = 0 ;

    for (pLineStruct = pGraph->pLineFirst ;
        pLineStruct ;
        pLineStruct = pLineStruct->pLineNext) {
        nLegendItems++ ;
    }

    if (nLegendItems == 0)
        return(FALSE) ;

    // get current select line for highlighting
    if (pGraph->HighLightOnOff) {
        pCurrentLine = CurrentGraphLine (hWndGraph) ;
    } else {
        pCurrentLine = NULL ;
    }

    // Determine the width of each bar.
    cx = pGraph->rectData.right - pGraph->rectData.left ;


    if (PlayingBackLog()) {
        // get the average using the start and stop data point
        // from the log file
        PlaybackLines (pGraph->pSystemFirst,
                       pGraph->pLineFirst,
                       PlaybackLog.StartIndexPos.iPosition) ;
        PlaybackLines (pGraph->pSystemFirst,
                       pGraph->pLineFirst,
                       PlaybackLog.StopIndexPos.iPosition) ;
    } else {
        // Loop through all the DataLines and draw a bar for
        // it's last value.
        xDataPoint = pGraph->gKnownValue % pGraph->gMaxValues ;
    }

    rectBar.bottom = pGraph->rectData.bottom + 1 ;

    rectBkgrnd = pGraph->rectData ;

    hOldBrush = SelectBrush (hDC, hBrushFace) ;

    PatBlt (hDC,
            rectBkgrnd.left, rectBkgrnd.top,
            rectBkgrnd.right - rectBkgrnd.left,
            rectBkgrnd.bottom - rectBkgrnd.top + 1,
            PATCOPY) ;
    DrawGrid(hDC, pGraph, &(rectBkgrnd), FALSE) ;

    rectBar.right = pGraph->rectData.left ;
    for (pLineStruct = pGraph->pLineFirst ;
        pLineStruct ;
        pLineStruct = pLineStruct->pLineNext) {
        pDataPoints = pLineStruct->lnValues ;

        if (PlayingBackLog()) {
            eValue = CounterEntry (pLineStruct) ;
        } else {
            eValue = pDataPoints[xDataPoint] ;
        }


        y = ScaleAndInvertY (eValue,
                             pLineStruct,
                             pGraph) ;

        rectBar.left   = rectBar.right ;
        rectBar.top    = y ;

        // nomore line to draw
        if (nLegendItems == 0 ) {
            break ;
        }

        cxBar = DDA_DISTRIBUTE (cx, nLegendItems) ;
        rectBar.right  = rectBar.left + cxBar ;

        // setup for next DDA
        nLegendItems-- ;
        cx -= cxBar ;

        // NOTE: this handle creation should be moved to line
        //       create time.

        if (pCurrentLine == pLineStruct) {
            SetBkColor (hDC, crWhite) ;
        } else {
            SetBkColor (hDC, pLineStruct->Visual.crColor) ;
        }
        ExtTextOut (hDC, rectBar.right, rectBar.top, ETO_OPAQUE,
                    &rectBar, NULL, 0, NULL) ;
    }

    return (TRUE) ;
}


/***************************************************************************
 * DrawTLGraphData - Draw Time Line Graph Data.
 *
 *  Some notes about drawing the DataPoint graphs.
 *
 *      1]  It's real expensive to make a GDI call. So, we do not
 *          make a MoveToEx and LineTo call for each point.  Instead
 *          we create a polyline and send it down to GDI.
 *
 *      2]  The X coordinates for each point in the polyline is generated
 *          from our favorite xDataPoint to xWindows DDA.
 *
 *      3]  The Y coordinate is generated from the pLineStruct->lnValues[x]
 *          data associated with each line.
 ***************************************************************************/
BOOL
DrawTLGraphData (
                HDC hDC,
                BOOL bForPaint,
                PRECT prctPaint,
                PGRAPHSTRUCT pGraph
                )
/*
   Called By:     UpdateGraphDisplay only.
*/
{
    PLINESTRUCT pLineStruct ;
    HPEN        hPen = 0 ;
    HPEN        hOldPen ;
    PFLOAT      pDataPoints ;
    INT         i, j,
    iValidValues,
    xDispDataPoint,
    xLeftLimit,
    xRightLimit ;
    PPOINT      pptDataPoints ;
    INT         numOfData, rectWidth, xPos ;
    PLINESTRUCT pCurrentLine ;
    INT         DrawZeroPoint = 0 ;

    //   SetBkColor (hDC, crLightGray) ;

    if (!IsPrinterDC (hDC)) {
        if (bForPaint) {
            IntersectClipRect (hDC,
                               pGraph->rectData.left,
                               pGraph->rectData.top,
                               pGraph->rectData.right,
                               pGraph->rectData.bottom + 1) ;
        } else {
            IntersectClipRect (hDC,
                               pGraph->rectData.left,
                               pGraph->rectData.top,
                               PlayingBackLog () ?
                               pGraph->rectData.right :
                               min (pGraph->rectData.right,
                                    pGraph->gTimeLine.xLastTime + 2),
                               pGraph->rectData.bottom + 1) ;
        }
    }

    xLeftLimit  = prctPaint->left  - pGraph->gTimeLine.ppd - 1 ;

    if (bForPaint)
        xRightLimit = prctPaint->right + pGraph->gTimeLine.ppd ;
    else
        xRightLimit = prctPaint->right ;

    pptDataPoints  = pGraph->pptDataPoints ;

    iValidValues   = pGraph->gTimeLine.iValidValues ;

    if (!PlayingBackLog() &&
        pGraph->gOptions.iGraphOrHistogram == LINE_GRAPH) {
        // drawing the 0th at the end of the chart.
        DrawZeroPoint = 1 ;
        if (iValidValues == pGraph->gMaxValues) {
            iValidValues++ ;
        }
    }

    // get current select line for highlighting
    if (pGraph->HighLightOnOff) {
        pCurrentLine = CurrentGraphLine (hWndGraph) ;
    } else {
        pCurrentLine = NULL ;
    }

    // loop through lines to plot
    for (pLineStruct = pGraph->pLineFirst ;
        pLineStruct || pCurrentLine;
        pLineStruct = pLineStruct->pLineNext) {

        if (pLineStruct == NULL) {
            // now draw the current line
            pLineStruct = pCurrentLine ;
        } else if (pLineStruct == pCurrentLine) {
            // skip this line and draw it later
            continue ;
        }

        // "Localize" some variables from the line data structure.
        pDataPoints    = pLineStruct->lnValues ;


        rectWidth      = pGraph->rectData.right - pGraph->rectData.left ;
        numOfData      = pGraph->gMaxValues - 1 + DrawZeroPoint ;

        // Generate the polyline data.
        xDispDataPoint = pGraph->rectData.left ;

        // Only process points that lie within the update region.
        // Also only process points that have valid data.
        j = 0 ;

        for (i = 0 ; i < iValidValues ; i++) {
            if (xDispDataPoint > xRightLimit) {
                // we are done!
                break ;
            }
            if (xDispDataPoint >= xLeftLimit) {
                // It is within the limits, plot the point
                pptDataPoints[j].x = xDispDataPoint ;
                pptDataPoints[j].y = ScaleAndInvertY (
                                                     (i == pGraph->gMaxValues) ? pDataPoints[0] : pDataPoints[i],
                                                     pLineStruct,
                                                     pGraph) ;
                j++ ;
            }

            // setup for the next point
            if (!numOfData) {
                // no more points to go
                break ;
            }

            xPos = DDA_DISTRIBUTE (rectWidth, numOfData) ;
            xDispDataPoint += xPos ;
            numOfData-- ;
            rectWidth -= xPos ;
        }

        // only need to draw the line if there is point to draw.
        if (j > 0) {
            // Set the pen color and draw the polyline.
            if (IsPrinterDC (hDC)) {
                hPen = LineCreatePen (hDC, &(pLineStruct->Visual), TRUE) ;
                hOldPen = SelectObject (hDC, hPen) ;
            } else {
                if (pCurrentLine == pLineStruct) {
                    // highlight this line by turning it into White color
                    hOldPen = SelectObject (hDC, hWhitePen) ;
                } else {
                    SelectObject (hDC, pLineStruct->hPen) ;
                }
            }

            Polyline(hDC, pptDataPoints, j) ;

            if (hPen) {
                SelectObject (hDC, hOldPen) ;

                if (hPen != hWhitePen) {
                    DeletePen (hPen) ;
                }
                hPen = 0 ;
            }
        }

        if (pCurrentLine == pLineStruct) {
            // We are done...
            break ;
        }
    }

    if (IsTLineWindowUp()) {
        // re-draw the timelines if need
        TLineRedraw (hDC, pGraph) ;
    }

    // reset the clipping region
    SelectClipRgn (hDC, pGraph->hGraphRgn) ;

    return (TRUE) ;
}



/***************************************************************************
 * bInitTimeLine - Initialize the fields of the time line structure.
 ***************************************************************************/
BOOL
bInitTimeLine(
             PGRAPHSTRUCT pGraph
             )
{
    pGraph->gTimeLine.xLastTime      = 0 ;
    pGraph->gTimeLine.ppd            = 0 ;
    pGraph->gTimeLine.rppd           = 0 ;
    pGraph->gTimeLine.iValidValues   = 1 ;

    return (TRUE) ;
}


/***************************************************************************
 * Scale Time Line
 *
 *  This routine should be called from the WM_SIZE message.
 *  It does the scaling from the number of data points to the
 *  size of the window.
 ***************************************************************************/
void
ScaleTimeLine (
              PGRAPHSTRUCT pGraph
              )
{
    INT     nDataPoints,
    cxClient ;

    // Calculate the pels per data point.
    nDataPoints = pGraph->gMaxValues - 1 ;
    cxClient    = pGraph->rectData.right - pGraph->rectData.left ;

    // ppd  = Pixels per DataPoint.
    // rppd = Remaining Pixels per DataPoint.
    pGraph->gTimeLine.ppd  = cxClient / nDataPoints ;
    pGraph->gTimeLine.rppd = cxClient % nDataPoints ;
}


void
DisplayTimeLine(
               HDC hDC,
               PGRAPHSTRUCT pGraph
               )
/*
   Called By:     OnPaint only.

   Assert:        xDisplayPoint has been set by UpdateTimeLine on this
                  same timer tick.
*/
{
    INT     xDisplayPoint ;
    RECT    rect ;

    if (pGraph->gTimeLine.xLastTime == -1) {
        UpdateTimeLine (hGraphDisplayDC, pGraph, TRUE) ;
    }

    // xDisplayPoint is X coordinate to display the time line at.
    if ((xDisplayPoint = pGraph->gTimeLine.xLastTime) == 0)
        return ;

    SelectBrush (hDC, pGraph->hbRed) ;

    if (xDisplayPoint >= pGraph->rectData.right) {
        rect.left   = pGraph->rectData.left ;
    } else {
        //      rect.left   = xDisplayPoint++ ;
        rect.left   = xDisplayPoint ;
    }
    rect.top    = pGraph->rectData.top ;
    rect.right  = rect.left + 2 ;
    rect.bottom = pGraph->rectData.bottom ;

    //   IntersectRect (&rect, &rect, &pGraph->rectData) ;
    if (rect.right > pGraph->rectData.right) {
        rect.right = pGraph->rectData.right ;
    }
    PatBlt (hDC,
            rect.left, rect.top,
            rect.right - rect.left,
            rect.bottom - rect.top + 1 ,
            PATCOPY) ;

}

int
SuggestedNumTics (
                 int iRange
                 )
/*
   Effect:        Return an appropriate number of tic marks to display
                  within iRange pixels.

                  These numbers are empirically chosen for pleasing
                  results.
*/
{
    if (iRange < 20)
        return (0) ;

    if (iRange < 50)
        return (2) ;

    if (iRange < 100)
        return (4) ;

    if (iRange < 150)
        return (5) ;

    if (iRange < 300)
        return (10) ;

    if (iRange < 500)
        return (20) ;

    return (25) ;
}



void
SetGridPositions (
                 PGRAPHSTRUCT pGraph
                 )
{
    int            xDataWidth ;
    int            yDataHeight ;

    int            iCurrentTicPixels ;
    int            iNumTics ;

    int            i ;


    //=============================//
    // Set number of Tics          //
    //=============================//

    xDataWidth = pGraph->rectData.right - pGraph->rectData.left ;
    yDataHeight = pGraph->rectData.bottom - pGraph->rectData.top ;

    pGraph->xNumTics = PinInclusive (SuggestedNumTics (xDataWidth),
                                     0, iGraphMaxTics) ;
    pGraph->yNumTics = PinInclusive (SuggestedNumTics (yDataHeight),
                                     0, iGraphMaxTics) ;

    // if we have more tics than possible integral values, reduce the number
    // of tics.
    if (pGraph->gOptions.iVertMax < pGraph->yNumTics)
        pGraph->yNumTics = pGraph->gOptions.iVertMax ;


    //=============================//
    // Set X Tic Positions         //
    //=============================//

    if (pGraph->xNumTics) {
        iNumTics = pGraph->xNumTics ;

        pGraph->axTics[0] = 0 ;
        for (i = 1; i < pGraph->xNumTics; i++) {
            if (iNumTics == 0) {
                break ;
            }
            iCurrentTicPixels = DDA_DISTRIBUTE (xDataWidth, iNumTics) ;
            pGraph->axTics [i] = pGraph->axTics [i - 1] + iCurrentTicPixels ;

            xDataWidth -= iCurrentTicPixels ;
            iNumTics-- ;
        }
    }


    //=============================//
    // Set Y Tic Positions         //
    //=============================//

    if (pGraph->yNumTics) {
        iNumTics = pGraph->yNumTics ;

        pGraph->ayTics[0] = 0 ;
        for (i = 1; i < pGraph->yNumTics; i++) {
            if (iNumTics == 0) {
                break ;
            }
            iCurrentTicPixels = DDA_DISTRIBUTE (yDataHeight, iNumTics) ;
            pGraph->ayTics [i] = pGraph->ayTics [i- 1] + iCurrentTicPixels ;

            yDataHeight -= iCurrentTicPixels ;
            iNumTics-- ;
        }
    }
}

int
GraphVerticalScaleWidth (
                        HDC hDC,
                        PGRAPHSTRUCT pGraph
                        )
{
    TCHAR          szMaxValue [20] ;
    int            xWidth ;

    if (!pGraph->gOptions.bLabelsChecked)
        return (0) ;

    //   SelectFont (hDC, IsPrinterDC (hDC) ? hFontPrinterScales : hFontScales) ;

    TSPRINTF (szMaxValue, TEXT(" %1d "),
              pGraph->gOptions.iVertMax * 10 ) ;

    xWidth = TextWidth (hDC, szMaxValue) ;

    return (xWidth) ;
}


void
DrawGraphScale (
               HDC hDC,
               PGRAPHSTRUCT pGraph
               )
{
    TCHAR   szScale [20] ;

    INT     len,
    i,
    nLines,
    iUnitsPerLine = 0;
    FLOAT   ePercentOfTotal  = 0.0f;
    FLOAT   eDiff ;
    BOOL    bUseFloatingPt = FALSE ;

    //=============================//
    // Draw Vertical Scale?        //
    //=============================//

    if (!pGraph->gOptions.bLabelsChecked)
        return ;

    // Get the number of lines.
    nLines = pGraph->yNumTics ;

    // nLines may be zero if the screen size if getting too small
    if (nLines > 0) {
        // Calculate what percentage of the total each line represents.
        ePercentOfTotal = ((FLOAT) 1.0) / ((FLOAT) nLines)  ;

        // Calculate the amount (number of units) of the Vertical max each
        // each line in the graph represents.
        iUnitsPerLine = (INT) ((FLOAT) pGraph->gOptions.iVertMax * ePercentOfTotal) ;
        ePercentOfTotal *= (FLOAT) pGraph->gOptions.iVertMax ;
        eDiff = (FLOAT)iUnitsPerLine - ePercentOfTotal ;
        if (eDiff < (FLOAT) 0.0)
            eDiff = -eDiff ;

        if (eDiff > (FLOAT) 0.1)
            bUseFloatingPt = TRUE ;
    }

    //=============================//
    // Set Drawing Attributes      //
    //=============================//

    //   SelectFont (hDC, IsPrinterDC (hDC) ? hFontPrinterScales : hFontScales) ;
    SetBkMode(hDC, TRANSPARENT) ;
    SetTextAlign (hDC, TA_TOP | TA_RIGHT) ;
    SelectObject(hDC, GetStockObject (BLACK_PEN)) ;

    // Set the background color to gray
    if (!IsPrinterDC (hDC))
        //      FillRect (hDC, &(pGraph->rectVertScale), hbLightGray) ;
        FillRect (hDC, &(pGraph->rectVertScale), hBrushFace) ;

    // TESTING TESTING
#ifdef   PERFMON_DEBUG
    GdiSetBatchLimit(1) ;   // disable Batching
#endif

    // Now Output each string.
    for (i = 0; i < nLines; i++) {
        if (bUseFloatingPt) {
            len = TSPRINTF (szScale, TEXT("%1.1f"),
                            (FLOAT)pGraph->gOptions.iVertMax - ((FLOAT)i *
                                                                ePercentOfTotal)) ;
            ConvertDecimalPoint (szScale) ;
        } else {
            len = TSPRINTF (szScale, TEXT("%d"),
                            pGraph->gOptions.iVertMax - (i * iUnitsPerLine)) ;
        }
        TextOut (hDC,
                 pGraph->rectVertScale.right,
                 pGraph->ayTics[i] +
                 pGraph->rectData.top - HalfTextHeight,
                 szScale,
                 len) ;
    }

    // Output the "min value" separately.
    TextOut (hDC,
             pGraph->rectVertScale.right,
             pGraph->rectData.bottom - HalfTextHeight,
             TEXT("0"),
             1) ;

#ifdef   PERFMON_DEBUG
    // TESTING TESTING
    GdiSetBatchLimit(0) ;   // enable default Batching
#endif
}

void
SizeGraphDisplayComponentsRect (
                               HDC hDC,
                               PGRAPHSTRUCT pGraph,
                               RECT rectDisplay
                               )
{
    int            xScaleWidth ;

    if (!rectDisplay.right || !rectDisplay.bottom)
        return ;

    //=============================//
    // Size the Vertical Scale     //
    //=============================//

    xScaleWidth = GraphVerticalScaleWidth (hDC, pGraph) ;
    pGraph->rectVertScale.left = rectDisplay.left ;
    pGraph->rectVertScale.top = rectDisplay.top ;
    pGraph->rectVertScale.right = rectDisplay.left + xScaleWidth ;
    pGraph->rectVertScale.bottom = rectDisplay.bottom ;

    //=============================//
    // Size the Horizontal Scale   //
    //=============================//

    pGraph->rectHorzScale.left = 0 ;
    pGraph->rectHorzScale.top = 0 ;
    pGraph->rectHorzScale.right = 0 ;
    pGraph->rectHorzScale.bottom = 0 ;

    //=============================//
    // Size the Data Area          //
    //=============================//

    pGraph->rectData.left = pGraph->rectVertScale.right + 3 + ThreeDPad ;
    pGraph->rectData.right = rectDisplay.right - 5 - ThreeDPad ;
    pGraph->rectData.top = rectDisplay.top + 5 + ThreeDPad ;
    pGraph->rectData.bottom = rectDisplay.bottom - 5 - ThreeDPad ;

    SetGridPositions (pGraph) ;
    ScaleTimeLine (pGraph) ;

    //==========================================//
    // Invalidate the last time line poisition  //
    //==========================================//
    pGraph->gTimeLine.xLastTime = -1 ;

    if (pGraph->hGraphRgn) {
        DeleteObject (pGraph->hGraphRgn) ;
    }

    pGraph->hGraphRgn = CreateRectRgn (rectDisplay.left,
                                       rectDisplay.top,
                                       rectDisplay.right,
                                       rectDisplay.bottom) ;

    SelectClipRgn (hDC, pGraph->hGraphRgn) ;

}


void
SizeGraphDisplayComponents (
                           HWND hWnd
                           )
/*
   Effect:        Given the graph display window hWnd, of size
                  (xWidth x yHeight), determine the size and position
                  of the various graph display components: the vertical
                  scale, the horizontal scale, and the data area.

   Called By:     OnSize, any other routine that changes the visibility
                  of a vertical or horizontal scale.

   Note:          This function has multiple return points.
*/
{  // SizeGraphDisplayComponents
    PGRAPHSTRUCT   pGraph ;
    RECT           rectClient ;

    pGraph = GraphData (hWnd) ;
    GetClientRect (hWnd, &rectClient) ;

    SizeGraphDisplayComponentsRect (hGraphDisplayDC, pGraph, rectClient) ;
}


void
UpdateGraphDisplay (
                   HDC hDC,
                   BOOL bForPaint,
                   LPRECT lpRect,
                   PGRAPHSTRUCT pGraph
                   )
/*
   Effect:        Draw the portions of the graph that change as the
                  graph's values change. This includes the background,
                  the grid, the lines, and the timeline.
*/
{
    RECT           rectUpdate ;

    if (!bForPaint && !IsPrinterDC (hDC) &&
        pGraph->gOptions.iGraphOrHistogram == LINE_GRAPH) {
        HBRUSH         hOldBrush ;

        rectUpdate = pGraph->rectData ;
        rectUpdate.bottom += 1 ;

        IntersectRect (&rectUpdate, lpRect, &rectUpdate) ;
        hOldBrush = SelectBrush (hDC, hBrushFace) ;

        PatBlt (hDC,
                rectUpdate.left, rectUpdate.top,
                rectUpdate.right - rectUpdate.left,
                rectUpdate.bottom - rectUpdate.top,
                PATCOPY) ;
    } else {
        IntersectRect (&rectUpdate, lpRect, &pGraph->rectData) ;
    }

    if (pGraph->gOptions.iGraphOrHistogram == LINE_GRAPH) {
        DrawGrid(hDC, pGraph, &rectUpdate, bForPaint) ;
        if (pGraph->pLineFirst != NULL) {
            DrawTLGraphData(hDC, bForPaint, &rectUpdate, pGraph) ;
            if (!PlayingBackLog ())
                DisplayTimeLine(hDC, pGraph) ;
        }
    } else {
        DrawBarChartData (hDC, pGraph) ;
    }
}


BOOL
UpdateTimeLine (
               HDC hDC,
               PGRAPHSTRUCT pGraph,
               BOOL getLastTimeLocation
               )
/*
   Called By:     GraphTimer only.

   See Also:      UpdateGraphDisplay.
*/
{
    INT     i,
    xDisplayPoint,
    xDataPoint ;
    RECT    rctUpdate ;
    INT     xLastTime ;
    INT     rectWidth,
    xPos,
    numOfPoints ;


    if ((xLastTime = pGraph->gTimeLine.xLastTime) != 0) {
        if ((pGraph->gKnownValue % pGraph->gMaxValues) == 1) {
            // Data wrap around case
            rctUpdate.left   = pGraph->rectData.left ;
            rctUpdate.right  = pGraph->rectData.left +
                               pGraph->gTimeLine.ppd + 1 ;
        } else {
            rctUpdate.left   = xLastTime - pGraph->gTimeLine.ppd ;
            rctUpdate.right  = xLastTime +
                               pGraph->gTimeLine.ppd + 1 ;
        }
        rctUpdate.top    = pGraph->rectData.top ;
        rctUpdate.bottom = pGraph->rectData.bottom + 1 ;
    }

    // Calculate where to draw the time line.
    // This is done by running a simple DDA (Digital Differential Analyzer)
    // We have to position the time depending upon the size of the
    // graph window.  In essence we need to calculate the x display
    // coordinate.

    // Note we should wrap Known Value in UpdateGLData.
    // We should also use a data buffer of 256 bytes so we can
    // wrap with and AND.

    // xDataPoint =  pGraph->gKnownValue ;
    xDataPoint =  pGraph->gKnownValue % pGraph->gMaxValues ;

    xDisplayPoint = pGraph->rectData.left ;

    numOfPoints = pGraph->gMaxValues - 1 ;

    if (!PlayingBackLog() &&
        pGraph->gOptions.iGraphOrHistogram == LINE_GRAPH) {
        // drawing the 0th at the end of the chart.
        // So, we do have gMaxValues points
        numOfPoints++ ;
        if ((pGraph->gKnownValue % pGraph->gMaxValues) == 0) {
            xDataPoint = pGraph->gMaxValues ;
        }
    }

    rectWidth = pGraph->rectData.right - pGraph->rectData.left ;

    for (i = 0 ; i < xDataPoint ; i++) {
        if (numOfPoints == 0) {
            break ;
        }
        xPos = DDA_DISTRIBUTE (rectWidth, numOfPoints) ;
        xDisplayPoint += xPos ;
        rectWidth -= xPos ;
        numOfPoints-- ;
    }

    pGraph->gTimeLine.xLastTime = xDisplayPoint ;

    if (!getLastTimeLocation && iPerfmonView == IDM_VIEWCHART && !bPerfmonIconic) {
        UpdateGraphDisplay (hDC, FALSE, &rctUpdate, pGraph) ;
    }

    return(TRUE) ;
}


//==========================================================================//
//                              Message Handlers                            //
//==========================================================================//


void
/*static*/
OnCreate (
         HWND hWnd
         )
/*
   Effect:        Perform all actions needed when a GraphDisplay window is
                  created.
                  In particular, initialize the graph instance data and
                  create the child windows.

   Called By:     GraphDisplayWndProc, in response to a WM_CREATE message.
*/
{
    LOGBRUSH       LogBrush ;
    TEXTMETRIC     tmScales ;

    hGraphDisplayDC = GetDC(hWnd) ;
    if (!hGraphDisplayDC)
        return;

    SelectFont(hGraphDisplayDC, hFontScales) ;
    GetTextMetrics(hGraphDisplayDC, &tmScales) ;
    HalfTextHeight = tmScales.tmHeight / 2 ;

    //   SetBkColor (hGraphDisplayDC, crLightGray) ;
    SetBkColor (hGraphDisplayDC, ColorBtnFace) ;


    InsertGraph(hWnd) ;
    bInitTimeLine(pGraphs) ;

    pGraphs->hWnd = hWnd ;

    // Create the brush and pen used by the time line.
    // We don't want to create these on every timer tick.

    LogBrush.lbStyle = BS_SOLID ;
    LogBrush.lbColor = RGB(0xff, 0, 0) ;
    LogBrush.lbHatch = 0 ;

    // Now get the system resources we use "all the time"
    pGraphs->hbRed = CreateBrushIndirect(&LogBrush) ;
    pGraphs->hGridPen = CreatePen (PS_SOLID, 1, crGray) ;

    pGraphs->xNumTics = 0 ;
    pGraphs->yNumTics = 0 ;
}


void
/*static*/
OnSize (
       HWND hWnd,
       WORD xWidth,
       WORD yHeight
       )
{
    PGRAPHSTRUCT   pGraph ;

    pGraph = GraphData (hWnd) ;

    SizeGraphDisplayComponents (hWnd) ;
}


void
/*static*/
OnPaint (
        HWND hWnd
        )
{
    HDC            hDC ;
    PAINTSTRUCT    ps ;
    PGRAPHSTRUCT   pGraph ;

    pGraph = GraphData (hWnd) ;
    hDC = BeginPaint(hWnd, &ps) ;

    DrawGraphDisplay (hDC, ps.rcPaint, pGraph) ;

    EndPaint(hWnd, &ps) ;
}


//==========================================================================//
//                             Exported Functions                           //
//==========================================================================//

#ifdef KEEP_PRINT
void PrintGraphDisplay (HDC hDC,
                        PGRAPHSTRUCT pGraph)
{
    DrawGraphScale (hDC, pGraph) ;


    //!!   UpdateGraphDisplay (hDC, TRUE, &(pGraph->rectData), pGraph) ;

    IntersectClipRect (hDC, 0, 0, 10000, 10000) ;
    SelectBrush (hDC, GetStockObject (HOLLOW_BRUSH)) ;
    SelectPen (hDC, GetStockObject (BLACK_PEN)) ;
    Rectangle (hDC,
               pGraph->rectData.left,
               pGraph->rectData.top,
               pGraph->rectData.right,
               pGraph->rectData.bottom) ;
}
#endif



void
DrawGraphDisplay (
                 HDC hDC,
                 RECT rectDraw,
                 PGRAPHSTRUCT pGraph
                 )
{
    BOOL        bPaintScale ;
    INT         LocalThreeDPad = ThreeDPad - 1 ;

    // Only draw the vertical labels if the paint rectangle
    // any portion of the window to the left of the graph area.

    bPaintScale = (rectDraw.left <= pGraph->rectVertScale.right) ;
    if (bPaintScale)
        DrawGraphScale (hDC, pGraph) ;
    if (IsPrinterDC (hDC))
        Rectangle (hDC,
                   pGraph->rectData.left,
                   pGraph->rectData.top,
                   pGraph->rectData.right,
                   pGraph->rectData.bottom) ;
    else
        ThreeDConcave1 (hDC,
                        pGraph->rectData.left - LocalThreeDPad,
                        pGraph->rectData.top - LocalThreeDPad,
                        pGraph->rectData.right + LocalThreeDPad,
                        pGraph->rectData.bottom + LocalThreeDPad + 1) ;

    UpdateGraphDisplay (hDC, TRUE, &(rectDraw), pGraph) ;
}


LRESULT
APIENTRY
GraphDisplayWndProc (
                    HWND hWnd,
                    UINT uMsg,
                    WPARAM wParam,
                    LPARAM lParam
                    )
{
    LRESULT     lret = 0L ;
    BOOL        bCallDefProc = FALSE ;

    switch (LOWORD (uMsg)) {
        case WM_LBUTTONDOWN:
            DoWindowDrag (hWnd, lParam) ;
            break ;

        case WM_LBUTTONDBLCLK:
            SendMessage (hWndMain, uMsg, wParam, lParam) ;
            break ;

        case WM_CREATE:
            OnCreate (hWnd) ;
            break ;

        case WM_SIZE:
            OnSize (hWnd, LOWORD (lParam), HIWORD (lParam)) ;
            break ;

        case WM_DESTROY:
            KillTimer(hWndMain, GRAPH_TIMER_ID) ;
            break ;

        case WM_PAINT:
            OnPaint (hWnd) ;
            break ;

        case WM_TIMER:
            GraphTimer (hWnd, FALSE) ;
            break ;

        default:
            bCallDefProc = TRUE ;
            break ;
    }  // switch


    if (bCallDefProc) {
        lret = DefWindowProc(hWnd, uMsg, wParam, lParam) ;
    }
    return (lret) ;
}


BOOL
GraphDisplayInitializeApplication (void)
{
    WNDCLASS       wc ;

    wc.style         = dwGraphDisplayClassStyle ;
    wc.lpfnWndProc   = GraphDisplayWndProc ;
    wc.hInstance     = hInstance ;
    wc.cbClsExtra    = iGraphDisplayWindowExtra ;
    wc.cbWndExtra    = iGraphDisplayClassExtra ;
    wc.hIcon         = NULL ;
    wc.hCursor       = LoadCursor(NULL, IDC_ARROW) ;
    //   wc.hbrBackground = hbLightGray ;
    wc.hbrBackground = hBrushFace ;
    wc.lpszMenuName  = NULL ;
    wc.lpszClassName = (LPTSTR) szGraphDisplayWindowClass ;

    return (RegisterClass (&wc)) ;
}



HWND
CreateGraphDisplayWindow (
                         HWND hWndGraph
                         )
{
    return (CreateWindow (szGraphDisplayWindowClass,   // class
                          NULL,                        // caption
                          dwGraphDisplayWindowStyle,   // window style
                          0, 0,                        // position
                          0, 0,                        // size
                          hWndGraph,                   // parent window
                          NULL,                        // menu
                          hInstance,                  // program instance
                          NULL)) ;                     // user-supplied data
}

BOOL
ToggleGraphRefresh (
                   HWND hWnd
                   )
{
    PGRAPHSTRUCT   pGraph ;

    pGraph = GraphData (hWnd) ;

    if (pGraph->bManualRefresh)
        SetGraphTimer (pGraph) ;
    else
        ClearGraphTimer (pGraph) ;

    pGraph->bManualRefresh = !pGraph->bManualRefresh ;
    return (pGraph->bManualRefresh) ;
}

BOOL
GraphRefresh (
             HWND hWnd
             )
{
    PGRAPHSTRUCT   pGraph ;

    pGraph = GraphData (hWnd) ;

    return (pGraph->bManualRefresh) ;
}


void
GraphTimer (
           HWND hWnd,
           BOOL bForce
           )
/*
   Effect:        Handle any actions necessary when the graph display
                  window hWnd receives a timer tick. In particular,
                  update the graph display and update the status bar
                  if it is showing.

   Called By:     GraphDisplayWndProc, in response to a WM_TIMER message.
*/
{
    PGRAPHSTRUCT         pGraph ;

    pGraph = GraphData (hWnd) ;

    if (!pGraph->pLineFirst)
        return ;

    if (bForce || !pGraph->bManualRefresh) {

        HandleGraphTimer () ;

        // If we are displaying a time-line graph then do the
        // calculations for the minimal update region.
        // If were doing a bar graph, then draw the
        // whole graph area.

        if (pGraph->gOptions.iGraphOrHistogram == LINE_GRAPH)
            UpdateTimeLine (hGraphDisplayDC, pGraph, FALSE) ;
        else
            DrawBarChartData (hGraphDisplayDC, pGraph) ;

        // Take care of the status bar window
        StatusTimer (hWndGraphStatus, FALSE) ;

    }  // if
}

// this routine set/reset the line highlight mode
void
ChartHighlight (void)
{
    PGRAPHSTRUCT         pGraph ;


    if (pGraph = GraphData (hWndGraph)) {
        if (pGraph->pLineFirst) {
            // toggle the HightlightOnOff mode
            pGraph->HighLightOnOff = !pGraph->HighLightOnOff ;
            WindowInvalidate (hWndGraphDisplay) ;
        } else {
            // no line availble, just turn it off
            pGraph->HighLightOnOff = FALSE ;
        }
    }
}