![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to grafdisp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / perfmon|
Return to grafdisp.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / perfmon |
1.1 ! root 1: //==========================================================================// ! 2: // Includes // ! 3: //==========================================================================// ! 4: ! 5: ! 6: #include <stdio.h> ! 7: #include "perfmon.h" ! 8: #include "grafdisp.h" // external declarations for this file ! 9: ! 10: #include "grafdata.h" // for InsertGraph, et al. ! 11: #include "graph.h" ! 12: #include "legend.h" ! 13: #include "line.h" // for LineCreatePen ! 14: #include "perfmops.h" // for DoWindowDrag ! 15: #include "playback.h" // for PlayingBackLog ! 16: #include "valuebar.h" ! 17: #include "utils.h" ! 18: #include "timeline.h" // for IsTLineWindowUp & TLineRedraw ! 19: ! 20: //==========================================================================// ! 21: // Constants // ! 22: //==========================================================================// ! 23: ! 24: // this macro is used in doing a simple DDA (Digital Differential Analyzer) ! 25: // * 10 + 5 is to make the result round up with .5 ! 26: #define DDA_DISTRIBUTE(TotalTics, numOfData) \ ! 27: ((TotalTics * 10 / numOfData) + 5) / 10 ! 28: ! 29: HDC hGraphDisplayDC ; ! 30: //=============================// ! 31: // GraphDisplay Class // ! 32: //=============================// ! 33: ! 34: ! 35: TCHAR szGraphDisplayWindowClass[] = TEXT("PerfmonGraphDisplayClass") ; ! 36: #define dwGraphDisplayClassStyle (CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | CS_OWNDC) ! 37: #define iGraphDisplayClassExtra (0) ! 38: #define iGraphDisplayWindowExtra (0) ! 39: #define dwGraphDisplayWindowStyle (WS_CHILD | WS_VISIBLE) ! 40: ! 41: ! 42: ! 43: //==========================================================================// ! 44: // Local Functions // ! 45: //==========================================================================// ! 46: BOOL UpdateTimeLine (HDC hDC, PGRAPHSTRUCT pGraph, BOOL getLastTimeLocation) ; ! 47: ! 48: #if 0 ! 49: PGRAPHSTRUCT GraphData (HWND hWndGraphDisplay) ! 50: /* ! 51: Effect: Return the graph associated with graph display window ! 52: hWndGraphData. At the present time, we only have one ! 53: graph data window and one graph structure. In the ! 54: future, we may have several of each. The graph structure ! 55: is conceptually instance data of the graph display ! 56: window. Use of this function allows for easier additions ! 57: to the code. ! 58: */ ! 59: { ! 60: return (pGraphs) ; ! 61: } ! 62: #endif ! 63: ! 64: INT ScaleAndInvertY (FLOAT ey, ! 65: PLINESTRUCT pLineStruct, ! 66: PGRAPHSTRUCT pGraph) ! 67: /* ! 68: Effect: Given data value ey, scale and fit the value to fit ! 69: within the graph data area of the window, considering ! 70: the scale set for the line and the current size of the ! 71: data rectangle. ! 72: */ ! 73: { // ScaleAndInvertY ! 74: INT yGraphDataHeight, // Height of graph area ! 75: yInverted ; // Scaled & Inverted Y. ! 76: FLOAT eppd, ! 77: eyScaled ; ! 78: ! 79: ! 80: // Take care of any scaling now, at output time. ! 81: ey *= pLineStruct->eScale ; ! 82: ! 83: // Calculate the Cy of the graph area. ! 84: yGraphDataHeight = pGraph->rectData.bottom - pGraph->rectData.top ; ! 85: ! 86: // Calculate the pixels per data point. ! 87: eppd = (FLOAT) ((FLOAT) yGraphDataHeight / (FLOAT) pGraph->gOptions.iVertMax) ; ! 88: eyScaled = eppd * ey ; ! 89: yInverted = (INT) (((FLOAT) yGraphDataHeight) - eyScaled) ; ! 90: ! 91: yInverted += pGraph->rectData.top ; ! 92: ! 93: // Clamp the range to fit with in the graph portion of the windows ! 94: yInverted = PinInclusive (yInverted, ! 95: pGraph->rectData.top, pGraph->rectData.bottom) ; ! 96: return (yInverted) ; ! 97: } // ScaleAndInvertY ! 98: ! 99: ! 100: ! 101: BOOL DrawGrid (HDC hDC, ! 102: PGRAPHSTRUCT pGraph, ! 103: LPRECT lpRect, ! 104: BOOL bForPaint) ! 105: /* ! 106: Effect: Draw the grid lines in the graph display window. ! 107: These grid lines are in the graph data area only, ! 108: which is indicated by pGraph->rectData. ! 109: ! 110: Called By: OnPaint only. ! 111: */ ! 112: { // DrawGrid ! 113: int iGrid, iLines ; ! 114: int xGrid, yGrid ; ! 115: POINT aPoints [4 * iGraphMaxTics] ; ! 116: DWORD aCounts [2 * iGraphMaxTics] ; ! 117: HPEN hPenPrevious ; ! 118: int bottomAdjust ; ! 119: ! 120: if (!pGraph->gOptions.bHorzGridChecked && ! 121: !pGraph->gOptions.bVertGridChecked) ! 122: return (FALSE) ; ! 123: ! 124: ! 125: hPenPrevious = SelectPen (hDC, IsPrinterDC (hDC) ? ! 126: GetStockObject (BLACK_PEN) : pGraph->hGridPen) ; ! 127: ! 128: iLines = 0 ; ! 129: ! 130: if (pGraph->gOptions.bHorzGridChecked) ! 131: { ! 132: for (iGrid = 1 ; ! 133: iGrid < pGraph->yNumTics ; ! 134: iGrid++) ! 135: { // for ! 136: yGrid = pGraph->ayTics[iGrid] + pGraph->rectData.top ; ! 137: if (yGrid >= lpRect->top && ! 138: yGrid <= lpRect->bottom) ! 139: { // if ! 140: aPoints[2 * iLines].x = lpRect->left ; ! 141: aPoints[2 * iLines].y = yGrid ; ! 142: aPoints[2 * iLines + 1].x = lpRect->right ; ! 143: aPoints[2 * iLines + 1].y = yGrid ; ! 144: ! 145: aCounts[iLines] = 2 ; ! 146: iLines++ ; ! 147: } // if ! 148: } // for ! 149: } // if ! 150: ! 151: if (pGraph->gOptions.bVertGridChecked) ! 152: { ! 153: bottomAdjust = lpRect->bottom + (bForPaint ? 1 : 0) ; ! 154: for (iGrid = 1 ; ! 155: iGrid < pGraph->xNumTics ; ! 156: iGrid++) ! 157: { // for ! 158: xGrid = pGraph->axTics[iGrid] + pGraph->rectData.left ; ! 159: if (xGrid >= lpRect->left && ! 160: xGrid <= lpRect->right) ! 161: { // if ! 162: aPoints[2 * iLines].x = xGrid ; ! 163: aPoints[2 * iLines].y = lpRect->top ; ! 164: aPoints[2 * iLines + 1].x = xGrid ; ! 165: aPoints[2 * iLines + 1].y = bottomAdjust ; ! 166: ! 167: aCounts[iLines] = 2 ; ! 168: iLines++ ; ! 169: } // if ! 170: } // for ! 171: } // if ! 172: ! 173: if (iLines) ! 174: PolyPolyline (hDC, aPoints, aCounts, iLines) ; ! 175: ! 176: SelectPen (hDC, hPenPrevious) ; ! 177: ! 178: return (TRUE) ; ! 179: } // DrawGrid ! 180: ! 181: ! 182: ! 183: BOOL DrawBarChartData (HDC hDC, ! 184: PGRAPHSTRUCT pGraph) ! 185: { // DrawBarChartData ! 186: PLINESTRUCT pLineStruct ; ! 187: PFLOAT pDataPoints ; ! 188: INT nLegendItems, ! 189: cx, ! 190: cxBar, ! 191: xDataPoint, ! 192: y ; ! 193: RECT rectBar ; ! 194: RECT rectBkgrnd ; ! 195: HBRUSH hOldBrush ; ! 196: FLOAT eValue ; ! 197: PLINESTRUCT pCurrentLine ; ! 198: ! 199: // Determine how many items are in the legend. ! 200: ! 201: nLegendItems = 0 ; ! 202: ! 203: for (pLineStruct = pGraph->pLineFirst ; ! 204: pLineStruct ; ! 205: pLineStruct = pLineStruct->pLineNext) ! 206: { // for ! 207: nLegendItems++ ; ! 208: } // for ! 209: ! 210: if (nLegendItems == 0) ! 211: return(FALSE) ; ! 212: ! 213: // get current select line for highlighting ! 214: if (pGraph->HighLightOnOff) ! 215: { ! 216: pCurrentLine = CurrentGraphLine (hWndGraph) ; ! 217: } ! 218: else ! 219: { ! 220: pCurrentLine = NULL ; ! 221: } ! 222: ! 223: // Determine the width of each bar. ! 224: cx = pGraph->rectData.right - pGraph->rectData.left ; ! 225: ! 226: ! 227: if (PlayingBackLog()) ! 228: { ! 229: // get the average using the start and stop data point ! 230: // from the log file ! 231: PlaybackLines (pGraph->pSystemFirst, ! 232: pGraph->pLineFirst, ! 233: PlaybackLog.StartIndexPos.iPosition) ; ! 234: PlaybackLines (pGraph->pSystemFirst, ! 235: pGraph->pLineFirst, ! 236: PlaybackLog.StopIndexPos.iPosition) ; ! 237: } ! 238: else ! 239: { ! 240: // Loop through all the DataLines and draw a bar for ! 241: // it's last value. ! 242: xDataPoint = pGraph->gKnownValue % pGraph->gMaxValues ; ! 243: } ! 244: ! 245: rectBar.bottom = pGraph->rectData.bottom + 1 ; ! 246: ! 247: rectBkgrnd = pGraph->rectData ; ! 248: ! 249: hOldBrush = SelectBrush (hDC, hBrushFace) ; ! 250: ! 251: PatBlt (hDC, ! 252: rectBkgrnd.left, rectBkgrnd.top, ! 253: rectBkgrnd.right - rectBkgrnd.left, ! 254: rectBkgrnd.bottom - rectBkgrnd.top + 1, ! 255: PATCOPY) ; ! 256: DrawGrid(hDC, pGraph, &(rectBkgrnd), FALSE) ; ! 257: ! 258: rectBar.right = pGraph->rectData.left ; ! 259: for (pLineStruct = pGraph->pLineFirst ; ! 260: pLineStruct ; ! 261: pLineStruct = pLineStruct->pLineNext) ! 262: { // for ! 263: pDataPoints = pLineStruct->lnValues ; ! 264: ! 265: if (PlayingBackLog()) ! 266: { ! 267: eValue = (*(pLineStruct->valNext))(pLineStruct) ; ! 268: } ! 269: else ! 270: { ! 271: eValue = pDataPoints[xDataPoint] ; ! 272: } ! 273: ! 274: ! 275: y = ScaleAndInvertY (eValue, ! 276: pLineStruct, ! 277: pGraph) ; ! 278: ! 279: rectBar.left = rectBar.right ; ! 280: rectBar.top = y ; ! 281: ! 282: // nomore line to draw ! 283: if (nLegendItems == 0 ) ! 284: { ! 285: break ; ! 286: } ! 287: ! 288: cxBar = DDA_DISTRIBUTE (cx, nLegendItems) ; ! 289: rectBar.right = rectBar.left + cxBar ; ! 290: ! 291: // setup for next DDA ! 292: nLegendItems-- ; ! 293: cx -= cxBar ; ! 294: ! 295: // NOTE: this handle creation should be moved to line ! 296: // create time. ! 297: ! 298: if (pCurrentLine == pLineStruct) ! 299: { ! 300: SetBkColor (hDC, crWhite) ; ! 301: } ! 302: else ! 303: { ! 304: SetBkColor (hDC, pLineStruct->Visual.crColor) ; ! 305: } ! 306: ExtTextOut (hDC, rectBar.right, rectBar.top, ETO_OPAQUE, ! 307: &rectBar, NULL, 0, NULL) ; ! 308: } // for ! 309: ! 310: return (TRUE) ; ! 311: } ! 312: ! 313: ! 314: /*************************************************************************** ! 315: * DrawTLGraphData - Draw Time Line Graph Data. ! 316: * ! 317: * Some notes about drawing the DataPoint graphs. ! 318: * ! 319: * 1] It's real expensive to make a GDI call. So, we do not ! 320: * make a MoveToEx and LineTo call for each point. Instead ! 321: * we create a polyline and send it down to GDI. ! 322: * ! 323: * 2] The X coordinates for each point in the polyline is generated ! 324: * from our favorite xDataPoint to xWindows DDA. ! 325: * ! 326: * 3] The Y coordinate is generated from the pLineStruct->lnValues[x] ! 327: * data associated with each line. ! 328: ***************************************************************************/ ! 329: BOOL DrawTLGraphData (HDC hDC, ! 330: BOOL bForPaint, ! 331: PRECT prctPaint, ! 332: PGRAPHSTRUCT pGraph) ! 333: /* ! 334: Called By: UpdateGraphDisplay only. ! 335: */ ! 336: { ! 337: PLINESTRUCT pLineStruct ; ! 338: HPEN hPen = 0 ; ! 339: HPEN hOldPen ; ! 340: PFLOAT pDataPoints ; ! 341: INT i, j, ! 342: iValidValues, ! 343: xDispDataPoint, ! 344: xLeftLimit, ! 345: xRightLimit ; ! 346: PPOINT pptDataPoints ; ! 347: INT numOfData, rectWidth, xPos ; ! 348: PLINESTRUCT pCurrentLine ; ! 349: INT DrawZeroPoint = 0 ; ! 350: ! 351: // SetBkColor (hDC, crLightGray) ; ! 352: ! 353: if (!IsPrinterDC (hDC)) ! 354: { ! 355: if (bForPaint) ! 356: { ! 357: IntersectClipRect (hDC, ! 358: pGraph->rectData.left, ! 359: pGraph->rectData.top, ! 360: pGraph->rectData.right, ! 361: pGraph->rectData.bottom + 1) ; ! 362: } ! 363: else ! 364: { ! 365: IntersectClipRect (hDC, ! 366: pGraph->rectData.left, ! 367: pGraph->rectData.top, ! 368: PlayingBackLog () ? ! 369: pGraph->rectData.right : ! 370: min (pGraph->rectData.right, ! 371: pGraph->gTimeLine.xLastTime + 2), ! 372: pGraph->rectData.bottom + 1) ; ! 373: } ! 374: } ! 375: ! 376: xLeftLimit = prctPaint->left - pGraph->gTimeLine.ppd - 1 ; ! 377: // xRightLimit = prctPaint->right + pGraph->gTimeLine.ppd ; ! 378: xRightLimit = prctPaint->right ; ! 379: pptDataPoints = pGraph->pptDataPoints ; ! 380: ! 381: iValidValues = pGraph->gTimeLine.iValidValues ; ! 382: ! 383: if (!PlayingBackLog() && ! 384: pGraph->gOptions.iGraphOrHistogram == LINE_GRAPH) ! 385: { ! 386: // drawing the 0th at the end of the chart. ! 387: DrawZeroPoint = 1 ; ! 388: if (iValidValues == pGraph->gMaxValues) ! 389: { ! 390: iValidValues++ ; ! 391: } ! 392: } ! 393: ! 394: // get current select line for highlighting ! 395: if (pGraph->HighLightOnOff) ! 396: { ! 397: pCurrentLine = CurrentGraphLine (hWndGraph) ; ! 398: } ! 399: else ! 400: { ! 401: pCurrentLine = NULL ; ! 402: } ! 403: ! 404: // loop through lines to plot ! 405: for (pLineStruct = pGraph->pLineFirst ; ! 406: pLineStruct || pCurrentLine; ! 407: pLineStruct = pLineStruct->pLineNext) ! 408: { // for ! 409: ! 410: if (pLineStruct == NULL) ! 411: { ! 412: // now draw the current line ! 413: pLineStruct = pCurrentLine ; ! 414: } ! 415: else if (pLineStruct == pCurrentLine) ! 416: { ! 417: // skip this line and draw it later ! 418: continue ; ! 419: } ! 420: ! 421: // "Localize" some variables from the line data structure. ! 422: pDataPoints = pLineStruct->lnValues ; ! 423: ! 424: ! 425: rectWidth = pGraph->rectData.right - pGraph->rectData.left ; ! 426: numOfData = pGraph->gMaxValues - 1 + DrawZeroPoint ; ! 427: ! 428: // Generate the polyline data. ! 429: xDispDataPoint = pGraph->rectData.left ; ! 430: ! 431: // Only process points that lie within the update region. ! 432: // Also only process points that have valid data. ! 433: j = 0 ; ! 434: ! 435: for (i = 0 ; i < iValidValues ; i++) ! 436: { // for ! 437: if (xDispDataPoint > xRightLimit) ! 438: { ! 439: // we are done! ! 440: break ; ! 441: } ! 442: if (xDispDataPoint >= xLeftLimit) ! 443: { ! 444: // It is within the limits, plot the point ! 445: pptDataPoints[j].x = xDispDataPoint ; ! 446: pptDataPoints[j].y = ScaleAndInvertY ( ! 447: (i == pGraph->gMaxValues) ? pDataPoints[0] : pDataPoints[i], ! 448: pLineStruct, ! 449: pGraph) ; ! 450: j++ ; ! 451: } // if ! 452: ! 453: // setup for the next point ! 454: if (!numOfData) ! 455: { ! 456: // no more points to go ! 457: break ; ! 458: } ! 459: ! 460: xPos = DDA_DISTRIBUTE (rectWidth, numOfData) ; ! 461: xDispDataPoint += xPos ; ! 462: numOfData-- ; ! 463: rectWidth -= xPos ; ! 464: } // for i ! 465: ! 466: // only need to draw the line if there is point to draw. ! 467: if (j > 0) ! 468: { ! 469: // Set the pen color and draw the polyline. ! 470: if (IsPrinterDC (hDC)) ! 471: { ! 472: hPen = LineCreatePen (hDC, &(pLineStruct->Visual), TRUE) ; ! 473: hOldPen = SelectObject (hDC, hPen) ; ! 474: } ! 475: else ! 476: { ! 477: if (pCurrentLine == pLineStruct) ! 478: { ! 479: // highlight this line by turning it into White color ! 480: hOldPen = SelectObject (hDC, hWhitePen) ; ! 481: } ! 482: else ! 483: { ! 484: SelectObject (hDC, pLineStruct->hPen) ; ! 485: } ! 486: } ! 487: ! 488: Polyline(hDC, pptDataPoints, j) ; ! 489: ! 490: if (hPen) ! 491: { ! 492: SelectObject (hDC, hOldPen) ; ! 493: ! 494: if (hPen != hWhitePen) ! 495: { ! 496: DeletePen (hPen) ; ! 497: } ! 498: hPen = 0 ; ! 499: } ! 500: } ! 501: ! 502: if (pCurrentLine == pLineStruct) ! 503: { ! 504: // We are done... ! 505: break ; ! 506: } ! 507: } // for pLine ! 508: ! 509: if (IsTLineWindowUp()) ! 510: { ! 511: // re-draw the timelines if need ! 512: TLineRedraw (hDC, pGraph) ; ! 513: } ! 514: ! 515: // reset the clipping region ! 516: SelectClipRgn (hDC, pGraph->hGraphRgn) ; ! 517: ! 518: return (TRUE) ; ! 519: } // DrawTLGraphData ! 520: ! 521: ! 522: ! 523: /*************************************************************************** ! 524: * bInitTimeLine - Initialize the fields of the time line structure. ! 525: ***************************************************************************/ ! 526: BOOL bInitTimeLine(PGRAPHSTRUCT pGraph) ! 527: { ! 528: ! 529: pGraph->gTimeLine.xLastTime = 0 ; ! 530: pGraph->gTimeLine.ppd = 0 ; ! 531: pGraph->gTimeLine.rppd = 0 ; ! 532: pGraph->gTimeLine.iValidValues = 1 ; ! 533: ! 534: return (TRUE) ; ! 535: ! 536: } ! 537: ! 538: ! 539: /*************************************************************************** ! 540: * Scale Time Line ! 541: * ! 542: * This routine should be called from the WM_SIZE message. ! 543: * It does the scaling from the number of data points to the ! 544: * size of the window. ! 545: ***************************************************************************/ ! 546: void ScaleTimeLine (PGRAPHSTRUCT pGraph) ! 547: { ! 548: INT nDataPoints, ! 549: cxClient ; ! 550: ! 551: // Calculate the pels per data point. ! 552: nDataPoints = pGraph->gMaxValues - 1 ; ! 553: cxClient = pGraph->rectData.right - pGraph->rectData.left ; ! 554: ! 555: // ppd = Pixels per DataPoint. ! 556: // rppd = Remaining Pixels per DataPoint. ! 557: pGraph->gTimeLine.ppd = cxClient / nDataPoints ; ! 558: pGraph->gTimeLine.rppd = cxClient % nDataPoints ; ! 559: } ! 560: ! 561: ! 562: void DisplayTimeLine(HDC hDC, PGRAPHSTRUCT pGraph) ! 563: /* ! 564: Called By: OnPaint only. ! 565: ! 566: Assert: xDisplayPoint has been set by UpdateTimeLine on this ! 567: same timer tick. ! 568: */ ! 569: { // DisplayTimeLine ! 570: INT xDisplayPoint ; ! 571: RECT rect ; ! 572: ! 573: if (pGraph->gTimeLine.xLastTime == -1) ! 574: { ! 575: UpdateTimeLine (hGraphDisplayDC, pGraph, TRUE) ; ! 576: } ! 577: ! 578: // xDisplayPoint is X coordinate to display the time line at. ! 579: if ((xDisplayPoint = pGraph->gTimeLine.xLastTime) == 0) ! 580: return ; ! 581: ! 582: SelectBrush (hDC, pGraph->hbRed) ; ! 583: ! 584: if (xDisplayPoint >= pGraph->rectData.right) ! 585: { ! 586: rect.left = pGraph->rectData.left ; ! 587: } ! 588: else ! 589: { ! 590: // rect.left = xDisplayPoint++ ; ! 591: rect.left = xDisplayPoint ; ! 592: } ! 593: rect.top = pGraph->rectData.top ; ! 594: rect.right = rect.left + 2 ; ! 595: rect.bottom = pGraph->rectData.bottom ; ! 596: ! 597: // IntersectRect (&rect, &rect, &pGraph->rectData) ; ! 598: if (rect.right > pGraph->rectData.right) ! 599: { ! 600: rect.right = pGraph->rectData.right ; ! 601: } ! 602: PatBlt (hDC, ! 603: rect.left, rect.top, ! 604: rect.right - rect.left, ! 605: rect.bottom - rect.top + 1 , ! 606: PATCOPY) ; ! 607: ! 608: } // DisplayTimeLine ! 609: ! 610: ! 611: ! 612: int SuggestedNumTics (int iRange) ! 613: /* ! 614: Effect: Return an appropriate number of tic marks to display ! 615: within iRange pixels. ! 616: ! 617: These numbers are empirically chosen for pleasing ! 618: results. ! 619: */ ! 620: { // SuggestedNumTics ! 621: if (iRange < 20) ! 622: return (0) ; ! 623: ! 624: if (iRange < 50) ! 625: return (2) ; ! 626: ! 627: if (iRange < 100) ! 628: return (4) ; ! 629: ! 630: if (iRange < 150) ! 631: return (5) ; ! 632: ! 633: if (iRange < 300) ! 634: return (10) ; ! 635: ! 636: if (iRange < 500) ! 637: return (20) ; ! 638: ! 639: return (25) ; ! 640: } // SuggestedNumTics ! 641: ! 642: ! 643: ! 644: void SetGridPositions (PGRAPHSTRUCT pGraph) ! 645: { // SetGridPositions ! 646: int xDataWidth ; ! 647: int yDataHeight ; ! 648: ! 649: int iCurrentTicPixels ; ! 650: int iNumTics ; ! 651: ! 652: int i ; ! 653: ! 654: ! 655: //=============================// ! 656: // Set number of Tics // ! 657: //=============================// ! 658: ! 659: xDataWidth = pGraph->rectData.right - pGraph->rectData.left ; ! 660: yDataHeight = pGraph->rectData.bottom - pGraph->rectData.top ; ! 661: ! 662: pGraph->xNumTics = PinInclusive (SuggestedNumTics (xDataWidth), ! 663: 0, iGraphMaxTics) ; ! 664: pGraph->yNumTics = PinInclusive (SuggestedNumTics (yDataHeight), ! 665: 0, iGraphMaxTics) ; ! 666: ! 667: // if we have more tics than possible integral values, reduce the number ! 668: // of tics. ! 669: if (pGraph->gOptions.iVertMax < pGraph->yNumTics) ! 670: pGraph->yNumTics = pGraph->gOptions.iVertMax ; ! 671: ! 672: ! 673: //=============================// ! 674: // Set X Tic Positions // ! 675: //=============================// ! 676: ! 677: if (pGraph->xNumTics) ! 678: { ! 679: iNumTics = pGraph->xNumTics ; ! 680: ! 681: pGraph->axTics[0] = 0 ; ! 682: for (i = 1 ; ! 683: i < pGraph->xNumTics ; ! 684: i++) ! 685: { // for ! 686: if (iNumTics == 0) ! 687: { ! 688: break ; ! 689: } ! 690: iCurrentTicPixels = DDA_DISTRIBUTE (xDataWidth, iNumTics) ; ! 691: pGraph->axTics [i] = pGraph->axTics [i - 1] + iCurrentTicPixels ; ! 692: ! 693: xDataWidth -= iCurrentTicPixels ; ! 694: iNumTics-- ; ! 695: } // for ! 696: } // if ! 697: ! 698: ! 699: //=============================// ! 700: // Set Y Tic Positions // ! 701: //=============================// ! 702: ! 703: if (pGraph->yNumTics) ! 704: { ! 705: iNumTics = pGraph->yNumTics ; ! 706: ! 707: pGraph->ayTics[0] = 0 ; ! 708: for (i = 1 ; ! 709: i < pGraph->yNumTics ; ! 710: i++) ! 711: { // for ! 712: if (iNumTics == 0) ! 713: { ! 714: break ; ! 715: } ! 716: iCurrentTicPixels = DDA_DISTRIBUTE (yDataHeight, iNumTics) ; ! 717: pGraph->ayTics [i] = pGraph->ayTics [i- 1] + iCurrentTicPixels ; ! 718: ! 719: yDataHeight -= iCurrentTicPixels ; ! 720: iNumTics-- ; ! 721: } // for ! 722: } // if ! 723: } // SetGridPositions ! 724: ! 725: ! 726: ! 727: int GraphVerticalScaleWidth (HDC hDC, ! 728: PGRAPHSTRUCT pGraph) ! 729: { ! 730: TCHAR szMaxValue [20] ; ! 731: int xWidth ; ! 732: ! 733: if (!pGraph->gOptions.bLabelsChecked) ! 734: return (0) ; ! 735: ! 736: ! 737: // SelectFont (hDC, IsPrinterDC (hDC) ? hFontPrinterScales : hFontScales) ; ! 738: ! 739: ! 740: TSPRINTF (szMaxValue, TEXT(" %1d "), ! 741: pGraph->gOptions.iVertMax * 10 ) ; ! 742: ! 743: xWidth = TextWidth (hDC, szMaxValue) ; ! 744: ! 745: return (xWidth) ; ! 746: } ! 747: ! 748: ! 749: ! 750: void DrawGraphScale (HDC hDC, ! 751: PGRAPHSTRUCT pGraph) ! 752: { ! 753: TCHAR szScale [20] ; ! 754: ! 755: INT len, ! 756: i, ! 757: nLines, ! 758: iUnitsPerLine ; ! 759: FLOAT ePercentOfTotal ; ! 760: FLOAT eDiff ; ! 761: BOOL bUseFloatingPt = FALSE ; ! 762: ! 763: //=============================// ! 764: // Draw Vertical Scale? // ! 765: //=============================// ! 766: ! 767: if (!pGraph->gOptions.bLabelsChecked) ! 768: return ; ! 769: ! 770: // Get the number of lines. ! 771: nLines = pGraph->yNumTics ; ! 772: ! 773: // Calculate what percentage of the total each line represents. ! 774: ePercentOfTotal = ((FLOAT) 1.0) / ((FLOAT) nLines) ; ! 775: ! 776: // Calculate the amount (number of units) of the Vertical max each ! 777: // each line in the graph represents. ! 778: iUnitsPerLine = (INT) ((FLOAT) pGraph->gOptions.iVertMax * ePercentOfTotal) ; ! 779: ePercentOfTotal *= (FLOAT) pGraph->gOptions.iVertMax ; ! 780: eDiff = (FLOAT)iUnitsPerLine - ePercentOfTotal ; ! 781: if (eDiff < (FLOAT) 0.0) ! 782: eDiff = -eDiff ; ! 783: ! 784: if (eDiff > (FLOAT) 0.1) ! 785: bUseFloatingPt = TRUE ; ! 786: ! 787: //=============================// ! 788: // Set Drawing Attributes // ! 789: //=============================// ! 790: ! 791: // SelectFont (hDC, IsPrinterDC (hDC) ? hFontPrinterScales : hFontScales) ; ! 792: SetBkMode(hDC, TRANSPARENT) ; ! 793: SetTextAlign (hDC, TA_TOP | TA_RIGHT) ; ! 794: SelectObject(hDC, GetStockObject (BLACK_PEN)) ; ! 795: ! 796: // Set the background color to gray ! 797: if (!IsPrinterDC (hDC)) ! 798: FillRect (hDC, &(pGraph->rectVertScale), hbLightGray) ; ! 799: ! 800: // Now Output each string. ! 801: for (i = 0 ; ! 802: i < nLines ; ! 803: i++) ! 804: { // for ! 805: if (bUseFloatingPt) ! 806: { ! 807: len = TSPRINTF (szScale, TEXT("%1.1f"), ! 808: (FLOAT)pGraph->gOptions.iVertMax - ((FLOAT)i * ! 809: ePercentOfTotal)) ; ! 810: TextOut (hDC, ! 811: pGraph->rectVertScale.right, ! 812: pGraph->ayTics[i] + ! 813: pGraph->rectData.top - HalfTextHeight, ! 814: szScale, ! 815: lstrlen(szScale)) ; ! 816: } ! 817: else ! 818: { ! 819: len = TSPRINTF (szScale, TEXT("%d"), ! 820: pGraph->gOptions.iVertMax - (i * iUnitsPerLine)) ; ! 821: TextOut (hDC, ! 822: pGraph->rectVertScale.right, ! 823: pGraph->ayTics[i] + ! 824: pGraph->rectData.top - HalfTextHeight, ! 825: szScale, ! 826: lstrlen(szScale)) ; ! 827: } ! 828: } // for ! 829: ! 830: // Output the "min value" separately. ! 831: TextOut (hDC, ! 832: pGraph->rectVertScale.right, ! 833: pGraph->rectData.bottom - HalfTextHeight, ! 834: TEXT("0"), ! 835: 1) ; ! 836: } // DrawGraphScale ! 837: ! 838: ! 839: ! 840: void SizeGraphDisplayComponentsRect (HDC hDC, ! 841: PGRAPHSTRUCT pGraph, ! 842: RECT rectDisplay) ! 843: { // SizeGraphDisplayComponentsRect ! 844: int xScaleWidth ; ! 845: ! 846: if (!rectDisplay.right || !rectDisplay.bottom) ! 847: return ; ! 848: ! 849: //=============================// ! 850: // Size the Vertical Scale // ! 851: //=============================// ! 852: ! 853: xScaleWidth = GraphVerticalScaleWidth (hDC, pGraph) ; ! 854: pGraph->rectVertScale.left = rectDisplay.left ; ! 855: pGraph->rectVertScale.top = rectDisplay.top ; ! 856: pGraph->rectVertScale.right = rectDisplay.left + xScaleWidth ; ! 857: pGraph->rectVertScale.bottom = rectDisplay.bottom ; ! 858: ! 859: //=============================// ! 860: // Size the Horizontal Scale // ! 861: //=============================// ! 862: ! 863: pGraph->rectHorzScale.left = 0 ; ! 864: pGraph->rectHorzScale.top = 0 ; ! 865: pGraph->rectHorzScale.right = 0 ; ! 866: pGraph->rectHorzScale.bottom = 0 ; ! 867: ! 868: //=============================// ! 869: // Size the Data Area // ! 870: //=============================// ! 871: ! 872: pGraph->rectData.left = pGraph->rectVertScale.right + 3 + ThreeDPad ; ! 873: pGraph->rectData.right = rectDisplay.right - 5 - ThreeDPad ; ! 874: pGraph->rectData.top = rectDisplay.top + 5 + ThreeDPad ; ! 875: pGraph->rectData.bottom = rectDisplay.bottom - 5 - ThreeDPad ; ! 876: ! 877: SetGridPositions (pGraph) ; ! 878: ScaleTimeLine (pGraph) ; ! 879: ! 880: //==========================================// ! 881: // Invalidate the last time line poisition // ! 882: //==========================================// ! 883: pGraph->gTimeLine.xLastTime = -1 ; ! 884: ! 885: if (pGraph->hGraphRgn) ! 886: { ! 887: DeleteObject (pGraph->hGraphRgn) ; ! 888: } ! 889: ! 890: pGraph->hGraphRgn = CreateRectRgn (rectDisplay.left, ! 891: rectDisplay.top, ! 892: rectDisplay.right, ! 893: rectDisplay.bottom) ; ! 894: ! 895: SelectClipRgn (hDC, pGraph->hGraphRgn) ; ! 896: ! 897: } // SizeGraphDisplayComponentsRect ! 898: ! 899: ! 900: void SizeGraphDisplayComponents (HWND hWnd) ! 901: /* ! 902: Effect: Given the graph display window hWnd, of size ! 903: (xWidth x yHeight), determine the size and position ! 904: of the various graph display components: the vertical ! 905: scale, the horizontal scale, and the data area. ! 906: ! 907: Called By: OnSize, any other routine that changes the visibility ! 908: of a vertical or horizontal scale. ! 909: ! 910: Note: This function has multiple return points. ! 911: */ ! 912: { // SizeGraphDisplayComponents ! 913: PGRAPHSTRUCT pGraph ; ! 914: RECT rectClient ; ! 915: ! 916: pGraph = GraphData (hWnd) ; ! 917: GetClientRect (hWnd, &rectClient) ; ! 918: ! 919: SizeGraphDisplayComponentsRect (hGraphDisplayDC, pGraph, rectClient) ; ! 920: } ! 921: ! 922: ! 923: void UpdateGraphDisplay (HDC hDC, ! 924: BOOL bForPaint, ! 925: LPRECT lpRect, ! 926: PGRAPHSTRUCT pGraph) ! 927: /* ! 928: Effect: Draw the portions of the graph that change as the ! 929: graph's values change. This includes the background, ! 930: the grid, the lines, and the timeline. ! 931: */ ! 932: { // UpdateGraphDisplay ! 933: RECT rectUpdate ; ! 934: ! 935: if (!bForPaint && !IsPrinterDC (hDC) && ! 936: pGraph->gOptions.iGraphOrHistogram == LINE_GRAPH) ! 937: { ! 938: HBRUSH hOldBrush ; ! 939: ! 940: rectUpdate = pGraph->rectData ; ! 941: rectUpdate.bottom += 1 ; ! 942: ! 943: IntersectRect (&rectUpdate, lpRect, &rectUpdate) ; ! 944: hOldBrush = SelectBrush (hDC, hBrushFace) ; ! 945: ! 946: PatBlt (hDC, ! 947: rectUpdate.left, rectUpdate.top, ! 948: rectUpdate.right - rectUpdate.left, ! 949: rectUpdate.bottom - rectUpdate.top, ! 950: PATCOPY) ; ! 951: } ! 952: else ! 953: { ! 954: IntersectRect (&rectUpdate, lpRect, &pGraph->rectData) ; ! 955: } ! 956: ! 957: if (pGraph->gOptions.iGraphOrHistogram == LINE_GRAPH) ! 958: { ! 959: DrawGrid(hDC, pGraph, &rectUpdate, bForPaint) ; ! 960: if (pGraph->pLineFirst != NULL) ! 961: { ! 962: DrawTLGraphData(hDC, bForPaint, &rectUpdate, pGraph) ; ! 963: if (!PlayingBackLog ()) ! 964: DisplayTimeLine(hDC, pGraph) ; ! 965: } ! 966: } ! 967: else ! 968: { ! 969: DrawBarChartData (hDC, pGraph) ; ! 970: } ! 971: } // UpdateGraphDisplay ! 972: ! 973: ! 974: BOOL UpdateTimeLine (HDC hDC, ! 975: PGRAPHSTRUCT pGraph, ! 976: BOOL getLastTimeLocation) ! 977: /* ! 978: Called By: GraphTimer only. ! 979: ! 980: See Also: UpdateGraphDisplay. ! 981: */ ! 982: { ! 983: INT i, ! 984: xDisplayPoint, ! 985: xDataPoint ; ! 986: RECT rctUpdate ; ! 987: INT xLastTime ; ! 988: INT rectWidth, ! 989: xPos, ! 990: numOfPoints ; ! 991: ! 992: ! 993: if ((xLastTime = pGraph->gTimeLine.xLastTime) != 0) ! 994: { ! 995: if ((pGraph->gKnownValue % pGraph->gMaxValues) == 1) ! 996: { ! 997: // Data wrap around case ! 998: rctUpdate.left = pGraph->rectData.left ; ! 999: rctUpdate.right = pGraph->rectData.left + ! 1000: pGraph->gTimeLine.ppd + 1 ; ! 1001: } ! 1002: else ! 1003: { ! 1004: rctUpdate.left = xLastTime - pGraph->gTimeLine.ppd ; ! 1005: rctUpdate.right = xLastTime + ! 1006: pGraph->gTimeLine.ppd + 1 ; ! 1007: } ! 1008: rctUpdate.top = pGraph->rectData.top ; ! 1009: rctUpdate.bottom = pGraph->rectData.bottom + 1 ; ! 1010: } ! 1011: ! 1012: // Calculate where to draw the time line. ! 1013: // This is done by running a simple DDA (Digital Differential Analyzer) ! 1014: // We have to position the time depending upon the size of the ! 1015: // graph window. In essence we need to calculate the x display ! 1016: // coordinate. ! 1017: ! 1018: // Note we should wrap Known Value in UpdateGLData. ! 1019: // We should also use a data buffer of 256 bytes so we can ! 1020: // wrap with and AND. ! 1021: ! 1022: // xDataPoint = pGraph->gKnownValue ; ! 1023: xDataPoint = pGraph->gKnownValue % pGraph->gMaxValues ; ! 1024: ! 1025: xDisplayPoint = pGraph->rectData.left ; ! 1026: ! 1027: numOfPoints = pGraph->gMaxValues - 1 ; ! 1028: ! 1029: if (!PlayingBackLog() && ! 1030: pGraph->gOptions.iGraphOrHistogram == LINE_GRAPH) ! 1031: { ! 1032: // drawing the 0th at the end of the chart. ! 1033: // So, we do have gMaxValues points ! 1034: numOfPoints++ ; ! 1035: if ((pGraph->gKnownValue % pGraph->gMaxValues) == 0) ! 1036: { ! 1037: xDataPoint = pGraph->gMaxValues ; ! 1038: } ! 1039: } ! 1040: ! 1041: rectWidth = pGraph->rectData.right - pGraph->rectData.left ; ! 1042: ! 1043: for (i = 0 ; i < xDataPoint ; i++) ! 1044: { ! 1045: if (numOfPoints == 0) ! 1046: { ! 1047: break ; ! 1048: } ! 1049: xPos = DDA_DISTRIBUTE (rectWidth, numOfPoints) ; ! 1050: xDisplayPoint += xPos ; ! 1051: rectWidth -= xPos ; ! 1052: numOfPoints-- ; ! 1053: } // for ! 1054: ! 1055: pGraph->gTimeLine.xLastTime = xDisplayPoint ; ! 1056: ! 1057: if (!getLastTimeLocation && iPerfmonView == IDM_VIEWCHART && !bPerfmonIconic) ! 1058: { ! 1059: UpdateGraphDisplay (hDC, FALSE, &rctUpdate, pGraph) ; ! 1060: } ! 1061: ! 1062: return(TRUE) ; ! 1063: } ! 1064: ! 1065: ! 1066: //==========================================================================// ! 1067: // Message Handlers // ! 1068: //==========================================================================// ! 1069: ! 1070: ! 1071: void /*static*/ OnCreate (HWND hWnd) ! 1072: /* ! 1073: Effect: Perform all actions needed when a GraphDisplay window is ! 1074: created. ! 1075: In particular, initialize the graph instance data and ! 1076: create the child windows. ! 1077: ! 1078: Called By: GraphDisplayWndProc, in response to a WM_CREATE message. ! 1079: */ ! 1080: { // OnCreate ! 1081: LOGBRUSH LogBrush ; ! 1082: TEXTMETRIC tmScales ; ! 1083: ! 1084: hGraphDisplayDC = GetDC(hWnd) ; ! 1085: ! 1086: SelectFont(hGraphDisplayDC, hFontScales) ; ! 1087: GetTextMetrics(hGraphDisplayDC, &tmScales) ; ! 1088: HalfTextHeight = tmScales.tmHeight / 2 ; ! 1089: ! 1090: SetBkColor (hGraphDisplayDC, crLightGray) ; ! 1091: ! 1092: ! 1093: InsertGraph(hWnd) ; ! 1094: bInitTimeLine(pGraphs) ; ! 1095: ! 1096: pGraphs->hWnd = hWnd ; ! 1097: ! 1098: // Create the brush and pen used by the time line. ! 1099: // We don't want to create these on every timer tick. ! 1100: ! 1101: LogBrush.lbStyle = BS_SOLID ; ! 1102: LogBrush.lbColor = RGB(0xff, 0, 0) ; ! 1103: LogBrush.lbHatch = 0 ; ! 1104: ! 1105: // Now get the system resources we use "all the time" ! 1106: pGraphs->hbRed = CreateBrushIndirect(&LogBrush) ; ! 1107: pGraphs->hGridPen = CreatePen (PS_SOLID, 1, crGray) ; ! 1108: ! 1109: pGraphs->xNumTics = 0 ; ! 1110: pGraphs->yNumTics = 0 ; ! 1111: } // OnCreate ! 1112: ! 1113: ! 1114: void /*static*/ OnSize (HWND hWnd, ! 1115: WORD xWidth, ! 1116: WORD yHeight) ! 1117: { // OnSize ! 1118: PGRAPHSTRUCT pGraph ; ! 1119: ! 1120: pGraph = GraphData (hWnd) ; ! 1121: ! 1122: SizeGraphDisplayComponents (hWnd) ; ! 1123: } // OnSize ! 1124: ! 1125: ! 1126: void /*static*/ OnPaint (HWND hWnd) ! 1127: { ! 1128: HDC hDC ; ! 1129: PAINTSTRUCT ps ; ! 1130: PGRAPHSTRUCT pGraph ; ! 1131: ! 1132: pGraph = GraphData (hWnd) ; ! 1133: hDC = BeginPaint(hWnd, &ps) ; ! 1134: ! 1135: DrawGraphDisplay (hDC, ps.rcPaint, pGraph) ; ! 1136: ! 1137: EndPaint(hWnd, &ps) ; ! 1138: } // OnPaint ! 1139: ! 1140: ! 1141: //==========================================================================// ! 1142: // Exported Functions // ! 1143: //==========================================================================// ! 1144: ! 1145: #ifdef KEEP_PRINT ! 1146: void PrintGraphDisplay (HDC hDC, ! 1147: PGRAPHSTRUCT pGraph) ! 1148: { ! 1149: DrawGraphScale (hDC, pGraph) ; ! 1150: ! 1151: ! 1152: //!! UpdateGraphDisplay (hDC, TRUE, &(pGraph->rectData), pGraph) ; ! 1153: ! 1154: IntersectClipRect (hDC, 0, 0, 10000, 10000) ; ! 1155: SelectBrush (hDC, GetStockObject (HOLLOW_BRUSH)) ; ! 1156: SelectPen (hDC, GetStockObject (BLACK_PEN)) ; ! 1157: Rectangle (hDC, ! 1158: pGraph->rectData.left, ! 1159: pGraph->rectData.top, ! 1160: pGraph->rectData.right, ! 1161: pGraph->rectData.bottom) ; ! 1162: } // PrintGraphDisplay ! 1163: #endif ! 1164: ! 1165: ! 1166: ! 1167: void DrawGraphDisplay (HDC hDC, ! 1168: RECT rectDraw, ! 1169: PGRAPHSTRUCT pGraph) ! 1170: { ! 1171: BOOL bPaintScale ; ! 1172: INT LocalThreeDPad = ThreeDPad - 1 ; ! 1173: ! 1174: // Only draw the vertical labels if the paint rectangle ! 1175: // any portion of the window to the left of the graph area. ! 1176: ! 1177: bPaintScale = (rectDraw.left <= pGraph->rectVertScale.right) ; ! 1178: if (bPaintScale) ! 1179: DrawGraphScale (hDC, pGraph) ; ! 1180: if (IsPrinterDC (hDC)) ! 1181: Rectangle (hDC, ! 1182: pGraph->rectData.left, ! 1183: pGraph->rectData.top, ! 1184: pGraph->rectData.right, ! 1185: pGraph->rectData.bottom) ; ! 1186: else ! 1187: ThreeDConcave1 (hDC, ! 1188: pGraph->rectData.left - LocalThreeDPad, ! 1189: pGraph->rectData.top - LocalThreeDPad, ! 1190: pGraph->rectData.right + LocalThreeDPad, ! 1191: pGraph->rectData.bottom + LocalThreeDPad + 1) ; ! 1192: ! 1193: UpdateGraphDisplay (hDC, TRUE, &(rectDraw), pGraph) ; ! 1194: } // DrawGraphDisplay ! 1195: ! 1196: ! 1197: LRESULT APIENTRY GraphDisplayWndProc (HWND hWnd, ! 1198: UINT uMsg, ! 1199: WPARAM wParam, ! 1200: LPARAM lParam) ! 1201: { // GraphDisplayWndProc ! 1202: LONG lret = 0L ; ! 1203: BOOL bCallDefProc = FALSE ; ! 1204: ! 1205: switch (LOWORD (uMsg)) ! 1206: { ! 1207: case WM_LBUTTONDOWN: ! 1208: DoWindowDrag (lParam) ; ! 1209: break ; ! 1210: ! 1211: case WM_LBUTTONDBLCLK: ! 1212: SendMessage (hWndMain, uMsg, wParam, lParam) ; ! 1213: break ; ! 1214: ! 1215: case WM_CREATE: ! 1216: OnCreate (hWnd) ; ! 1217: break ; ! 1218: ! 1219: case WM_SIZE: ! 1220: OnSize (hWnd, LOWORD (lParam), HIWORD (lParam)) ; ! 1221: break ; ! 1222: ! 1223: case WM_DESTROY: ! 1224: KillTimer(hWndMain, GRAPH_TIMER_ID) ; ! 1225: break ; ! 1226: ! 1227: case WM_PAINT: ! 1228: OnPaint (hWnd) ; ! 1229: break ; ! 1230: ! 1231: case WM_TIMER: ! 1232: GraphTimer (hWnd, FALSE) ; ! 1233: break ; ! 1234: ! 1235: default: ! 1236: bCallDefProc = TRUE ; ! 1237: break ; ! 1238: } // switch ! 1239: ! 1240: ! 1241: if (bCallDefProc) ! 1242: { ! 1243: lret = DefWindowProc(hWnd, uMsg, wParam, lParam) ; ! 1244: } ! 1245: return (lret) ; ! 1246: } ! 1247: ! 1248: ! 1249: BOOL GraphDisplayInitializeApplication (void) ! 1250: { // GraphDisplayInitializeApplication ! 1251: WNDCLASS wc ; ! 1252: ! 1253: wc.style = dwGraphDisplayClassStyle ; ! 1254: wc.lpfnWndProc = (WNDPROC) GraphDisplayWndProc ; ! 1255: wc.hInstance = hInstance ; ! 1256: wc.cbClsExtra = iGraphDisplayWindowExtra ; ! 1257: wc.cbWndExtra = iGraphDisplayClassExtra ; ! 1258: wc.hIcon = NULL ; ! 1259: wc.hCursor = LoadCursor(NULL, IDC_ARROW) ; ! 1260: wc.hbrBackground = hbLightGray ; ! 1261: wc.lpszMenuName = NULL ; ! 1262: wc.lpszClassName = (LPTSTR) szGraphDisplayWindowClass ; ! 1263: ! 1264: return (RegisterClass (&wc)) ; ! 1265: } // GraphDisplayInitializeApplication ! 1266: ! 1267: ! 1268: ! 1269: HWND CreateGraphDisplayWindow (HWND hWndGraph) ! 1270: { ! 1271: return (CreateWindow (szGraphDisplayWindowClass, // class ! 1272: NULL, // caption ! 1273: dwGraphDisplayWindowStyle, // window style ! 1274: 0, 0, // position ! 1275: 0, 0, // size ! 1276: hWndGraph, // parent window ! 1277: NULL, // menu ! 1278: hInstance, // program instance ! 1279: NULL)) ; // user-supplied data ! 1280: } ! 1281: ! 1282: ! 1283: ! 1284: BOOL ToggleGraphRefresh (HWND hWnd) ! 1285: { // ToggleGraphRefresh ! 1286: PGRAPHSTRUCT pGraph ; ! 1287: ! 1288: pGraph = GraphData (hWnd) ; ! 1289: ! 1290: if (pGraph->bManualRefresh) ! 1291: SetGraphTimer (pGraph) ; ! 1292: else ! 1293: ClearGraphTimer (pGraph) ; ! 1294: ! 1295: pGraph->bManualRefresh = !pGraph->bManualRefresh ; ! 1296: return (pGraph->bManualRefresh) ; ! 1297: } // ToggleGraphRefresh ! 1298: ! 1299: BOOL GraphRefresh (HWND hWnd) ! 1300: { // GraphRefresh ! 1301: PGRAPHSTRUCT pGraph ; ! 1302: ! 1303: pGraph = GraphData (hWnd) ; ! 1304: ! 1305: return (pGraph->bManualRefresh) ; ! 1306: } // GraphRefresh ! 1307: ! 1308: ! 1309: void GraphTimer (HWND hWnd, ! 1310: BOOL bForce) ! 1311: /* ! 1312: Effect: Handle any actions necessary when the graph display ! 1313: window hWnd receives a timer tick. In particular, ! 1314: update the graph display and update the status bar ! 1315: if it is showing. ! 1316: ! 1317: Called By: GraphDisplayWndProc, in response to a WM_TIMER message. ! 1318: */ ! 1319: { // GraphTimer ! 1320: PGRAPHSTRUCT pGraph ; ! 1321: ! 1322: pGraph = GraphData (hWnd) ; ! 1323: ! 1324: if (!pGraph->pLineFirst) ! 1325: return ; ! 1326: ! 1327: ! 1328: if (bForce || !pGraph->bManualRefresh) ! 1329: { ! 1330: ! 1331: ! 1332: HandleGraphTimer () ; ! 1333: ! 1334: // If we are displaying a time-line graph then do the ! 1335: // calculations for the minimal update region. ! 1336: // If were doing a bar graph, then draw the ! 1337: // whole graph area. ! 1338: ! 1339: if (pGraph->gOptions.iGraphOrHistogram == LINE_GRAPH) ! 1340: UpdateTimeLine (hGraphDisplayDC, pGraph, FALSE) ; ! 1341: else ! 1342: DrawBarChartData (hGraphDisplayDC, pGraph) ; ! 1343: ! 1344: // Take care of the status bar window ! 1345: StatusTimer (hWndGraphStatus, FALSE) ; ! 1346: ! 1347: } // if ! 1348: } // GraphTimer ! 1349: ! 1350: // this routine set/reset the line highlight mode ! 1351: void ChartHighlight (void) ! 1352: { ! 1353: PGRAPHSTRUCT pGraph ; ! 1354: ! 1355: ! 1356: if (pGraph = GraphData (hWndGraph)) ! 1357: { ! 1358: if (pGraph->pLineFirst) ! 1359: { ! 1360: // toggle the HightlightOnOff mode ! 1361: pGraph->HighLightOnOff = !pGraph->HighLightOnOff ; ! 1362: WindowInvalidate (hWndGraphDisplay) ; ! 1363: } ! 1364: else ! 1365: { ! 1366: // no line availble, just turn it off ! 1367: pGraph->HighLightOnOff = FALSE ; ! 1368: } ! 1369: } ! 1370: } // ChartHighlight ! 1371: ! 1372:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.