Return to log.c CVS log

Up to [WindowsNT SDKs] / mstools / samples / sdktools / perfmon

Annotation of mstools/samples/sdktools/perfmon/log.c, revision 1.1

1.1     ! root        1: /*****************************************************************************
        !             2:  *
        !             3:  *  Log.c - This module handles the Logging.
        !             4:  *
        !             5:  *  Microsoft Confidential
        !             6:  *  Copyright (c) 1992-1993 Microsoft Corporation
        !             7:  *
        !             8:  *
        !             9:  ****************************************************************************/
        !            10: 
        !            11: 
        !            12: //==========================================================================//
        !            13: //                                  Includes                                //
        !            14: //==========================================================================//
        !            15: 
        !            16: #include <stdio.h>
        !            17: 
        !            18: #include "perfmon.h"
        !            19: #include "log.h"
        !            20: 
        !            21: #include "fileutil.h"
        !            22: #include "owndraw.h"
        !            23: #include "pmemory.h"       // for MemoryXXX (mallloc-type) routines
        !            24: #include "perfmops.h"      // for SystemAdd
        !            25: #include "perfdata.h"
        !            26: #include "playback.h"      // for PlayingBackLog
        !            27: #include "status.h"        // for StatusUpdateIcons
        !            28: #include "system.h"        // for SystemAdd
        !            29: #include "utils.h"
        !            30: #include "fileopen.h"      // for FileGetName
        !            31: #include "command.h"
        !            32: 
        !            33: extern TCHAR LOCAL_SYS_CODE_NAME[] ;
        !            34: 
        !            35: //==========================================================================//
        !            36: //                              Funtion Prototypes                          //
        !            37: //==========================================================================//
        !            38: 
        !            39: 
        !            40: BOOL LogWriteStartBookmark (HWND hWnd, SYSTEMTIME *pSystemTime) ;
        !            41: BOOL LogWriteBookmarkData (HWND hWnd, PBOOKMARK pBookMark) ;
        !            42: 
        !            43: 
        !            44: //==========================================================================//
        !            45: //                                  Constants                               //
        !            46: //==========================================================================//
        !            47: 
        !            48: 
        !            49: 
        !            50: #define LogNameMinLen             15
        !            51: #define LogObjectMinLen           20
        !            52: 
        !            53: // This is set to 1 min
        !            54: #define LARGE_INTERVAL            60
        !            55: 
        !            56: //=============================//
        !            57: // Log Class                   //
        !            58: //=============================//
        !            59: 
        !            60: 
        !            61: #define dwLogClassStyle           (CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS)
        !            62: #define iLogClassExtra            (0)
        !            63: #define iLogWindowExtra           (0)
        !            64: #define dwLogWindowStyle          (WS_CHILD)
        !            65: 
        !            66: 
        !            67: //==========================================================================//
        !            68: //                                Local Data                                //
        !            69: //==========================================================================//
        !            70: 
        !            71: 
        !            72: 
        !            73: int            xStatusWidth ;
        !            74: int            xNameMinWidth ;
        !            75: 
        !            76: TCHAR          szClosed [ShortTextLen] ;
        !            77: TCHAR          szCollecting [ShortTextLen] ;
        !            78: // TCHAR          szPaused [ControlStringLen + 1] ;
        !            79: 
        !            80: 
        !            81: HWND           hWndLogEntries ;
        !            82: 
        !            83: LOGINDEXBLOCK  *pLogIndexBlock ;
        !            84: 
        !            85: 
        !            86: //==========================================================================//
        !            87: //                                   Macros                                 //
        !            88: //==========================================================================//
        !            89: 
        !            90: 
        !            91: #define LogEntryN(hWndLogEntries, iIndex)        \
        !            92:    ((PLOGENTRY) LBData (hWndLogEntries, iIndex))
        !            93: 
        !            94: 
        !            95: //==========================================================================//
        !            96: //                              Local Functions                             //
        !            97: //==========================================================================//
        !            98: 
        !            99: void LogAddEntryToList (PLOGENTRY *ppLogEntryFirst, PLOGENTRY pLogNewEntry)
        !           100: {
        !           101:    // insert the new entry at the beginning
        !           102:    pLogNewEntry->pNextLogEntry = *ppLogEntryFirst ;
        !           103:    *ppLogEntryFirst = pLogNewEntry ;
        !           104: }
        !           105: 
        !           106: void LogDeleteEntryFromList (PLOGENTRY *ppLogEntryFirst, PLOGENTRY pLogEntryDel)
        !           107: {
        !           108:    PLOGENTRY   pLogEntry ;
        !           109: 
        !           110:    if (*ppLogEntryFirst == pLogEntryDel)
        !           111:       {
        !           112:       *ppLogEntryFirst = pLogEntryDel->pNextLogEntry ;
        !           113:       }
        !           114:    else
        !           115:       {
        !           116:       for (pLogEntry = *ppLogEntryFirst ;
        !           117:          pLogEntry ;
        !           118:          pLogEntry = pLogEntry->pNextLogEntry)
        !           119:          {
        !           120:          if (pLogEntry->pNextLogEntry == pLogEntryDel)
        !           121:             {
        !           122:             // found, remove this entry from the list
        !           123:             pLogEntry->pNextLogEntry =
        !           124:                pLogEntryDel->pNextLogEntry ;
        !           125:             break ;
        !           126:             }
        !           127:          }
        !           128:       }
        !           129: }
        !           130: 
        !           131: 
        !           132: // LogDeleteIndex - delete the log entry specified by iIndex
        !           133: // and do memory clean-up
        !           134: void static LogDeleteIndex (HWND hWndLogEntries, int iIndex)
        !           135: {
        !           136:    PLOGENTRY   pLogEntry ;
        !           137:    PLOG        pLog ;
        !           138: 
        !           139:    pLogEntry = (PLOGENTRY) LBData(hWndLogEntries, iIndex) ;
        !           140: 
        !           141:    
        !           142:    if (pLogEntry && pLogEntry != (PLOGENTRY)LB_ERR)
        !           143:       {
        !           144:       pLog = LogData (hWndLog) ;
        !           145: 
        !           146:       if (pLog->pLogEntryFirst)
        !           147:          {
        !           148:          LogDeleteEntryFromList (&(pLog->pLogEntryFirst), pLogEntry) ;
        !           149:          }
        !           150: 
        !           151:       MemoryFree (pLogEntry) ;
        !           152:       }
        !           153:       
        !           154:    LBDelete (hWndLogEntries, iIndex) ;
        !           155: }
        !           156: 
        !           157: 
        !           158: void LogEntriesChanged (HWND hWndLogEntries)
        !           159: /*
        !           160:    Effect:        Perform any actions needed when an entry has been added or
        !           161:                   removed from the log. In particular, determine if a new
        !           162:                   "Object" column width is appropriate. If it is, then
        !           163:                   change the width and redraw the log entries list.
        !           164: */
        !           165:    {  // LogEntriesChanged
        !           166:    int         iIndex ;
        !           167:    int         iIndexNum ;
        !           168:    int         xCol1Width ;
        !           169:    HDC         hDC ;
        !           170:    PLOG        pLog ;
        !           171:    PLOGENTRY   pLogEntry ;
        !           172:    PPERFSYSTEM pSystem;
        !           173: 
        !           174:    pLog = LogData (hWndLog) ;
        !           175:    xCol1Width = 0 ;
        !           176: 
        !           177:    hDC = GetDC (hWndLog) ;
        !           178:    iIndexNum = LBNumItems (hWndLogEntries) ;
        !           179:     
        !           180:     // clear value Strings for all systems
        !           181: 
        !           182:     for (pSystem = pLog->pSystemFirst;
        !           183:          pSystem;
        !           184:          pSystem = pSystem->pSystemNext) {
        !           185:         if (pSystem) {
        !           186:             RemoveObjectsFromSystem (pSystem);
        !           187:         }
        !           188:     }
        !           189: 
        !           190:    for (iIndex = 0 ;
        !           191:         iIndex < iIndexNum ;
        !           192:         iIndex++)
        !           193:       {  // for all items in the list
        !           194:       pLogEntry = LogEntryN (hWndLogEntries, iIndex) ;
        !           195:       xCol1Width = max (TextWidth (hDC, pLogEntry->szObject), 
        !           196:                         xCol1Width) ;
        !           197: 
        !           198:       pSystem = SystemGet (pLog->pSystemFirst, pLogEntry->szComputer);
        !           199:       if (pSystem) {
        !           200:         AppendObjectToValueList (
        !           201:                 pLogEntry->ObjectTitleIndex,
        !           202:                 pSystem->lpszValue);
        !           203:         } 
        !           204:       
        !           205:       }  // for
        !           206: 
        !           207:    xCol1Width += 2 * xScrollWidth ;
        !           208:    xCol1Width = max (xCol1Width, 
        !           209:                      TextAvgWidth (hDC, LogObjectMinLen)) ;
        !           210:    if (xCol1Width != pLog->xCol1Width)
        !           211:       {
        !           212:       pLog->xCol1Width = xCol1Width ;
        !           213:       WindowInvalidate (hWndLogEntries) ;
        !           214:       }
        !           215:    ReleaseDC (hWndLog, hDC) ;
        !           216:    }  // LogEntriesChanged
        !           217: 
        !           218: 
        !           219: LPTSTR StatusText (int iPMStatus)
        !           220: /*
        !           221:    Effect:        Return a string representation of the log status
        !           222:                   iPMStatus.
        !           223: 
        !           224:    Note:          Since these are globals, we can just return a pointer
        !           225:                   to them. The user of this routine should not free
        !           226:                   these pointers or modify the string.
        !           227: */
        !           228:    {
        !           229:    switch (iPMStatus)
        !           230:       {  // switch
        !           231:       case iPMStatusClosed:
        !           232:          return (szClosed) ;
        !           233: 
        !           234:       case iPMStatusCollecting:
        !           235:          return (szCollecting) ;
        !           236: 
        !           237: //      case iPMStatusPaused:
        !           238: //         return (szPaused) ;
        !           239: 
        !           240:       default:
        !           241:          return (szClosed) ;
        !           242:       }  // switch
        !           243:    }  // StatusText
        !           244: 
        !           245: 
        !           246: PLOG AllocateLogData (HWND hWndLog)
        !           247:    {
        !           248:    PLOG           pLog ;
        !           249: 
        !           250:    pLog = LogData (hWndLog) ;
        !           251: 
        !           252:    pLog->iStatus = iPMStatusClosed ;
        !           253:    pLog->bManualRefresh = FALSE ;
        !           254: 
        !           255:    // let's not give it a filename
        !           256: 
        !           257: /*!!
        !           258:    FileCombine (pLog->szFilePath, 
        !           259:                 szDefaultLogDirectory, szDefaultLogFileName) ;
        !           260: !!*/
        !           261:    strclr (pLog->szFilePath) ;
        !           262: 
        !           263:    pLog->pSystemFirst = NULL;
        !           264:    pLog->lFileSize = 0L ;
        !           265:    pLog->iIntervalMSecs = iDefaultLogIntervalSecs * 1000 ;
        !           266: 
        !           267:    pLog->pPerfData = (PPERFDATA) MemoryAllocate (STARTING_SYSINFO_SIZE) ;
        !           268:    pLog->pLogData = (PPERFDATA) MemoryAllocate (STARTING_SYSINFO_SIZE) ;
        !           269:    pLog->dwDetailLevel = PERF_DETAIL_WIZARD ;
        !           270:    LogEntriesChanged (hWndLogEntries) ;
        !           271: 
        !           272:    return (pLog) ;
        !           273:    }  // AllocateLogData
        !           274: 
        !           275: 
        !           276: void FreeLogData (PLOG pLog)
        !           277:    {  // FreeLogData
        !           278:    MemoryFree (pLog->pPerfData) ;
        !           279:    MemoryFree (pLog->pLogData) ;
        !           280:    }  // FreeLogData
        !           281: 
        !           282: 
        !           283: void UpdateLogSize (HWND hWnd)
        !           284: /*
        !           285:    Effect:        Set the size value to the current size.  Also change the
        !           286:                   size entry in the status line.
        !           287: */
        !           288:    {  // UpdateLogSize
        !           289:    PLOG           pLog ;
        !           290:    TCHAR          szSize [ShortTextLen + 1] ;
        !           291: 
        !           292:    pLog = LogData (hWnd) ;
        !           293:    
        !           294:    LongToCommaString (pLog->lFileSize, szSize) ;
        !           295:    SetDlgItemText (hWnd, IDD_LOGSIZE, szSize) ;
        !           296: 
        !           297:    if (!PlayingBackLog())
        !           298:       {
        !           299:       StatusUpdateIcons (hWndStatus) ;
        !           300:       }
        !           301:    }  // UpdateLogSize
        !           302: 
        !           303: 
        !           304: HANDLE LogAppendSetup(PLOG pLog, PLOGHEADER pLogFileHeader)
        !           305:    {  // LogAppendSetup
        !           306:    PLOGHEADER     pHeader ;
        !           307:    LOGPOSITION    LP ;
        !           308:    DWORD          lPreviousIndexBlock ;
        !           309:    DWORD          lNextIndexBlock ;
        !           310:    PLOGHEADER     pPlaybackLogHeader ;
        !           311:    HANDLE         hMapHandle ;
        !           312: 
        !           313:    pHeader = (PLOGHEADER) FileMap(pLog->hFile, &hMapHandle) ;
        !           314:    if (!pHeader ||
        !           315:        !strsame(pHeader->szSignature, LogFileSignature) ||
        !           316:        pHeader->wVersion != LogFileVersion ||
        !           317:        pHeader->wRevision != LogFileRevision)
        !           318:       {
        !           319:       if (pHeader)
        !           320:          {
        !           321:          FileUnMap((LPVOID)pHeader, hMapHandle) ;
        !           322:          }
        !           323:       return 0 ;
        !           324:       }
        !           325: 
        !           326:    *pLogFileHeader = *pHeader ;
        !           327: 
        !           328: 
        !           329:    LP.pIndexBlock = FirstIndexBlock(pHeader) ;
        !           330:    LP.iIndex = 0 ;
        !           331:    LP.iPosition = 0 ;
        !           332:    lPreviousIndexBlock = pHeader->iLength ;
        !           333:    lNextIndexBlock = LP.pIndexBlock->lNextBlockOffset ;
        !           334: 
        !           335:    // since inside NextReLogIndexPosition would eventually call
        !           336:    // PlaybackSeek for large log file, we have to temporarily
        !           337:    // setup PlaybackLog.pHeader.   Not a good fix but it works...
        !           338:    pPlaybackLogHeader = PlaybackLog.pHeader ;
        !           339:    PlaybackLog.pHeader = pHeader ;
        !           340:    while (NextReLogIndexPosition(&LP))
        !           341:       {
        !           342:       if (LP.pIndexBlock->lNextBlockOffset != lNextIndexBlock)
        !           343:          {
        !           344:          lPreviousIndexBlock = lNextIndexBlock ;
        !           345:          lNextIndexBlock = LP.pIndexBlock->lNextBlockOffset ;
        !           346:          }
        !           347:       }
        !           348: 
        !           349:    PlaybackLog.pHeader = pPlaybackLogHeader ;
        !           350:    if (!pLogIndexBlock)
        !           351:       {
        !           352:       pLogIndexBlock = (LOGINDEXBLOCK *) MemoryAllocate (sizeof(LOGINDEXBLOCK)) ;
        !           353:       }
        !           354:    *pLogIndexBlock = *LP.pIndexBlock ;
        !           355:    pLog->lIndexBlockOffset = lPreviousIndexBlock ;
        !           356:    pLog->iIndex = ++LP.iIndex ;
        !           357:    pLog->lFileSize = FileSeekEnd(pLog->hFile, 0) ;
        !           358: 
        !           359:    FileUnMap((LPVOID)pHeader, hMapHandle) ;
        !           360:    return pLog->hFile ;
        !           361:    }  // LogAppendSetup
        !           362: 
        !           363: void LogRemoveCounterName (PLOG pLog)
        !           364:    {
        !           365:    PPERFSYSTEM    pSystem ;
        !           366: 
        !           367:    if (pLog->pBaseCounterName)
        !           368:       {
        !           369:       MemoryFree (pLog->pBaseCounterName) ;
        !           370:       }
        !           371:    pLog->pBaseCounterName = 0 ;
        !           372:    pLog->lBaseCounterNameSize = 0 ;
        !           373:    pLog->lBaseCounterNameOffset = 0 ;
        !           374: 
        !           375:    // clear all the system marker to indicate they have not been 
        !           376:    // saved
        !           377:    for (pSystem = pLog->pSystemFirst ;
        !           378:       pSystem ;
        !           379:       pSystem = pSystem->pSystemNext)
        !           380:       {
        !           381:       pSystem->bSystemCounterNameSaved = FALSE ;
        !           382:       }
        !           383:    }
        !           384: 
        !           385: int CreateLogFile (PLOG pLog, BOOL bCreateFile, BOOL bSameFile)
        !           386:    {  // CreateLogFile
        !           387:    HANDLE               returnHandle ;
        !           388:    LOGHEADER            LogFileHeader ;
        !           389:    long                 lCurPosition ;
        !           390:    LOGFILECOUNTERNAME   CounterNameRecord ;
        !           391: 
        !           392:    pLog->lFileSize = 0 ;
        !           393: 
        !           394:    if (!pLogIndexBlock)
        !           395:       {
        !           396:       pLogIndexBlock = (LOGINDEXBLOCK *) MemoryAllocate (sizeof(LOGINDEXBLOCK)) ;
        !           397:       }
        !           398: 
        !           399:    lstrcpy (pLogIndexBlock->szSignature, LogIndexSignature) ;
        !           400:    pLog->hFile = FileHandleOpen (pLog->szFilePath) ;
        !           401:    if (pLog->hFile != INVALID_HANDLE_VALUE)
        !           402:       {
        !           403:       // if this is a pre-existing log file, set up to append to it
        !           404:       returnHandle = LogAppendSetup(pLog, &LogFileHeader) ;
        !           405:       if (!returnHandle)
        !           406:          {
        !           407:          // this is not a log file...
        !           408:          CloseHandle (pLog->hFile) ;
        !           409:          return (ERR_BAD_LOG_FILE) ;
        !           410:          }
        !           411:       
        !           412:       pLog->hFile = returnHandle ;
        !           413:       }
        !           414: 
        !           415:    if (bCreateFile && (!pLog->hFile || pLog->hFile == INVALID_HANDLE_VALUE))
        !           416:       {
        !           417:       // Create a new log file if needed.
        !           418:       pLog->hFile = FileHandleCreate (pLog->szFilePath) ;
        !           419:       if (!pLog->hFile)
        !           420:          return (ERR_LOG_FILE) ;
        !           421:       lstrcpy (LogFileHeader.szSignature, LogFileSignature) ;
        !           422:       LogFileHeader.wVersion = LogFileVersion ;
        !           423:       LogFileHeader.wRevision = LogFileRevision ;
        !           424:       LogFileHeader.iLength = sizeof (LOGHEADER) ;
        !           425:       LogFileHeader.lBaseCounterNameOffset = 0 ;
        !           426:       if (!FileWrite (pLog->hFile, &LogFileHeader, sizeof (LogFileHeader)))
        !           427:          {
        !           428:          CloseHandle (pLog->hFile) ;
        !           429:          return (ERR_LOG_FILE) ;
        !           430:          }
        !           431: 
        !           432:       pLog->iIndex = 0 ;
        !           433:       pLog->lIndexBlockOffset = FileTell (pLog->hFile) ;
        !           434:       FileSeekCurrent (pLog->hFile, sizeof (LOGINDEXBLOCK)) ;
        !           435:       pLog->lFileSize = sizeof(LOGHEADER) + sizeof (LOGINDEXBLOCK) ;
        !           436:       pLogIndexBlock->iNumIndexes = 0 ;
        !           437:       pLogIndexBlock->lNextBlockOffset = 0 ;
        !           438: 
        !           439:       // get rid of any previous counter names and get ready for start
        !           440:       if (!bSameFile)
        !           441:          {
        !           442:          LogRemoveCounterName (pLog) ;
        !           443:          }
        !           444:       }
        !           445:    else if (bCreateFile)
        !           446:       {
        !           447:       // this is an existing log file, setup the counter names
        !           448:       // LogFileHeader already has the header info filled in
        !           449:       // by LogAppendSetup
        !           450:       if (!bSameFile || !pLog->pBaseCounterName)
        !           451:          {
        !           452:          // get rid of any previous counter names
        !           453:          LogRemoveCounterName (pLog) ;
        !           454: 
        !           455:          // read the new names and get ready for start
        !           456:          lCurPosition = FileTell (pLog->hFile) ;
        !           457: 
        !           458:          FileSeekBegin (pLog->hFile,
        !           459:             LogFileHeader.lBaseCounterNameOffset) ;
        !           460: 
        !           461:          if (!(FileRead (pLog->hFile,
        !           462:             &CounterNameRecord,
        !           463:             sizeof (CounterNameRecord))))
        !           464:             {
        !           465:             FileSeekBegin (pLog->hFile,
        !           466:                lCurPosition) ;
        !           467:             goto EXIT ;
        !           468:             }
        !           469: 
        !           470:          FileSeekBegin (pLog->hFile,
        !           471:             CounterNameRecord.lCurrentCounterNameOffset) ;
        !           472: 
        !           473:          if (!(pLog->pBaseCounterName = MemoryAllocate (
        !           474:             CounterNameRecord.lUnmatchCounterNames)))
        !           475:             {
        !           476:             FileSeekBegin (pLog->hFile,
        !           477:                lCurPosition) ;
        !           478:             goto EXIT ;
        !           479:             }
        !           480:          if (!(FileRead (pLog->hFile,
        !           481:             pLog->pBaseCounterName,
        !           482:             CounterNameRecord.lUnmatchCounterNames)))
        !           483:             {
        !           484:             MemoryFree (pLog->pBaseCounterName) ;
        !           485:             pLog->pBaseCounterName = NULL ;
        !           486:             FileSeekBegin (pLog->hFile,
        !           487:                lCurPosition) ;
        !           488:             goto EXIT ;
        !           489:             }
        !           490:          // we got the data, fill in other info
        !           491:          pLog->lBaseCounterNameSize =
        !           492:             CounterNameRecord.lUnmatchCounterNames ;
        !           493:          pLog->lBaseCounterNameOffset =
        !           494:             LogFileHeader.lBaseCounterNameOffset ;
        !           495:                
        !           496:          FileSeekBegin (pLog->hFile,
        !           497:             lCurPosition) ;
        !           498:          }
        !           499:       }
        !           500: 
        !           501: EXIT:
        !           502: 
        !           503:    return (0) ;
        !           504: 
        !           505:    }  // CreateLogFile
        !           506: 
        !           507: 
        !           508: BOOL LogGetSystemPerfData (PLOG pLog,
        !           509:                            HKEY hKey)
        !           510:    {
        !           511:    long           lError ;
        !           512:    DWORD          dwSize;
        !           513: 
        !           514:    while (TRUE)
        !           515:       {
        !           516:       dwSize = MemorySize (pLog->pPerfData);
        !           517:       lError = GetSystemPerfData (hKey, L"Global", pLog->pPerfData,
        !           518:                                   &dwSize) ;
        !           519: 
        !           520:       if (!lError)
        !           521:          return (TRUE) ;
        !           522: 
        !           523:       if (lError == ERROR_MORE_DATA)
        !           524:          {
        !           525:          pLog->pPerfData = MemoryResize (pLog->pPerfData, 
        !           526:                                          MemorySize (pLog->pPerfData) +
        !           527:                                          dwPerfDataIncrease) ;
        !           528:          if (!pLog->pPerfData)
        !           529:             return (FALSE) ;
        !           530:          }
        !           531:       else
        !           532:          {
        !           533:          return (FALSE) ;
        !           534:          }
        !           535:       }  // while
        !           536:    }
        !           537: 
        !           538: void LogWriteIndexBlock (PLOG pLog)
        !           539:    {
        !           540:    FileSeekBegin (pLog->hFile, 
        !           541:                   pLog->lIndexBlockOffset) ;
        !           542:    pLogIndexBlock->lNextBlockOffset = 0 ;
        !           543:    FileWrite (pLog->hFile,
        !           544:               (LPSTR) pLogIndexBlock,
        !           545:               sizeof (LOGINDEXBLOCK)) ;
        !           546:    }  // LogWriteIndexBlock
        !           547: 
        !           548: 
        !           549: BOOL LogWriteIndex (PLOG pLog,
        !           550:                     UINT uFlags,
        !           551:                     SYSTEMTIME *pSystemTime,
        !           552:                     LONG lDataOffset,
        !           553:                     int iSystemsLogged) 
        !           554:    {  // LogWriteIndex
        !           555:    LOGINDEX       Index ;
        !           556:    long           lNextBlockOffset ;
        !           557:    BOOL           WriteOK ;
        !           558:    //=============================//
        !           559:    // Add Index Block Entry       //
        !           560:    //=============================//
        !           561:    //=============================//
        !           562:    // Index Block Full?           //
        !           563:    //=============================//
        !           564: 
        !           565:    WriteOK = TRUE ;
        !           566: 
        !           567:    if (pLog->iIndex == LogFileBlockMaxIndexes - 1)
        !           568:       {
        !           569:       lNextBlockOffset = FileTell (pLog->hFile) ;
        !           570:       pLogIndexBlock->lNextBlockOffset = lNextBlockOffset ;
        !           571:       FileSeekBegin (pLog->hFile, 
        !           572:                      pLog->lIndexBlockOffset) ;
        !           573:       WriteOK = FileWrite (pLog->hFile,
        !           574:                            (LPSTR) pLogIndexBlock,
        !           575:                            sizeof (LOGINDEXBLOCK)) ;
        !           576:       if (WriteOK)
        !           577:          {
        !           578:          FileSeekBegin (pLog->hFile,
        !           579:                         lNextBlockOffset) ;
        !           580:          // Fake file end until we really write the block
        !           581:          pLogIndexBlock->iNumIndexes = 0 ;
        !           582:          pLogIndexBlock->lNextBlockOffset = 0 ;
        !           583:          WriteOK = FileWrite (pLog->hFile,
        !           584:                               (LPSTR) pLogIndexBlock,
        !           585:                               sizeof (LOGINDEXBLOCK)) ;
        !           586:          if (WriteOK)
        !           587:             {
        !           588:             pLog->lIndexBlockOffset = lNextBlockOffset ;
        !           589:             pLog->iIndex = 0 ;
        !           590:             pLog->lFileSize += sizeof (LOGINDEXBLOCK) ;
        !           591:             }
        !           592:          }
        !           593:       }  // if
        !           594: 
        !           595:    //=============================//
        !           596:    // Add Index Block Entry       //
        !           597:    //=============================//
        !           598: 
        !           599:    Index.uFlags = uFlags ;
        !           600:    Index.SystemTime = *pSystemTime ;
        !           601:    Index.lDataOffset = lDataOffset ;
        !           602:    Index.iSystemsLogged = iSystemsLogged ;
        !           603:     
        !           604:    pLogIndexBlock->aIndexes [pLog->iIndex] = Index ;
        !           605:    pLog->iIndex++ ;
        !           606:    pLogIndexBlock->iNumIndexes++ ;
        !           607: 
        !           608:    // write out the index block if the log interval if too large
        !           609:    if (pLog->iIntervalMSecs >= LARGE_INTERVAL * 1000 )
        !           610:       {
        !           611:       LONG           lCurPosition ;
        !           612:    
        !           613:       // save the current file position
        !           614:       lCurPosition = FileTell (pLog->hFile) ;
        !           615: 
        !           616:       // flush the index block to the file
        !           617:       LogWriteIndexBlock (pLog) ;
        !           618: 
        !           619:       // restore previous file position since
        !           620:       // LogWriteIndexBlock has messed it up
        !           621:       FileSeekBegin (pLog->hFile, lCurPosition) ;
        !           622:       }
        !           623:    return (WriteOK) ;
        !           624:    }  // LogWriteIndex
        !           625: 
        !           626: 
        !           627: 
        !           628: BOOL LogWritePerfData (HWND hWnd,
        !           629:                        PLOG pLog,
        !           630:                        PPERFDATA pPerfData,
        !           631:                        SYSTEMTIME *pSystemTime,
        !           632:                        DWORD iNumSystems,
        !           633:                        BOOL bWriteIndex)
        !           634:    {  // LogWritePerfData
        !           635:    LONG           lSize ;
        !           636:    BOOL           WriteOK ;
        !           637:    LONG           lCurPosition ;
        !           638:    
        !           639:    lSize = pPerfData->TotalByteLength ;
        !           640: 
        !           641:    lCurPosition = FileTell (pLog->hFile) ;
        !           642: 
        !           643:    //=============================//
        !           644:    // Write Perf Data             //
        !           645:    //=============================//
        !           646: 
        !           647:    WriteOK = FileWrite (pLog->hFile, (LPSTR) pPerfData, lSize) ;
        !           648:    if (WriteOK)
        !           649:       {
        !           650:       pLog->lFileSize += lSize ;
        !           651: 
        !           652:       if (bWriteIndex)
        !           653:          {
        !           654:          WriteOK = LogWriteIndex (pLog,
        !           655:                                   LogFileIndexData,
        !           656:                                   pSystemTime,
        !           657:                                   lCurPosition,
        !           658:                                   iNumSystems) ;
        !           659:          }
        !           660:       }
        !           661:    if ( !WriteOK )
        !           662:       {
        !           663:       CloseLog (hWnd, pLog) ;
        !           664:       PrepareMenu (GetMenu (hWndMain)) ;
        !           665:       UpdateLogDisplay (hWnd) ;   
        !           666:       DlgErrorBox (hWnd, ERR_LOG_FILE, pLog->szFilePath) ;
        !           667:       }
        !           668:    return (WriteOK) ;
        !           669:    }  // LogWritePerfData
        !           670: 
        !           671: 
        !           672: //==========================================================================//
        !           673: //                              Message Handlers                            //
        !           674: //==========================================================================//
        !           675: 
        !           676: 
        !           677: void static OnSize (HWND hDlg,
        !           678:                     int xWidth,
        !           679:                     int yHeight)
        !           680: /*
        !           681:    Effect:        Perform any actions necessary when the log window (dialog)
        !           682:                   is resized. In particular, move and resize some of the
        !           683:                   dialogs controls.
        !           684: 
        !           685:    Internals:     The rightmost control, the log status, contains one of
        !           686:                   only several values. These values are all within 
        !           687:                   xStatusWidth, computed at init time. Put this control
        !           688:                   one scroll width away from the right edge at fixed
        !           689:                   width. Move its associated text prompt with it. Then
        !           690:                   use the remaining space for the filename control, which
        !           691:                   can probably use it.
        !           692: 
        !           693:    To Do:         Need to consider minimum first.
        !           694: */
        !           695:    {  // OnSize
        !           696:    int            xStatusPos ;
        !           697:    int            xStatusTextPos ;
        !           698:    int            xNameWidth ;
        !           699:    int            xMinWidth ;
        !           700: 
        !           701:    //=============================//
        !           702:    // Enough space for minimums?  //
        !           703:    //=============================//
        !           704: 
        !           705:    xMinWidth = 
        !           706:       xScrollWidth +                         // margin before prompt
        !           707:       DialogWidth (hDlg, IDD_LOGFILETEXT) +  // width of prompt
        !           708:       xNameMinWidth +                        // width of name
        !           709:       xScrollWidth +
        !           710:       DialogWidth (hDlg, IDD_LOGSTATUSTEXT) +
        !           711:       DialogWidth (hDlg, IDD_LOGSTATUS) + 
        !           712:       xScrollWidth ;
        !           713: 
        !           714: 
        !           715:    xStatusPos = xWidth - xStatusWidth - xScrollWidth ;   
        !           716:    DialogMove (hDlg, IDD_LOGSTATUS,
        !           717:                xStatusPos, NOCHANGE,
        !           718:                xStatusWidth, NOCHANGE) ;
        !           719: 
        !           720:    xStatusTextPos = xStatusPos - 
        !           721:                     DialogWidth (hDlg, IDD_LOGSTATUSTEXT) - 
        !           722:                     xScrollWidth ;
        !           723:    DialogMove (hDlg, IDD_LOGSTATUSTEXT, 
        !           724:                xStatusTextPos, NOCHANGE,
        !           725:                NOCHANGE, NOCHANGE) ;
        !           726: 
        !           727:    xNameWidth = xStatusTextPos - 
        !           728:                 DialogWidth (hDlg, IDD_LOGFILETEXT) -
        !           729:                 2 * xScrollWidth ;
        !           730:    DialogMove (hDlg, IDD_LOGFILE,
        !           731:                NOCHANGE, NOCHANGE,
        !           732:                xNameWidth, NOCHANGE) ;
        !           733: 
        !           734:    DialogMove (hDlg, IDD_LOGSIZE,
        !           735:                DialogXPos (hDlg, IDD_LOGFILE), NOCHANGE,
        !           736:                DialogWidth (hDlg, IDD_LOGFILE), NOCHANGE) ;
        !           737: 
        !           738:    DialogMove (hDlg, IDD_LOGINTERVALTEXT,
        !           739:                DialogXPos (hDlg, IDD_LOGSTATUSTEXT), NOCHANGE,
        !           740:                DialogWidth (hDlg, IDD_LOGSTATUSTEXT), NOCHANGE) ;
        !           741: 
        !           742:    DialogMove (hDlg, IDD_LOGINTERVAL,
        !           743:                DialogXPos (hDlg, IDD_LOGSTATUS), NOCHANGE,
        !           744:                DialogWidth (hDlg, IDD_LOGSTATUS), NOCHANGE) ;
        !           745: 
        !           746:    DialogMove (hDlg, IDD_LOGENTRIESTEXT,
        !           747:                xScrollWidth, NOCHANGE, NOCHANGE, NOCHANGE) ;
        !           748: 
        !           749:    DialogMove (hDlg, IDD_LOGENTRIES, 
        !           750:                xScrollWidth, NOCHANGE,
        !           751:                xWidth - 2 * xScrollWidth,
        !           752:                yHeight - DialogYPos (hDlg, IDD_LOGENTRIES) - yScrollHeight) ;
        !           753:    WindowInvalidate (hDlg) ;
        !           754:    }  // OnSize
        !           755: 
        !           756: 
        !           757: int OnCtlColor (HWND hDlg,
        !           758:                        HDC hDC)
        !           759:    {
        !           760:    SetTextColor (hDC, crBlack) ;
        !           761:    SetBkColor (hDC, crLightGray) ;
        !           762:    return ((int) hbLightGray) ;
        !           763:    }
        !           764: 
        !           765: 
        !           766: void static OnInitDialog (HWND hDlg)
        !           767:    {
        !           768:    HDC            hDC ;
        !           769:    PLOG           pLog ;
        !           770: 
        !           771:    hWndLogEntries = DialogControl (hDlg, IDD_LOGENTRIES) ;
        !           772: 
        !           773:    pLog = AllocateLogData (hDlg) ;
        !           774:    if (!pLog)
        !           775:       return ;
        !           776: 
        !           777:    StringLoad (IDS_CLOSED, szClosed) ;
        !           778: //   StringLoad (IDS_PAUSED, szPaused) ;
        !           779:    StringLoad (IDS_COLLECTING, szCollecting) ;
        !           780:    UpdateLogDisplay (hDlg) ;
        !           781: 
        !           782:    hDC = GetDC (hDlg) ;
        !           783:    xStatusWidth = max (TextWidth (hDC, szClosed), 
        !           784:                        TextWidth (hDC, szCollecting)) ;
        !           785: //                       max (TextWidth (hDC, szPaused),
        !           786: //                            TextWidth (hDC, szCollecting))) ;
        !           787:    xStatusWidth += xScrollWidth ;
        !           788: 
        !           789:    xNameMinWidth = TextAvgWidth (hDC, LogNameMinLen) ;
        !           790:    ReleaseDC (hDlg, hDC) ;
        !           791:    }
        !           792: 
        !           793: 
        !           794: 
        !           795: void static OnDestroy (HWND hWnd)
        !           796: /*
        !           797:    Effect:        Perform any actions necessary when a LogDisplay window
        !           798:                   is being destroyed. In particular, free the instance
        !           799:                   data for the log.  
        !           800: 
        !           801:                   Since we really only have one log window and one global
        !           802:                   log data structure, we don't free the structure. We do,
        !           803:                   however, delete the objects allocated within the structure.
        !           804: */
        !           805:    {  // OnDestroy
        !           806:    PLOG           pLog ;
        !           807: 
        !           808:    pLog = LogData (hWnd) ;
        !           809:    FreeLogData (pLog) ;
        !           810:    }  // OnDestroy
        !           811: 
        !           812: 
        !           813: void static OnDrawItem (HWND hWnd, LPDRAWITEMSTRUCT lpDI)
        !           814:    {  // OnDrawItem
        !           815:    HDC            hDC ;
        !           816:    RECT           rectComputer, rectObject ;
        !           817:    PLOGENTRY      pLogEntry ;
        !           818:    PLOG           pLog ;
        !           819:    COLORREF       preBkColor ;
        !           820:    COLORREF       preTextColor ;
        !           821: 
        !           822:    pLog = LogData (hWnd) ;
        !           823: 
        !           824:    pLogEntry = LogEntryN (hWndLogEntries, DIIndex (lpDI)) ;
        !           825: 
        !           826:    // LogEntryN (SendMessage) will return LB_ERR for error, have to
        !           827:    // check for that case
        !           828:    if (!pLogEntry || pLogEntry == (PLOGENTRY)LB_ERR)
        !           829:       {
        !           830:       return ;
        !           831:       }
        !           832: 
        !           833:    hDC = lpDI->hDC ;
        !           834: 
        !           835:    SelectFont (hDC, hFontScales) ;
        !           836: 
        !           837:    if (DISelected (lpDI)) 
        !           838:       {  // if
        !           839:       preTextColor = SetTextColor (hDC, GetSysColor (COLOR_HIGHLIGHTTEXT)) ;
        !           840:       preBkColor = SetBkColor (hDC, GetSysColor (COLOR_HIGHLIGHT)) ;
        !           841:       }  // if
        !           842: 
        !           843:    rectObject.left = lpDI->rcItem.left ;
        !           844:    rectObject.top = lpDI->rcItem.top ;
        !           845:    rectObject.right = rectObject.left + pLog->xCol1Width ;
        !           846:    rectObject.bottom = lpDI->rcItem.bottom ;
        !           847: 
        !           848:    ExtTextOut (hDC,  
        !           849:                rectObject.left + xScrollWidth, rectObject.top,   
        !           850:                ETO_OPAQUE,
        !           851:                &rectObject,
        !           852:                pLogEntry->szObject,
        !           853:                lstrlen (pLogEntry->szObject),
        !           854:                NULL) ;
        !           855: 
        !           856: 
        !           857:    rectComputer.left = rectObject.right ;
        !           858:    rectComputer.top = lpDI->rcItem.top ;
        !           859:    rectComputer.right = lpDI->rcItem.right ;
        !           860:    rectComputer.bottom = lpDI->rcItem.bottom ;
        !           861: 
        !           862:    ExtTextOut (hDC,  
        !           863:                rectComputer.left, rectComputer.top,
        !           864:                ETO_OPAQUE,
        !           865:                &rectComputer,
        !           866:                pLogEntry->szComputer,
        !           867:                lstrlen (pLogEntry->szComputer),
        !           868:                NULL) ;
        !           869: 
        !           870:    if (DIFocus (lpDI))
        !           871:       DrawFocusRect (hDC, &(lpDI->rcItem)) ;
        !           872: 
        !           873:    if (DISelected (lpDI))
        !           874:       {  // if
        !           875:       preTextColor = SetTextColor (hDC, preTextColor) ;
        !           876:       preBkColor = SetBkColor (hDC, preBkColor) ;
        !           877:       }  // if
        !           878: //   RestoreDC (hDC, -1) ;
        !           879:    }  // OnDrawItem
        !           880: 
        !           881: 
        !           882:    
        !           883: //==========================================================================//
        !           884: //                             Exported Functions                           //
        !           885: //==========================================================================//
        !           886: 
        !           887: 
        !           888: int APIENTRY LogDisplayDlgProc (HWND hDlg,
        !           889:                                 unsigned iMessage,
        !           890:                                 WPARAM wParam,
        !           891:                                 LONG lParam)
        !           892: /*
        !           893:    Note:          This function must be exported in the application's
        !           894:                   linker-definition file, perfmon.def.
        !           895: */
        !           896:    {  // LogDisplayDlgProc
        !           897: //   HDC            hDC ;
        !           898: 
        !           899:    switch (iMessage)
        !           900:       {
        !           901:       case WM_INITDIALOG:
        !           902:          OnInitDialog (hDlg) ;
        !           903:          break ;
        !           904: 
        !           905:       case WM_CTLCOLORDLG:
        !           906:       case WM_CTLCOLOREDIT:
        !           907:       case WM_CTLCOLORBTN:
        !           908:       case WM_CTLCOLORSTATIC:
        !           909:          return (OnCtlColor (hDlg, (HDC) wParam)) ;
        !           910:          break ;
        !           911: 
        !           912:       case WM_DRAWITEM:
        !           913:          OnDrawItem (hDlg, (LPDRAWITEMSTRUCT) lParam) ;
        !           914:          break ;
        !           915: 
        !           916:       case WM_LBUTTONDBLCLK:
        !           917:          SendMessage (hWndMain, WM_LBUTTONDBLCLK, wParam, lParam) ;
        !           918:          break ;
        !           919: 
        !           920:       case WM_LBUTTONDOWN:
        !           921:          DoWindowDrag (lParam) ;
        !           922:          break ;
        !           923: 
        !           924:       case WM_SIZE:
        !           925:          OnSize (hDlg, LOWORD (lParam), HIWORD (lParam)) ;
        !           926:          break ;
        !           927: 
        !           928:       case WM_TIMER:
        !           929:          LogTimer (hDlg, FALSE) ;
        !           930:          break ;
        !           931: 
        !           932:       case WM_DESTROY:
        !           933:          OnDestroy (hDlg) ;
        !           934:          return (FALSE) ;
        !           935:          break ;
        !           936: 
        !           937:       default:
        !           938:          return (FALSE) ;
        !           939:       } // switch
        !           940: 
        !           941:    return (TRUE) ;
        !           942:    }  // LogDisplayDlgProc
        !           943: 
        !           944: 
        !           945: #if 0
        !           946: PLOG LogData (HWND hWndLog)
        !           947:    {
        !           948:    return (&Log) ;
        !           949:    }
        !           950: #endif
        !           951: 
        !           952: HWND CreateLogWindow (HWND hWndParent)
        !           953: /*
        !           954:    Effect:        Create the Log window. This window is a child of 
        !           955:                   hWndMain.
        !           956: 
        !           957:    Note:          We dont worry about the size here, as this window
        !           958:                   will be resized whenever the main window is resized.
        !           959: 
        !           960: */
        !           961:    {  // CreateLogWindow
        !           962:    HWND           hWnd ;
        !           963:    hWnd = CreateDialog (hInstance,
        !           964:                         MAKEINTRESOURCE (idDlgLogDisplay),
        !           965:                         hWndParent,
        !           966:                         (DLGPROC) LogDisplayDlgProc) ;
        !           967: 
        !           968:    return (hWnd) ;
        !           969:    }  // CreateLogWindow
        !           970: 
        !           971: 
        !           972: 
        !           973: void UpdateLogDisplay (HWND hWnd)
        !           974: /*
        !           975:    Effect:        Set the values for the various controls in the log
        !           976:                   display.
        !           977: 
        !           978:    Called By:     OnInitDialog, any other routines that change these
        !           979:                   values.
        !           980: */
        !           981:    {  // UpdateLogDisplay
        !           982:    PLOG           pLog ;
        !           983:    WCHAR          szSize [MiscTextLen + 1] ;
        !           984: 
        !           985:    pLog = LogData (hWnd) ;
        !           986: 
        !           987:    DialogSetString (hWnd, IDD_LOGFILE, pLog->szFilePath) ;
        !           988: 
        !           989:    // position the cursor at the end of the text
        !           990:    EditSetTextEndPos (hWnd, IDD_LOGFILE) ;
        !           991: 
        !           992: 
        !           993:    DialogSetString (hWnd, IDD_LOGSTATUS, StatusText (pLog->iStatus)) ;
        !           994: 
        !           995:    LongToCommaString (pLog->lFileSize, szSize) ;
        !           996:    DialogSetString (hWnd, IDD_LOGSIZE, szSize) ;
        !           997: 
        !           998:    DialogSetInterval (hWnd, IDD_LOGINTERVAL, pLog->iIntervalMSecs) ;
        !           999:    }  // UpdateLogDisplay
        !          1000: 
        !          1001: 
        !          1002: BOOL LogInitializeApplication (void)
        !          1003:    {
        !          1004:    return (TRUE) ;
        !          1005:    }  // LogInitializeApplication
        !          1006: 
        !          1007: 
        !          1008: void SetLogTimer (HWND hWnd,
        !          1009:                   int iIntervalMSecs)
        !          1010:    {
        !          1011:    PLOG           pLog ;
        !          1012: 
        !          1013:    pLog = LogData (hWnd) ;
        !          1014:    pLog->iIntervalMSecs = iIntervalMSecs ;
        !          1015: 
        !          1016:    KillTimer (hWnd, LogTimerID) ;
        !          1017:    SetTimer (hWnd, LogTimerID, pLog->iIntervalMSecs, NULL) ;
        !          1018:    }
        !          1019: 
        !          1020: 
        !          1021: void ClearLogTimer (HWND hWnd)
        !          1022:    {
        !          1023:    KillTimer (hWnd, LogTimerID) ;
        !          1024:    }
        !          1025: 
        !          1026: 
        !          1027: 
        !          1028: BOOL CloseLogStopTimer (HWND hWnd, PLOG pLog)
        !          1029:    {
        !          1030:    CloseHandle (pLog->hFile) ;
        !          1031: 
        !          1032:    pLog->hFile = 0 ;
        !          1033:    pLog->iStatus = iPMStatusClosed ;
        !          1034: 
        !          1035:    ClearLogTimer (hWnd) ;
        !          1036: 
        !          1037:    return (TRUE) ;
        !          1038:    }
        !          1039: 
        !          1040: 
        !          1041: BOOL CloseLog (HWND hWnd, PLOG pLog)
        !          1042:    {  // CloseLog
        !          1043:    LogWriteIndexBlock (pLog) ;
        !          1044:    CloseLogStopTimer (hWnd, pLog) ;
        !          1045:    WindowInvalidate (hWndStatus) ;
        !          1046:    return (TRUE) ;
        !          1047:    } // CloseLog
        !          1048: 
        !          1049: BOOL StartLog (HWND hWnd, PLOG pLog, BOOL bSameFile)
        !          1050:    {
        !          1051:    int            RetCode ;
        !          1052:    SYSTEMTIME     SystemTime ; 
        !          1053: 
        !          1054:    if ((RetCode = CreateLogFile (pLog, TRUE, bSameFile)) == 0)
        !          1055:       {
        !          1056:       pLog->iStatus = iPMStatusCollecting ;
        !          1057: 
        !          1058:       GetLocalTime (&SystemTime) ;
        !          1059: 
        !          1060:       // write a dummy record.
        !          1061:       // this is needed because when playingback log
        !          1062:       // it will skip the first index from the first
        !          1063:       // index block.
        !          1064:       LogWriteIndex (pLog, 0, &SystemTime, 0, 0) ;
        !          1065: 
        !          1066:       if (!PlayingBackLog())
        !          1067:          {
        !          1068:          // write out a bookmark to indicate start of new data
        !          1069:          LogWriteStartBookmark (hWnd, &SystemTime) ;
        !          1070:          }
        !          1071: 
        !          1072:       if (!PlayingBackLog () && !(pLog->bManualRefresh))
        !          1073:          {
        !          1074:          SetLogTimer (hWnd, pLog->iIntervalMSecs) ;
        !          1075:          WindowInvalidate (hWndStatus) ;
        !          1076:          }
        !          1077:       
        !          1078:       // write counter names if needed
        !          1079:       LogWriteSystemCounterNames (hWnd, pLog) ;
        !          1080: 
        !          1081:       return (TRUE) ;
        !          1082:       }
        !          1083: 
        !          1084:    pLog->hFile = 0 ;
        !          1085:    CloseLogStopTimer(hWnd, pLog);
        !          1086:    PrepareMenu (GetMenu (hWndMain)) ;
        !          1087:    UpdateLogDisplay (hWnd) ;   
        !          1088:    DlgErrorBox (hWnd, RetCode, pLog->szFilePath);
        !          1089:    return (FALSE) ;
        !          1090:    }
        !          1091: 
        !          1092: 
        !          1093: 
        !          1094: DWORD LogFindEntry(LPTSTR lpszComputer, DWORD ObjectTitleIndex)
        !          1095: /*
        !          1096:    Effect:         Returns the index of the specified Computer/Object
        !          1097:                    if it already exists in the Entries List Box,
        !          1098:                    otherwise returns LOG_ENTRY_NOT_FOUND
        !          1099: */
        !          1100:    {
        !          1101:    DWORD          iLogEntry ;
        !          1102:    DWORD          iLogNum ;
        !          1103:    PLOGENTRY      pLogEntry ;
        !          1104: 
        !          1105:    iLogNum = (DWORD) LBNumItems(hWndLogEntries) ;
        !          1106:    for (iLogEntry = 0;
        !          1107:         iLogEntry < iLogNum ;
        !          1108:         iLogEntry++)
        !          1109:       {
        !          1110:       pLogEntry = (PLOGENTRY) LBData(hWndLogEntries, iLogEntry) ;
        !          1111:       if (pLogEntry->ObjectTitleIndex == ObjectTitleIndex &&
        !          1112:           strsamei(pLogEntry->szComputer, lpszComputer))
        !          1113:          {
        !          1114:          return iLogEntry ;
        !          1115:          }
        !          1116:       }
        !          1117:    return (DWORD) LOG_ENTRY_NOT_FOUND;
        !          1118:    }
        !          1119: 
        !          1120: 
        !          1121: 
        !          1122: BOOL LogAddEntry (HWND hWndLog,
        !          1123:                   LPTSTR lpszComputer,
        !          1124:                   LPTSTR lpszObject,
        !          1125:                   DWORD ObjectTitleIndex)
        !          1126: /*
        !          1127:    Effect:        Add an entry in the log structure for the computer and
        !          1128:                   object to be logged.
        !          1129: 
        !          1130:    Returns:       Whether the operation could be performed.
        !          1131: */
        !          1132:    {  // LogAddEntry
        !          1133:    PLOG           pLog ;
        !          1134:    PLOGENTRY      pLogEntry ;
        !          1135:    UINT           iIndex ;
        !          1136: 
        !          1137: 
        !          1138:    pLog = LogData (hWndLog) ;
        !          1139:    
        !          1140:    SystemAdd (&(pLog->pSystemFirst), lpszComputer) ;
        !          1141: 
        !          1142:    pLogEntry = MemoryAllocate (sizeof (LOGENTRY)) ;
        !          1143:    if (!pLogEntry)
        !          1144:       return (FALSE) ;
        !          1145: 
        !          1146:    lstrcpy (pLogEntry->szComputer, lpszComputer) ;
        !          1147:    lstrcpy (pLogEntry->szObject, lpszObject) ;
        !          1148:    pLogEntry->ObjectTitleIndex = ObjectTitleIndex ;
        !          1149: 
        !          1150:    iIndex = LBAdd (hWndLogEntries, pLogEntry) ;
        !          1151: 
        !          1152:    if (iIndex == LB_ERR)
        !          1153:       {
        !          1154:       iIndex = 0 ;
        !          1155:       }
        !          1156: 
        !          1157:    LBSetSelection (hWndLogEntries, iIndex) ;
        !          1158:    LBSetVisible (hWndLogEntries, iIndex) ;
        !          1159: 
        !          1160:    LogEntriesChanged (hWndLogEntries) ;
        !          1161: 
        !          1162:    LogAddEntryToList (&(pLog->pLogEntryFirst), pLogEntry) ;
        !          1163: 
        !          1164: 
        !          1165:    }  // LogAddEntry
        !          1166: 
        !          1167: 
        !          1168: 
        !          1169: 
        !          1170: BOOL ToggleLogRefresh (HWND hWnd)
        !          1171:    {  // ToggleLogRefresh
        !          1172:    PLOG        pLog ;
        !          1173: 
        !          1174:    pLog = LogData (hWnd) ;
        !          1175: 
        !          1176:    if (pLog->bManualRefresh)
        !          1177:       SetLogTimer (hWnd, pLog->iIntervalMSecs) ;
        !          1178:    else
        !          1179:       ClearLogTimer (hWnd) ;
        !          1180: 
        !          1181:    pLog->bManualRefresh = !pLog->bManualRefresh ;
        !          1182:    return (pLog->bManualRefresh) ;
        !          1183:    }  // ToggleLogRefresh
        !          1184: 
        !          1185: BOOL LogRefresh (HWND hWnd)
        !          1186:    {  // LogRefresh
        !          1187:    PLOG        pLog ;
        !          1188: 
        !          1189:    pLog = LogData (hWnd) ;
        !          1190: 
        !          1191:    return (pLog->bManualRefresh) ;
        !          1192:    }  // LogRefresh
        !          1193: 
        !          1194: 
        !          1195: int SelectLogObjects(LPTSTR lpszComputer,
        !          1196:                      PPERFDATA pPerfData,
        !          1197:                      PPERFDATA *ppLogData)
        !          1198: /*
        !          1199:    Effect:        This routine copies the header from pPerfData
        !          1200:                   to pLogData and initializes the byte length and the
        !          1201:                   number of objects.  It then copies the previously
        !          1202:                   selected objects from pPerfData to pLogData.  If
        !          1203:                   pLogData must be enlarged to accomodate the new data,
        !          1204:                   this routine will enlarge it.
        !          1205: 
        !          1206:    Returns:       An updated pLogData, and TRUE if at least one object
        !          1207:                   was copied.
        !          1208: 
        !          1209: */
        !          1210: 
        !          1211:    {
        !          1212:    PLOGENTRY      pLogEntry ;
        !          1213:    PPERF_OBJECT_TYPE
        !          1214:                   pObject ;
        !          1215:    DWORD          TotalBytes ;
        !          1216:    DWORD          NumObjects ;
        !          1217:    PBYTE          pNextObject ;
        !          1218:    DWORD          MaxLogDataSize ;
        !          1219:    PLOG           pLog ;
        !          1220: 
        !          1221:    if (!*ppLogData || !pPerfData)
        !          1222:       return -1 ;
        !          1223: 
        !          1224:    memcpy (*ppLogData, pPerfData, pPerfData->HeaderLength) ;
        !          1225:    TotalBytes = pPerfData->HeaderLength ;
        !          1226:    MaxLogDataSize = MemorySize(*ppLogData) ;
        !          1227:    NumObjects = 0;
        !          1228: 
        !          1229:    
        !          1230:    pLog = LogData (hWndLog) ;
        !          1231: 
        !          1232:    for (pLogEntry = pLog->pLogEntryFirst ;
        !          1233:         pLogEntry ;
        !          1234:         pLogEntry = pLogEntry->pNextLogEntry)
        !          1235:       { // for
        !          1236:       if (strsamei(pLogEntry->szComputer, lpszComputer))
        !          1237:          {
        !          1238:          pObject = GetObjectDefByTitleIndex(pPerfData,
        !          1239:                                             pLogEntry->ObjectTitleIndex) ;
        !          1240: 
        !          1241:          if (pObject)
        !          1242:             {
        !          1243: 
        !          1244:             if (MaxLogDataSize < TotalBytes + pObject->TotalByteLength)
        !          1245:                {
        !          1246:                *ppLogData = MemoryResize(*ppLogData,
        !          1247:                                          TotalBytes + pObject->TotalByteLength) ;
        !          1248:                if (!*ppLogData)
        !          1249:                   return -1 ;
        !          1250: 
        !          1251:                }
        !          1252: 
        !          1253:             pNextObject = (PBYTE) *ppLogData + TotalBytes ;
        !          1254:             memcpy (pNextObject, pObject, pObject->TotalByteLength);
        !          1255:             TotalBytes += pObject->TotalByteLength ;
        !          1256:             NumObjects++;
        !          1257:             }
        !          1258:          else
        !          1259:             {
        !          1260:             }
        !          1261:          }
        !          1262:       } // for
        !          1263: 
        !          1264:    if (!NumObjects)
        !          1265:       return 1 ;
        !          1266: 
        !          1267:    (*ppLogData)->TotalByteLength = TotalBytes ;
        !          1268:    (*ppLogData)->NumObjectTypes = NumObjects ;
        !          1269: 
        !          1270:    return 0 ;
        !          1271:    }
        !          1272: 
        !          1273: 
        !          1274: void LogTimer (HWND hWnd, BOOL bForce)
        !          1275: /*
        !          1276:    Effect:        Perform all actions necessary when the log window 
        !          1277:                   receives a timer tic. In particular, if we are
        !          1278:                   collecting data, get a new perf_data_block and add a 
        !          1279:                   header entry. If the header block is full, write the
        !          1280:                   data to disk.
        !          1281: 
        !          1282:    Called By:     LogDisplayDlgProc, in response to a WM_TIMER message.
        !          1283: */
        !          1284:    {  // OnTimer
        !          1285:    PLOG           pLog ;
        !          1286:    PPERFSYSTEM       pSystem ;
        !          1287:    BOOL           bWriteIndex ;
        !          1288:    DWORD          iNumSystems ;
        !          1289:    SYSTEMTIME     SystemTime ;
        !          1290:    int            iNoUseSystemDetected = 0 ;
        !          1291: 
        !          1292:    pLog = LogData (hWnd) ;
        !          1293: 
        !          1294:    if (pLog->iStatus != iPMStatusCollecting)
        !          1295:       return ;
        !          1296: 
        !          1297:    if (bForce || !pLog->bManualRefresh) 
        !          1298:       {
        !          1299:       iNumSystems = SystemCount(pLog->pSystemFirst) ;
        !          1300:       bWriteIndex = TRUE ;
        !          1301:       for (pSystem = pLog->pSystemFirst ;
        !          1302:            pSystem ;
        !          1303:            pSystem = pSystem->pSystemNext)
        !          1304:          {  // for
        !          1305:          if (UpdateSystemData (pSystem, &pLog->pPerfData))
        !          1306:             {
        !          1307:             if (bWriteIndex)
        !          1308:                {
        !          1309:                GetLocalTime (&SystemTime) ;
        !          1310:                }
        !          1311: 
        !          1312:             if (SelectLogObjects(pSystem->sysName,
        !          1313:                                  pLog->pPerfData,
        !          1314:                                  &pLog->pLogData) == 0)
        !          1315:                {
        !          1316:                if ( !LogWritePerfData (hWnd, pLog, pLog->pLogData, &SystemTime,
        !          1317:                                        iNumSystems, bWriteIndex) )
        !          1318:                   {
        !          1319:                   CloseLogStopTimer(hWnd, pLog) ;
        !          1320:                   return ;
        !          1321:                   }
        !          1322:                // write an index for only the first system
        !          1323:                bWriteIndex = FALSE ;
        !          1324:                }
        !          1325:             else
        !          1326:                {
        !          1327:                if (!bAddLineInProgress)
        !          1328:                   {
        !          1329:                   pSystem->bSystemNoLongerNeeded = TRUE ;
        !          1330:                   iNoUseSystemDetected ++ ;
        !          1331:                   }
        !          1332:                }
        !          1333:             }
        !          1334:          }  // for
        !          1335: 
        !          1336:       if (!bWriteIndex)
        !          1337:          {
        !          1338:          UpdateLogSize (hWnd) ;
        !          1339:          }
        !          1340:       }  // if
        !          1341: 
        !          1342:    if (iNoUseSystemDetected)
        !          1343:       {
        !          1344:       DeleteUnusedSystems (&(pLog->pSystemFirst), iNoUseSystemDetected) ;
        !          1345:       }
        !          1346:    }  // LogTimer
        !          1347: 
        !          1348: 
        !          1349: 
        !          1350: BOOL NextIntervalIndexPosition (PLOG pLog, PLOGPOSITION pLP, int *pNumTics)
        !          1351:    { 
        !          1352:    SYSTEMTIME     SystemTime1 ;
        !          1353:    SYSTEMTIME     SystemTime2 ;
        !          1354:    LOGPOSITION    LP ;
        !          1355:    PLOGINDEX      pIndex ;
        !          1356:    DWORD          TimeDiff ;
        !          1357: 
        !          1358:    LogPositionSystemTime (pLP, &SystemTime1) ;
        !          1359: 
        !          1360:    LP = *pLP ;
        !          1361: 
        !          1362:    while (NextReLogIndexPosition (&LP))
        !          1363:       {  // while
        !          1364: 
        !          1365:       *pNumTics = *pNumTics - 1 ;
        !          1366: 
        !          1367:       pIndex = IndexFromPosition (&LP) ;
        !          1368:       if (pIndex && IsBookmarkIndex (pIndex))
        !          1369:          {
        !          1370:          *pLP = LP ;
        !          1371:          return TRUE ;
        !          1372:          }
        !          1373:       LogPositionSystemTime (&LP, &SystemTime2) ;
        !          1374:       TimeDiff = (DWORD) SystemTimeDifference (&SystemTime1, &SystemTime2) ;
        !          1375:       if (TimeDiff * 1000 >= pLog->iIntervalMSecs)
        !          1376:          {  // if
        !          1377:          *pLP = LP ;
        !          1378:          return (TRUE) ;
        !          1379:          }  // if
        !          1380:       }  // while
        !          1381: 
        !          1382:    return (FALSE) ;
        !          1383:    }  // NextIntervalIndexPosition
        !          1384: 
        !          1385: 
        !          1386: 
        !          1387: BOOL ReLogTimer (HWND hWnd,
        !          1388:                  PLOG pLog,
        !          1389:                  LOGPOSITION lp,
        !          1390:                  BOOL *pWriteBookmark)
        !          1391:    {  // ReLogTimer
        !          1392:    PPERFSYSTEM    pSystem ;
        !          1393:    BOOL           bWriteIndex ;
        !          1394:    DWORD          iNumSystems ;
        !          1395:    SYSTEMTIME     SystemTime ;
        !          1396:    PPERFDATA      pPerfData ;
        !          1397: 
        !          1398:    bWriteIndex = TRUE ;
        !          1399: 
        !          1400:    // First count number of systems to be logged
        !          1401: 
        !          1402:    iNumSystems = 0;
        !          1403: 
        !          1404:    for (pSystem = pLog->pSystemFirst ;
        !          1405:         pSystem ;
        !          1406:         pSystem = pSystem->pSystemNext)
        !          1407:       {  // for
        !          1408:       pPerfData = LogDataFromPosition (pSystem, &lp) ;
        !          1409:       if (pPerfData)
        !          1410:          {
        !          1411:          if (SelectLogObjects(pSystem->sysName,
        !          1412:                               pPerfData,
        !          1413:                               &pLog->pLogData) == 0)
        !          1414:             {
        !          1415:             iNumSystems++;
        !          1416:             }
        !          1417:          }
        !          1418:       }  // for
        !          1419: 
        !          1420:    // Now we can log the data
        !          1421: 
        !          1422:    for (pSystem = pLog->pSystemFirst ;
        !          1423:         pSystem ;
        !          1424:         pSystem = pSystem->pSystemNext)
        !          1425:       {  // for
        !          1426:       pPerfData = LogDataFromPosition (pSystem, &lp) ;
        !          1427:       if (pPerfData)
        !          1428:          {
        !          1429:          // write an index for only the first system
        !          1430:          LogPositionSystemTime (&lp, &SystemTime) ;
        !          1431:          if (SelectLogObjects(pSystem->sysName,
        !          1432:                               pPerfData,
        !          1433:                               &pLog->pLogData) == 0)
        !          1434:             {
        !          1435:             if (*pWriteBookmark)
        !          1436:                {
        !          1437:                // only need to write the start bookmark once.
        !          1438:                *pWriteBookmark = FALSE ;
        !          1439:                LogWriteStartBookmark (hWnd, &SystemTime) ;
        !          1440:                }
        !          1441:             if ( !LogWritePerfData (hWnd, pLog, pLog->pLogData, &SystemTime,
        !          1442:                                     iNumSystems, bWriteIndex) )
        !          1443:                {
        !          1444:                CloseLogStopTimer(hWnd, pLog) ;
        !          1445:                return FALSE ;
        !          1446:                }
        !          1447:             else
        !          1448:                {
        !          1449:                // write the index for only the first system logged
        !          1450:                bWriteIndex = FALSE ;
        !          1451:                }
        !          1452:             }
        !          1453:          }
        !          1454:       }  // for
        !          1455: 
        !          1456:    return TRUE ;
        !          1457:    }  // ReLogTimer
        !          1458: 
        !          1459: 
        !          1460: void ReLog (HWND hWndLog, BOOL bSameFile)
        !          1461:    {  // PlaybackLog
        !          1462:    PLOG           pLog ;
        !          1463:    LOGPOSITION    lp ;
        !          1464: //   SYSTEMTIME     SystemTime ;
        !          1465:    PLOGINDEX      pIndex ;
        !          1466:    PBOOKMARK      pBookmark;
        !          1467:    int            iDisplayTics ;
        !          1468: 
        !          1469:    // bWriteBookmark tell relogtimer to write start bookmark
        !          1470:    BOOL           bWriteBookmark = TRUE ;    
        !          1471: 
        !          1472:    pLog = LogData (hWndLog) ;
        !          1473:    StartLog (hWndLog, pLog, bSameFile) ;
        !          1474: 
        !          1475:    lp = PlaybackLog.StartIndexPos ;
        !          1476:    iDisplayTics = PlaybackLog.iSelectedTics;
        !          1477: 
        !          1478:    while (iDisplayTics > 0)
        !          1479:       {
        !          1480:       pIndex = IndexFromPosition (&lp) ;
        !          1481:       if (pIndex)
        !          1482:          {
        !          1483:          if (IsBookmarkIndex (pIndex))
        !          1484:             {
        !          1485:             pBookmark = (PBOOKMARK) PlaybackSeek (pIndex->lDataOffset) ;
        !          1486:             if (!LogWriteBookmarkData (hWndLog, pBookmark))
        !          1487:                break;
        !          1488:             }
        !          1489:          else if (!ReLogTimer (hWndLog, pLog, lp, &bWriteBookmark))
        !          1490:             break ;
        !          1491:          }
        !          1492:       
        !          1493:       if (!NextIntervalIndexPosition (pLog, &lp, &iDisplayTics))
        !          1494:          break ;
        !          1495:       
        !          1496:       }  // while
        !          1497:    UpdateLogSize (hWndLog) ;
        !          1498:    CloseLog (hWndLog, pLog) ;
        !          1499:    }  // ReLog
        !          1500: 
        !          1501: // SaveLog is diff than other because we are not saving a "Line"
        !          1502: // We are actually saving an entry in the hWndLogEntries listbox.
        !          1503: // It only contains the system & object name.
        !          1504: BOOL SaveLog (HWND hWndLog, HANDLE hInputFile, BOOL bGetFileName)
        !          1505:    {
        !          1506:    int         iIndex, iIndexNum ;
        !          1507:    PLOG        pLog ;
        !          1508:    PLOGENTRY   pLogEntry ;
        !          1509:    LOGENTRY       tempLogEntry ;
        !          1510:    HANDLE         hFile ;
        !          1511:    DISKLOG        DiskLog ;
        !          1512:    PERFFILEHEADER FileHeader ;
        !          1513:    TCHAR          szFileName [256] ;
        !          1514:    BOOL           newFileName = FALSE ;
        !          1515: 
        !          1516:    pLog = LogData (hWndLog) ;
        !          1517:    if (!pLog)
        !          1518:       {
        !          1519:       return (FALSE) ;
        !          1520:       }
        !          1521: 
        !          1522:    if (hInputFile)
        !          1523:       {
        !          1524:       // use the input file handle if it is available
        !          1525:       // this is the case for saving workspace data
        !          1526:       hFile = hInputFile ;
        !          1527:       }
        !          1528:    else
        !          1529:       {
        !          1530:       if (pLogFullFileName)
        !          1531:          {
        !          1532:          lstrcpy (szFileName, pLogFullFileName) ;
        !          1533:          }
        !          1534:       if (bGetFileName || pLogFullFileName == NULL)
        !          1535:          {
        !          1536: //         if (pLogFullFileName == NULL)
        !          1537: //            {
        !          1538: //            StringLoad (IDS_LOG_FNAME, szFileName) ;
        !          1539: //            }
        !          1540: 
        !          1541:          if (!FileGetName (hWndLog, IDS_LOGFILE, szFileName))
        !          1542:             {
        !          1543:             return (FALSE) ;
        !          1544:             }
        !          1545:          newFileName = TRUE ;
        !          1546:          }
        !          1547: 
        !          1548:       hFile = FileHandleCreate (szFileName) ;
        !          1549: 
        !          1550:       if (hFile && newFileName)
        !          1551:          {
        !          1552:          ChangeSaveFileName (szFileName, IDM_VIEWLOG) ;
        !          1553:          }
        !          1554:       else if (!hFile)
        !          1555:          {
        !          1556:          DlgErrorBox (hWndLog, ERR_CANT_OPEN, szFileName) ;
        !          1557:          }
        !          1558:       }
        !          1559: 
        !          1560:    if (!hFile)
        !          1561:       return (FALSE) ;
        !          1562: 
        !          1563:    iIndexNum = LBNumItems (hWndLogEntries) ;
        !          1564: 
        !          1565:    if (!hInputFile)
        !          1566:       {
        !          1567:       memset (&FileHeader, 0, sizeof (FileHeader)) ;
        !          1568:       lstrcpy (FileHeader.szSignature, szPerfLogSignature) ;
        !          1569:       FileHeader.dwMajorVersion = LogMajorVersion ;
        !          1570:       FileHeader.dwMinorVersion = LogMinorVersion ;
        !          1571:    
        !          1572:       if (!FileWrite (hFile, &FileHeader, sizeof (PERFFILEHEADER)))
        !          1573:          {
        !          1574:          goto Exit0 ;
        !          1575:          }
        !          1576:       }
        !          1577: 
        !          1578:    DiskLog.dwIntervalSecs = pLog->iIntervalMSecs ;
        !          1579:    DiskLog.dwNumLines = iIndexNum ;
        !          1580:    DiskLog.bManualRefresh = pLog->bManualRefresh ;
        !          1581:    DiskLog.perfmonOptions = Options ;
        !          1582: 
        !          1583:    if (!FileWrite (hFile, &DiskLog, sizeof (DISKLOG)))
        !          1584:       {
        !          1585:       goto Exit0 ;
        !          1586:       }
        !          1587: 
        !          1588:    for (iIndex = 0 ;
        !          1589:         iIndex < iIndexNum ;
        !          1590:         iIndex++)
        !          1591:       {  // for
        !          1592:       pLogEntry = LogEntryN (hWndLogEntries, iIndex) ;
        !          1593:       if (pstrsamei (pLogEntry->szComputer, LocalComputerName))
        !          1594:          {
        !          1595:          tempLogEntry = *pLogEntry ;
        !          1596:          lstrcpy (tempLogEntry.szComputer, LOCAL_SYS_CODE_NAME) ;
        !          1597:          if (!FileWrite (hFile,
        !          1598:                &tempLogEntry,
        !          1599:                sizeof(LOGENTRY)-sizeof(pLogEntry->pNextLogEntry)))
        !          1600:             {
        !          1601:             goto Exit0 ;
        !          1602:             }
        !          1603:          }
        !          1604:       else
        !          1605:          {
        !          1606:          if (!FileWrite (hFile,
        !          1607:                pLogEntry,
        !          1608:                sizeof(LOGENTRY)-sizeof(pLogEntry->pNextLogEntry)))
        !          1609:             {
        !          1610:             goto Exit0 ;
        !          1611:             }
        !          1612:          }
        !          1613:       }  // for
        !          1614: 
        !          1615:    if (!hInputFile)
        !          1616:       {
        !          1617:       CloseHandle (hFile) ;
        !          1618:       }
        !          1619: 
        !          1620:    return (TRUE) ;
        !          1621: 
        !          1622: Exit0:
        !          1623:    if (!hInputFile)
        !          1624:       {
        !          1625:       CloseHandle (hFile) ;
        !          1626: 
        !          1627:       // only need to report error if not workspace 
        !          1628:       DlgErrorBox (hWndLog, ERR_SETTING_FILE, szFileName) ;
        !          1629:       }
        !          1630:    return (FALSE) ;
        !          1631:    }
        !          1632: 
        !          1633: BOOL OpenLogVer1 (HWND hWndLog, HANDLE hFile, DISKLOG *pDiskLog, PLOG
        !          1634:    pLog, DWORD dwMinorVersion)
        !          1635:    {
        !          1636:    int            iIndex, iIndexNum ;
        !          1637:    PLOGENTRY      pLogEntry ;
        !          1638:    LOGENTRY       LogEntry ;
        !          1639:    PPERFSYSTEM    pSystem;
        !          1640: 
        !          1641:    pLog->iIntervalMSecs = pDiskLog->dwIntervalSecs ;
        !          1642:    if (dwMinorVersion < 3)
        !          1643:       {
        !          1644:       pLog->iIntervalMSecs *= 1000 ;
        !          1645:       }
        !          1646: 
        !          1647:    pLog->bManualRefresh = pDiskLog->bManualRefresh ;
        !          1648:    iIndexNum = pDiskLog->dwNumLines ;
        !          1649: 
        !          1650:    LBSetRedraw (hWndLogEntries, FALSE) ;
        !          1651: 
        !          1652:    for (iIndex = 0 ; iIndex < iIndexNum ; iIndex++)
        !          1653:       {
        !          1654:       if (!FileRead (hFile,
        !          1655:             &LogEntry,
        !          1656:             sizeof(LOGENTRY)-sizeof(LogEntry.pNextLogEntry)))
        !          1657:          {
        !          1658:          break ;
        !          1659:          }
        !          1660: 
        !          1661:       if (pstrsame (LogEntry.szComputer, LOCAL_SYS_CODE_NAME))
        !          1662:          {
        !          1663:          // convert it back to the local name
        !          1664:          lstrcpy (LogEntry.szComputer, LocalComputerName) ;
        !          1665:          }
        !          1666: 
        !          1667:       LogAddEntry (hWndLog,
        !          1668:                   LogEntry.szComputer,
        !          1669:                   LogEntry.szObject,
        !          1670:                   LogEntry.ObjectTitleIndex) ;
        !          1671:       }
        !          1672: 
        !          1673:    LBSetRedraw (hWndLogEntries, TRUE) ;
        !          1674: 
        !          1675:    for (pSystem = pLog->pSystemFirst ;
        !          1676:       pSystem ;
        !          1677:       pSystem = pSystem->pSystemNext)
        !          1678:       {
        !          1679:       if (pSystem)
        !          1680:          {
        !          1681:          RemoveObjectsFromSystem (pSystem);
        !          1682:          }
        !          1683:       }
        !          1684: 
        !          1685: 
        !          1686:    for (iIndex = 0 ;
        !          1687:         iIndex < iIndexNum ;
        !          1688:         iIndex++)
        !          1689:       {  // for all items in the list
        !          1690:       pLogEntry = LogEntryN (hWndLogEntries, iIndex) ;
        !          1691: 
        !          1692:       pSystem = SystemGet (pLog->pSystemFirst, pLogEntry->szComputer);
        !          1693:       if (pSystem) {
        !          1694:          AppendObjectToValueList (
        !          1695:                 pLogEntry->ObjectTitleIndex,
        !          1696:                 pSystem->lpszValue);
        !          1697:          } 
        !          1698:       }  // for
        !          1699: 
        !          1700:    return (TRUE) ;
        !          1701:    }
        !          1702: 
        !          1703: BOOL OpenLog (HWND hWndLog,
        !          1704:               HANDLE hFile,
        !          1705:               DWORD dwMajorVersion,
        !          1706:               DWORD dwMinorVersion,
        !          1707:               BOOL bLogFile)
        !          1708:    {
        !          1709:    PLOG        pLog ;
        !          1710:    DISKLOG     DiskLog ;
        !          1711:    BOOL        bSuccess = TRUE ;
        !          1712: 
        !          1713:    pLog = LogData (hWndLog) ;
        !          1714:    if (!pLog)
        !          1715:       {
        !          1716:       bSuccess = FALSE ;
        !          1717:       goto Exit0 ;
        !          1718:       }
        !          1719: 
        !          1720:    if (!FileRead (hFile, &DiskLog, sizeof (DISKLOG)))
        !          1721:       {
        !          1722:       bSuccess = FALSE ;
        !          1723:       goto Exit0 ;
        !          1724:       }
        !          1725: 
        !          1726:    switch (dwMajorVersion)
        !          1727:       {  
        !          1728:       case (1):
        !          1729: 
        !          1730:          SetHourglassCursor() ;
        !          1731:          
        !          1732:          ResetLogView (hWndLog) ;
        !          1733: 
        !          1734:          OpenLogVer1 (hWndLog, hFile, &DiskLog, pLog, dwMinorVersion) ;
        !          1735: 
        !          1736:          // change to log view if we are opening a 
        !          1737:          // log file
        !          1738:          if (bLogFile && iPerfmonView != IDM_VIEWLOG)
        !          1739:             {
        !          1740:             SendMessage (hWndMain, WM_COMMAND, (LONG)IDM_VIEWLOG, 0L) ;
        !          1741:             }
        !          1742:  
        !          1743:          if (iPerfmonView == IDM_VIEWLOG)
        !          1744:             {
        !          1745:             SetPerfmonOptions (&DiskLog.perfmonOptions) ;
        !          1746:             }
        !          1747:          
        !          1748:          UpdateLogDisplay (hWndLog) ;   
        !          1749:          
        !          1750:          SetArrowCursor() ;
        !          1751:          
        !          1752:          break ;
        !          1753:       }
        !          1754: 
        !          1755: Exit0:
        !          1756: 
        !          1757:    if (bLogFile)
        !          1758:       {
        !          1759:       CloseHandle (hFile) ;
        !          1760:       }
        !          1761: 
        !          1762:    return (bSuccess) ;
        !          1763:    }  // OpenLog
        !          1764: 
        !          1765: 
        !          1766: BOOL LogCollecting (HWND hWndLog)
        !          1767: /*
        !          1768:    Effect:        Return whether the log associated with hWndLog is currently
        !          1769:                   collecting data (writing performance values to disk).
        !          1770: */
        !          1771:    {  // LogCollecting
        !          1772:    PLOG           pLog ;
        !          1773: 
        !          1774:    pLog = LogData (hWndLog) ;
        !          1775: 
        !          1776:    return (pLog->iStatus == iPMStatusCollecting) ;
        !          1777:    }  // LogCollecting
        !          1778: 
        !          1779: 
        !          1780: int LogFileSize (HWND hWndLog)
        !          1781:    {
        !          1782:    PLOG           pLog ;
        !          1783: 
        !          1784:    pLog = LogData (hWndLog) ;
        !          1785: 
        !          1786:    return (pLog->lFileSize) ;
        !          1787:    }
        !          1788: 
        !          1789: BOOL LogWriteStartBookmark (HWND hWnd, SYSTEMTIME *pSystemTime)
        !          1790:    {
        !          1791:    BOOKMARK       Bookmark ;
        !          1792:    TCHAR    NewDataBookmark [MiscTextLen] ;
        !          1793: 
        !          1794:    memset (&Bookmark, 0, sizeof (BOOKMARK)) ;
        !          1795: 
        !          1796:    NewDataBookmark [0] = TEXT('\0') ;
        !          1797:    StringLoad (IDS_NEWDATA_BOOKMARK, NewDataBookmark) ;
        !          1798:    Bookmark.SystemTime = *pSystemTime ;
        !          1799:    lstrcpy (Bookmark.szComment, NewDataBookmark) ;
        !          1800: 
        !          1801:    return (LogWriteBookmarkData (hWndLog, &Bookmark)) ;
        !          1802:    }
        !          1803: 
        !          1804: BOOL LogWriteBookmarkData (HWND hWnd, PBOOKMARK pBookmark)
        !          1805:    {
        !          1806:    PLOG           pLog ;
        !          1807:    LONG           lDataOffset ;
        !          1808:    BOOL           WriteOK ;
        !          1809: 
        !          1810:    pLog = LogData (hWndLog) ;
        !          1811:    if (!pLog)
        !          1812:       return (FALSE) ;
        !          1813: 
        !          1814:    lDataOffset = FileTell (pLog->hFile) ;
        !          1815:    WriteOK = FileWrite (pLog->hFile, pBookmark, sizeof (BOOKMARK)) ;
        !          1816:    if ( WriteOK )
        !          1817:       {
        !          1818:       pLog->lFileSize += sizeof (BOOKMARK) ;
        !          1819:       UpdateLogSize (hWndLog) ;
        !          1820: 
        !          1821:       WriteOK = LogWriteIndex (pLog, LogFileIndexBookmark,
        !          1822:                                &(pBookmark->SystemTime),
        !          1823:                                lDataOffset,
        !          1824:                                0) ;
        !          1825:       }
        !          1826:    if ( !WriteOK )
        !          1827:       {
        !          1828:       CloseLog (hWndLog, pLog) ;
        !          1829:       PrepareMenu (GetMenu (hWndMain)) ;
        !          1830:       UpdateLogDisplay (hWndLog) ;   
        !          1831:       DlgErrorBox (hWndLog, ERR_LOG_FILE, pLog->szFilePath);
        !          1832:       }
        !          1833:    }
        !          1834: 
        !          1835: 
        !          1836: 
        !          1837: BOOL LogWriteBookmark (HWND hWndLog,
        !          1838:                        LPCTSTR lpszComment)
        !          1839:    {  // LogWriteBookmark
        !          1840:    BOOKMARK       Bookmark ;
        !          1841: 
        !          1842:    memset (&Bookmark, 0, sizeof (BOOKMARK)) ;
        !          1843: 
        !          1844:    GetLocalTime (&Bookmark.SystemTime) ;
        !          1845:    lstrcpy (Bookmark.szComment, lpszComment) ;
        !          1846: 
        !          1847:    return (LogWriteBookmarkData (hWndLog, &Bookmark)) ;
        !          1848:    }  // LogWriteBookmark
        !          1849:    
        !          1850: 
        !          1851: BOOL AnyLogLine (void)
        !          1852: {  // CurrentLogLine
        !          1853:    int iIndex ;
        !          1854: 
        !          1855:    iIndex = LBSelection (hWndLogEntries) ;
        !          1856:    if (iIndex == LB_ERR)
        !          1857:       {
        !          1858:       return (FALSE) ;
        !          1859:       }
        !          1860:    else
        !          1861:       {
        !          1862:       return (TRUE) ;
        !          1863:       }
        !          1864: }
        !          1865: 
        !          1866: void ResetLogView (HWND hWndLog)
        !          1867: {
        !          1868:    PLOG        pLog ;
        !          1869: 
        !          1870:    pLog = LogData (hWndLog) ;
        !          1871: 
        !          1872:    ChangeSaveFileName (NULL, IDM_VIEWLOG) ;
        !          1873: 
        !          1874:    if (pLog && pLog->pSystemFirst)
        !          1875:       {
        !          1876:       ResetLog (hWndLog) ;
        !          1877:       }
        !          1878: }  // ResetLogView
        !          1879: 
        !          1880: BOOL ResetLog (HWND hWndLog)
        !          1881: {
        !          1882:    int         iIndex ;
        !          1883:    PLOG        pLog ;
        !          1884:    int         iEntriesNum ;
        !          1885: 
        !          1886:    pLog = LogData (hWndLog) ;
        !          1887: 
        !          1888:    if (LogCollecting (hWndLog))
        !          1889:       {
        !          1890:       CloseLog (hWndLog, pLog) ;
        !          1891:       }
        !          1892:  
        !          1893:    LBSetRedraw (hWndLogEntries, FALSE) ;
        !          1894:    iEntriesNum = LBNumItems (hWndLogEntries) ;
        !          1895: 
        !          1896:    // only need to zero out the list head
        !          1897:    // each item will be deleted by LogDeleteIndex via the listbox
        !          1898:    pLog->pLogEntryFirst = NULL ;
        !          1899: 
        !          1900:    // delete each line
        !          1901:    for (iIndex = iEntriesNum - 1 ;
        !          1902:         iIndex >= 0 ;
        !          1903:         iIndex-- )
        !          1904:       {
        !          1905:       LogDeleteIndex (hWndLogEntries, iIndex) ;
        !          1906:       }
        !          1907: 
        !          1908:    LBSetRedraw (hWndLogEntries, TRUE) ;
        !          1909: 
        !          1910:    if (pLog->pSystemFirst)
        !          1911:       {
        !          1912:       FreeSystems (pLog->pSystemFirst) ;
        !          1913:       pLog->pSystemFirst = NULL ;
        !          1914:       }
        !          1915: 
        !          1916:    MemoryFree (pLog->pPerfData) ;
        !          1917:    MemoryFree (pLog->pLogData) ;
        !          1918: 
        !          1919:    pLog->pPerfData = (PPERFDATA) MemoryAllocate (STARTING_SYSINFO_SIZE) ;
        !          1920:    pLog->pLogData = (PPERFDATA) MemoryAllocate (STARTING_SYSINFO_SIZE) ;
        !          1921: 
        !          1922:    LogEntriesChanged (hWndLogEntries) ;
        !          1923: 
        !          1924:    pLog->iStatus = iPMStatusClosed ;
        !          1925:    UpdateLogDisplay (hWndLog) ;
        !          1926: 
        !          1927:    return (TRUE) ;
        !          1928: }
        !          1929: 
        !          1930: BOOL LogDeleteEntry (HWND hWndLog)
        !          1931: {
        !          1932:    int         iIndex ;
        !          1933:    PLOG        pLog ;
        !          1934:    BOOL        retCode ;
        !          1935:    int         iEntriesNum ;
        !          1936: 
        !          1937:    pLog = LogData (hWndLog) ;
        !          1938: 
        !          1939:    iIndex = LBSelection (hWndLogEntries) ;
        !          1940: 
        !          1941:    if (iIndex == LB_ERR)
        !          1942:       {
        !          1943:       retCode = FALSE ;
        !          1944:       }
        !          1945:    else
        !          1946:       {
        !          1947:       // remove the current selection
        !          1948:       LogDeleteIndex (hWndLogEntries, iIndex) ;
        !          1949: 
        !          1950:       iEntriesNum = LBNumItems (hWndLogEntries) ;
        !          1951: 
        !          1952:       if (iEntriesNum == 0 || iEntriesNum == LB_ERR)
        !          1953:          {
        !          1954:          // delete the last line or something bad happened, 
        !          1955:          // then reset the window.
        !          1956:          ResetLog (hWndLog) ;
        !          1957:          }
        !          1958:       else
        !          1959:          {
        !          1960:          // set selection on the item above the deleted item.
        !          1961:          iIndex-- ;
        !          1962:          if (iIndex < 0)
        !          1963:             {
        !          1964:             iIndex = 0 ;
        !          1965:             }
        !          1966:          LBSetSelection (hWndLogEntries, iIndex) ;
        !          1967:          LBSetVisible (hWndLogEntries, iIndex) ;
        !          1968:          }
        !          1969: 
        !          1970:       LogEntriesChanged (hWndLogEntries) ;
        !          1971:       retCode = TRUE ;
        !          1972:       }
        !          1973:    return (retCode) ;
        !          1974: }
        !          1975: 
        !          1976: 
        !          1977: void ExportLog (void)
        !          1978: {
        !          1979:    HANDLE      hFile ;
        !          1980:    PLOG        pLog ;
        !          1981:    PLOGENTRY   pLogEntry ;
        !          1982:    int         iIndex ;
        !          1983:    int         iIndexNum ;
        !          1984:    CHAR        TempBuff [LongTextLen] ;
        !          1985:    TCHAR       UnicodeBuff [LongTextLen] ;
        !          1986:    TCHAR       UnicodeBuff1 [MiscTextLen] ;
        !          1987:    int         StringLen ;
        !          1988:    LPTSTR      pFileName = NULL ;
        !          1989:    INT         ErrCode = 0 ;
        !          1990: 
        !          1991:    if (!(pLog = LogData (hWndLog)))
        !          1992:       {
        !          1993:       return ;
        !          1994:       }
        !          1995: 
        !          1996:    // see if there is anything to export..
        !          1997:    iIndexNum = LBNumItems (hWndLogEntries) ;
        !          1998:    if (iIndexNum == 0 || iIndexNum == LB_ERR)
        !          1999:       {
        !          2000:       return ;
        !          2001:       }
        !          2002: 
        !          2003:    if (!FileGetName (hWndLog, IDS_EXPORTFILE, UnicodeBuff))
        !          2004:       {
        !          2005:       // user cancel 
        !          2006:       return ;
        !          2007:       }
        !          2008: 
        !          2009:    pFileName = StringAllocate (UnicodeBuff) ;
        !          2010: 
        !          2011:    // open the file..
        !          2012:    if (!(hFile = FileHandleCreate (UnicodeBuff)))
        !          2013:       {
        !          2014:       // can't open the file
        !          2015:       ErrCode = ERR_CANT_OPEN ;
        !          2016:       return ;
        !          2017:       }
        !          2018: 
        !          2019: 
        !          2020:    SetHourglassCursor() ;
        !          2021: 
        !          2022:    // get header
        !          2023:    StringLoad (IDS_REPORT_HEADER, UnicodeBuff) ;
        !          2024:    ConvertUnicodeStr (TempBuff, UnicodeBuff) ;
        !          2025:    StringLen = strlen (TempBuff) ;
        !          2026:    ConvertUnicodeStr (&TempBuff[StringLen], LocalComputerName) ;
        !          2027:    strcat (TempBuff, LineEndStr) ;
        !          2028: 
        !          2029:    if (!FileWrite (hFile, TempBuff, strlen(TempBuff)))
        !          2030:       {
        !          2031:       ErrCode = ERR_EXPORT_FILE ;
        !          2032:       goto Exit0 ;
        !          2033:       }
        !          2034: 
        !          2035:    if (!(strempty(pLog->szFilePath)))
        !          2036:       {
        !          2037:       // export filename is there is one
        !          2038:       StringLoad (IDS_REPORT_LOGFILE, UnicodeBuff) ;
        !          2039:       ConvertUnicodeStr (TempBuff, UnicodeBuff) ;
        !          2040:       StringLen = strlen (TempBuff) ;
        !          2041:       ConvertUnicodeStr (&TempBuff[StringLen], pLog->szFilePath) ;
        !          2042:       strcat (TempBuff, LineEndStr) ;
        !          2043: 
        !          2044:       if (!FileWrite (hFile, TempBuff, strlen(TempBuff)))
        !          2045:          {
        !          2046:          ErrCode = ERR_EXPORT_FILE ;
        !          2047:          goto Exit0 ;
        !          2048:          }
        !          2049:       }
        !          2050: 
        !          2051:    // export interval 
        !          2052:    StringLoad (IDS_CHARTINT_FORMAT, UnicodeBuff1) ;
        !          2053:    TSPRINTF (UnicodeBuff, UnicodeBuff1,
        !          2054:        (FLOAT) pLog->iIntervalMSecs / (FLOAT) 1000.0) ;
        !          2055:    ConvertUnicodeStr (TempBuff, UnicodeBuff) ;
        !          2056:    strcat (TempBuff, LineEndStr) ;
        !          2057:    strcat (TempBuff, LineEndStr) ;
        !          2058: 
        !          2059:    if (!FileWrite (hFile, TempBuff, strlen(TempBuff)))
        !          2060:       {
        !          2061:       ErrCode = ERR_EXPORT_FILE ;
        !          2062:       goto Exit0 ;
        !          2063:       }
        !          2064: 
        !          2065:    // export Labels
        !          2066:    StringLoad (IDS_LABELOBJECT, UnicodeBuff) ;
        !          2067:    ConvertUnicodeStr (TempBuff, UnicodeBuff) ;
        !          2068:    strcat (TempBuff, pDelimiter) ;
        !          2069: 
        !          2070:    if (!FileWrite (hFile, TempBuff, strlen(TempBuff)))
        !          2071:       {
        !          2072:       ErrCode = ERR_EXPORT_FILE ;
        !          2073:       goto Exit0 ;
        !          2074:       }
        !          2075: 
        !          2076:    StringLoad (IDS_LABELSYSTEM, UnicodeBuff) ;
        !          2077:    ConvertUnicodeStr (TempBuff, UnicodeBuff) ;
        !          2078:    strcat (TempBuff, LineEndStr) ;
        !          2079: 
        !          2080:    if (!FileWrite (hFile, TempBuff, strlen(TempBuff)))
        !          2081:       {
        !          2082:       ErrCode = ERR_EXPORT_FILE ;
        !          2083:       goto Exit0 ;
        !          2084:       }
        !          2085: 
        !          2086: 
        !          2087:    // export each counter
        !          2088:    for (iIndex = 0 ; iIndex < iIndexNum ; iIndex++)
        !          2089:       {  // for
        !          2090:       
        !          2091:       pLogEntry = LogEntryN (hWndLogEntries, iIndex) ;
        !          2092:       
        !          2093:       if (!pLogEntry || pLogEntry == (PLOGENTRY)LB_ERR)
        !          2094:          {
        !          2095:          continue ;
        !          2096:          }
        !          2097: 
        !          2098:       ConvertUnicodeStr (TempBuff, pLogEntry->szObject) ;
        !          2099:       strcat (TempBuff, pDelimiter) ;
        !          2100: 
        !          2101:       if (!FileWrite (hFile, TempBuff, strlen(TempBuff)))
        !          2102:          {
        !          2103:          ErrCode = ERR_EXPORT_FILE ;
        !          2104:          break ;
        !          2105:          }
        !          2106: 
        !          2107:       ConvertUnicodeStr (TempBuff, pLogEntry->szComputer) ;
        !          2108:       strcat (TempBuff, LineEndStr) ;
        !          2109: 
        !          2110:       if (!FileWrite (hFile, TempBuff, strlen(TempBuff)))
        !          2111:          {
        !          2112:          ErrCode = ERR_EXPORT_FILE ;
        !          2113:          break ;
        !          2114:          }
        !          2115:       }
        !          2116: 
        !          2117: Exit0:
        !          2118: 
        !          2119:    SetArrowCursor() ;
        !          2120:    CloseHandle (hFile) ;
        !          2121: 
        !          2122:    if (pFileName)
        !          2123:       {
        !          2124:       if (ErrCode)
        !          2125:          {
        !          2126:          DlgErrorBox (hWndGraph, ErrCode, pFileName) ;
        !          2127:          }
        !          2128:       MemoryFree (pFileName) ;
        !          2129:       }
        !          2130: 
        !          2131: }  // ExportLog
        !          2132: 
        !          2133: 
        !          2134: LPTSTR   MatchSystemCounters (LPTSTR pBaseSysCounter,
        !          2135:    long   lBaseSysSize,
        !          2136:    LPTSTR pSysCounter,
        !          2137:    long   lSysSize,
        !          2138:    long   *pMatchPortion)
        !          2139: {
        !          2140:    LPTSTR   pNotMatch = NULL ;
        !          2141:    long     i, lSizeToCompare ;
        !          2142: 
        !          2143:    *pMatchPortion = 0 ;
        !          2144:    lSizeToCompare = min (lBaseSysSize, lSysSize) / sizeof (TCHAR) ;
        !          2145: 
        !          2146:    for (i = 0 ; i < lSizeToCompare ; i++, pBaseSysCounter++, pSysCounter++)
        !          2147:       {
        !          2148:       if (*pBaseSysCounter != *pSysCounter)
        !          2149:          {
        !          2150:          pNotMatch = pSysCounter ;
        !          2151:          break ;
        !          2152:          }
        !          2153:       }
        !          2154: 
        !          2155:    if (pNotMatch == NULL)
        !          2156:       {
        !          2157:       if (lBaseSysSize < lSysSize)
        !          2158:          {
        !          2159:          // the new system has longer counter names than base system
        !          2160:          // setup the extra portion.
        !          2161:          pNotMatch = pSysCounter ;
        !          2162:          }
        !          2163:       else
        !          2164:          {
        !          2165:          // new system counter name is shorter than or equal to
        !          2166:          // the base system counter names
        !          2167:          *pMatchPortion = lSysSize ;
        !          2168:          }
        !          2169:       }
        !          2170: 
        !          2171:    return (pNotMatch) ;
        !          2172: 
        !          2173: }
        !          2174:  
        !          2175: void LogWriteSystemCounterNames (HWND hWnd, PLOG pLog)
        !          2176:    {
        !          2177:    long           dwArraySize ;
        !          2178:    PPERFSYSTEM    pSystem = pLog->pSystemFirst ;
        !          2179:    LPTSTR         pMatchLen ;
        !          2180:    LPTSTR         pCounterName ;
        !          2181:    long           lMatchLen, lMatchPortion ;
        !          2182: 
        !          2183:    for (pSystem = pLog->pSystemFirst ;
        !          2184:         pSystem ;
        !          2185:         pSystem = pSystem->pSystemNext)
        !          2186:       {
        !          2187:       if (pSystem->bSystemCounterNameSaved == TRUE)
        !          2188:          {
        !          2189:          // we have wrote out the counter name for 
        !          2190:          // this system, skip it then.
        !          2191:          continue ;
        !          2192:          }
        !          2193: 
        !          2194:       dwArraySize = (pSystem->CounterInfo.dwLastId + 1 ) ;
        !          2195: 
        !          2196:       if (!pLog->lBaseCounterNameOffset)
        !          2197:          {
        !          2198:          LogWriteCounterName (hWnd, pSystem, pLog,
        !          2199:             (LPTSTR)(pSystem->CounterInfo.TextString + dwArraySize),
        !          2200:             0,
        !          2201:             pSystem->CounterInfo.dwCounterSize,
        !          2202:             0 ) ;
        !          2203:          }
        !          2204:       else
        !          2205:          {
        !          2206:          // check for matched characters between this system and the 
        !          2207:          // base system
        !          2208:          pCounterName = (LPTSTR)(pSystem->CounterInfo.TextString + dwArraySize) ;
        !          2209:          pMatchLen = MatchSystemCounters (pLog->pBaseCounterName,
        !          2210:                         pLog->lBaseCounterNameSize,
        !          2211:                         pCounterName,
        !          2212:                         pSystem->CounterInfo.dwCounterSize,
        !          2213:                         &lMatchPortion) ;
        !          2214: 
        !          2215:          if (pMatchLen)
        !          2216:             {
        !          2217:             // This system matches part of the base system
        !          2218:             // (all if it has more names)
        !          2219:             lMatchLen = (long) (pMatchLen - pCounterName) * sizeof (TCHAR) ;
        !          2220:             LogWriteCounterName (hWnd, pSystem, pLog,
        !          2221:                pMatchLen,
        !          2222:                lMatchLen,
        !          2223:                pSystem->CounterInfo.dwCounterSize - lMatchLen,
        !          2224:                0 ) ;
        !          2225:             }
        !          2226:          else
        !          2227:             {
        !          2228:             // This system matches the based system
        !          2229:             LogWriteCounterName (hWnd, pSystem, pLog,
        !          2230:                NULL,
        !          2231:                lMatchPortion,
        !          2232:                0,
        !          2233:                0 ) ;
        !          2234:             }
        !          2235:          }
        !          2236:       }
        !          2237:    } // LogWriteSystemCounterNames
        !          2238: 
        !          2239: 
        !          2240: BOOL LogWriteCounterName (HWND hWnd,
        !          2241:                           PPERFSYSTEM pSystem,
        !          2242:                           PLOG   pLog,
        !          2243:                           LPTSTR pCounterName,
        !          2244:                           long sizeMatched,
        !          2245:                           long sizeOfData,
        !          2246:                           BOOL bBaseCounterName)
        !          2247:    {
        !          2248:    BOOL                 ReadOK ;
        !          2249:    BOOL                 WriteOK ;
        !          2250:    SYSTEMTIME           SystemTime ;
        !          2251:    LOGFILECOUNTERNAME   CounterNameRecord ;
        !          2252:    LOGHEADER            LogFileHeader ;
        !          2253:    long                 lDataOffset, lCurPosition ;
        !          2254:    TCHAR                Dummy [sizeof(DWORD)] ;
        !          2255:    int                  PatchBytes ;
        !          2256: 
        !          2257:    if (pSystem->bSystemCounterNameSaved == TRUE)
        !          2258:       return FALSE ;
        !          2259: 
        !          2260:    GetLocalTime (&SystemTime) ;
        !          2261: 
        !          2262:    lCurPosition = FileTell (pLog->hFile) ;
        !          2263:    
        !          2264:    lstrcpy (CounterNameRecord.szComputer, pSystem->sysName) ;
        !          2265:    CounterNameRecord.lBaseCounterNameOffset = pLog->lBaseCounterNameOffset ;
        !          2266:    CounterNameRecord.lCurrentCounterNameOffset =
        !          2267:       lCurPosition + sizeof (LOGFILECOUNTERNAME) ;
        !          2268:    CounterNameRecord.lMatchLength = sizeMatched ;
        !          2269:    CounterNameRecord.lUnmatchCounterNames = sizeOfData ;
        !          2270:    CounterNameRecord.dwLastCounterId = pSystem->CounterInfo.dwLastId ;
        !          2271:    CounterNameRecord.dwLangId = pSystem->CounterInfo.dwLangId ;
        !          2272:    WriteOK = FileWrite (pLog->hFile, &CounterNameRecord,
        !          2273:       sizeof (CounterNameRecord)) ;
        !          2274: 
        !          2275:    if (WriteOK)
        !          2276:       {
        !          2277:       pLog->lFileSize += sizeof (LOGFILECOUNTERNAME) ;
        !          2278: 
        !          2279:       if (sizeOfData)
        !          2280:          {
        !          2281:       
        !          2282:          WriteOK = FileWrite (pLog->hFile, pCounterName, sizeOfData) ;
        !          2283:          
        !          2284:          if (WriteOK && (PatchBytes = sizeOfData % sizeof(DWORD)) > 0)
        !          2285:             {
        !          2286:             // ensure the file is in DWORD boundary.
        !          2287:             WriteOK = FileWrite (pLog->hFile, Dummy, PatchBytes) ;
        !          2288:             }
        !          2289: 
        !          2290:          if (WriteOK)
        !          2291:             {
        !          2292:             pLog->lFileSize += sizeOfData + PatchBytes ;
        !          2293: 
        !          2294:             if (!pLog->lBaseCounterNameOffset)
        !          2295:                {
        !          2296:                // this is the first counter name data block
        !          2297:                // then update the log file header
        !          2298:                lDataOffset = FileTell (pLog->hFile) ;
        !          2299: 
        !          2300:                FileSeekBegin (pLog->hFile, 0L) ;
        !          2301: 
        !          2302:                ReadOK = FileRead (pLog->hFile,
        !          2303:                   &LogFileHeader,
        !          2304:                   sizeof (LogFileHeader)) ;
        !          2305: 
        !          2306:                if (ReadOK)
        !          2307:                   {
        !          2308:                   LogFileHeader.lBaseCounterNameOffset = lCurPosition ;
        !          2309:                   FileSeekBegin (pLog->hFile, 0L) ;
        !          2310:                   WriteOK = FileWrite (pLog->hFile,
        !          2311:                      &LogFileHeader,
        !          2312:                      sizeof (LogFileHeader)) ;
        !          2313:                   }
        !          2314:                else
        !          2315:                   {
        !          2316:                   // flag an error
        !          2317:                   WriteOK = FALSE ; 
        !          2318:                   }
        !          2319: 
        !          2320:                // retore back to current file position
        !          2321:                FileSeekBegin (pLog->hFile, lDataOffset) ;
        !          2322: 
        !          2323:                if (ReadOK && WriteOK)
        !          2324:                   {
        !          2325:                   // allocate memory to save the base system counter names
        !          2326:                   if (pLog->pBaseCounterName)
        !          2327:                      {
        !          2328:                      MemoryFree (pLog->pBaseCounterName) ;
        !          2329:                      }
        !          2330:                   if (pLog->pBaseCounterName = MemoryAllocate (sizeOfData))
        !          2331:                      {
        !          2332:                      memcpy (pLog->pBaseCounterName,
        !          2333:                         pCounterName,
        !          2334:                         sizeOfData) ;
        !          2335:                      pLog->lBaseCounterNameOffset = lCurPosition ;
        !          2336:                      pLog->lBaseCounterNameSize = sizeOfData ;
        !          2337:                      }
        !          2338:                   }
        !          2339:                }  // if (!pLog->lBaseCounterNameOffset)
        !          2340:             }
        !          2341:          }  // if (sizeOfData)
        !          2342:       }
        !          2343: 
        !          2344:    if ( WriteOK )
        !          2345:       {
        !          2346:       WriteOK = LogWriteIndex (pLog, LogFileIndexCounterName,
        !          2347:                                &SystemTime,
        !          2348:                                lCurPosition,
        !          2349:                                0) ;
        !          2350:       }
        !          2351: 
        !          2352:    if ( !WriteOK )
        !          2353:       {
        !          2354:       CloseLog (hWndLog, pLog) ;
        !          2355:       PrepareMenu (GetMenu (hWndMain)) ;
        !          2356:       UpdateLogDisplay (hWndLog) ;   
        !          2357:       DlgErrorBox (hWndLog, ERR_LOG_FILE, pLog->szFilePath);
        !          2358:       }
        !          2359:    else
        !          2360:       {
        !          2361:       UpdateLogSize (hWnd) ;
        !          2362:       pSystem->bSystemCounterNameSaved = TRUE ;
        !          2363:       }
        !          2364: 
        !          2365:    return (TRUE) ;
        !          2366:    }
        !          2367: 
        !          2368: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.