![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to report.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 report.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / perfmon |
1.1 root 1: #include "perfmon.h"
2: #include <stdio.h> // for sprintf
3: #include <string.h> // for strncpy
4: #include "report.h" // Exported declarations for this file
5:
6: #include "addline.h" // for AddLine, EditLine
7: #include "perferr.h" // for PostError
8: #include "fileutil.h" // for FileHandleCreate
9: #include "line.h" // for LineAppend
10: #include "pmemory.h" // for MemoryXXX (mallloc-type) routines
11: #include "perfdata.h" // for UpdateLines
12: #include "perfmops.h" // for DoWindowDrag
13: #include "playback.h" // for PlaybackLines, PlayingBackLog
14: #include "print.h" // for PrintDC
15: #include "system.h" // for SystemGet
16: #include "utils.h"
17: #include "menuids.h" // for IDM_VIEWREPORT
18: #include "fileopen.h" // for FileGetName
19:
20:
21: //==========================================================================//
22: // Local Data //
23: //==========================================================================//
24:
25: TCHAR szSystemFormat [ResourceStringLen] ;
26: TCHAR szObjectFormat [ResourceStringLen] ;
27:
28:
29:
30:
31:
32: //==========================================================================//
33: // Constants //
34: //==========================================================================//
35:
36:
37: #define xSystemMargin (xScrollWidth)
38: #define xObjectMargin (2 * xScrollWidth)
39: #define xCounterMargin (3 * xScrollWidth)
40: #define xColumnMargin (xScrollWidth)
41:
42: #define RightHandMargin xObjectMargin
43: #define ValueMargin(pReport) \
44: (4 * xScrollWidth + pReport->xMaxCounterWidth)
45:
46:
47: //=============================//
48: // Report Class //
49: //=============================//
50:
51:
52: TCHAR szReportWindowClass[] = TEXT("PerfmonReportClass") ;
53: #define dwReportClassStyle (CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS)
54: #define iReportClassExtra (0)
55: #define iReportWindowExtra (0)
56: #define dwReportWindowStyle (WS_CHILD | WS_VSCROLL | WS_HSCROLL)
57:
58:
59: #define szValuePlaceholder TEXT("-999999999.999")
60: #define szLargeValueFormat TEXT("%12.0f")
61: #define eStatusLargeValueMax ((FLOAT) 999999999.0)
62: #define szValueFormat TEXT("%12.3f")
63:
64:
65: //==========================================================================//
66: // Local Functions //
67: //==========================================================================//
68:
69:
70: PREPORT AllocateReportData (HWND hWndReport)
71: {
72: PREPORT pReport ;
73:
74: pReport = ReportData (hWndReport) ;
75:
76: pReport->hWnd = hWndReport ;
77: pReport->iStatus = iPMStatusClosed ;
78: pReport->bManualRefresh = FALSE ;
79: pReport->bModified = FALSE ;
80:
81: pReport->Visual.iColorIndex = 0 ;
82: pReport->Visual.iWidthIndex = -1 ;
83: pReport->Visual.iStyleIndex = -1 ;
84:
85: pReport->iIntervalMSecs = iDefaultReportIntervalSecs * 1000 ;
86: pReport->pSystemFirst = NULL ;
87: pReport->pLineFirst = NULL ;
88:
89: pReport->pLineCurrent = NULL ;
90:
91: return (pReport) ;
92: } // AllocateReportData
93:
94:
95: void FreeReportData (PREPORT pReport)
96: { // FreeReportData
97: } // FreeReportData
98:
99:
100:
101: BOOL LineCounterRemove (PPLINE ppLineFirst,
102: PLINE pLineRemove)
103: {
104: PLINE pLine ;
105:
106: if (*ppLineFirst == pLineRemove)
107: {
108: *ppLineFirst = (*ppLineFirst)->pLineCounterNext ;
109: return (TRUE) ;
110: }
111:
112: for (pLine = *ppLineFirst ;
113: pLine->pLineCounterNext ;
114: pLine = pLine->pLineCounterNext)
115: { // for
116: if (pLine->pLineCounterNext == pLineRemove)
117: {
118: pLine->pLineCounterNext = pLineRemove->pLineCounterNext ;
119: return (TRUE) ;
120: } // if
121: } // for
122:
123: return (FALSE) ;
124: } // LineCounterRemove
125:
126:
127: //======================================//
128: // Column Group routines //
129: //======================================//
130:
131:
132: BOOL ColumnSame (PCOLUMNGROUP pColumnGroup,
133: LPTSTR lpszParentName,
134: LPTSTR lpszInstanceName)
135: { // ColumnSame
136: BOOL bParentSame ;
137: BOOL bInstanceSame ;
138:
139: bParentSame = (!lpszParentName && !pColumnGroup->lpszParentName) ||
140: strsame (lpszParentName, pColumnGroup->lpszParentName) ;
141: bInstanceSame = (!lpszInstanceName && !pColumnGroup->lpszInstanceName) ||
142: strsame (lpszInstanceName, pColumnGroup->lpszInstanceName) ;
143:
144: return (bParentSame && bInstanceSame) ;
145: } // ColumnSame
146:
147:
148: PCOLUMNGROUP ColumnGroupCreate (PREPORT pReport,
149: int xPos,
150: LPTSTR lpszParentName,
151: LPTSTR lpszInstanceName,
152: int PreviousColumnNumber)
153: { // ColumnGroupCreate
154: PCOLUMNGROUP pColumnGroup ;
155: HDC hDC ;
156:
157: hDC = GetDC (pReport->hWnd) ;
158: pColumnGroup = MemoryAllocate (sizeof (COLUMNGROUP)) ;
159:
160: if (pColumnGroup)
161: {
162: pColumnGroup->pColumnGroupNext = NULL ;
163: pColumnGroup->lpszParentName = StringAllocate (lpszParentName) ;
164: pColumnGroup->lpszInstanceName = StringAllocate (lpszInstanceName) ;
165: pColumnGroup->ParentNameTextWidth = TextWidth (hDC, lpszParentName) ;
166: pColumnGroup->InstanceNameTextWidth = TextWidth (hDC, lpszInstanceName) ;
167: pColumnGroup->xPos = xPos ;
168: pColumnGroup->ColumnNumber = PreviousColumnNumber + 1 ;
169: pColumnGroup->xWidth = max (max (pColumnGroup->ParentNameTextWidth,
170: pColumnGroup->InstanceNameTextWidth),
171: pReport->xValueWidth) ;
172:
173: pReport->xWidth = max (pReport->xWidth,
174: RightHandMargin +
175: ValueMargin (pReport) +
176: pColumnGroup->xPos + pColumnGroup->xWidth +
177: xColumnMargin) ;
178: } // if
179:
180: ReleaseDC (pReport->hWnd, hDC) ;
181: return (pColumnGroup) ;
182: } // ColumnGroupCreate
183:
184:
185:
186: PCOLUMNGROUP ColumnGroup (PREPORT pReport,
187: POBJECTGROUP pObjectGroup,
188: PLINE pLine)
189: /*
190: Effect: Return a pointer to the appropriate column group from
191: within the groups of pObject. If the line is a counter
192: without instances, return NULL. Otherwise, determine
193: if the counter's parent/instance pair is already found
194: in an existing column and return a pointer to that column.
195:
196: If a column with the appropriate parent/instance isn't
197: found, add a new column *at the end*, and return that
198: column.
199:
200: Note: This function has multiple return points.
201: */
202: { // ColumnGroup
203: PCOLUMNGROUP pColumnGroup ;
204: LPTSTR lpszParentName ;
205: LPTSTR lpszInstanceName ;
206:
207:
208: if (!LineInstanceName (pLine))
209: return (NULL) ;
210:
211:
212: lpszParentName = LineParentName (pLine) ;
213: lpszInstanceName = LineInstanceName (pLine) ;
214:
215: if (!pObjectGroup->pColumnGroupFirst)
216: {
217: pObjectGroup->pColumnGroupFirst =
218: ColumnGroupCreate (pReport, 0, lpszParentName, lpszInstanceName, -1) ;
219: return (pObjectGroup->pColumnGroupFirst) ;
220: }
221:
222: for (pColumnGroup = pObjectGroup->pColumnGroupFirst ;
223: pColumnGroup ;
224: pColumnGroup = pColumnGroup->pColumnGroupNext)
225: { // for
226: if (ColumnSame (pColumnGroup, lpszParentName, lpszInstanceName))
227: return (pColumnGroup) ;
228:
229: else if (!pColumnGroup->pColumnGroupNext)
230: { // if
231: pColumnGroup->pColumnGroupNext =
232: ColumnGroupCreate (pReport,
233: pColumnGroup->xPos + pColumnGroup->xWidth +
234: xColumnMargin,
235: lpszParentName,
236: lpszInstanceName,
237: pColumnGroup->ColumnNumber) ;
238: return (pColumnGroup->pColumnGroupNext) ;
239: } // if
240: } // for
241:
242: return (NULL) ;
243: } // ColumnGroup
244:
245:
246:
247: //======================================//
248: // Counter Group routines //
249: //======================================//
250:
251:
252: PCOUNTERGROUP CounterGroupCreate (DWORD dwCounterIndex)
253: { // CounterGroupCreate
254: PCOUNTERGROUP pCounterGroup ;
255:
256: pCounterGroup = MemoryAllocate (sizeof (COUNTERGROUP)) ;
257:
258: if (pCounterGroup)
259: {
260: pCounterGroup->pCounterGroupNext = NULL ;
261: pCounterGroup->pLineFirst = NULL ;
262: pCounterGroup->dwCounterIndex = dwCounterIndex ;
263: } // if
264:
265: return (pCounterGroup) ;
266: } // CounterGroupCreate
267:
268:
269: PCOUNTERGROUP CounterGroup (POBJECTGROUP pObjectGroup,
270: DWORD dwCounterIndex,
271: BOOL *pbCounterGroupCreated)
272: { // CounterGroup
273: PCOUNTERGROUP pCounterGroup ;
274:
275: *pbCounterGroupCreated = FALSE ;
276: if (!pObjectGroup)
277: return (FALSE) ;
278:
279: if (!pObjectGroup->pCounterGroupFirst)
280: {
281: pObjectGroup->pCounterGroupFirst = CounterGroupCreate (dwCounterIndex) ;
282: *pbCounterGroupCreated = TRUE ;
283: return (pObjectGroup->pCounterGroupFirst) ;
284: }
285:
286: for (pCounterGroup = pObjectGroup->pCounterGroupFirst ;
287: pCounterGroup ;
288: pCounterGroup = pCounterGroup->pCounterGroupNext)
289: { // for
290: if (pCounterGroup->dwCounterIndex == dwCounterIndex)
291: return (pCounterGroup) ;
292: else if (!pCounterGroup->pCounterGroupNext)
293: { // if
294: pCounterGroup->pCounterGroupNext =
295: CounterGroupCreate (dwCounterIndex) ;
296: *pbCounterGroupCreated = TRUE ;
297: return (pCounterGroup->pCounterGroupNext) ;
298: } // if
299: } // for
300:
301: return (NULL) ;
302: } // CounterGroup
303:
304:
305: //======================================//
306: // Object Group routines //
307: //======================================//
308:
309:
310: POBJECTGROUP ObjectGroupCreate (LPTSTR lpszObjectName)
311: { // ObjectGroupCreate
312: POBJECTGROUP pObjectGroup ;
313: HDC hDC ;
314: PREPORT pReport ;
315: int OldCounterWidth ;
316:
317: pObjectGroup = MemoryAllocate (sizeof (OBJECTGROUP)) ;
318:
319: if (pObjectGroup)
320: {
321: pObjectGroup->pObjectGroupNext = NULL ;
322: pObjectGroup->pCounterGroupFirst = NULL ;
323: pObjectGroup->pColumnGroupFirst = NULL ;
324: pObjectGroup->lpszObjectName = StringAllocate (lpszObjectName) ;
325:
326: hDC = GetDC (hWndReport) ;
327: pReport = ReportData (hWndReport) ;
328: SelectFont (hDC, pReport->hFontHeaders) ;
329:
330: // re-calc. the max. counter group width
331: OldCounterWidth = pReport->xMaxCounterWidth ;
332: pReport->xMaxCounterWidth =
333: max (pReport->xMaxCounterWidth,
334: TextWidth (hDC, lpszObjectName) + xObjectMargin) ;
335:
336: if (OldCounterWidth < pReport->xMaxCounterWidth)
337: {
338: // adjust the report width with the new counter width
339: pReport->xWidth +=
340: (pReport->xMaxCounterWidth - OldCounterWidth);
341: }
342:
343: ReleaseDC (hWndReport, hDC) ;
344: } // if
345: return (pObjectGroup) ;
346: } // ObjectGroupCreate
347:
348:
349: POBJECTGROUP ObjectGroup (PSYSTEMGROUP pSystemGroup,
350: LPTSTR lpszObjectName)
351: {
352: POBJECTGROUP pObjectGroup ;
353:
354: if (!pSystemGroup)
355: return (FALSE) ;
356:
357: if (!pSystemGroup->pObjectGroupFirst)
358: {
359: pSystemGroup->pObjectGroupFirst = ObjectGroupCreate (lpszObjectName) ;
360: return (pSystemGroup->pObjectGroupFirst) ;
361: }
362:
363: for (pObjectGroup = pSystemGroup->pObjectGroupFirst ;
364: pObjectGroup ;
365: pObjectGroup = pObjectGroup->pObjectGroupNext)
366: { // for
367: if (strsame (pObjectGroup->lpszObjectName, lpszObjectName))
368: {
369: return (pObjectGroup) ;
370: }
371: else if (!pObjectGroup->pObjectGroupNext)
372: { // if
373: pObjectGroup->pObjectGroupNext =
374: ObjectGroupCreate (lpszObjectName) ;
375: return (pObjectGroup->pObjectGroupNext) ;
376: } // if
377: } // for
378:
379: } // ObjectGroup
380:
381:
382: //======================================//
383: // System Group routines //
384: //======================================//
385:
386:
387: PSYSTEMGROUP SystemGroupCreate (LPTSTR lpszSystemName)
388: { // SystemGroupCreate
389: PSYSTEMGROUP pSystemGroup ;
390:
391: pSystemGroup = MemoryAllocate (sizeof (SYSTEMGROUP)) ;
392:
393: if (pSystemGroup)
394: {
395: pSystemGroup->pSystemGroupNext = NULL ;
396: pSystemGroup->pObjectGroupFirst = NULL ;
397: pSystemGroup->lpszSystemName = StringAllocate (lpszSystemName) ;
398: } // if
399:
400: return (pSystemGroup) ;
401: } // SystemGroupCreate
402:
403:
404: PSYSTEMGROUP SystemGroup (PREPORT pReport,
405: LPTSTR lpszSystemName)
406: /*
407: Effect; Return a pointer to the system group of pReport with
408: a system name of lpszSystemName. If no system group
409: has that name, add a new system group.
410: */
411: { // SystemGroup
412: PSYSTEMGROUP pSystemGroup ;
413:
414: if (!pReport->pSystemGroupFirst)
415: {
416: pReport->pSystemGroupFirst = SystemGroupCreate (lpszSystemName) ;
417: return (pReport->pSystemGroupFirst) ;
418: }
419:
420: for (pSystemGroup = pReport->pSystemGroupFirst ;
421: pSystemGroup ;
422: pSystemGroup = pSystemGroup->pSystemGroupNext)
423: { // for
424: if (strsamei (pSystemGroup->lpszSystemName, lpszSystemName))
425: return (pSystemGroup) ;
426: else if (!pSystemGroup->pSystemGroupNext)
427: { // if
428: pSystemGroup->pSystemGroupNext =
429: SystemGroupCreate (lpszSystemName) ;
430: return (pSystemGroup->pSystemGroupNext) ;
431: } // if
432: } // for
433: } // SystemGroup
434:
435:
436:
437: void DrawCounter (HDC hDC, PREPORT pReport,
438: PCOUNTERGROUP pCounterGroup)
439: { // DrawCounter
440:
441:
442: if (!pCounterGroup->pLineFirst)
443: return ;
444:
445: SelectFont (hDC, pReport->hFont) ;
446: TextOut (hDC, xCounterMargin, pCounterGroup->yLine,
447: pCounterGroup->pLineFirst->lnCounterName,
448: lstrlen (pCounterGroup->pLineFirst->lnCounterName)) ;
449: } // DrawCounter
450:
451:
452: void DrawObject (HDC hDC, PREPORT pReport,
453: POBJECTGROUP pObjectGroup)
454: { // DrawObject
455: TCHAR szLine [LongTextLen] ;
456: PCOUNTERGROUP pCounterGroup ;
457: PCOLUMNGROUP pColumnGroup ;
458:
459: if (!pObjectGroup->pCounterGroupFirst)
460: {
461: return ;
462: }
463:
464: SelectFont (hDC, pReport->hFontHeaders) ;
465:
466: SetTextAlign (hDC, TA_RIGHT) ;
467:
468: for (pColumnGroup = pObjectGroup->pColumnGroupFirst ;
469: pColumnGroup ;
470: pColumnGroup = pColumnGroup->pColumnGroupNext)
471: { // for
472: // Draw Parent
473: if (pColumnGroup->lpszParentName)
474: TextOut (hDC,
475: ValueMargin (pReport) +
476: pColumnGroup->xPos + pColumnGroup->xWidth,
477: pObjectGroup->yFirstLine - pReport->yLineHeight,
478: pColumnGroup->lpszParentName,
479: lstrlen (pColumnGroup->lpszParentName)) ;
480:
481: // Draw Instance
482: if (pColumnGroup->lpszInstanceName)
483: TextOut (hDC,
484: ValueMargin (pReport) +
485: pColumnGroup->xPos + pColumnGroup->xWidth,
486: pObjectGroup->yFirstLine,
487: pColumnGroup->lpszInstanceName,
488: lstrlen (pColumnGroup->lpszInstanceName)) ;
489: } // for
490: SetTextAlign (hDC, TA_LEFT) ;
491:
492: TSPRINTF (szLine, szObjectFormat, pObjectGroup->lpszObjectName) ;
493: TextOut (hDC,
494: xObjectMargin, pObjectGroup->yFirstLine,
495: szLine, lstrlen (szLine)) ;
496:
497: SelectFont (hDC, pReport->hFont) ;
498:
499: for (pCounterGroup = pObjectGroup->pCounterGroupFirst ;
500: pCounterGroup ;
501: pCounterGroup = pCounterGroup->pCounterGroupNext)
502: { // for
503: DrawCounter (hDC, pReport, pCounterGroup) ;
504: } // for
505:
506: } // DrawObject
507:
508:
509: void DrawSystem (HDC hDC, PREPORT pReport, PSYSTEMGROUP pSystemGroup)
510: { // DrawSystem
511: TCHAR szLine [LongTextLen] ;
512: POBJECTGROUP pObjectGroup ;
513:
514: SelectFont (hDC, pReport->hFontHeaders) ;
515:
516: if (!pSystemGroup->pObjectGroupFirst)
517: return ;
518:
519: SetTextAlign (hDC, TA_LEFT) ;
520: TSPRINTF (szLine, szSystemFormat, pSystemGroup->lpszSystemName) ;
521: TextOut (hDC,
522: xSystemMargin, pSystemGroup->yFirstLine,
523: szLine, lstrlen (szLine)) ;
524:
525: for (pObjectGroup = pSystemGroup->pObjectGroupFirst ;
526: pObjectGroup ;
527: pObjectGroup = pObjectGroup->pObjectGroupNext)
528: { // for
529: DrawObject (hDC, pReport, pObjectGroup) ;
530: } // for
531: } // DrawSystem
532:
533:
534: void ReportValueRect (PREPORT pReport,
535: PLINE pLine,
536: LPRECT lpRect)
537: { // ReportValueRect
538: lpRect->left = ValueMargin (pReport) + pLine->xReportPos ;
539: lpRect->top = pLine->yReportPos ;
540: lpRect->right = lpRect->left + pReport->xValueWidth ;
541: lpRect->bottom = lpRect->top + pReport->yLineHeight ;
542: } // ReportValueRect
543:
544:
545: void DrawReportValue (HDC hDC, PREPORT pReport, PLINE pLine)
546: { // DrawReportValue
547: TCHAR szValue [20] ;
548: FLOAT eValue ;
549: RECT rectValue ;
550:
551: // skip until we have collect enough samples for the first data
552: if (pLine->bFirstTime == 0)
553: {
554: eValue = (*(pLine->valNext)) (pLine) ;
555: TSPRINTF (szValue,
556: (eValue > eStatusLargeValueMax) ?
557: szLargeValueFormat : szValueFormat,
558: eValue) ;
559: }
560: else
561: {
562: // draw "- - - -"
563: lstrcpy(szValue, TEXT("- - - -"));
564: }
565:
566: ReportValueRect (pReport, pLine, &rectValue) ;
567:
568: ExtTextOut (hDC,
569: rectValue.right - 2, rectValue.top,
570: ETO_CLIPPED | ETO_OPAQUE,
571: &rectValue,
572: szValue, lstrlen (szValue), NULL) ;
573:
574: if (pLine == pReport->pLineCurrent)
575: {
576: DrawFocusRect (hDC, &rectValue) ;
577: }
578: } // DrawReportValue
579:
580:
581: void DrawReportValues (HDC hDC, PREPORT pReport)
582: {
583: PSYSTEMGROUP pSystemGroup ;
584: POBJECTGROUP pObjectGroup ;
585: PCOUNTERGROUP pCounterGroup ;
586: PLINE pLine ;
587:
588: SelectFont (hDC, pReport->hFont) ;
589: SetTextAlign (hDC, TA_RIGHT) ;
590:
591: for (pSystemGroup = pReport->pSystemGroupFirst ;
592: pSystemGroup ;
593: pSystemGroup = pSystemGroup->pSystemGroupNext)
594: { // for System...
595: for (pObjectGroup = pSystemGroup->pObjectGroupFirst ;
596: pObjectGroup ;
597: pObjectGroup = pObjectGroup->pObjectGroupNext)
598: { // for Object...
599: for (pCounterGroup = pObjectGroup->pCounterGroupFirst ;
600: pCounterGroup ;
601: pCounterGroup = pCounterGroup->pCounterGroupNext)
602: { // for Counter...
603: for (pLine = pCounterGroup->pLineFirst ;
604: pLine ;
605: pLine = pLine->pLineCounterNext)
606: { // for Line...
607: DrawReportValue (hDC, pReport, pLine) ;
608: } // for Line...
609: } // for Counter...
610: } // for Object
611: } // for System...
612:
613: }
614:
615:
616: void DrawReportHeaders (HDC hDC, PREPORT pReport)
617: { // DrawReportHeaders
618: PSYSTEMGROUP pSystemGroup ;
619:
620: for (pSystemGroup = pReport->pSystemGroupFirst ;
621: pSystemGroup ;
622: pSystemGroup = pSystemGroup->pSystemGroupNext)
623: { // for
624: DrawSystem (hDC, pReport, pSystemGroup) ;
625: } // for
626: } // DrawReportHeaders
627:
628:
629: void DrawReport (HDC hDC, PREPORT pReport)
630: {
631: SetBkColor (hDC, GetSysColor(COLOR_WINDOW)) ;
632: DrawReportHeaders (hDC, pReport) ;
633: //UpdateLines (&(pReport->pSystemFirst), pReport->pLineFirst) ;
634: DrawReportValues (hDC, pReport) ;
635: }
636:
637:
638:
639: void SetLinePosition (HDC hDC,
640: PREPORT pReport,
641: POBJECTGROUP pObjectGroup,
642: PLINE pLine)
643: { // SetLinePositions
644: PCOLUMNGROUP pColumnGroup ;
645:
646:
647: pColumnGroup = ColumnGroup (pReport, pObjectGroup, pLine) ;
648: if (!pColumnGroup)
649: {
650: pLine->xReportPos = 0 ;
651: pLine->iScaleIndex = -1 ;
652: }
653: else
654: {
655: pLine->xReportPos = pColumnGroup->xPos ;
656: pLine->iScaleIndex = pColumnGroup->ColumnNumber ;
657: }
658: } // SetLinePosition
659:
660:
661: void SetCounterPositions (HDC hDC,
662: PREPORT pReport,
663: POBJECTGROUP pObjectGroup,
664: PCOUNTERGROUP pCounterGroup,
665: int yLine)
666: { // SetCounterPositions
667: PLINE pLine ;
668: int yPos ;
669:
670:
671: if (!pCounterGroup->pLineFirst)
672: return ;
673:
674: yPos = pCounterGroup->yLine ;
675:
676: SelectFont (hDC, pReport->hFontHeaders) ;
677:
678: for (pLine = pCounterGroup->pLineFirst ;
679: pLine ;
680: pLine = pLine->pLineCounterNext)
681: { // for
682: SetLinePosition (hDC, pReport, pObjectGroup, pLine) ;
683: pLine->yReportPos = yPos ;
684: } // for
685: } // SetCounterPositions
686:
687:
688: void SetColumnPositions (HDC hDC,
689: PREPORT pReport,
690: POBJECTGROUP pObjectGroup)
691: { // SetColumnPositions
692: int xPos ;
693: PCOLUMNGROUP pColumnGroup ;
694:
695: xPos = 0 ;
696: for (pColumnGroup = pObjectGroup->pColumnGroupFirst ;
697: pColumnGroup ;
698: pColumnGroup = pColumnGroup->pColumnGroupNext)
699: { // for
700: pColumnGroup->xWidth = max (max (pColumnGroup->ParentNameTextWidth,
701: pColumnGroup->InstanceNameTextWidth),
702: pReport->xValueWidth) ;
703: pColumnGroup->xPos = xPos ;
704: xPos += (pColumnGroup->xWidth + xColumnMargin) ;
705: } // for
706: } // SetColumnPositions
707:
708:
709: void SetObjectPositions (HDC hDC,
710: PREPORT pReport,
711: POBJECTGROUP pObjectGroup,
712: int yLine)
713: /*
714: Effect: Determine and set the logical coordinates for the
715: object pObject within the report pReport.
716:
717: For each instance x counter, determine the appropriate
718: column, adding a column description to the object if
719: needed.
720:
721: Called By: SetSystemPositions only.
722:
723: See Also: SetSystemPositions, SetCounterPositions, ColumnGroup.
724: */
725: { // SetObjectPositions
726: PCOUNTERGROUP pCounterGroup ;
727: int yPos ;
728:
729: yPos = pObjectGroup->yFirstLine + yLine ;
730:
731: SetColumnPositions (hDC, pReport, pObjectGroup) ;
732:
733: for (pCounterGroup = pObjectGroup->pCounterGroupFirst ;
734: pCounterGroup ;
735: pCounterGroup = pCounterGroup->pCounterGroupNext)
736: { // for
737: pCounterGroup->yLine = yPos + yLine ;
738:
739: SetCounterPositions (hDC, pReport, pObjectGroup, pCounterGroup, yLine) ;
740:
741: yPos = pCounterGroup->yLine ;
742: } // for
743:
744: pObjectGroup->yLastLine = yPos + yLine ;
745: } // SetObjectPositions
746:
747:
748: void SetSystemPositions (HDC hDC,
749: PREPORT pReport,
750: PSYSTEMGROUP pSystemGroup,
751: int yLine)
752: { // SetSystemPositions
753: POBJECTGROUP pObjectGroup ;
754: int yPos ;
755:
756: yPos = pSystemGroup->yFirstLine ;
757:
758: for (pObjectGroup = pSystemGroup->pObjectGroupFirst ;
759: pObjectGroup ;
760: pObjectGroup = pObjectGroup->pObjectGroupNext)
761: { // for
762: pObjectGroup->yFirstLine = yPos + yLine ;
763:
764: SetObjectPositions (hDC, pReport, pObjectGroup, yLine) ;
765:
766: yPos = pObjectGroup->yLastLine ;
767: } // for
768:
769: pSystemGroup->yLastLine = yPos + yLine ;
770: } // SetSystemPositions
771:
772:
773: void static SetScrollRanges (HWND hWnd)
774: { // SetScrollRanges
775: PREPORT pReport ;
776: RECT rectClient ;
777: int xWidth, yHeight ;
778:
779: GetClientRect (hWnd, &rectClient) ;
780: xWidth = rectClient.right - rectClient.left ;
781: yHeight = rectClient.bottom - rectClient.top ;
782:
783: pReport = ReportData (hWnd) ;
784:
785: SetScrollRange (hWnd, SB_VERT,
786: 0, max (0, pReport->yHeight - yHeight),
787: TRUE) ;
788: SetScrollRange (hWnd, SB_HORZ,
789: 0, max (0, pReport->xWidth - xWidth),
790: TRUE) ;
791: } // SetScrollRanges
792:
793:
794: BOOL SystemGroupRemove (PSYSTEMGROUP *ppSystemGroupFirst,
795: PSYSTEMGROUP pSystemGroupRemove)
796: {
797: PSYSTEMGROUP pSystemGroup ;
798:
799: if (*ppSystemGroupFirst == pSystemGroupRemove)
800: {
801: *ppSystemGroupFirst = (*ppSystemGroupFirst)->pSystemGroupNext ;
802: MemoryFree (pSystemGroupRemove->lpszSystemName) ;
803: MemoryFree (pSystemGroupRemove) ;
804: return (TRUE) ;
805: }
806:
807: for (pSystemGroup = *ppSystemGroupFirst ;
808: pSystemGroup->pSystemGroupNext ;
809: pSystemGroup = pSystemGroup->pSystemGroupNext)
810: { // for
811: if (pSystemGroup->pSystemGroupNext == pSystemGroupRemove)
812: {
813: pSystemGroup->pSystemGroupNext = pSystemGroupRemove->pSystemGroupNext ;
814: MemoryFree (pSystemGroupRemove->lpszSystemName) ;
815: MemoryFree (pSystemGroupRemove) ;
816: return (TRUE) ;
817: } // if
818: } // for
819:
820: return (FALSE) ;
821: }
822:
823: void ColumnGroupRemove (PCOLUMNGROUP pColumnGroupFirst)
824: {
825: PCOLUMNGROUP pColumnGroup ;
826: PCOLUMNGROUP pNextColumnGroup ;
827:
828: for (pColumnGroup = pColumnGroupFirst ;
829: pColumnGroup ;
830: pColumnGroup = pNextColumnGroup)
831: {
832: pNextColumnGroup = pColumnGroup->pColumnGroupNext ;
833:
834: // free memory for this column group
835: MemoryFree (pColumnGroup->lpszParentName) ;
836: MemoryFree (pColumnGroup->lpszInstanceName) ;
837: MemoryFree (pColumnGroup) ;
838: }
839: } // ColumnGroupRemove
840:
841: BOOL ObjectGroupRemove (POBJECTGROUP *ppObjectGroupFirst,
842: POBJECTGROUP pObjectGroupRemove)
843: {
844: POBJECTGROUP pObjectGroup ;
845:
846: if (*ppObjectGroupFirst == pObjectGroupRemove)
847: {
848: *ppObjectGroupFirst = (*ppObjectGroupFirst)->pObjectGroupNext ;
849:
850: // clean up the allocated memory
851: ColumnGroupRemove (pObjectGroupRemove->pColumnGroupFirst) ;
852: MemoryFree (pObjectGroupRemove->lpszObjectName) ;
853: MemoryFree (pObjectGroupRemove) ;
854: return (TRUE) ;
855: }
856:
857: for (pObjectGroup = *ppObjectGroupFirst ;
858: pObjectGroup->pObjectGroupNext ;
859: pObjectGroup = pObjectGroup->pObjectGroupNext)
860: { // for
861: if (pObjectGroup->pObjectGroupNext == pObjectGroupRemove)
862: {
863: pObjectGroup->pObjectGroupNext = pObjectGroupRemove->pObjectGroupNext ;
864:
865: // clean up the allocated memory
866: ColumnGroupRemove (pObjectGroupRemove->pColumnGroupFirst) ;
867: MemoryFree (pObjectGroupRemove->lpszObjectName) ;
868: MemoryFree (pObjectGroupRemove) ;
869: return (TRUE) ;
870: } // if
871: } // for
872:
873: return (FALSE) ;
874: }
875:
876:
877: BOOL CounterGroupRemove (PCOUNTERGROUP *ppCounterGroupFirst,
878: PCOUNTERGROUP pCounterGroupRemove)
879: {
880: PCOUNTERGROUP pCounterGroup ;
881:
882: if (*ppCounterGroupFirst == pCounterGroupRemove)
883: {
884: *ppCounterGroupFirst = (*ppCounterGroupFirst)->pCounterGroupNext ;
885: MemoryFree (pCounterGroupRemove) ;
886: return (TRUE) ;
887: }
888:
889: for (pCounterGroup = *ppCounterGroupFirst ;
890: pCounterGroup->pCounterGroupNext ;
891: pCounterGroup = pCounterGroup->pCounterGroupNext)
892: { // for
893: if (pCounterGroup->pCounterGroupNext == pCounterGroupRemove)
894: {
895: pCounterGroup->pCounterGroupNext = pCounterGroupRemove->pCounterGroupNext ;
896: MemoryFree (pCounterGroupRemove) ;
897: return (TRUE) ;
898: } // if
899: } // for
900:
901: return (FALSE) ;
902: }
903:
904:
905: //==========================================================================//
906: // Message Handlers //
907: //==========================================================================//
908:
909:
910: void static OnCreate (HWND hWnd)
911: { // OnCreate
912: HDC hDC ;
913: PREPORT pReport ;
914:
915: pReport = AllocateReportData (hWnd) ;
916: if (!pReport)
917: return ;
918:
919: pReport->hFont = hFontScales ;
920: pReport->hFontHeaders = hFontScalesBold ;
921:
922: pReport->pLineFirst = NULL ;
923: pReport->pSystemFirst = NULL ;
924:
925: pReport->pSystemGroupFirst = NULL ;
926:
927: hDC = GetDC (hWnd) ;
928:
929: SelectFont (hDC, pReport->hFont) ;
930:
931:
932: pReport->yLineHeight = FontHeight (hDC, TRUE) ;
933: pReport->xValueWidth = TextWidth (hDC, szValuePlaceholder) ;
934: ReleaseDC (hWnd, hDC) ;
935:
936: pReport->xWidth = 0 ;
937: pReport->yHeight = 0 ;
938:
939: StringLoad (IDS_SYSTEMFORMAT, szSystemFormat) ;
940: StringLoad (IDS_OBJECTFORMAT, szObjectFormat) ;
941: } // OnCreate
942:
943:
944: void static OnPaint (HWND hWnd)
945: {
946: HDC hDC ;
947: PAINTSTRUCT ps ;
948: PREPORT pReport ;
949:
950:
951:
952: pReport = ReportData (hWnd) ;
953:
954: hDC = BeginPaint (hWnd, &ps) ;
955: //hDC = hReportDC ;
956: SetWindowOrgEx (hDC,
957: GetScrollPos (hWnd, SB_HORZ),
958: GetScrollPos (hWnd, SB_VERT),
959: NULL) ;
960:
961: DrawReport (hDC, pReport) ;
962:
963: EndPaint (hWnd, &ps) ;
964: }
965:
966:
967: void static UpdateReportValues (PREPORT pReport)
968: /*
969: Effect: Redraw all the visible report values of pReport.
970: Since drawing the values completely covers any
971: previous values, there is no need to erase (or flicker)
972: between updating values.
973:
974: Called By: ReportTimer, OnVScroll, OnHScroll.
975: */
976: { // UpdateReportValues
977: HDC hDC ;
978:
979: hDC = GetDC (pReport->hWnd) ;
980:
981: SetBkColor (hDC, GetSysColor(COLOR_WINDOW)) ;
982: SetWindowOrgEx (hDC,
983: GetScrollPos (pReport->hWnd, SB_HORZ),
984: GetScrollPos (pReport->hWnd, SB_VERT),
985: NULL) ;
986:
987: DrawReportValues (hDC, pReport) ;
988: ReleaseDC (pReport->hWnd, hDC) ;
989:
990: } // UpdateReportValues
991:
992:
993:
994: void static OnHScroll (HWND hWnd,
995: int iScrollCode,
996: int iScrollNewPos)
997: { // OnHScroll
998: PREPORT pReport ;
999: int iScrollAmt, iScrollPos, iScrollRange ;
1000: int iScrollLo ;
1001: RECT rectClient ;
1002:
1003: pReport = ReportData (hWnd) ;
1004:
1005: iScrollPos = GetScrollPos (hWnd, SB_HORZ) ;
1006: GetScrollRange (hWnd, SB_HORZ, &iScrollLo, &iScrollRange) ;
1007:
1008: GetClientRect (hWnd, &rectClient) ;
1009:
1010: switch (iScrollCode)
1011: {
1012: case SB_LINEUP:
1013: iScrollAmt = - Report.yLineHeight ;
1014: break ;
1015:
1016: case SB_LINEDOWN:
1017: iScrollAmt = Report.yLineHeight ;
1018: break ;
1019:
1020: case SB_PAGEUP:
1021: iScrollAmt = - (rectClient.right - rectClient.left) / 2 ;
1022: break ;
1023:
1024: case SB_PAGEDOWN:
1025: iScrollAmt = (rectClient.right - rectClient.left) / 2 ;
1026: break ;
1027:
1028: case SB_THUMBPOSITION:
1029: iScrollAmt = iScrollNewPos - iScrollPos ;
1030: break ;
1031:
1032: default:
1033: iScrollAmt = 0 ;
1034: } // switch
1035:
1036: iScrollAmt = PinInclusive (iScrollAmt,
1037: -iScrollPos,
1038: iScrollRange - iScrollPos) ;
1039: if (iScrollAmt)
1040: {
1041: iScrollPos += iScrollAmt ;
1042: ScrollWindow (hWnd, -iScrollAmt, 0, NULL, NULL) ;
1043: SetScrollPos (hWnd, SB_HORZ, iScrollPos, TRUE) ;
1044: UpdateWindow (hWnd) ;
1045:
1046: UpdateReportValues (pReport) ;
1047: }
1048: } // OnHScroll
1049:
1050:
1051:
1052: void static OnVScroll (HWND hWnd,
1053: int iScrollCode,
1054: int iScrollNewPos)
1055: { // OnVScroll
1056: PREPORT pReport ;
1057: int iScrollAmt, iScrollPos, iScrollRange ;
1058: int iScrollLo ;
1059: RECT rectClient ;
1060:
1061: pReport = ReportData (hWnd) ;
1062:
1063: iScrollPos = GetScrollPos (hWnd, SB_VERT) ;
1064: GetScrollRange (hWnd, SB_VERT, &iScrollLo, &iScrollRange) ;
1065:
1066: GetClientRect (hWnd, &rectClient) ;
1067:
1068: switch (iScrollCode)
1069: {
1070: case SB_LINEUP:
1071: iScrollAmt = - Report.yLineHeight ;
1072: break ;
1073:
1074: case SB_LINEDOWN:
1075: iScrollAmt = Report.yLineHeight ;
1076: break ;
1077:
1078: case SB_PAGEUP:
1079: iScrollAmt = - (rectClient.bottom - rectClient.top) / 2 ;
1080: break ;
1081:
1082: case SB_PAGEDOWN:
1083: iScrollAmt = (rectClient.bottom - rectClient.top) / 2 ;
1084: break ;
1085:
1086: case SB_THUMBPOSITION:
1087: iScrollAmt = iScrollNewPos - iScrollPos ;
1088: break ;
1089:
1090: default:
1091: iScrollAmt = 0 ;
1092: } // switch
1093:
1094: iScrollAmt = PinInclusive (iScrollAmt,
1095: -iScrollPos,
1096: iScrollRange - iScrollPos) ;
1097: if (iScrollAmt)
1098: {
1099: iScrollPos += iScrollAmt ;
1100: ScrollWindow (hWnd, 0, -iScrollAmt, NULL, NULL) ;
1101: SetScrollPos (hWnd, SB_VERT, iScrollPos, TRUE) ;
1102: WindowInvalidate (hWnd) ;
1103: UpdateWindow (hWnd) ;
1104:
1105: UpdateReportValues (pReport) ;
1106: }
1107: } // OnVScroll
1108:
1109:
1110: BOOL static OnLButtonDown (HWND hWnd,
1111: WORD xPos,
1112: WORD yPos)
1113: {
1114: HDC hDC ;
1115: PREPORT pReport ;
1116: PLINE pLine ;
1117: PLINE pLinePrevious ;
1118: RECT rect ;
1119: POINT pt ;
1120: int xOffset, yOffset ;
1121:
1122:
1123: pReport = ReportData (hWnd) ;
1124: if (!pReport)
1125: return (FALSE) ;
1126:
1127: xOffset = GetScrollPos (hWnd, SB_HORZ) ;
1128: yOffset = GetScrollPos (hWnd, SB_VERT) ;
1129: pt.x = xPos + xOffset ;
1130: pt.y = yPos + yOffset ;
1131:
1132: pLinePrevious = pReport->pLineCurrent ;
1133:
1134: for (pLine = pReport->pLineFirst ;
1135: pLine ;
1136: pLine = pLine->pLineNext)
1137: { // for
1138: ReportValueRect (pReport, pLine, &rect) ;
1139: if (PtInRect (&rect, pt))
1140: {
1141: if (pLine != pLinePrevious)
1142: {
1143: pReport->pLineCurrent = pLine ;
1144: hDC = GetDC (hWnd) ;
1145: SetWindowOrgEx (hDC, xOffset, yOffset, NULL) ;
1146: SelectFont (hDC, pReport->hFont) ;
1147: SetTextAlign (hDC, TA_RIGHT) ;
1148: SetBkColor (hDC, GetSysColor(COLOR_WINDOW)) ;
1149: DrawReportValue (hDC, pReport, pLine) ;
1150: if (pLinePrevious)
1151: DrawReportValue (hDC, pReport, pLinePrevious) ;
1152:
1153: ReleaseDC (hWnd, hDC) ;
1154: return (TRUE) ;
1155: }
1156: return (FALSE) ;
1157: }
1158: } // for
1159:
1160: return (FALSE) ;
1161: } // OnLButtonDown
1162:
1163:
1164: LRESULT APIENTRY ReportWndProc (HWND hWnd,
1165: WORD wMsg,
1166: DWORD wParam,
1167: LONG lParam)
1168: { // ReportWndProc
1169: BOOL bCallDefProc ;
1170: LRESULT lReturnValue ;
1171:
1172: bCallDefProc = FALSE ;
1173: lReturnValue = 0L ;
1174:
1175: switch (wMsg)
1176: { // switch
1177: case WM_CREATE:
1178: OnCreate (hWnd) ;
1179: break ;
1180:
1181: case WM_LBUTTONDOWN:
1182:
1183: if (!OnLButtonDown (hWnd, LOWORD (lParam), HIWORD (lParam)))
1184: {
1185: // mouse click do not hit on any entries, see if we
1186: // need to drag Perfmon
1187: if (!(Options.bMenubar))
1188: {
1189: DoWindowDrag (lParam) ;
1190: }
1191: }
1192: break ;
1193:
1194: case WM_LBUTTONDBLCLK:
1195: SendMessage (hWndMain, WM_LBUTTONDBLCLK, wParam, lParam) ;
1196: break ;
1197:
1198: case WM_PAINT:
1199: OnPaint (hWnd) ;
1200: break ;
1201:
1202: case WM_SIZE:
1203: SetScrollRanges (hWnd) ;
1204: break ;
1205:
1206: case WM_HSCROLL:
1207: OnHScroll (hWnd, LOWORD (wParam), HIWORD (wParam)) ;
1208: break ;
1209:
1210: case WM_VSCROLL:
1211: OnVScroll (hWnd, LOWORD (wParam), HIWORD (wParam)) ;
1212: break ;
1213:
1214: case WM_TIMER:
1215: ReportTimer (hWnd, FALSE) ;
1216: break ;
1217:
1218: case WM_DESTROY:
1219: KillTimer (hWnd, ReportTimerID) ;
1220: break ;
1221:
1222: default:
1223: bCallDefProc = TRUE ;
1224: } // switch
1225:
1226:
1227: if (bCallDefProc)
1228: lReturnValue = DefWindowProc (hWnd, wMsg, wParam, lParam) ;
1229:
1230: return (lReturnValue);
1231: } // ReportWndProc
1232:
1233:
1234:
1235: //==========================================================================//
1236: // Exported Functions //
1237: //==========================================================================//
1238:
1239: #if 0
1240: PREPORT ReportData (HWND hWndReport)
1241: {
1242: return (&Report) ;
1243: }
1244: #endif
1245:
1246: void SetReportTimer (PREPORT pReport)
1247: {
1248: if (pReport->iStatus == iPMStatusCollecting)
1249: KillTimer (pReport->hWnd, ReportTimerID) ;
1250:
1251: SetTimer (pReport->hWnd, ReportTimerID,
1252: pReport->iIntervalMSecs , NULL) ;
1253: pReport->iStatus = iPMStatusCollecting ;
1254: }
1255:
1256:
1257: void ClearReportTimer (PREPORT pReport)
1258: {
1259: pReport->iStatus = iPMStatusClosed ;
1260: KillTimer (pReport->hWnd, ReportTimerID) ;
1261: }
1262:
1263:
1264: BOOL ReportInitializeApplication (void)
1265: { // ReportInitializeApplication
1266: BOOL bSuccess ;
1267: WNDCLASS wc ;
1268:
1269: //=============================//
1270: // Register ReportWindow class //
1271: //=============================//
1272:
1273:
1274: wc.style = dwReportClassStyle ;
1275: wc.lpfnWndProc = (WNDPROC) ReportWndProc ;
1276: wc.hInstance = hInstance ;
1277: wc.cbClsExtra = iReportWindowExtra ;
1278: wc.cbWndExtra = iReportClassExtra ;
1279: wc.hIcon = NULL ;
1280: wc.hCursor = LoadCursor(NULL, IDC_ARROW) ;
1281: // wc.hbrBackground = GetStockObject (WHITE_BRUSH) ;
1282: wc.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1) ;
1283: wc.lpszMenuName = NULL ;
1284: wc.lpszClassName = szReportWindowClass ;
1285:
1286: bSuccess = RegisterClass (&wc) ;
1287:
1288:
1289: //=============================//
1290: // Register Child classes //
1291: //=============================//
1292:
1293: return (bSuccess) ;
1294: } // ReportInitializeApplication
1295:
1296:
1297:
1298:
1299: BOOL ReportDeleteLine (HWND hWnd, PLINE pLine)
1300: /*
1301: Effect: Delete the line pLine into the data structures for the
1302: Report of window hWnd. The line is added to the list of
1303: lines, and also added to the report structure in the
1304: appropriate System, Object, and Counter.
1305:
1306: Returns: Whether the function was successful. If this function
1307: returns FALSE, the line was not added.
1308: */
1309: { // ReportDeleteLine
1310: HDC hDC ;
1311: PREPORT pReport ;
1312: PSYSTEMGROUP pSystemGroup ;
1313: POBJECTGROUP pObjectGroup ;
1314: PCOUNTERGROUP pCounterGroup ;
1315: BOOL bCreatNewCounterGroup ;
1316:
1317:
1318: pReport = ReportData (hWnd) ;
1319: pReport->bModified = TRUE ;
1320:
1321: //=============================//
1322: // Remove line, line's system //
1323: //=============================//
1324:
1325: LineRemove (&pReport->pLineFirst, pLine) ;
1326:
1327: // no more line, no more timer...
1328: if (!pReport->pLineFirst)
1329: {
1330: pReport->xWidth = 0 ;
1331: pReport->yHeight = 0 ;
1332: pReport->xMaxCounterWidth = 0 ;
1333: ClearReportTimer (pReport) ;
1334: }
1335:
1336:
1337: //=============================//
1338: // Get correct spot; remove line //
1339: //=============================//
1340:
1341: pSystemGroup = SystemGroup (pReport, pLine->lnSystemName) ;
1342: pObjectGroup = ObjectGroup (pSystemGroup, pLine->lnObjectName) ;
1343: pCounterGroup = CounterGroup (pObjectGroup,
1344: pLine->lnCounterDef.CounterNameTitleIndex,
1345: &bCreatNewCounterGroup) ;
1346:
1347: if (!pCounterGroup)
1348: return (FALSE) ;
1349:
1350: LineCounterRemove (&pCounterGroup->pLineFirst, pLine) ;
1351:
1352: if (!(pCounterGroup->pLineFirst))
1353: CounterGroupRemove (&pObjectGroup->pCounterGroupFirst, pCounterGroup) ;
1354:
1355: if (!(pObjectGroup->pCounterGroupFirst))
1356: ObjectGroupRemove (&pSystemGroup->pObjectGroupFirst, pObjectGroup) ;
1357:
1358: if (!(pSystemGroup->pObjectGroupFirst))
1359: SystemGroupRemove (&pReport->pSystemGroupFirst, pSystemGroup) ;
1360:
1361:
1362: LineFree (pLine) ;
1363: pReport->pLineCurrent = pReport->pLineFirst ;
1364:
1365: if (pReport->pLineFirst)
1366: {
1367: BuildNewValueListForReport () ;
1368: }
1369:
1370: //=============================//
1371: // Calculate report positions //
1372: //=============================//
1373:
1374: hDC = GetDC (hWnd) ;
1375: SetReportPositions (hDC, pReport) ;
1376: ReleaseDC (hWnd, hDC) ;
1377:
1378: WindowInvalidate (hWnd) ;
1379: } // ReportDeleteLine
1380:
1381:
1382: HWND CreateReportWindow (HWND hWndParent)
1383: /*
1384: Effect: Create the graph window. This window is a child of
1385: hWndMain and is a container for the graph data,
1386: graph label, graph legend, and graph status windows.
1387:
1388: Note: We dont worry about the size here, as this window
1389: will be resized whenever the main window is resized.
1390:
1391: */
1392: {
1393: return (CreateWindow (szReportWindowClass, // window class
1394: NULL, // caption
1395: dwReportWindowStyle, // style for window
1396: 0, 0, // initial position
1397: 0, 0, // initial size
1398: hWndParent, // parent
1399: NULL, // menu
1400: hInstance, // program instance
1401: NULL)) ; // user-supplied data
1402: } // CreateReportWindow
1403:
1404:
1405:
1406:
1407: BOOL ReportInsertLine (HWND hWnd, PLINE pLine)
1408: /*
1409: Effect: Insert the line pLine into the data structures for the
1410: Report of window hWnd. The line is added to the list of
1411: lines, and also added to the report structure in the
1412: appropriate System, Object, and Counter.
1413:
1414: Returns: Whether the function was successful. If this function
1415: returns FALSE, the line was not added.
1416: */
1417: { // ReportInsertLine
1418: HDC hDC ;
1419: PREPORT pReport ;
1420: PSYSTEMGROUP pSystemGroup ;
1421: POBJECTGROUP pObjectGroup ;
1422: PCOUNTERGROUP pCounterGroup ;
1423: PLINE pLineEquivalent ;
1424: int OldCounterWidth ;
1425: BOOL bNewCounterGroup ;
1426:
1427: pReport = ReportData (hWnd) ;
1428: pReport->bModified = TRUE ;
1429:
1430: pLineEquivalent = FindEquivalentLine (pLine, pReport->pLineFirst) ;
1431: if (pLineEquivalent)
1432: {
1433: return (FALSE) ;
1434: }
1435: else
1436: {
1437: //=============================//
1438: // Add line, line's system //
1439: //=============================//
1440:
1441: LineAppend (&pReport->pLineFirst, pLine) ;
1442: SystemAdd (&pReport->pSystemFirst, pLine->lnSystemName) ;
1443:
1444:
1445: //=============================//
1446: // Find correct spot; add line //
1447: //=============================//
1448:
1449: pSystemGroup = SystemGroup (pReport, pLine->lnSystemName) ;
1450: pObjectGroup = ObjectGroup (pSystemGroup, pLine->lnObjectName) ;
1451: pCounterGroup = CounterGroup (pObjectGroup,
1452: pLine->lnCounterDef.CounterNameTitleIndex,
1453: &bNewCounterGroup) ;
1454:
1455: if (!pCounterGroup)
1456: return (FALSE) ;
1457:
1458: LineCounterAppend (&pCounterGroup->pLineFirst, pLine) ;
1459:
1460: //=============================//
1461: // Calculate report positions //
1462: //=============================//
1463: hDC = GetDC (hWnd) ;
1464: SelectFont (hDC, pReport->hFontHeaders) ;
1465:
1466: if (bNewCounterGroup)
1467: {
1468: // re-calc. the max. counter group width
1469: OldCounterWidth = pReport->xMaxCounterWidth ;
1470: pReport->xMaxCounterWidth =
1471: max (pReport->xMaxCounterWidth,
1472: TextWidth (hDC, pLine->lnCounterName)) ;
1473: if (OldCounterWidth < pReport->xMaxCounterWidth)
1474: {
1475: // adjust the report width with the new counter width
1476: pReport->xWidth +=
1477: (pReport->xMaxCounterWidth - OldCounterWidth);
1478: }
1479: }
1480:
1481: if (!bDelayAddAction)
1482: {
1483: SetReportPositions (hDC, pReport) ;
1484: }
1485: ReleaseDC (hWnd, hDC) ;
1486:
1487: pReport->pLineCurrent = pLine ;
1488:
1489: if (!bDelayAddAction)
1490: {
1491: if (PlayingBackLog ())
1492: {
1493: PlaybackReport (hWndReport) ;
1494: }
1495: else if (pReport->iStatus == iPMStatusClosed)
1496: {
1497: SetReportTimer (pReport) ;
1498: }
1499:
1500: WindowInvalidate (hWnd) ;
1501: }
1502: } // else
1503:
1504: return (TRUE) ;
1505: } // ReportInsertLine
1506:
1507:
1508:
1509: void SetReportPositions (HDC hDC,
1510: PREPORT pReport)
1511: {
1512: PSYSTEMGROUP pSystemGroup ;
1513: int yLine ;
1514: int yPos ;
1515:
1516:
1517: // pReport->xMaxCounterWidth = 0 ;
1518:
1519: yLine = pReport->yLineHeight ;
1520: yPos = 2 * yLine ;
1521:
1522: for (pSystemGroup = pReport->pSystemGroupFirst ;
1523: pSystemGroup ;
1524: pSystemGroup = pSystemGroup->pSystemGroupNext)
1525: { // for
1526: pSystemGroup->yFirstLine = yPos + yLine ;
1527:
1528: SetSystemPositions (hDC, pReport, pSystemGroup, yLine) ;
1529:
1530: yPos = pSystemGroup->yLastLine ;
1531: } // for
1532:
1533: pReport->yHeight = yPos ;
1534:
1535: SetScrollRanges (pReport->hWnd) ;
1536: } // SetReportPositions
1537:
1538:
1539:
1540: void PlaybackReport (HWND hWndReport)
1541: { // PlaybackReport
1542: PREPORT pReport ;
1543:
1544: pReport = ReportData (hWndReport) ;
1545:
1546: PlaybackLines (pReport->pSystemFirst,
1547: pReport->pLineFirst,
1548: PlaybackLog.StartIndexPos.iPosition) ;
1549: PlaybackLines (pReport->pSystemFirst,
1550: pReport->pLineFirst,
1551: PlaybackLog.StopIndexPos.iPosition) ;
1552: } // PlaybackReport
1553:
1554:
1555: PLINESTRUCT CurrentReportLine (HWND hWndReport)
1556: { // CurrentReportLine
1557: PREPORT pReport ;
1558:
1559: pReport = ReportData (hWndReport) ;
1560: if (!pReport)
1561: return (NULL) ;
1562:
1563: return (pReport->pLineCurrent) ;
1564: } // CurrentReportLine
1565:
1566:
1567:
1568: BOOL AddReport (HWND hWndParent)
1569: {
1570: PREPORT pReport ;
1571:
1572: pReport = ReportData (hWndReport) ;
1573:
1574: return (AddLine (hWndParent,
1575: &(pReport->pSystemFirst),
1576: &(pReport->Visual),
1577: LineTypeReport)) ;
1578: }
1579:
1580:
1581:
1582: BOOL EditReport (HWND hWndParent)
1583: { // EditReport
1584: PREPORT pReport ;
1585:
1586: pReport = ReportData (hWndReport) ;
1587:
1588: return (EditLine (hWndParent,
1589: &(pReport->pSystemFirst),
1590: CurrentReportLine (hWndReport),
1591: LineTypeReport)) ;
1592: } // EditReport
1593:
1594:
1595: BOOL ToggleReportRefresh (HWND hWnd)
1596: { // ToggleReportRefresh
1597: PREPORT pReport ;
1598:
1599: pReport = ReportData (hWnd) ;
1600:
1601: if (pReport->bManualRefresh)
1602: SetReportTimer (pReport) ;
1603: else
1604: ClearReportTimer (pReport) ;
1605:
1606: pReport->bManualRefresh = !pReport->bManualRefresh ;
1607: return (pReport->bManualRefresh) ;
1608: } // ToggleReportRefresh
1609:
1610: BOOL ReportRefresh (HWND hWnd)
1611: { // ReportRefresh
1612: PREPORT pReport ;
1613:
1614: pReport = ReportData (hWnd) ;
1615:
1616: return (pReport->bManualRefresh) ;
1617: } // ReportRefresh
1618:
1619:
1620:
1621: void ReportTimer (HWND hWnd, BOOL bForce)
1622: {
1623: PREPORT pReport ;
1624:
1625: pReport = ReportData (hWnd) ;
1626:
1627: if (PlayingBackLog () || !pReport)
1628: {
1629: return;
1630: }
1631:
1632: if (bForce || !pReport->bManualRefresh)
1633: { // if
1634: UpdateLines (&(pReport->pSystemFirst), pReport->pLineFirst) ;
1635: if (iPerfmonView == IDM_VIEWREPORT && !bPerfmonIconic)
1636: {
1637: // only need to draw the data when we are viewing it...
1638: UpdateReportValues (pReport) ;
1639: }
1640: } // if
1641: } // ReportTimer
1642:
1643:
1644:
1645:
1646:
1647:
1648: BOOL SaveReport (HWND hWndReport, HANDLE hInputFile, BOOL bGetFileName)
1649: {
1650: PREPORT pReport ;
1651: PLINE pLine ;
1652: HANDLE hFile ;
1653: DISKREPORT DiskReport ;
1654: PERFFILEHEADER FileHeader ;
1655: TCHAR szFileName [256] ;
1656: BOOL newFileName = FALSE ;
1657:
1658: pReport = ReportData (hWndReport) ;
1659: if (!pReport)
1660: {
1661: return (FALSE) ;
1662: }
1663:
1664: if (hInputFile)
1665: {
1666: // use the input file handle if it is available
1667: // this is the case for saving workspace data
1668: hFile = hInputFile ;
1669: }
1670: else
1671: {
1672: if (pReportFullFileName)
1673: {
1674: lstrcpy (szFileName, pReportFullFileName) ;
1675: }
1676: if (bGetFileName || pReportFullFileName == NULL)
1677: {
1678: // if (pReportFullFileName == NULL)
1679: // {
1680: // StringLoad (IDS_REPORT_FNAME, szFileName) ;
1681: // }
1682: if (!FileGetName (hWndReport, IDS_REPORTFILE, szFileName))
1683: {
1684: return (FALSE) ;
1685: }
1686: newFileName = TRUE ;
1687: }
1688:
1689: hFile = FileHandleCreate (szFileName) ;
1690:
1691: if (hFile && newFileName)
1692: {
1693: ChangeSaveFileName (szFileName, IDM_VIEWREPORT) ;
1694: }
1695: else if (!hFile)
1696: {
1697: DlgErrorBox (hWndReport, ERR_CANT_OPEN, szFileName) ;
1698: }
1699: }
1700:
1701:
1702: if (!hFile)
1703: return (FALSE) ;
1704:
1705:
1706: if (!hInputFile)
1707: {
1708: memset (&FileHeader, 0, sizeof (FileHeader)) ;
1709: lstrcpy (FileHeader.szSignature, szPerfReportSignature) ;
1710: FileHeader.dwMajorVersion = ReportMajorVersion ;
1711: FileHeader.dwMinorVersion = ReportMinorVersion ;
1712:
1713: if (!FileWrite (hFile, &FileHeader, sizeof (PERFFILEHEADER)))
1714: {
1715: goto Exit0 ;
1716: }
1717: }
1718:
1719: DiskReport.Visual = pReport->Visual ;
1720: DiskReport.bManualRefresh = pReport->bManualRefresh ;
1721: DiskReport.dwIntervalSecs = pReport->iIntervalMSecs ;
1722: DiskReport.dwNumLines = NumLines (pReport->pLineFirst) ;
1723: DiskReport.perfmonOptions = Options ;
1724:
1725: if (!FileWrite (hFile, &DiskReport, sizeof (DISKREPORT)))
1726: {
1727: goto Exit0 ;
1728: }
1729:
1730: for (pLine = pReport->pLineFirst ;
1731: pLine ;
1732: pLine = pLine->pLineNext)
1733: { // for
1734: if (!WriteLine (pLine, hFile))
1735: {
1736: goto Exit0 ;
1737: }
1738: } // for
1739:
1740: if (!hInputFile)
1741: {
1742: CloseHandle (hFile) ;
1743: }
1744:
1745: return (TRUE) ;
1746:
1747: Exit0:
1748: if (!hInputFile)
1749: {
1750: CloseHandle (hFile) ;
1751:
1752: // only need to report error if not workspace
1753: DlgErrorBox (hWndReport, ERR_SETTING_FILE, szFileName) ;
1754: }
1755: return (FALSE) ;
1756: } // SaveReport
1757:
1758:
1759: void ReportAddAction (PREPORT pReport)
1760: {
1761: HDC hDC ;
1762:
1763: //=============================//
1764: // Calculate report positions //
1765: //=============================//
1766:
1767: hDC = GetDC (hWndReport) ;
1768: SetReportPositions (hDC, pReport) ;
1769: ReleaseDC (hWndReport, hDC) ;
1770:
1771: if (PlayingBackLog ())
1772: {
1773: PlaybackReport (hWndReport) ;
1774: }
1775: else if (pReport->iStatus == iPMStatusClosed)
1776: {
1777: SetReportTimer (pReport) ;
1778: }
1779:
1780: WindowInvalidate (hWndReport) ;
1781: }
1782:
1783:
1784: BOOL OpenReportVer1 (HANDLE hFile,
1785: DISKREPORT *pDiskReport,
1786: PREPORT pReport,
1787: DWORD dwMinorVersion)
1788: {
1789: HDC hDC ;
1790:
1791: pReport->Visual = pDiskReport->Visual ;
1792: pReport->iIntervalMSecs = pDiskReport->dwIntervalSecs ;
1793: if (dwMinorVersion < 3)
1794: {
1795: // convert this to msec
1796: pReport->iIntervalMSecs *= 1000 ;
1797: }
1798: pReport->bManualRefresh = pDiskReport->bManualRefresh ;
1799:
1800: bDelayAddAction = TRUE ;
1801: ReadLines (hFile, pDiskReport->dwNumLines,
1802: &(pReport->pSystemFirst), &(pReport->pLineFirst), IDM_VIEWREPORT) ;
1803: bDelayAddAction = FALSE ;
1804:
1805: //=============================//
1806: // Calculate report positions //
1807: //=============================//
1808:
1809: hDC = GetDC (hWndReport) ;
1810: SetReportPositions (hDC, pReport) ;
1811: ReleaseDC (hWndReport, hDC) ;
1812:
1813: if (PlayingBackLog ())
1814:
1815: {
1816: PlaybackReport (hWndReport) ;
1817: }
1818: else if (pReport->iStatus == iPMStatusClosed)
1819: {
1820: SetReportTimer (pReport) ;
1821: }
1822:
1823: WindowInvalidate (hWndReport) ;
1824:
1825: return (TRUE) ;
1826: } // OpenReportVer1
1827:
1828:
1829:
1830: BOOL OpenReport (HWND hWndReport,
1831: HANDLE hFile,
1832: DWORD dwMajorVersion,
1833: DWORD dwMinorVersion,
1834: BOOL bReportFile)
1835: {
1836: PREPORT pReport ;
1837: DISKREPORT DiskReport ;
1838: BOOL bSuccess = TRUE ;
1839:
1840: pReport = ReportData (hWndReport) ;
1841: if (!pReport)
1842: {
1843: bSuccess = FALSE ;
1844: goto Exit0 ;
1845: }
1846:
1847: if (!FileRead (hFile, &DiskReport, sizeof (DISKREPORT)))
1848: {
1849: bSuccess = FALSE ;
1850: goto Exit0 ;
1851: }
1852:
1853:
1854: switch (dwMajorVersion)
1855: {
1856: case (1):
1857:
1858: SetHourglassCursor() ;
1859:
1860: ResetReportView (hWndReport) ;
1861:
1862: OpenReportVer1 (hFile, &DiskReport, pReport, dwMinorVersion) ;
1863:
1864: // change to report view if we are opening a
1865: // report file
1866: if (bReportFile && iPerfmonView != IDM_VIEWREPORT)
1867: {
1868: SendMessage (hWndMain, WM_COMMAND, (LONG)IDM_VIEWREPORT, 0L) ;
1869: }
1870:
1871: if (iPerfmonView == IDM_VIEWREPORT)
1872: {
1873: SetPerfmonOptions (&DiskReport.perfmonOptions) ;
1874: }
1875:
1876: SetArrowCursor() ;
1877:
1878: break ;
1879: } // switch
1880:
1881: Exit0:
1882:
1883: if (bReportFile)
1884: {
1885: CloseHandle (hFile) ;
1886: }
1887:
1888: return (bSuccess) ;
1889: } // OpenReport
1890:
1891:
1892:
1893: BOOL QuerySaveReport (HWND hWndParent,
1894: HWND hWndReport)
1895: { // QuerySaveReport
1896: #ifdef KEEP_QUERY
1897: PREPORT pReport ;
1898: int iReturn ;
1899:
1900: pReport = ReportData (hWndReport) ;
1901: if (!pReport)
1902: return (TRUE) ;
1903:
1904: if (!pReport->bModified)
1905: return (TRUE) ;
1906:
1907: iReturn = MessageBoxResource (hWndParent,
1908: IDS_SAVEREPORT, IDS_MODIFIEDREPORT,
1909: MB_YESNOCANCEL | MB_ICONASTERISK) ;
1910:
1911: if (iReturn == IDCANCEL)
1912: return (FALSE) ;
1913:
1914: if (iReturn == IDYES)
1915: SaveReport (hWndReport) ;
1916: #endif
1917:
1918: return (TRUE) ;
1919: } // QuerySaveReport
1920:
1921: void ResetReportView (HWND hWndReport)
1922: { // ResetReportView
1923: PREPORT pReport ;
1924:
1925: pReport = ReportData (hWndReport) ;
1926:
1927: if (!pReport)
1928: {
1929: return ;
1930: }
1931:
1932: ChangeSaveFileName (NULL, IDM_VIEWREPORT) ;
1933:
1934: if (pReport->pSystemGroupFirst)
1935: {
1936: ResetReport (hWndReport) ;
1937: }
1938: } // ResetReportView
1939:
1940:
1941: void ResetReport (HWND hWndReport)
1942: { // ResetReport
1943: PREPORT pReport ;
1944: PSYSTEMGROUP pSystemGroup, pSystemGroupDelete ;
1945: POBJECTGROUP pObjectGroup, pObjectGroupDelete ;
1946: PCOUNTERGROUP pCounterGroup, pCounterGroupDelete ;
1947: HDC hDC ;
1948:
1949: pReport = ReportData (hWndReport) ;
1950: if (!pReport)
1951: return ;
1952:
1953: ClearReportTimer (pReport) ;
1954:
1955: pSystemGroup = pReport->pSystemGroupFirst ;
1956: while (pSystemGroup)
1957: {
1958: pObjectGroup = pSystemGroup->pObjectGroupFirst ;
1959: while (pObjectGroup)
1960: {
1961: pCounterGroup = pObjectGroup->pCounterGroupFirst ;
1962: while (pCounterGroup)
1963: {
1964: pCounterGroupDelete = pCounterGroup ;
1965: pCounterGroup = pCounterGroup->pCounterGroupNext ;
1966: MemoryFree (pCounterGroupDelete) ;
1967: } // while pCounter...
1968:
1969: pObjectGroupDelete = pObjectGroup ;
1970: pObjectGroup = pObjectGroup->pObjectGroupNext ;
1971: ColumnGroupRemove (pObjectGroupDelete->pColumnGroupFirst) ;
1972: MemoryFree (pObjectGroupDelete->lpszObjectName) ;
1973: MemoryFree (pObjectGroupDelete) ;
1974: } // while pObject
1975:
1976: pSystemGroupDelete = pSystemGroup ;
1977: pSystemGroup = pSystemGroup->pSystemGroupNext ;
1978: MemoryFree (pSystemGroupDelete->lpszSystemName) ;
1979: MemoryFree (pSystemGroupDelete) ;
1980: } // while pSystem...
1981:
1982: FreeLines (pReport->pLineFirst) ;
1983: pReport->pLineFirst = NULL ;
1984:
1985: FreeSystems (pReport->pSystemFirst) ;
1986: pReport->pSystemFirst = NULL ;
1987:
1988: pReport->pSystemGroupFirst = NULL ;
1989: pReport->pLineCurrent = NULL ;
1990:
1991: // reset scrolling ranges
1992: pReport->xWidth = 0 ;
1993: pReport->yHeight = 0 ;
1994: pReport->xMaxCounterWidth = 0 ;
1995: hDC = GetDC (hWndReport) ;
1996: SetReportPositions (hDC, pReport) ;
1997: ReleaseDC (hWndReport, hDC) ;
1998:
1999: WindowInvalidate (hWndReport) ;
2000: } // ResetReport
2001:
2002: void ClearReportDisplay (HWND hWndReport)
2003: { // ResetReport
2004: PREPORT pReport ;
2005: PLINE pLine;
2006:
2007: if (PlayingBackLog())
2008: {
2009: return ;
2010: }
2011:
2012: pReport = ReportData (hWndReport) ;
2013: if (!pReport || !pReport->pLineFirst)
2014: return ;
2015:
2016: for (pLine = pReport->pLineFirst ;
2017: pLine ;
2018: pLine = pLine->pLineNext)
2019: {
2020: // reset the new data counts
2021: pLine->bFirstTime = 2 ;
2022: }
2023:
2024: // re-draw the values
2025: UpdateReportValues (pReport) ;
2026:
2027: } // ClearReportDisplay
2028:
2029: //=========================================
2030: // we don't print. we just export
2031: //
2032: // if need printint, define KEEP_PRINT
2033: //=========================================
2034: #ifdef KEEP_PRINT
2035: BOOL PrintReportDisplay (HDC hDC,
2036: PREPORT pReport)
2037: {
2038: SetReportPositions (hDC, pReport) ;
2039: DrawReport (hDC, pReport) ;
2040: return TRUE ;
2041: } // PrintReportDisplay
2042:
2043:
2044:
2045: BOOL PrintReport (HWND hWndParent,
2046: HWND hWndReport)
2047: {
2048: PREPORT pReport ;
2049: HDC hDC ;
2050: int xPageWidth ;
2051: int yPageHeight ;
2052: int xValueWidth ;
2053:
2054: HFONT hFont, hFontHeaders ;
2055: int yLineHeight ;
2056:
2057: pReport = ReportData (hWndReport) ;
2058: if (!pReport)
2059: return (FALSE) ;
2060:
2061: hDC = PrintDC () ;
2062: if (!hDC)
2063: {
2064: PostError () ;
2065: return (FALSE) ;
2066: }
2067:
2068: xPageWidth = GetDeviceCaps (hDC, HORZRES) ;
2069: yPageHeight = GetDeviceCaps (hDC, VERTRES) ;
2070:
2071:
2072: StartJob (hDC, TEXT("Performance Monitor Report")) ;
2073: StartPage (hDC) ;
2074:
2075:
2076: hFont = pReport->hFont ;
2077: hFontHeaders = pReport->hFontHeaders ;
2078: yLineHeight = pReport->yLineHeight ;
2079: xValueWidth = pReport->xValueWidth ;
2080:
2081: pReport->hFont = hFontPrinterScales ;
2082: pReport->hFontHeaders = hFontPrinterScalesBold ;
2083:
2084: SelectFont (hDC, pReport->hFont) ;
2085: pReport->yLineHeight = FontHeight (hDC, TRUE) ;
2086:
2087: pReport->xValueWidth = TextWidth (hDC, szValuePlaceholder) ;
2088:
2089: PrintReportDisplay (hDC, pReport) ;
2090:
2091: EndPage (hDC) ;
2092: EndJob (hDC) ;
2093:
2094: DeleteDC (hDC) ;
2095:
2096:
2097: pReport->hFont = hFont ;
2098: pReport->hFontHeaders = hFontHeaders ;
2099: pReport->yLineHeight = yLineHeight ;
2100:
2101: pReport->xValueWidth = xValueWidth ;
2102:
2103: hDC = GetDC ()hWndReport) ;
2104: SetReportPositions (hDC, pReport) ;
2105: ReleaseDC (hWndReport, hDC) ;
2106:
2107: return (FALSE) ;
2108: } // PrintReport
2109:
2110: // we don't print. we just export
2111: #endif
2112:
2113: BOOL ExportComputerName (HANDLE hFile, PSYSTEMGROUP pSystemGroup)
2114: {
2115: int StringLen ;
2116: BOOL bWriteSuccess = TRUE ;
2117: CHAR TempBuff [LongTextLen] ;
2118: TCHAR UnicodeBuff [LongTextLen] ;
2119:
2120: // export computer name
2121: strcpy (TempBuff, LineEndStr) ;
2122: strcat (TempBuff, LineEndStr) ;
2123: StringLen = strlen (TempBuff) ;
2124: TSPRINTF (UnicodeBuff, szSystemFormat, pSystemGroup->lpszSystemName) ;
2125: ConvertUnicodeStr (&TempBuff[StringLen], UnicodeBuff) ;
2126: strcat (TempBuff, LineEndStr) ;
2127:
2128: if (!FileWrite (hFile, TempBuff, strlen(TempBuff)))
2129: {
2130: bWriteSuccess = FALSE ;
2131: }
2132:
2133: return (bWriteSuccess) ;
2134: } // ExportComputerName
2135:
2136: BOOL ExportObjectName (HANDLE hFile, POBJECTGROUP pObjectGroup, int *pColNum)
2137: {
2138: int StringLen ;
2139: BOOL bNeedToExport ;
2140: BOOL bWriteSuccess = TRUE ;
2141: CHAR TempBuff [LongTextLen] ;
2142: TCHAR UnicodeBuff [LongTextLen] ;
2143: PCOLUMNGROUP pColumnGroup ;
2144: int ParentNum, InstanceNum ;
2145:
2146:
2147: ParentNum = InstanceNum = 0 ;
2148:
2149: if (pColNum)
2150: {
2151: *pColNum = 0 ;
2152: }
2153:
2154: // export object name
2155: strcpy (TempBuff, LineEndStr) ;
2156: StringLen = strlen (TempBuff) ;
2157: TSPRINTF (UnicodeBuff, szObjectFormat, pObjectGroup->lpszObjectName) ;
2158: ConvertUnicodeStr (&TempBuff[StringLen], UnicodeBuff) ;
2159: strcat (TempBuff, LineEndStr) ;
2160:
2161: if (!FileWrite (hFile, TempBuff, strlen(TempBuff)))
2162: {
2163: goto Exit0 ;
2164: }
2165:
2166:
2167: // export column group
2168: if (pObjectGroup->pColumnGroupFirst)
2169: {
2170: strcpy (TempBuff, pDelimiter) ;
2171: strcat (TempBuff, pDelimiter) ;
2172: StringLen = strlen (TempBuff) ;
2173:
2174: bNeedToExport = FALSE ;
2175:
2176: // export Parent Names
2177: for (pColumnGroup = pObjectGroup->pColumnGroupFirst ;
2178: pColumnGroup ;
2179: pColumnGroup = pColumnGroup->pColumnGroupNext)
2180: { // for
2181:
2182: if (pColumnGroup->lpszParentName)
2183: {
2184: ParentNum++ ;
2185: bNeedToExport = TRUE ;
2186: ConvertUnicodeStr (&TempBuff[StringLen],
2187: pColumnGroup->lpszParentName) ;
2188: StringLen = strlen (TempBuff) ;
2189: }
2190:
2191: strcat (&TempBuff[StringLen], pDelimiter) ;
2192: StringLen = strlen (TempBuff) ;
2193: }
2194:
2195: if (bNeedToExport)
2196: {
2197: // only need to export when there is Parent Instance
2198: strcat (&TempBuff[StringLen], LineEndStr) ;
2199: if (!FileWrite (hFile, TempBuff, strlen(TempBuff)))
2200: {
2201: goto Exit0 ;
2202: }
2203: }
2204: else
2205: {
2206: ParentNum = 0 ;
2207: }
2208:
2209:
2210: // setup to export Instances
2211: strcpy (TempBuff, pDelimiter) ;
2212: strcat (TempBuff, pDelimiter) ;
2213: StringLen = strlen (TempBuff) ;
2214: bNeedToExport = FALSE ;
2215:
2216: // export Instance Names
2217: for (pColumnGroup = pObjectGroup->pColumnGroupFirst ;
2218: pColumnGroup ;
2219: pColumnGroup = pColumnGroup->pColumnGroupNext)
2220: { // for
2221:
2222: if (pColumnGroup->lpszInstanceName)
2223: {
2224: InstanceNum++ ;
2225: bNeedToExport = TRUE ;
2226: ConvertUnicodeStr (&TempBuff[StringLen],
2227: pColumnGroup->lpszInstanceName) ;
2228: StringLen = strlen (TempBuff) ;
2229: }
2230:
2231: strcat (&TempBuff[StringLen], pDelimiter) ;
2232: StringLen = strlen (TempBuff) ;
2233: }
2234:
2235: if (bNeedToExport)
2236: {
2237: strcat (&TempBuff[StringLen], LineEndStr) ;
2238: if (!FileWrite (hFile, TempBuff, strlen(TempBuff)))
2239: {
2240: goto Exit0 ;
2241: }
2242: }
2243: else
2244: {
2245: InstanceNum = 0 ;
2246: }
2247: }
2248:
2249: if (pColNum)
2250: {
2251: *pColNum = max (ParentNum, InstanceNum) ;
2252: }
2253:
2254: return (TRUE) ;
2255:
2256: Exit0:
2257: return (FALSE) ;
2258:
2259: } // ExportObjectName
2260:
2261: BOOL ExportLineName (HANDLE hFile, PLINE pLine, int *pExportCounterName)
2262: {
2263: FLOAT eValue ;
2264: int StringLen ;
2265: BOOL bWriteSuccess = TRUE ;
2266: CHAR TempBuff [LongTextLen] ;
2267: TCHAR UnicodeBuff [LongTextLen] ;
2268:
2269:
2270: strcpy (TempBuff, pDelimiter) ;
2271:
2272: if (*pExportCounterName)
2273: {
2274: StringLen = strlen (TempBuff) ;
2275: ConvertUnicodeStr (&TempBuff[StringLen], pLine->lnCounterName) ;
2276: strcat (TempBuff, pDelimiter) ;
2277: *pExportCounterName = FALSE ;
2278: }
2279: StringLen = strlen (TempBuff) ;
2280:
2281: if (pLine->bFirstTime == 0)
2282: {
2283: eValue = (*(pLine->valNext)) (pLine) ;
2284: TSPRINTF (UnicodeBuff,
2285: (eValue > eStatusLargeValueMax) ?
2286: szLargeValueFormat : szValueFormat,
2287: eValue) ;
2288: ConvertUnicodeStr (&TempBuff[StringLen], UnicodeBuff) ;
2289: }
2290: else
2291: {
2292: // export "----" for unstable values
2293: strcat (&TempBuff[StringLen], "----");
2294: }
2295:
2296: // write the line value, it may be inefficient but we
2297: // don't want to overflow TempBuff with line values..
2298: if (!FileWrite (hFile, TempBuff, strlen(TempBuff)))
2299: {
2300: goto Exit0 ;
2301: }
2302:
2303: return (TRUE) ;
2304:
2305:
2306: Exit0:
2307: return (FALSE) ;
2308: } // ExportLineName
2309:
2310:
2311: // This routine is need to insert the line values into its
2312: // column location. It is needed because not all the instances (columns)
2313: // are available for the same line.
2314: void SaveColumnLineData (PLINE pLine, LPSTR pColumnLineData)
2315: {
2316: FLOAT eValue ;
2317: LPSTR pColumnLine ;
2318: CHAR TempBuff [LongTextLen] ;
2319: TCHAR UnicodeBuff [LongTextLen] ;
2320:
2321: if (!pColumnLineData)
2322: {
2323: return ;
2324: }
2325:
2326: // find the offset into the pColumnLineData buffer for current line
2327: pColumnLine = pColumnLineData + pLine->iScaleIndex * ShortTextLen ;
2328:
2329: if (pLine->bFirstTime == 0)
2330: {
2331: eValue = (*(pLine->valNext)) (pLine) ;
2332: TSPRINTF (UnicodeBuff,
2333: (eValue > eStatusLargeValueMax) ?
2334: szLargeValueFormat : szValueFormat,
2335: eValue) ;
2336:
2337: ConvertUnicodeStr (TempBuff, UnicodeBuff) ;
2338: strncpy (pColumnLine, TempBuff, ShortTextLen) ;
2339: *(pColumnLine + ShortTextLen - 1) = '\0' ;
2340: }
2341: else
2342: {
2343: // export "----" for unstable values
2344: strcpy (pColumnLine, "----");
2345: }
2346: } // SaveColumnLineData
2347:
2348: BOOL ExportColumnLineData (HANDLE hFile,
2349: int ColumnTotal,
2350: PCOUNTERGROUP pCounterGroup,
2351: LPSTR pColumnLineData)
2352: {
2353: int iIndex ;
2354: int StringLen ;
2355: CHAR TempBuff [LongTextLen] ;
2356: LPSTR pCurrentLineData ;
2357:
2358: // export the counter name
2359: strcpy (TempBuff, pDelimiter) ;
2360: StringLen = strlen (TempBuff) ;
2361: ConvertUnicodeStr (&TempBuff[StringLen], pCounterGroup->pLineFirst->lnCounterName) ;
2362: strcat (TempBuff, pDelimiter) ;
2363: if (!FileWrite (hFile, TempBuff, strlen(TempBuff)))
2364: {
2365: goto Exit0 ;
2366: }
2367:
2368: // go thru each column and export the line value if it has been stored
2369: for (iIndex = 0, pCurrentLineData = pColumnLineData ;
2370: iIndex < ColumnTotal ;
2371: iIndex++, pCurrentLineData += ShortTextLen )
2372: {
2373: if (*pCurrentLineData != 0)
2374: {
2375: // data available for this column
2376: if (!FileWrite (hFile, pCurrentLineData, strlen(pCurrentLineData)))
2377: {
2378: goto Exit0 ;
2379: }
2380: }
2381:
2382: if (!FileWrite (hFile, pDelimiter, strlen(pDelimiter)))
2383: {
2384: goto Exit0 ;
2385: }
2386: }
2387:
2388: if (!FileWrite (hFile, LineEndStr, strlen(LineEndStr)))
2389: {
2390: goto Exit0 ;
2391: }
2392:
2393: return (TRUE) ;
2394:
2395:
2396: Exit0:
2397: return (FALSE) ;
2398:
2399: } // ExportColumnLineData
2400:
2401: void ExportReport (void)
2402: {
2403: HANDLE hFile = 0 ;
2404: PREPORT pReport ;
2405: PSYSTEMGROUP pSystemGroup ;
2406: POBJECTGROUP pObjectGroup ;
2407: PCOUNTERGROUP pCounterGroup ;
2408: PLINE pLine ;
2409: BOOL bExportComputer ;
2410: BOOL bExportObject ;
2411: BOOL bExportCounterName ;
2412: int ColumnTotal = 0 ;
2413: LPSTR pColumnLineData = NULL ;
2414: LPTSTR pFileName = NULL ;
2415: INT ErrCode = 0 ;
2416:
2417: if (!(pReport = ReportData (hWndReport)))
2418: {
2419: return ;
2420: }
2421:
2422: // see if there is anything to export..
2423: if (!(pReport->pSystemGroupFirst))
2424: {
2425: return ;
2426: }
2427:
2428: SetHourglassCursor() ;
2429:
2430: if (ErrCode = ExportFileOpen (hWndReport, &hFile,
2431: pReport->iIntervalMSecs, &pFileName))
2432: {
2433: goto Exit0 ;
2434: }
2435:
2436: if (!pFileName)
2437: {
2438: // the case when user cancel
2439: goto Exit0 ;
2440: }
2441:
2442: // export each system group
2443:
2444: for (pSystemGroup = pReport->pSystemGroupFirst ;
2445: pSystemGroup ;
2446: pSystemGroup = pSystemGroup->pSystemGroupNext)
2447: { // for System...
2448:
2449: bExportComputer = TRUE ;
2450:
2451: for (pObjectGroup = pSystemGroup->pObjectGroupFirst ;
2452: pObjectGroup ;
2453: pObjectGroup = pObjectGroup->pObjectGroupNext)
2454: { // for Object...
2455:
2456: bExportObject = TRUE ;
2457:
2458: for (pCounterGroup = pObjectGroup->pCounterGroupFirst ;
2459: pCounterGroup ;
2460: pCounterGroup = pCounterGroup->pCounterGroupNext)
2461: { // for Counter...
2462:
2463: bExportCounterName = TRUE ;
2464:
2465: // Column data buffer has been allocated for this object type,
2466: // zero out the buffer and prepare for next round.
2467:
2468: if (pColumnLineData)
2469: {
2470: memset (pColumnLineData, 0, ColumnTotal * ShortTextLen) ;
2471: }
2472:
2473: for (pLine = pCounterGroup->pLineFirst ;
2474: pLine ;
2475: pLine = pLine->pLineCounterNext)
2476: { // for Line...
2477:
2478: if (bExportComputer)
2479: {
2480: // only need to do this for the first object
2481: bExportComputer = FALSE ;
2482: if (!ExportComputerName (hFile, pSystemGroup))
2483: {
2484: ErrCode = ERR_EXPORT_FILE ;
2485: goto Exit0 ;
2486: }
2487: }
2488:
2489: if (bExportObject)
2490: {
2491: // only need to do this for the first counter group
2492: bExportObject = FALSE ;
2493: if (!ExportObjectName (hFile, pObjectGroup, &ColumnTotal))
2494: {
2495: ErrCode = ERR_EXPORT_FILE ;
2496: goto Exit0 ;
2497: }
2498:
2499: if (ColumnTotal > 1)
2500: {
2501: // special case to setup a column array and export
2502: // the line values later
2503: pColumnLineData = MemoryAllocate (ColumnTotal * ShortTextLen) ;
2504: if (!pColumnLineData)
2505: {
2506: ErrCode = ERR_EXPORT_FILE ;
2507: goto Exit0 ;
2508: }
2509: }
2510: }
2511:
2512: if (ColumnTotal > 1)
2513: {
2514: // save the line value into its column & export later
2515: SaveColumnLineData (pLine, pColumnLineData) ;
2516: }
2517: else
2518: {
2519: // simple case, export the line now
2520: if (!ExportLineName (hFile, pLine, &bExportCounterName))
2521: {
2522: ErrCode = ERR_EXPORT_FILE ;
2523: goto Exit0 ;
2524: }
2525: }
2526: } // for Line...
2527:
2528: if (!bExportCounterName)
2529: {
2530: // export the line end
2531: if (!FileWrite (hFile, LineEndStr, strlen(LineEndStr)))
2532: {
2533: ErrCode = ERR_EXPORT_FILE ;
2534: goto Exit0 ;
2535: }
2536: }
2537:
2538: if (pColumnLineData)
2539: {
2540: // now, do the actual export
2541: if (!ExportColumnLineData (hFile,
2542: ColumnTotal,
2543: pCounterGroup,
2544: pColumnLineData))
2545: {
2546: ErrCode = ERR_EXPORT_FILE ;
2547: goto Exit0 ;
2548: }
2549: }
2550: } // for Counter...
2551:
2552: // done with the object, done with the buffer
2553: if (pColumnLineData)
2554: {
2555: MemoryFree (pColumnLineData) ;
2556: ColumnTotal = 0 ;
2557: pColumnLineData = NULL ;
2558: }
2559: } // for Object
2560:
2561:
2562: } // for System...
2563:
2564: Exit0:
2565:
2566: SetArrowCursor() ;
2567:
2568: if (pColumnLineData)
2569: {
2570: MemoryFree (pColumnLineData) ;
2571: }
2572:
2573: if (hFile)
2574: {
2575: CloseHandle (hFile) ;
2576: }
2577:
2578: if (pFileName)
2579: {
2580: if (ErrCode)
2581: {
2582: DlgErrorBox (hWndGraph, ErrCode, pFileName) ;
2583: }
2584:
2585: MemoryFree (pFileName) ;
2586: }
2587:
2588: } // ExportReport
2589:
2590:
2591: BOOL
2592: BuildNewValueListForReport (
2593: )
2594: {
2595: PREPORT pReport;
2596:
2597: pReport = ReportData (hWndReport);
2598:
2599: return BuildValueListForSystems (
2600: pReport->pSystemFirst,
2601: pReport->pLineFirst);
2602:
2603: }
2604:
2605:
2606:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.