![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to grafdata.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 grafdata.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / perfmon |
1.1 ! root 1: /***************************************************************************** ! 2: * ! 3: * Grafdata.c - This module handles the non-drawing functions of the graph, ! 4: * such as allocating linked structures and their memory, freeing it, ! 5: * unlinking, starting and stopping the timer, ! 6: * setting up the first graph (CPU), and all the numeric functions for ! 7: * the different counter types. ! 8: * ! 9: * Microsoft Confidential ! 10: * Copyright (c) 1992-1993 Microsoft Corporation ! 11: * ! 12: * ! 13: ****************************************************************************/ ! 14: ! 15: ! 16: //==========================================================================// ! 17: // Includes // ! 18: //==========================================================================// ! 19: ! 20: #include <stdio.h> // for sprintf ! 21: ! 22: #include "perfmon.h" // main perfmon declarations ! 23: #include "grafdata.h" // external declarations for this file ! 24: #include <float.h> // for FLT_MAX constant ! 25: ! 26: #include "addline.h" // for AddLine, EditLine ! 27: #include "counters.h" // for Counter_Counter, et al. ! 28: #include "graph.h" // for SizeGraphComponents ! 29: #include "pmemory.h" // for MemoryXXX (mallloc-type) routines ! 30: #include "perfdata.h" // for UpdateLines ! 31: #include "playback.h" // for PlayingBackLog, PlaybackLines ! 32: #include "legend.h" ! 33: #include "system.h" // for SystemGet ! 34: #include "utils.h" ! 35: #include "line.h" // for LineFree ! 36: #include "valuebar.h" // for StatusTimer ! 37: ! 38: #include "fileopen.h" // for FileGetName ! 39: #include "fileutil.h" // for FileRead... ! 40: #include "menuids.h" // for IDM_VIEWCHART ! 41: #include "perfmops.h" // for ExportFileHeader ! 42: #include "status.h" // for StatusLineReady ! 43: ! 44: extern BOOL SaveFileHandler(HWND hWnd,DWORD type) ; ! 45: ! 46: // this macro is used in doing a simple DDA (Digital Differential Analyzer) ! 47: // * 10 + 5 is to make the result round up with .5 ! 48: #define DDA_DISTRIBUTE(TotalTics, numOfData) \ ! 49: ((TotalTics * 10 / numOfData) + 5) / 10 ! 50: ! 51: #define szSmallValueFormat TEXT("%10.3f") ! 52: #define szLargeValueFormat TEXT("%10.0f") ! 53: ! 54: //==========================================================================// ! 55: // Local Data // ! 56: //==========================================================================// ! 57: ! 58: ! 59: ! 60: ! 61: //==========================================================================// ! 62: // Local Functions // ! 63: //==========================================================================// ! 64: ! 65: ! 66: /**************************************************************************** ! 67: * eUpdateMinMaxAve - ! 68: ****************************************************************************/ ! 69: void eUpdateMinMaxAve (FLOAT eValue, PLINESTRUCT pLineStruct, INT iValidValues, ! 70: INT iTotalValidPoints, INT iDataPoint, INT gMaxPoints) ! 71: { ! 72: INT i ; ! 73: INT iDataNum = iTotalValidPoints ; ! 74: FLOAT eMin, ! 75: eMax, ! 76: eSum, ! 77: eNewValue ; ! 78: ! 79: ! 80: eMax = eMin = eValue ; ! 81: ! 82: if (PlayingBackLog()) ! 83: { ! 84: eSum = (FLOAT) 0.0 ; ! 85: } ! 86: else ! 87: { ! 88: eSum = eValue ; ! 89: } ! 90: ! 91: if (iValidValues == iTotalValidPoints) ! 92: { ! 93: for (i=0 ; i < iValidValues ; i++) ! 94: { ! 95: if (i == iDataPoint) ! 96: { ! 97: // skip the data point we are going to replace ! 98: continue ; ! 99: } ! 100: ! 101: eNewValue = pLineStruct->lnValues[i] ; ! 102: ! 103: eSum += eNewValue ; ! 104: ! 105: if (eNewValue > eMax) ! 106: { ! 107: eMax = eNewValue ; ! 108: } ! 109: ! 110: if (eNewValue < eMin) ! 111: { ! 112: eMin = eNewValue ; ! 113: } ! 114: } ! 115: } ! 116: else ! 117: { ! 118: // special case when we start the new line in the middle of the chart ! 119: for (i = iDataPoint, iTotalValidPoints-- ; ! 120: iTotalValidPoints > 0 ; ! 121: iTotalValidPoints-- ) ! 122: { ! 123: i-- ; ! 124: if (i < 0) ! 125: { ! 126: // for the wrap-around case.. ! 127: i = gMaxPoints - 1 ; ! 128: } ! 129: ! 130: if (i == iDataPoint) ! 131: { ! 132: // skip the data point we are going to replace ! 133: continue ; ! 134: } ! 135: eNewValue = pLineStruct->lnValues[i] ; ! 136: ! 137: eSum += eNewValue ; ! 138: ! 139: if (eNewValue > eMax) ! 140: { ! 141: eMax = eNewValue ; ! 142: } ! 143: ! 144: if (eNewValue < eMin) ! 145: { ! 146: eMin = eNewValue ; ! 147: } ! 148: } ! 149: } ! 150: ! 151: pLineStruct->lnMinValue = eMin ; ! 152: pLineStruct->lnMaxValue = eMax ; ! 153: ! 154: if (iDataNum) ! 155: { ! 156: pLineStruct->lnAveValue = eSum / (FLOAT) iDataNum ; ! 157: } ! 158: else ! 159: { ! 160: pLineStruct->lnAveValue = (FLOAT) 0.0 ; ! 161: } ! 162: } ! 163: ! 164: ! 165: // UpdateValueBarData is used to update the value bar data ! 166: // It is called when the user switches to a diff. line from ! 167: // the legned window. ! 168: VOID UpdateValueBarData (PGRAPHSTRUCT pGraph) ! 169: { ! 170: PLINESTRUCT pCurrentGraphLine ; ! 171: INT KnownValue, ! 172: MaxValues, ! 173: iValidValues, ! 174: iDataPoint ; ! 175: FLOAT eValue ; ! 176: pCurrentGraphLine = CurrentGraphLine (hWndGraph) ; ! 177: ! 178: if (!pCurrentGraphLine || pCurrentGraphLine->bFirstTime) ! 179: { ! 180: // we have not collect enough samples ! 181: return ; ! 182: } ! 183: ! 184: KnownValue = pGraph->gKnownValue ; ! 185: MaxValues = pGraph->gMaxValues ; ! 186: ! 187: // The valid values is the number of valid entries in the ! 188: // data buffer. After we wrap the buffer, all the values are ! 189: // valid. ! 190: iValidValues = pGraph->gTimeLine.iValidValues ; ! 191: ! 192: // Get the index to the data point we are updating. ! 193: ! 194: iDataPoint = KnownValue % MaxValues ; ! 195: eValue = pCurrentGraphLine->lnValues[iDataPoint] ; ! 196: ! 197: // get the statistical data for this line ! 198: eUpdateMinMaxAve(eValue, pCurrentGraphLine, ! 199: iValidValues, pCurrentGraphLine->lnValidValues, ! 200: iDataPoint, MaxValues) ; ! 201: } // UpdateValueBarData ! 202: ! 203: ! 204: VOID UpdateLGData (PGRAPHSTRUCT pGraph) ! 205: { ! 206: PLINESTRUCT pLine ; ! 207: PLINESTRUCT pCurrentGraphLine ; ! 208: INT KnownValue, ! 209: MaxValues, ! 210: iValidValues, ! 211: iDataPoint ; ! 212: FLOAT eValue ; ! 213: // Known Value is the where data is placed in the buffer. ! 214: pGraph->gKnownValue++; ! 215: ! 216: KnownValue = pGraph->gKnownValue ; ! 217: ! 218: // Update the high water mark for valid data in the lnValues ! 219: // (aka DataPoint) buffer. ! 220: ! 221: ! 222: MaxValues = pGraph->gMaxValues ; ! 223: ! 224: // The valid values is the number of valid entries in the ! 225: // data buffer. After we wrap the buffer, all the values are ! 226: // valid. ! 227: iValidValues = pGraph->gTimeLine.iValidValues ; ! 228: ! 229: if (iValidValues < MaxValues) ! 230: iValidValues = (KnownValue % MaxValues) + 1 ; ! 231: ! 232: pGraph->gTimeLine.iValidValues = iValidValues ; ! 233: ! 234: // Get the index to the data point we are updating. ! 235: ! 236: iDataPoint = KnownValue % MaxValues ; ! 237: ! 238: // loop through lines, ! 239: // If one of the lines is highlighted then do the calculations ! 240: // for average, min, & max on that line. ! 241: ! 242: pCurrentGraphLine = CurrentGraphLine (hWndGraph) ; ! 243: ! 244: for (pLine=pGraph->pLineFirst; pLine; pLine=pLine->pLineNext) ! 245: { // for ! 246: ! 247: if (pLine->bFirstTime) ! 248: { ! 249: // skip until we have collect enough samples to plot the first data ! 250: continue ; ! 251: } ! 252: ! 253: if (pLine->lnValidValues < MaxValues) ! 254: { ! 255: (pLine->lnValidValues)++ ; ! 256: } ! 257: ! 258: // Get the new value for this line. ! 259: eValue = (*(pLine->valNext))(pLine) ; ! 260: ! 261: if (pLine == pCurrentGraphLine) ! 262: { // if ! 263: // get the statistical data for this line ! 264: eUpdateMinMaxAve (eValue, pLine, ! 265: iValidValues, pLine->lnValidValues, ! 266: iDataPoint, MaxValues) ; ! 267: } // if ! 268: ! 269: // Now put the new value into the data array ! 270: pLine->lnValues[iDataPoint] = eValue ; ! 271: } ! 272: ! 273: GetLocalTime (&(pGraph->pDataTime[iDataPoint])) ; ! 274: } // UpdateLGData ! 275: ! 276: ! 277: ! 278: BOOL HandleGraphTimer (void) ! 279: { ! 280: PGRAPHSTRUCT pGraph; ! 281: ! 282: //NOTE: get a strategy for these "no-go" states ! 283: if (!(pGraph = pGraphs) || !pGraphs->pSystemFirst) ! 284: return(FALSE); ! 285: ! 286: ! 287: if (!UpdateLines(&(pGraphs->pSystemFirst), pGraphs->pLineFirst)) ! 288: return (TRUE) ; ! 289: ! 290: UpdateLGData(pGraph); ! 291: ! 292: return(TRUE); ! 293: } ! 294: ! 295: ! 296: VOID ClearGraphTimer(PGRAPHSTRUCT pGraph) ! 297: { ! 298: KillTimer(pGraph->hWnd, GRAPH_TIMER_ID); ! 299: } ! 300: ! 301: ! 302: VOID SetGraphTimer(PGRAPHSTRUCT pGraph) ! 303: { ! 304: SetTimer(pGraph->hWnd, GRAPH_TIMER_ID, pGraph->gInterval, NULL) ; ! 305: } ! 306: ! 307: VOID ResetGraphTimer(PGRAPHSTRUCT pGraph) ! 308: { ! 309: KillTimer(pGraph->hWnd, GRAPH_TIMER_ID); ! 310: SetGraphTimer(pGraph); ! 311: } ! 312: ! 313: ! 314: VOID GetGraphConfig(PGRAPHSTRUCT pGraph) ! 315: { ! 316: ! 317: LoadRefreshSettings(pGraph); ! 318: LoadLineGraphSettings(pGraph); ! 319: ! 320: ! 321: // Init the structure ! 322: pGraph->pLineFirst = NULL; ! 323: ! 324: //NOTE: put the rest of this in Config ! 325: ! 326: pGraph->gOptions.bLegendChecked = TRUE; ! 327: pGraph->gOptions.bMenuChecked = TRUE; ! 328: pGraph->gOptions.bLabelsChecked = TRUE; ! 329: pGraph->gOptions.bVertGridChecked = FALSE; ! 330: pGraph->gOptions.bHorzGridChecked = FALSE; ! 331: pGraph->gOptions.bStatusBarChecked = TRUE; ! 332: pGraph->gOptions.GraphVGrid = TRUE; ! 333: pGraph->gOptions.GraphHGrid = TRUE; ! 334: pGraph->gOptions.HistVGrid = TRUE; ! 335: pGraph->gOptions.HistHGrid = TRUE; ! 336: ! 337: pGraph->gOptions.iGraphOrHistogram = LINE_GRAPH; // vs. BAR_GRAPH ! 338: pGraph->gOptions.iVertMax = DEF_GRAPH_VMAX; ! 339: ! 340: return; ! 341: } ! 342: ! 343: ! 344: BOOL InsertGraph (HWND hWnd) ! 345: { ! 346: PGRAPHSTRUCT pGraph; ! 347: ! 348: pGraph = MemoryAllocate (sizeof (GRAPHSTRUCT)) ; ! 349: if (!pGraph) ! 350: return (FALSE) ; ! 351: ! 352: ! 353: pGraphs = pGraph; ! 354: ! 355: ! 356: GetGraphConfig(pGraph); ! 357: pGraph->bManualRefresh = FALSE ; ! 358: ! 359: pGraph->gMaxValues = DEFAULT_MAX_VALUES; ! 360: pGraph->pptDataPoints = ! 361: (PPOINT) MemoryAllocate (sizeof (POINT) * pGraph->gMaxValues) ; ! 362: ! 363: pGraph->pDataTime = ! 364: (SYSTEMTIME *) MemoryAllocate (sizeof(SYSTEMTIME) * pGraph->gMaxValues) ; ! 365: ! 366: pGraph->hWnd = hWnd ; ! 367: pGraph->bModified = FALSE ; ! 368: ! 369: pGraph->Visual.iColorIndex = 0 ; ! 370: pGraph->Visual.iWidthIndex = 0 ; ! 371: pGraph->Visual.iStyleIndex = 0 ; ! 372: ! 373: return(TRUE) ; ! 374: } ! 375: ! 376: ! 377: ! 378: void PlaybackSetGraphLines (HWND hWndChart, ! 379: PLINE pLineFirst, ! 380: int iDisplayTic, ! 381: int iLogTic, ! 382: BOOL CalcData) ! 383: { ! 384: PLINE pLine ; ! 385: FLOAT eValue ; ! 386: ! 387: for (pLine = pLineFirst ; ! 388: pLine ; ! 389: pLine = pLine->pLineNext) ! 390: { // for ! 391: eValue = (*(pLine->valNext))(pLine) ; ! 392: pLine->lnValues[iDisplayTic] = eValue ; ! 393: pLine->aiLogIndexes[iDisplayTic] = iLogTic ; ! 394: ! 395: // only need to do this on request. ! 396: if (CalcData) ! 397: { ! 398: eUpdateMinMaxAve (eValue, pLine, iDisplayTic, iDisplayTic, ! 399: iDisplayTic, iDisplayTic) ; ! 400: } // if ! 401: } // for ! 402: } // PlaybackSetGraphLines ! 403: ! 404: ! 405: ! 406: BOOL ChartInsertLine (PGRAPHSTRUCT pGraph, ! 407: PLINE pLine) ! 408: /* ! 409: Effect: Insert the line pLine into the graph pGraph and ! 410: allocate space for the graph's number of values. ! 411: ! 412: Returns: Whether the line could be added and space allocated. ! 413: ! 414: See Also: LineAllocate (line.c), ChartDeleteLine. ! 415: */ ! 416: { // ChartInsertLine ! 417: PLINE pLineEquivalent ; ! 418: INT i ; ! 419: FLOAT *pTempPts; ! 420: HPEN tempPen ; ! 421: ! 422: pGraph->bModified = TRUE ; ! 423: ! 424: pLineEquivalent = FindEquivalentLine (pLine, pGraph->pLineFirst) ; ! 425: if (pLineEquivalent) ! 426: { ! 427: pLineEquivalent->Visual = pLine->Visual ; ! 428: pLineEquivalent->iScaleIndex = pLine->iScaleIndex ; ! 429: pLineEquivalent->eScale = pLine->eScale ; ! 430: ! 431: tempPen = pLineEquivalent->hPen ; ! 432: pLineEquivalent->hPen = pLine->hPen ; ! 433: pLine->hPen = tempPen ; ! 434: return FALSE ; ! 435: } ! 436: else ! 437: { ! 438: if (!pGraph->pLineFirst && !PlayingBackLog()) ! 439: { ! 440: SetGraphTimer (pGraph) ; ! 441: } ! 442: ! 443: if (!SystemAdd (&pGraph->pSystemFirst, pLine->lnSystemName)) ! 444: return FALSE; ! 445: ! 446: LineAppend (&pGraph->pLineFirst, pLine) ; ! 447: ! 448: pLine->lnMinValue = FLT_MAX ; ! 449: pLine->lnMaxValue = - FLT_MAX ; ! 450: pLine->lnAveValue = 0.0F ; ! 451: pLine->lnValidValues = 0 ; ! 452: ! 453: pLine->lnValues = ! 454: (FLOAT *) MemoryAllocate (sizeof (FLOAT) * pGraph->gMaxValues) ; ! 455: ! 456: for (i = pGraph->gMaxValues, pTempPts = pLine->lnValues ; ! 457: i > 0 ; ! 458: i-- ) ! 459: { ! 460: *pTempPts++ = (FLOAT) 0.0 ; ! 461: } ! 462: ! 463: if (PlayingBackLog ()) ! 464: { ! 465: pLine->aiLogIndexes = ! 466: (int *) MemoryAllocate (sizeof (LONG) * pGraph->gMaxValues) ; ! 467: } ! 468: ! 469: // Add the line to the legend, resize the legend window, and then ! 470: // select the new line as the current legend item. Do it in this ! 471: // sequence to avoid the legend scroll bar momentarily appearing and ! 472: // then disappearing, since the resize will obviate the scroll bar. ! 473: ! 474: LegendAddItem (hWndGraphLegend, pLine) ; ! 475: ! 476: if (!bDelayAddAction) ! 477: { ! 478: SizeGraphComponents (hWndGraph) ; ! 479: LegendSetSelection (hWndGraphLegend, ! 480: LegendNumItems (hWndGraphLegend) - 1) ; ! 481: ! 482: if (PlayingBackLog ()) ! 483: PlaybackChart (pGraph->hWnd) ; ! 484: } ! 485: } ! 486: ! 487: return (TRUE) ; ! 488: } // ChartInsertLine ! 489: ! 490: ! 491: VOID ChartDeleteLine (PGRAPHSTRUCT pGraph, ! 492: PLINESTRUCT pLine) ! 493: { ! 494: PLINESTRUCT npLine; ! 495: ! 496: ! 497: pGraph->bModified = TRUE ; ! 498: ! 499: if (pGraph->pLineFirst == pLine) ! 500: pGraph->pLineFirst = pLine->pLineNext; ! 501: else ! 502: { ! 503: for (npLine = pGraph->pLineFirst; npLine; npLine = npLine->pLineNext) ! 504: { ! 505: if (npLine->pLineNext == pLine) ! 506: npLine->pLineNext = pLine->pLineNext; ! 507: } ! 508: } ! 509: ! 510: if (!pGraph->pLineFirst) ! 511: { ! 512: ResetGraph (pGraph) ; ! 513: } ! 514: else ! 515: { ! 516: BuildNewValueListForGraph () ; ! 517: } ! 518: ! 519: // Delete the legend entry for this line. ! 520: // If the line was highlighted then this will undo the highlight. ! 521: ! 522: LegendDeleteItem (hWndGraphLegend, pLine) ; ! 523: ! 524: LineFree (pLine) ; ! 525: ! 526: SizeGraphComponents (hWndGraph) ; ! 527: ! 528: ! 529: } ! 530: ! 531: ! 532: FLOAT Counter_Queuelen(PLINESTRUCT pLine) ! 533: { ! 534: ! 535: return((FLOAT)0.0); ! 536: // pLine; ! 537: } ! 538: ! 539: ! 540: void ClearGraphDisplay (PGRAPHSTRUCT pGraph) ! 541: { ! 542: PLINESTRUCT pLine; ! 543: ! 544: // reset the timeline data ! 545: pGraph->gKnownValue = -1 ; ! 546: pGraph->gTimeLine.iValidValues = 0 ; ! 547: pGraph->gTimeLine.xLastTime = 0 ; ! 548: memset (pGraph->pDataTime, 0, sizeof(SYSTEMTIME) * pGraph->gMaxValues) ; ! 549: ! 550: // loop through lines, ! 551: // If one of the lines is highlighted then do the calculations ! 552: // for average, min, & max on that line. ! 553: ! 554: for (pLine=pGraph->pLineFirst; pLine; pLine=pLine->pLineNext) ! 555: { // for ! 556: ! 557: pLine->bFirstTime = 2 ; ! 558: pLine->lnMinValue = FLT_MAX ; ! 559: pLine->lnMaxValue = - FLT_MAX ; ! 560: pLine->lnAveValue = 0.0F ; ! 561: pLine->lnValidValues = 0 ; ! 562: memset (pLine->lnValues, 0, sizeof(FLOAT) * pGraph->gMaxValues) ; ! 563: } ! 564: ! 565: StatusTimer (hWndGraphStatus, TRUE) ; ! 566: WindowInvalidate (hWndGraphDisplay) ; ! 567: } ! 568: ! 569: void ResetGraphView (HWND hWndGraph) ! 570: { ! 571: PGRAPHSTRUCT pGraph ; ! 572: ! 573: pGraph = GraphData (hWndGraph) ; ! 574: ! 575: ! 576: if (!pGraph) ! 577: { ! 578: return ; ! 579: } ! 580: ! 581: ChangeSaveFileName (NULL, IDM_VIEWCHART) ; ! 582: ! 583: if (pGraph->pSystemFirst) ! 584: { ! 585: ResetGraph (pGraph) ; ! 586: } ! 587: } // ResetGraphView ! 588: ! 589: void ResetGraph (PGRAPHSTRUCT pGraph) ! 590: { ! 591: ClearGraphTimer (pGraph) ; ! 592: ClearLegend (hWndGraphLegend) ; ! 593: if (pGraph->pLineFirst) ! 594: { ! 595: FreeLines (pGraph->pLineFirst) ; ! 596: pGraph->pLineFirst = NULL ; ! 597: } ! 598: ! 599: if (pGraph->pSystemFirst) ! 600: { ! 601: FreeSystems (pGraph->pSystemFirst) ; ! 602: pGraph->pSystemFirst = NULL ; ! 603: } ! 604: ! 605: pGraph->gKnownValue = -1 ; ! 606: pGraph->gTimeLine.iValidValues = 0 ; ! 607: pGraph->gTimeLine.xLastTime = 0 ; ! 608: ! 609: // reset visual data ! 610: pGraph->Visual.iColorIndex = 0 ; ! 611: pGraph->Visual.iWidthIndex = 0 ; ! 612: pGraph->Visual.iStyleIndex = 0 ; ! 613: ! 614: memset (pGraph->pDataTime, 0, sizeof(SYSTEMTIME) * pGraph->gMaxValues) ; ! 615: ! 616: SizeGraphComponents (hWndGraph) ; ! 617: InvalidateRect(hWndGraph, NULL, TRUE) ; ! 618: } ! 619: ! 620: ! 621: ! 622: void PlaybackChart (HWND hWndChart) ! 623: { // PlaybackChart ! 624: int iDisplayTics ; // num visual points to display ! 625: int iDisplayTic ; ! 626: int iLogTic ; ! 627: int iLogTicsMove ; ! 628: BOOL bFirstTime = TRUE; ! 629: int iLogTicsRemaining ; ! 630: ! 631: if (!pGraphs->pLineFirst) ! 632: { ! 633: // no line to playback ! 634: return ; ! 635: } ! 636: ! 637: iLogTicsRemaining = PlaybackLog.iSelectedTics ; ! 638: ! 639: ! 640: // we only have iDisplayTics-1 points since ! 641: // we have to use the first two sample points to ! 642: // get the first data points. ! 643: if (iLogTicsRemaining <= pGraphs->gMaxValues) ! 644: { ! 645: iDisplayTics = iLogTicsRemaining ; ! 646: pGraphs->gTimeLine.iValidValues = iDisplayTics - 1 ; ! 647: } ! 648: else ! 649: { ! 650: iDisplayTics = pGraphs->gMaxValues ; ! 651: pGraphs->gTimeLine.iValidValues = iDisplayTics ; ! 652: } ! 653: ! 654: iDisplayTic = -1 ; ! 655: iLogTic = PlaybackLog.StartIndexPos.iPosition ; ! 656: ! 657: while (iDisplayTics) ! 658: { ! 659: ! 660: PlaybackLines (pGraphs->pSystemFirst, ! 661: pGraphs->pLineFirst, ! 662: iLogTic) ; ! 663: ! 664: if (bFirstTime) ! 665: { ! 666: bFirstTime = FALSE ; ! 667: ! 668: // get the second sample data to form the first data point ! 669: iLogTic++ ; ! 670: iLogTicsRemaining-- ; ! 671: PlaybackLines (pGraphs->pSystemFirst, ! 672: pGraphs->pLineFirst, ! 673: iLogTic) ; ! 674: } ! 675: iDisplayTic++ ; ! 676: PlaybackSetGraphLines (hWndChart, pGraphs->pLineFirst, ! 677: iDisplayTic, iLogTic, (iDisplayTics == 1)) ; ! 678: ! 679: // setup DDA to get the index of the next sample point ! 680: iLogTicsMove = DDA_DISTRIBUTE (iLogTicsRemaining, iDisplayTics) ; ! 681: iLogTicsRemaining -= iLogTicsMove ; ! 682: iLogTic += iLogTicsMove ; ! 683: ! 684: iDisplayTics-- ; ! 685: ! 686: } // while ! 687: ! 688: // point to the last value for valuebar display ! 689: pGraphs->gKnownValue = iDisplayTic ; ! 690: ! 691: } // PlaybackChart ! 692: ! 693: ! 694: ! 695: #if 0 ! 696: PLINESTRUCT CurrentGraphLine (HWND hWndGraph) ! 697: { // CurrentGraphLine ! 698: UNREFERENCED_PARAMETER (hWndGraph) ; ! 699: ! 700: return (LegendCurrentLine (hWndGraphLegend)) ; ! 701: } ! 702: #endif ! 703: ! 704: ! 705: BOOL AddChart (HWND hWndParent) ! 706: { ! 707: return (AddLine (hWndParent, ! 708: &(pGraphs->pSystemFirst), ! 709: &(pGraphs->Visual), ! 710: LineTypeChart)) ; ! 711: } ! 712: ! 713: ! 714: BOOL EditChart (HWND hWndParent) ! 715: { // EditChart ! 716: return (EditLine (hWndParent, ! 717: &(pGraphs->pSystemFirst), ! 718: CurrentGraphLine (hWndGraph), ! 719: LineTypeChart)) ; ! 720: } ! 721: ! 722: ! 723: BOOL QuerySaveChart (HWND hWndParent, PGRAPHSTRUCT pGraph) ! 724: /* ! 725: Effect: If the graph pGraph is modified, put up a message ! 726: box allowing the user to save the current graph. ! 727: ! 728: Return whether the caller should proceed to load in ! 729: a new or otherwise trash the current graph. ! 730: */ ! 731: { // QuerySaveChart ! 732: #ifdef KEEP_QUERY ! 733: int iReturn ; ! 734: ! 735: if (!pGraph->bModified) ! 736: return (TRUE) ; ! 737: ! 738: iReturn = MessageBoxResource (hWndParent, ! 739: IDS_SAVECHART, IDS_MODIFIEDCHART, ! 740: MB_YESNOCANCEL | MB_ICONASTERISK) ; ! 741: ! 742: if (iReturn == IDCANCEL) ! 743: return (FALSE) ; ! 744: ! 745: if (iReturn == IDYES) ! 746: SaveChart (hWndGraphs, 0, 0) ; ! 747: return (TRUE) ; ! 748: #endif ! 749: return (TRUE) ; // we don't want to query nor save change ! 750: ! 751: } // QuerySaveChart ! 752: ! 753: void GraphAddAction () ! 754: { ! 755: PGRAPHSTRUCT pGraph ; ! 756: ! 757: pGraph = GraphData (hWndGraph) ; ! 758: ! 759: SizeGraphComponents (hWndGraph) ; ! 760: ! 761: LegendSetSelection (hWndGraphLegend, ! 762: LegendNumItems (hWndGraphLegend) - 1) ; ! 763: ! 764: if (PlayingBackLog ()) ! 765: PlaybackChart (pGraph->hWnd) ; ! 766: } ! 767: ! 768: BOOL OpenChartVer1 (HANDLE hFile, ! 769: DISKCHART *pDiskChart, ! 770: PGRAPHSTRUCT pGraph) ! 771: { // OpenChartVer1 ! 772: bDelayAddAction = TRUE ; ! 773: pGraph->Visual = pDiskChart->Visual ; ! 774: pGraph->gOptions = pDiskChart->gOptions ; ! 775: pGraph->gMaxValues = pDiskChart->gMaxValues ; ! 776: pGraph->bManualRefresh = pDiskChart->bManualRefresh ; ! 777: pGraphs->gInterval = (INT) (pGraph->gOptions.eTimeInterval * (FLOAT) 1000.0) ; ! 778: ReadLines (hFile, pDiskChart->dwNumLines, ! 779: &(pGraph->pSystemFirst), &(pGraph->pLineFirst), IDM_VIEWCHART) ; ! 780: ! 781: bDelayAddAction = FALSE ; ! 782: ! 783: GraphAddAction () ; ! 784: ! 785: return (TRUE) ; ! 786: } // OpenChartVer1 ! 787: ! 788: ! 789: ! 790: BOOL OpenChart (HWND hWndGraph, ! 791: HANDLE hFile, ! 792: DWORD dwMajorVersion, ! 793: DWORD dwMinorVersion, ! 794: BOOL bChartFile) ! 795: { // OpenChart ! 796: PGRAPHSTRUCT pGraph ; ! 797: DISKCHART DiskChart ; ! 798: BOOL bSuccess = TRUE ; ! 799: ! 800: pGraph = pGraphs ; ! 801: if (!pGraph) ! 802: { ! 803: bSuccess = FALSE ; ! 804: goto Exit0 ; ! 805: } ! 806: ! 807: if (!FileRead (hFile, &DiskChart, sizeof (DISKCHART))) ! 808: { ! 809: bSuccess = FALSE ; ! 810: goto Exit0 ; ! 811: } ! 812: ! 813: ! 814: switch (dwMajorVersion) ! 815: { ! 816: case (1): ! 817: ! 818: SetHourglassCursor() ; ! 819: ! 820: ResetGraphView (hWndGraph) ; ! 821: ! 822: OpenChartVer1 (hFile, &DiskChart, pGraph) ; ! 823: ! 824: // change to chart view if we are opening a ! 825: // chart file ! 826: if (bChartFile && iPerfmonView != IDM_VIEWCHART) ! 827: { ! 828: SendMessage (hWndMain, WM_COMMAND, (LONG)IDM_VIEWCHART, 0L) ; ! 829: } ! 830: ! 831: if (iPerfmonView == IDM_VIEWCHART) ! 832: { ! 833: SetPerfmonOptions (&DiskChart.perfmonOptions) ; ! 834: } ! 835: ! 836: SetArrowCursor() ; ! 837: ! 838: break ; ! 839: } // switch ! 840: ! 841: Exit0: ! 842: ! 843: if (bChartFile) ! 844: { ! 845: CloseHandle (hFile) ; ! 846: } ! 847: ! 848: return (bSuccess) ; ! 849: } // OpenChart ! 850: ! 851: BOOL SaveChart (HWND hWndGraph, HANDLE hInputFile, BOOL bGetFileName) ! 852: { ! 853: PGRAPHSTRUCT pGraph ; ! 854: PLINE pLine ; ! 855: HANDLE hFile ; ! 856: DISKCHART DiskChart ; ! 857: PERFFILEHEADER FileHeader ; ! 858: TCHAR szFileName [256] ; ! 859: BOOL newFileName = FALSE ; ! 860: ! 861: if (hInputFile) ! 862: { ! 863: // use the input file handle if it is available ! 864: // this is the case for saving workspace data ! 865: hFile = hInputFile ; ! 866: } ! 867: else ! 868: { ! 869: if (pChartFullFileName) ! 870: { ! 871: lstrcpy (szFileName, pChartFullFileName) ; ! 872: } ! 873: if (bGetFileName || pChartFullFileName == NULL) ! 874: { ! 875: // if (!pChartFullFileName) ! 876: // { ! 877: // StringLoad (IDS_GRAPH_FNAME, szFileName) ; ! 878: // } ! 879: ! 880: if (!FileGetName (hWndGraph, IDS_CHARTFILE, szFileName)) ! 881: { ! 882: return (FALSE) ; ! 883: } ! 884: newFileName = TRUE ; ! 885: } ! 886: ! 887: hFile = FileHandleCreate (szFileName) ; ! 888: ! 889: if (hFile && newFileName) ! 890: { ! 891: ChangeSaveFileName (szFileName, IDM_VIEWCHART) ; ! 892: } ! 893: else if (!hFile) ! 894: { ! 895: DlgErrorBox (hWndGraph, ERR_CANT_OPEN, szFileName) ; ! 896: } ! 897: } ! 898: ! 899: if (!hFile) ! 900: return (FALSE) ; ! 901: ! 902: pGraph = pGraphs ; ! 903: if (!pGraph) ! 904: { ! 905: if (!hInputFile) ! 906: { ! 907: CloseHandle (hFile) ; ! 908: } ! 909: return (FALSE) ; ! 910: } ! 911: ! 912: if (!hInputFile) ! 913: { ! 914: // only need to write file header if not workspace ! 915: memset (&FileHeader, 0, sizeof (FileHeader)) ; ! 916: lstrcpy (FileHeader.szSignature, szPerfChartSignature) ; ! 917: FileHeader.dwMajorVersion = ChartMajorVersion ; ! 918: FileHeader.dwMinorVersion = ChartMinorVersion ; ! 919: ! 920: if (!FileWrite (hFile, &FileHeader, sizeof (PERFFILEHEADER))) ! 921: { ! 922: goto Exit0 ; ! 923: } ! 924: } ! 925: ! 926: DiskChart.Visual = pGraph->Visual ; ! 927: DiskChart.gOptions = pGraph->gOptions ; ! 928: DiskChart.gMaxValues = pGraph->gMaxValues ; ! 929: DiskChart.dwNumLines = NumLines (pGraph->pLineFirst) ; ! 930: DiskChart.bManualRefresh = pGraph->bManualRefresh ; ! 931: DiskChart.perfmonOptions = Options ; ! 932: ! 933: if (!FileWrite (hFile, &DiskChart, sizeof (DISKCHART))) ! 934: { ! 935: goto Exit0 ; ! 936: } ! 937: ! 938: for (pLine = pGraph->pLineFirst ; ! 939: pLine ; ! 940: pLine = pLine->pLineNext) ! 941: { // for ! 942: if (!WriteLine (pLine, hFile)) ! 943: { ! 944: goto Exit0 ; ! 945: } ! 946: } // for ! 947: ! 948: if (!hInputFile) ! 949: { ! 950: CloseHandle (hFile) ; ! 951: } ! 952: ! 953: return (TRUE) ; ! 954: ! 955: Exit0: ! 956: if (!hInputFile) ! 957: { ! 958: CloseHandle (hFile) ; ! 959: ! 960: // only need to report error if not workspace ! 961: DlgErrorBox (hWndGraph, ERR_SETTING_FILE, szFileName) ; ! 962: } ! 963: return (FALSE) ; ! 964: ! 965: } // SaveChart ! 966: ! 967: #define TIME_TO_WRITE 6 ! 968: BOOL ExportChartLabels (HANDLE hFile, PGRAPHSTRUCT pGraph) ! 969: { ! 970: TCHAR UnicodeBuff [MiscTextLen] ; ! 971: CHAR TempBuff [LongTextLen] ; ! 972: int StringLen ; ! 973: PLINESTRUCT pLine; ! 974: int TimeToWriteFile ; ! 975: int iIndex ; ! 976: LPTSTR lpItem ; ! 977: ! 978: for (iIndex = 0 ; iIndex < 5 ; iIndex++) ! 979: { ! 980: // for iIndex == 0, get counter name ! 981: // for iIndex == 1, get instance name ! 982: // for iIndex == 2, get parent name ! 983: // for iIndex == 3, get object name ! 984: // for iIndex == 4, get computer name ! 985: if (iIndex == 4) ! 986: { ! 987: // the last label field, write date/time labels ! 988: strcpy (TempBuff, LineEndStr) ; ! 989: StringLen = strlen (TempBuff) ; ! 990: StringLoad (IDS_EXPORT_DATE, UnicodeBuff) ; ! 991: ConvertUnicodeStr (&TempBuff[StringLen], UnicodeBuff) ; ! 992: strcat (TempBuff, pDelimiter) ; ! 993: StringLen = strlen (TempBuff) ; ! 994: ! 995: StringLoad (IDS_EXPORT_TIME, UnicodeBuff) ; ! 996: ConvertUnicodeStr (&TempBuff[StringLen], UnicodeBuff) ; ! 997: strcat (TempBuff, pDelimiter) ; ! 998: StringLen = strlen (TempBuff) ; ! 999: } ! 1000: else ! 1001: { ! 1002: strcpy (TempBuff, LineEndStr) ; ! 1003: strcat (TempBuff, pDelimiter) ; ! 1004: strcat (TempBuff, pDelimiter) ; ! 1005: StringLen = strlen (TempBuff) ; ! 1006: } ! 1007: ! 1008: TimeToWriteFile = 0 ; ! 1009: ! 1010: for (pLine=pGraph->pLineFirst; pLine; pLine=pLine->pLineNext) ! 1011: { ! 1012: switch (iIndex) ! 1013: { ! 1014: case 0: ! 1015: lpItem = (LPTSTR) pLine->lnCounterName ; ! 1016: break ; ! 1017: ! 1018: case 1: ! 1019: lpItem = (LPTSTR) pLine->lnInstanceName ; ! 1020: break ; ! 1021: ! 1022: case 2: ! 1023: lpItem = (LPTSTR) pLine->lnPINName ; ! 1024: break ; ! 1025: ! 1026: case 3: ! 1027: lpItem = (LPTSTR) pLine->lnObjectName ; ! 1028: break ; ! 1029: ! 1030: case 4: ! 1031: lpItem = (LPTSTR) pLine->lnSystemName ; ! 1032: break ; ! 1033: } ! 1034: ! 1035: if (lpItem) ! 1036: { ! 1037: ConvertUnicodeStr (&TempBuff[StringLen], lpItem) ; ! 1038: } ! 1039: else ! 1040: { ! 1041: TempBuff[StringLen] = '\0' ; ! 1042: } ! 1043: strcat (TempBuff, pDelimiter); ! 1044: StringLen = strlen (TempBuff) ; ! 1045: ! 1046: if (++TimeToWriteFile > TIME_TO_WRITE) ! 1047: { ! 1048: // better write the buffers before they overflow. ! 1049: // there are better ways to check for overflow ! 1050: // but this is good enough ! 1051: ! 1052: if (!FileWrite (hFile, TempBuff, StringLen)) ! 1053: { ! 1054: goto Exit0 ; ! 1055: } ! 1056: StringLen = TimeToWriteFile = 0 ; ! 1057: } ! 1058: } // for each line ! 1059: ! 1060: if (StringLen) ! 1061: { ! 1062: // write the last block of data ! 1063: if (!FileWrite (hFile, TempBuff, StringLen)) ! 1064: { ! 1065: goto Exit0 ; ! 1066: } ! 1067: } ! 1068: } // for iIndex ! 1069: ! 1070: return (TRUE) ; ! 1071: ! 1072: Exit0: ! 1073: return (FALSE) ; ! 1074: ! 1075: } // ExportChartLabels ! 1076: ! 1077: BOOL ExportLogChart (HANDLE hFile, PGRAPHSTRUCT pGraph) ! 1078: { ! 1079: TCHAR UnicodeBuff [MiscTextLen] ; ! 1080: CHAR TempBuff [LongTextLen] ; ! 1081: int StringLen ; ! 1082: PLINESTRUCT pLine; ! 1083: int TimeToWriteFile ; ! 1084: FLOAT eValue ; ! 1085: int iLogTic ; ! 1086: BOOL bFirstTime = TRUE ; ! 1087: SYSTEMTIME LogSystemTime ; ! 1088: LOGPOSITION LogPosition ; ! 1089: ! 1090: iLogTic = PlaybackLog.StartIndexPos.iPosition ; ! 1091: ! 1092: // we have to export every point from the log file ! 1093: ! 1094: for ( ; iLogTic <= PlaybackLog.StopIndexPos.iPosition ; iLogTic++) ! 1095: { ! 1096: ! 1097: PlaybackLines (pGraphs->pSystemFirst, ! 1098: pGraphs->pLineFirst, ! 1099: iLogTic) ; ! 1100: ! 1101: if (!bFirstTime) ! 1102: { ! 1103: // export the values ! 1104: TimeToWriteFile = 0 ; ! 1105: ! 1106: ! 1107: if (!LogPositionN (iLogTic, &LogPosition)) ! 1108: { ! 1109: goto Exit0 ; ! 1110: } ! 1111: ! 1112: LogPositionSystemTime (&LogPosition, &LogSystemTime) ; ! 1113: ! 1114: strcpy (TempBuff, LineEndStr) ; ! 1115: StringLen = strlen (TempBuff) ; ! 1116: ! 1117: SystemTimeDateString (&LogSystemTime, UnicodeBuff) ; ! 1118: ConvertUnicodeStr (&TempBuff[StringLen], UnicodeBuff) ; ! 1119: strcat (TempBuff, pDelimiter) ; ! 1120: StringLen = strlen (TempBuff) ; ! 1121: ! 1122: SystemTimeTimeString (&LogSystemTime, UnicodeBuff) ; ! 1123: ConvertUnicodeStr (&TempBuff[StringLen], UnicodeBuff) ; ! 1124: strcat (TempBuff, pDelimiter) ; ! 1125: StringLen = strlen (TempBuff) ; ! 1126: ! 1127: for (pLine=pGraph->pLineFirst; pLine; pLine=pLine->pLineNext) ! 1128: { ! 1129: ! 1130: eValue = (*(pLine->valNext))(pLine) ; ! 1131: ! 1132: TSPRINTF (UnicodeBuff, ! 1133: eValue > (FLOAT)999999.0 ? ! 1134: szLargeValueFormat : szSmallValueFormat, ! 1135: eValue) ; ! 1136: ConvertUnicodeStr (&TempBuff[StringLen], UnicodeBuff) ; ! 1137: strcat (TempBuff, pDelimiter) ; ! 1138: StringLen = strlen (TempBuff) ; ! 1139: ! 1140: if (++TimeToWriteFile > TIME_TO_WRITE) ! 1141: { ! 1142: if (!FileWrite (hFile, TempBuff, StringLen)) ! 1143: { ! 1144: goto Exit0 ; ! 1145: } ! 1146: StringLen = TimeToWriteFile = 0 ; ! 1147: TempBuff[0] = '\0' ; ! 1148: } ! 1149: } ! 1150: ! 1151: if (StringLen) ! 1152: { ! 1153: if (!FileWrite (hFile, TempBuff, StringLen)) ! 1154: { ! 1155: goto Exit0 ; ! 1156: } ! 1157: } ! 1158: } ! 1159: else ! 1160: { ! 1161: // skip the first data point since we ! 1162: // need 2 points to form the first value ! 1163: bFirstTime = FALSE ; ! 1164: } ! 1165: } ! 1166: ! 1167: return (TRUE) ; ! 1168: ! 1169: Exit0: ! 1170: return (FALSE) ; ! 1171: ! 1172: } // ExportLogChart ! 1173: ! 1174: BOOL ExportLineValue (HANDLE hFile, PGRAPHSTRUCT pGraph, ! 1175: int CurrentIndex, int iDataPoint) ! 1176: { ! 1177: TCHAR UnicodeBuff [MiscTextLen] ; ! 1178: CHAR TempBuff [LongTextLen] ; ! 1179: int StringLen ; ! 1180: PLINESTRUCT pLine; ! 1181: int MaxValues ; ! 1182: int TimeToWriteFile ; ! 1183: SYSTEMTIME *pSystemTime ; ! 1184: BOOL ValidValue ; ! 1185: ! 1186: pSystemTime = pGraph->pDataTime ; ! 1187: pSystemTime += CurrentIndex ; ! 1188: ! 1189: if (pSystemTime->wYear == 0 && pSystemTime->wYear == 0) ! 1190: { ! 1191: // ignore value that has 0 system time ! 1192: return (TRUE) ; ! 1193: } ! 1194: ! 1195: MaxValues = pGraph->gMaxValues ; ! 1196: strcpy (TempBuff, LineEndStr) ; ! 1197: StringLen = strlen (TempBuff) ; ! 1198: ! 1199: SystemTimeDateString (pSystemTime, UnicodeBuff) ; ! 1200: ConvertUnicodeStr (&TempBuff[StringLen], UnicodeBuff) ; ! 1201: strcat (TempBuff, pDelimiter) ; ! 1202: StringLen = strlen (TempBuff) ; ! 1203: ! 1204: SystemTimeTimeString (pSystemTime, UnicodeBuff) ; ! 1205: ConvertUnicodeStr (&TempBuff[StringLen], UnicodeBuff) ; ! 1206: strcat (TempBuff, pDelimiter) ; ! 1207: StringLen = strlen (TempBuff) ; ! 1208: ! 1209: TimeToWriteFile = 0 ; ! 1210: for (pLine=pGraph->pLineFirst; pLine; pLine=pLine->pLineNext) ! 1211: { ! 1212: if (!pLine->bFirstTime) ! 1213: { ! 1214: ValidValue = FALSE ; ! 1215: // check if this is a valid value ! 1216: if (pLine->lnValidValues == MaxValues) ! 1217: { ! 1218: // this is the simple case where we have filled up ! 1219: // the whole buffer ! 1220: ValidValue = TRUE ; ! 1221: } ! 1222: else if (pLine->lnValidValues <= iDataPoint) ! 1223: { ! 1224: if (CurrentIndex <= iDataPoint && ! 1225: CurrentIndex > iDataPoint - pLine->lnValidValues) ! 1226: { ! 1227: ValidValue = TRUE ; ! 1228: } ! 1229: } ! 1230: else ! 1231: { ! 1232: if (CurrentIndex <= iDataPoint || ! 1233: CurrentIndex > (MaxValues - pLine->lnValidValues + iDataPoint)) ! 1234: { ! 1235: // this is the case when we start the new line in the middle ! 1236: // and data buffer has been wrap-around. ! 1237: ValidValue = TRUE ; ! 1238: } ! 1239: } ! 1240: ! 1241: // only export the data when we determine it is valid ! 1242: if (ValidValue) ! 1243: { ! 1244: TSPRINTF (UnicodeBuff, ! 1245: pLine->lnValues[CurrentIndex] > (FLOAT)999999.0 ? ! 1246: szLargeValueFormat : szSmallValueFormat, ! 1247: pLine->lnValues[CurrentIndex]) ; ! 1248: ConvertUnicodeStr (&TempBuff[StringLen], UnicodeBuff) ; ! 1249: } ! 1250: } ! 1251: strcat (TempBuff, pDelimiter) ; ! 1252: StringLen = strlen (TempBuff) ; ! 1253: ! 1254: if (++TimeToWriteFile > TIME_TO_WRITE) ! 1255: { ! 1256: // better write the buffers before they overflow. ! 1257: // there are better ways to check for overflow ! 1258: // but this is good enough ! 1259: ! 1260: if (!FileWrite (hFile, TempBuff, StringLen)) ! 1261: { ! 1262: goto Exit0 ; ! 1263: } ! 1264: StringLen = TimeToWriteFile = 0 ; ! 1265: TempBuff[0] = '\0' ; ! 1266: } ! 1267: } ! 1268: ! 1269: if (StringLen) ! 1270: { ! 1271: // write the last block of data ! 1272: if (!FileWrite (hFile, TempBuff, StringLen)) ! 1273: { ! 1274: goto Exit0 ; ! 1275: } ! 1276: } ! 1277: ! 1278: return (TRUE) ; ! 1279: ! 1280: Exit0: ! 1281: return (FALSE) ; ! 1282: ! 1283: } // ExportLineValue ! 1284: ! 1285: BOOL ExportCurrentChart (HANDLE hFile, PGRAPHSTRUCT pGraph) ! 1286: { ! 1287: int KnownValue, ! 1288: MaxValues, ! 1289: iValidValues, ! 1290: iDataPoint ; ! 1291: BOOL SimpleCase = FALSE ; ! 1292: int iIndex ; ! 1293: ! 1294: MaxValues = pGraph->gMaxValues ; ! 1295: KnownValue = pGraph->gKnownValue ; ! 1296: iValidValues = pGraph->gTimeLine.iValidValues ; ! 1297: ! 1298: if (iValidValues < MaxValues) ! 1299: { ! 1300: // data have not wrapped around, so the oldest time ! 1301: // is started at 0. ! 1302: SimpleCase = TRUE ; ! 1303: iValidValues = (KnownValue % MaxValues) + 1 ; ! 1304: } ! 1305: ! 1306: iDataPoint = KnownValue % MaxValues ; ! 1307: ! 1308: if (!SimpleCase) ! 1309: { ! 1310: for (iIndex = iDataPoint+1 ; iIndex < MaxValues ; iIndex++) ! 1311: { ! 1312: if (!ExportLineValue (hFile, pGraph, iIndex, iDataPoint)) ! 1313: { ! 1314: goto Exit0 ; ! 1315: } ! 1316: } ! 1317: } ! 1318: ! 1319: for (iIndex = 0 ; iIndex <= iDataPoint ; iIndex++) ! 1320: { ! 1321: if (!ExportLineValue (hFile, pGraph, iIndex, iDataPoint)) ! 1322: { ! 1323: goto Exit0 ; ! 1324: } ! 1325: } ! 1326: ! 1327: return (TRUE) ; ! 1328: ! 1329: Exit0: ! 1330: return (FALSE) ; ! 1331: ! 1332: } // ExportCurrentChart ! 1333: ! 1334: ! 1335: void ExportChart (void) ! 1336: { ! 1337: ! 1338: PGRAPHSTRUCT pGraph ; ! 1339: HANDLE hFile = 0 ; ! 1340: LPTSTR pFileName = NULL ; ! 1341: INT ErrCode = 0 ; ! 1342: ! 1343: if (!(pGraph = pGraphs)) ! 1344: { ! 1345: return ; ! 1346: } ! 1347: ! 1348: // see if there is anything to export.. ! 1349: if (!(pGraph->pLineFirst)) ! 1350: { ! 1351: return ; ! 1352: } ! 1353: ! 1354: SetHourglassCursor() ; ! 1355: ! 1356: if (ErrCode = ExportFileOpen (hWndGraph, &hFile, pGraph->gInterval, &pFileName)) ! 1357: { ! 1358: goto Exit0 ; ! 1359: } ! 1360: ! 1361: if (!pFileName) ! 1362: { ! 1363: // this is the case when user cancel. ! 1364: goto Exit0 ; ! 1365: } ! 1366: ! 1367: // export the column labels ! 1368: if (!ExportChartLabels (hFile, pGraph)) ! 1369: { ! 1370: ! 1371: ErrCode = ERR_EXPORT_FILE ; ! 1372: goto Exit0 ; ! 1373: } ! 1374: ! 1375: // export the lines ! 1376: if (PlayingBackLog()) ! 1377: { ! 1378: if (!ExportLogChart (hFile, pGraph)) ! 1379: { ! 1380: ErrCode = ERR_EXPORT_FILE ; ! 1381: goto Exit0 ; ! 1382: } ! 1383: } ! 1384: else ! 1385: { ! 1386: if (!ExportCurrentChart (hFile, pGraph)) ! 1387: { ! 1388: ErrCode = ERR_EXPORT_FILE ; ! 1389: goto Exit0 ; ! 1390: } ! 1391: } ! 1392: Exit0: ! 1393: ! 1394: SetArrowCursor() ; ! 1395: ! 1396: if (hFile) ! 1397: { ! 1398: CloseHandle (hFile) ; ! 1399: } ! 1400: ! 1401: if (pFileName) ! 1402: { ! 1403: if (ErrCode) ! 1404: { ! 1405: DlgErrorBox (hWndGraph, ErrCode, pFileName) ; ! 1406: } ! 1407: ! 1408: MemoryFree (pFileName) ; ! 1409: } ! 1410: ! 1411: } // ExportChart ! 1412: ! 1413: ! 1414: typedef struct CHARTDATAPOINTSTRUCT ! 1415: { ! 1416: int iLogIndex ; ! 1417: int xDispDataPoint ; ! 1418: } CHARTDATAPOINT, *PCHARTDATAPOINT ; ! 1419: ! 1420: void PlaybackChartDataPoint (PCHARTDATAPOINT pChartDataPoint) ! 1421: { // PlaybackChartDataPoint ! 1422: int iDisplayTics ; // num visual points to display ! 1423: int iDisplayTic ; ! 1424: int iLogTic ; ! 1425: int iLogTicsMove ; ! 1426: BOOL bFirstTime = TRUE; ! 1427: int iLogTicsRemaining ; ! 1428: int numOfData, xDispDataPoint, rectWidth, xPos ; ! 1429: PGRAPHSTRUCT pGraph ; ! 1430: ! 1431: pGraph = GraphData (hWndGraph) ; ! 1432: ! 1433: iLogTicsRemaining = PlaybackLog.iSelectedTics ; ! 1434: ! 1435: ! 1436: // we only have iDisplayTics-1 points since ! 1437: // we have to use the first two sample points to ! 1438: // get the first data points. ! 1439: if (iLogTicsRemaining <= pGraphs->gMaxValues) ! 1440: { ! 1441: iDisplayTics = iLogTicsRemaining ; ! 1442: } ! 1443: else ! 1444: { ! 1445: iDisplayTics = pGraphs->gMaxValues ; ! 1446: } ! 1447: ! 1448: iDisplayTic = -1 ; ! 1449: iLogTic = PlaybackLog.StartIndexPos.iPosition ; ! 1450: ! 1451: numOfData = pGraph->gMaxValues - 1 ; ! 1452: rectWidth = pGraph->rectData.right - pGraph->rectData.left ; ! 1453: xDispDataPoint = pGraph->rectData.left ; ! 1454: ! 1455: while (iDisplayTics && numOfData) ! 1456: { ! 1457: ! 1458: if (!bFirstTime) ! 1459: { ! 1460: iDisplayTic++ ; ! 1461: } ! 1462: else ! 1463: { ! 1464: bFirstTime = FALSE ; ! 1465: ! 1466: // get the second sample data to form the first data point ! 1467: iLogTic++ ; ! 1468: iLogTicsRemaining-- ; ! 1469: ! 1470: iDisplayTic++ ; ! 1471: } ! 1472: ! 1473: pChartDataPoint[iDisplayTic].iLogIndex = iLogTic ; ! 1474: pChartDataPoint[iDisplayTic].xDispDataPoint = xDispDataPoint ; ! 1475: ! 1476: // setup DDA to get the index of the next sample point ! 1477: iLogTicsMove = DDA_DISTRIBUTE (iLogTicsRemaining, iDisplayTics) ; ! 1478: iLogTicsRemaining -= iLogTicsMove ; ! 1479: iLogTic += iLogTicsMove ; ! 1480: ! 1481: ! 1482: xPos = DDA_DISTRIBUTE (rectWidth, numOfData) ; ! 1483: xDispDataPoint += xPos ; ! 1484: numOfData-- ; ! 1485: rectWidth -= xPos ; ! 1486: ! 1487: iDisplayTics-- ; ! 1488: ! 1489: } // while ! 1490: ! 1491: } // PlaybackChartDataPoint ! 1492: ! 1493: ! 1494: BOOL ! 1495: BuildNewValueListForGraph ( ! 1496: ) ! 1497: { ! 1498: PGRAPHSTRUCT pGraph; ! 1499: ! 1500: pGraph = pGraphs; // set local pointer to global pointer ! 1501: ! 1502: return BuildValueListForSystems ( ! 1503: pGraphs->pSystemFirst, ! 1504: pGraphs->pLineFirst); ! 1505: ! 1506: } ! 1507:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.