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

/*****************************************************************************
 *
 *  Log.c - This module handles the Logging.
 *
 *  Microsoft Confidential
 *  Copyright (c) 1992-1993 Microsoft Corporation
 *
 *
 ****************************************************************************/


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

#include <stdio.h>

#include "perfmon.h"
#include "log.h"

#include "fileutil.h"
#include "owndraw.h"
#include "pmemory.h"       // for MemoryXXX (mallloc-type) routines
#include "perfmops.h"      // for SystemAdd
#include "perfdata.h"
#include "playback.h"      // for PlayingBackLog
#include "status.h"        // for StatusUpdateIcons
#include "system.h"        // for SystemAdd
#include "utils.h"
#include "fileopen.h"      // for FileGetName
#include "command.h"

extern TCHAR LOCAL_SYS_CODE_NAME[] ;

//==========================================================================//
//                              Funtion Prototypes                          //
//==========================================================================//


BOOL LogWriteStartBookmark (HWND hWnd, SYSTEMTIME *pSystemTime) ;
BOOL LogWriteBookmarkData (HWND hWnd, PBOOKMARK pBookMark) ;
BOOL LogWriteSystemBookmark (HWND hWnd, LPTSTR SysName, BOOL DisConnect, SYSTEMTIME *pSystemTime) ;


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



#define LogNameMinLen             15
#define LogObjectMinLen           20

// This is set to 1 min
#define LARGE_INTERVAL            60

//=============================//
// Log Class                   //
//=============================//


#define dwLogClassStyle           (CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS)
#define iLogClassExtra            (0)
#define iLogWindowExtra           (0)
#define dwLogWindowStyle          (WS_CHILD)


//==========================================================================//
//                                Local Data                                //
//==========================================================================//



int            xStatusWidth ;
int            xNameMinWidth ;

TCHAR          szClosed [ShortTextLen] ;
TCHAR          szCollecting [ShortTextLen] ;
// TCHAR          szPaused [ControlStringLen + 1] ;



LOGINDEXBLOCK  *pLogIndexBlock ;

#define WM_START_LOGGING  WM_USER+2

//==========================================================================//
//                                   Macros                                 //
//==========================================================================//


#define LogEntryN(hWndLogEntries, iIndex)        \
   ((PLOGENTRY) LBData (hWndLogEntries, iIndex))


//==========================================================================//
//                              Local Functions                             //
//==========================================================================//

void LogAddEntryToList (PLOGENTRY *ppLogEntryFirst, PLOGENTRY pLogNewEntry)
{
    // insert the new entry at the beginning
    pLogNewEntry->pNextLogEntry = *ppLogEntryFirst ;
    *ppLogEntryFirst = pLogNewEntry ;
}

void LogDeleteEntryFromList (PLOGENTRY *ppLogEntryFirst, PLOGENTRY pLogEntryDel)
{
    PLOGENTRY   pLogEntry ;

    if (*ppLogEntryFirst == pLogEntryDel) {
        *ppLogEntryFirst = pLogEntryDel->pNextLogEntry ;
    } else {
        for (pLogEntry = *ppLogEntryFirst ;
            pLogEntry ;
            pLogEntry = pLogEntry->pNextLogEntry) {
            if (pLogEntry->pNextLogEntry == pLogEntryDel) {
                // found, remove this entry from the list
                pLogEntry->pNextLogEntry =
                pLogEntryDel->pNextLogEntry ;
                break ;
            }
        }
    }
}


// LogDeleteIndex - delete the log entry specified by iIndex
// and do memory clean-up
void static LogDeleteIndex (HWND hWndLogEntries, INT_PTR iIndex)
{
    PLOGENTRY   pLogEntry ;
    PLOG        pLog ;

    pLogEntry = (PLOGENTRY) LBData(hWndLogEntries, iIndex) ;


    if (pLogEntry && pLogEntry != (PLOGENTRY)LB_ERR) {
        pLog = LogData (hWndLog) ;

        if (pLog->pLogEntryFirst) {
            LogDeleteEntryFromList (&(pLog->pLogEntryFirst), pLogEntry) ;
        }

        MemoryFree (pLogEntry) ;
    }

    LBDelete (hWndLogEntries, iIndex) ;
}


void LogEntriesChanged (HWND hWndLogEntries)
/*
   Effect:        Perform any actions needed when an entry has been added or
                  removed from the log. In particular, determine if a new
                  "Object" column width is appropriate. If it is, then
                  change the width and redraw the log entries list.
*/
{
    int         iIndex ;
    int         iIndexNum ;
    int         xCol1Width ;
    HDC         hDC ;
    PLOG        pLog ;
    PLOGENTRY   pLogEntry ;
    PPERFSYSTEM pSystem;

    pLog = LogData (hWndLog) ;
    xCol1Width = 0 ;

    hDC = GetDC (hWndLog) ;
    iIndexNum = LBNumItems (hWndLogEntries) ;

    // clear value Strings for all systems

    for (pSystem = pLog->pSystemFirst;
        pSystem;
        pSystem = pSystem->pSystemNext) {
        if (pSystem && pSystem->FailureTime == 0) {
            RemoveObjectsFromSystem (pSystem);
        }
    }

    for (iIndex = 0; iIndex < iIndexNum; iIndex++) {
        pLogEntry = LogEntryN (hWndLogEntries, iIndex) ;
        xCol1Width = max (TextWidth (hDC, pLogEntry->szObject),
                          xCol1Width) ;

        pSystem = SystemGet (pLog->pSystemFirst, pLogEntry->szComputer);
        if (pSystem && pSystem->FailureTime == 0) {
            AppendObjectToValueList (
                                    pLogEntry->ObjectTitleIndex,
                                    pSystem->lpszValue);
        }
    }

    xCol1Width += 2 * xScrollWidth ;
    xCol1Width = max (xCol1Width,
                      TextAvgWidth (hDC, LogObjectMinLen)) ;
    if (xCol1Width != pLog->xCol1Width) {
        pLog->xCol1Width = xCol1Width ;
        WindowInvalidate (hWndLogEntries) ;
    }
    ReleaseDC (hWndLog, hDC) ;
}


LPTSTR StatusText (int iPMStatus)
/*
   Effect:        Return a string representation of the log status
                  iPMStatus.

   Note:          Since these are globals, we can just return a pointer
                  to them. The user of this routine should not free
                  these pointers or modify the string.
*/
{
    switch (iPMStatus) {
        case iPMStatusClosed:
            return (szClosed) ;

        case iPMStatusCollecting:
            return (szCollecting) ;

            //      case iPMStatusPaused:
            //         return (szPaused) ;

        default:
            return (szClosed) ;
    }
}


PLOG AllocateLogData (HWND hWndLog)
{
    PLOG           pLog ;

    pLog = LogData (hWndLog) ;

    pLog->iStatus = iPMStatusClosed ;
    pLog->bManualRefresh = FALSE ;

    // let's not give it a filename

    /*!!
       FileCombine (pLog->szFilePath,
                    szDefaultLogDirectory, szDefaultLogFileName) ;
    !!*/
    strclr (pLog->szFilePath) ;

    pLog->pSystemFirst = NULL;
    pLog->lFileSize = 0L ;
    pLog->iIntervalMSecs = iDefaultLogIntervalSecs * 1000 ;

    pLog->pLogData = (PPERFDATA) MemoryAllocate (STARTING_SYSINFO_SIZE) ;
    pLog->dwDetailLevel = PERF_DETAIL_WIZARD ;
    LogEntriesChanged (hWndLogEntries) ;

    return (pLog) ;
}


void FreeLogData (PLOG pLog)
{
    MemoryFree ((LPMEMORY)pLog->pLogData) ;
}


void UpdateLogSize (HWND hWnd)
/*
   Effect:        Set the size value to the current size.  Also change the
                  size entry in the status line.
*/
{
    PLOG           pLog ;
    TCHAR          szSize [ShortTextLen + 1] ;

    pLog = LogData (hWnd) ;

    LongToCommaString (pLog->lFileSize, szSize) ;
    SetDlgItemText (hWnd, IDD_LOGSIZE, szSize) ;

    if (!PlayingBackLog()) {
        StatusUpdateIcons (hWndStatus) ;
    }
}


HANDLE LogAppendSetup(PLOG pLog, PLOGHEADER pLogFileHeader)
{
    PLOGHEADER     pHeader ;
    LOGPOSITION    LP ;
    DWORD          lPreviousIndexBlock ;
    DWORD          lNextIndexBlock ;
    PLOGHEADER     pPlaybackLogHeader ;
    HANDLE         hMapHandle ;

    pHeader = (PLOGHEADER) FileMap(pLog->hFile, &hMapHandle) ;
    if (!pHeader ||
        !strsame(pHeader->szSignature, LogFileSignature) ||
        pHeader->wVersion != LogFileVersion ||
        pHeader->wRevision != LogFileRevision) {
        if (pHeader) {
            FileUnMap((LPVOID)pHeader, hMapHandle) ;
        }
        return 0 ;
    }

    *pLogFileHeader = *pHeader ;


    LP.pIndexBlock = FirstIndexBlock(pHeader) ;
    LP.iIndex = 0 ;
    LP.iPosition = 0 ;
    lPreviousIndexBlock = pHeader->iLength ;
    lNextIndexBlock = LP.pIndexBlock->lNextBlockOffset ;

    // since inside NextReLogIndexPosition would eventually call
    // PlaybackSeek for large log file, we have to temporarily
    // setup PlaybackLog.pHeader.   Not a good fix but it works...
    pPlaybackLogHeader = PlaybackLog.pHeader ;
    PlaybackLog.pHeader = pHeader ;
    while (NextReLogIndexPosition(&LP)) {
        if (LP.pIndexBlock->lNextBlockOffset != lNextIndexBlock) {
            lPreviousIndexBlock = lNextIndexBlock ;
            lNextIndexBlock = LP.pIndexBlock->lNextBlockOffset ;
        }
    }

    // get the last system time from this log file
    if (LP.iIndex > 0) {
        SYSTEMTIME localSystemTime ;

        if (LogPositionSystemTime (&LP, &localSystemTime)) {
            pLog->LastLogTime = localSystemTime ;
        }
    }

    PlaybackLog.pHeader = pPlaybackLogHeader ;
    if (!pLogIndexBlock) {
        pLogIndexBlock = (LOGINDEXBLOCK *) MemoryAllocate (sizeof(LOGINDEXBLOCK)) ;
    }
    if (pLogIndexBlock) {
        *pLogIndexBlock = *LP.pIndexBlock ;
    }
    pLog->lIndexBlockOffset = lPreviousIndexBlock ;
    pLog->iIndex = ++LP.iIndex ;
    pLog->lFileSize = FileSeekEnd(pLog->hFile, 0) ;

    FileUnMap((LPVOID)pHeader, hMapHandle) ;
    return pLog->hFile ;
}

void LogRemoveCounterName (PLOG pLog)
{
    PPERFSYSTEM    pSystem ;

    if (pLog->pBaseCounterName) {
        MemoryFree (pLog->pBaseCounterName) ;
    }
    pLog->pBaseCounterName = 0 ;
    pLog->lBaseCounterNameSize = 0 ;
    pLog->lBaseCounterNameOffset = 0 ;

    // clear all the system marker to indicate they have not been
    // saved
    for (pSystem = pLog->pSystemFirst ;
        pSystem ;
        pSystem = pSystem->pSystemNext) {
        pSystem->bSystemCounterNameSaved = FALSE ;
    }
}

int CreateLogFile (PLOG pLog, BOOL bCreateFile, BOOL bSameFile)
{
    HANDLE               returnHandle ;
    LOGHEADER            LogFileHeader ;
    long                 lCurPosition ;
    LOGFILECOUNTERNAME   CounterNameRecord ;

    pLog->lFileSize = 0 ;
    memset (&(pLog->LastLogTime), 0, sizeof(SYSTEMTIME)) ;

    if (!pLogIndexBlock) {
        pLogIndexBlock = (LOGINDEXBLOCK *) MemoryAllocate (sizeof(LOGINDEXBLOCK)) ;
    }
    if (pLogIndexBlock) {
        lstrcpy (pLogIndexBlock->szSignature, LogIndexSignature) ;
    }
    else
        return ERROR_NOT_ENOUGH_MEMORY;

    pLog->hFile = FileHandleOpen (pLog->szFilePath) ;
    if (pLog->hFile != INVALID_HANDLE_VALUE) {
        // if this is a pre-existing log file, set up to append to it
        returnHandle = LogAppendSetup(pLog, &LogFileHeader) ;
        if (!returnHandle) {
            // this is not a log file...
            CloseHandle (pLog->hFile) ;
            return (ERR_BAD_LOG_FILE) ;
        }

        pLog->hFile = returnHandle ;
    }

    if (bCreateFile && (!pLog->hFile || pLog->hFile == INVALID_HANDLE_VALUE)) {
        // Create a new log file if needed.
        pLog->hFile = FileHandleCreate (pLog->szFilePath) ;
        if (!pLog->hFile || pLog->hFile == INVALID_HANDLE_VALUE)
            return (ERR_LOG_FILE) ;
        lstrcpy (LogFileHeader.szSignature, LogFileSignature) ;
        LogFileHeader.wVersion = LogFileVersion ;
        LogFileHeader.wRevision = LogFileRevision ;
        LogFileHeader.iLength = sizeof (LOGHEADER) ;
        LogFileHeader.lBaseCounterNameOffset = 0 ;
        if (!FileWrite (pLog->hFile, &LogFileHeader, sizeof (LogFileHeader))) {
            CloseHandle (pLog->hFile) ;
            return (ERR_LOG_FILE) ;
        }

        pLog->iIndex = 0 ;
        pLog->lIndexBlockOffset = FileTell (pLog->hFile) ;
        FileSeekCurrent (pLog->hFile, sizeof (LOGINDEXBLOCK)) ;
        pLog->lFileSize = sizeof(LOGHEADER) + sizeof (LOGINDEXBLOCK) ;
        pLogIndexBlock->iNumIndexes = 0 ;
        pLogIndexBlock->lNextBlockOffset = 0 ;

        // get rid of any previous counter names and get ready for start
        //      if (!bSameFile)
        //         {
        //         LogRemoveCounterName (pLog) ;
        //         }
        LogRemoveCounterName (pLog) ;
    } else if (bCreateFile) {
        // this is an existing log file, setup the counter names
        // LogFileHeader already has the header info filled in
        // by LogAppendSetup
        if (!bSameFile || !pLog->pBaseCounterName) {
            // get rid of any previous counter names
            LogRemoveCounterName (pLog) ;

            // read the new names and get ready for start
            lCurPosition = FileTell (pLog->hFile) ;

            FileSeekBegin (pLog->hFile,
                           LogFileHeader.lBaseCounterNameOffset) ;

            if (!(FileRead (pLog->hFile,
                            &CounterNameRecord,
                            sizeof (CounterNameRecord)))) {
                FileSeekBegin (pLog->hFile,
                               lCurPosition) ;
                goto EXIT ;
            }

            FileSeekBegin (pLog->hFile,
                           CounterNameRecord.lCurrentCounterNameOffset) ;

            if (!(pLog->pBaseCounterName = MemoryAllocate (
                                                          CounterNameRecord.lUnmatchCounterNames))) {
                FileSeekBegin (pLog->hFile,
                               lCurPosition) ;
                goto EXIT ;
            }
            if (!(FileRead (pLog->hFile,
                            pLog->pBaseCounterName,
                            CounterNameRecord.lUnmatchCounterNames))) {
                MemoryFree (pLog->pBaseCounterName) ;
                pLog->pBaseCounterName = NULL ;
                FileSeekBegin (pLog->hFile,
                               lCurPosition) ;
                goto EXIT ;
            }
            // we got the data, fill in other info
            pLog->lBaseCounterNameSize =
            CounterNameRecord.lUnmatchCounterNames ;
            pLog->lBaseCounterNameOffset =
            LogFileHeader.lBaseCounterNameOffset ;

            FileSeekBegin (pLog->hFile,
                           lCurPosition) ;
        }
    }

    EXIT:

    return (0) ;

}

void LogWriteIndexBlock (PLOG pLog)
{
    FileSeekBegin (pLog->hFile,
                   pLog->lIndexBlockOffset) ;
    pLogIndexBlock->lNextBlockOffset = 0 ;
    FileWrite (pLog->hFile,
               (LPSTR) pLogIndexBlock,
               sizeof (LOGINDEXBLOCK)) ;
}


BOOL LogWriteIndex (PLOG pLog,
                    UINT uFlags,
                    SYSTEMTIME *pSystemTime,
                    LONG lDataOffset,
                    int iSystemsLogged)
{
    LOGINDEX       Index ;
    long           lNextBlockOffset ;
    BOOL           WriteOK ;
    //=============================//
    // Add Index Block Entry       //
    //=============================//
    //=============================//
    // Index Block Full?           //
    //=============================//

    WriteOK = TRUE ;

    if (pLog->iIndex == LogFileBlockMaxIndexes - 1) {
        lNextBlockOffset = FileTell (pLog->hFile) ;
        pLogIndexBlock->lNextBlockOffset = lNextBlockOffset ;
        FileSeekBegin (pLog->hFile,
                       pLog->lIndexBlockOffset) ;
        WriteOK = FileWrite (pLog->hFile,
                             (LPSTR) pLogIndexBlock,
                             sizeof (LOGINDEXBLOCK)) ;
        if (WriteOK) {
            FileSeekBegin (pLog->hFile,
                           lNextBlockOffset) ;
            // Fake file end until we really write the block
            pLogIndexBlock->iNumIndexes = 0 ;
            pLogIndexBlock->lNextBlockOffset = 0 ;
            WriteOK = FileWrite (pLog->hFile,
                                 (LPSTR) pLogIndexBlock,
                                 sizeof (LOGINDEXBLOCK)) ;
            if (WriteOK) {
                pLog->lIndexBlockOffset = lNextBlockOffset ;
                pLog->iIndex = 0 ;
                pLog->lFileSize += sizeof (LOGINDEXBLOCK) ;
            }
        }
    }

    //=============================//
    // Add Index Block Entry       //
    //=============================//

    Index.uFlags = uFlags ;
    Index.SystemTime = *pSystemTime ;
    Index.lDataOffset = lDataOffset ;
    Index.iSystemsLogged = iSystemsLogged ;

    pLogIndexBlock->aIndexes [pLog->iIndex] = Index ;
    pLog->iIndex++ ;
    pLogIndexBlock->iNumIndexes++ ;

    // write out the index block if the log interval if too large
    if (pLog->iIntervalMSecs >= LARGE_INTERVAL * 1000 ) {
        LONG           lCurPosition ;

        // save the current file position
        lCurPosition = FileTell (pLog->hFile) ;

        // flush the index block to the file
        LogWriteIndexBlock (pLog) ;

        // restore previous file position since
        // LogWriteIndexBlock has messed it up
        FileSeekBegin (pLog->hFile, lCurPosition) ;
    }
    return (WriteOK) ;
}



BOOL LogWritePerfData (HWND hWnd,
                       PLOG pLog,
                       PPERFDATA pPerfData,
                       SYSTEMTIME *pSystemTime,
                       DWORD iNumSystems,
                       BOOL bWriteIndex)
{
    LONG           lSize ;
    BOOL           WriteOK ;
    LONG           lCurPosition ;

    lSize = pPerfData->TotalByteLength ;

    lCurPosition = FileTell (pLog->hFile) ;

    //=============================//
    // Write Perf Data             //
    //=============================//

    WriteOK = FileWrite (pLog->hFile, (LPSTR) pPerfData, lSize) ;
    if (WriteOK) {
        pLog->lFileSize += lSize ;

        if (bWriteIndex) {
            WriteOK = LogWriteIndex (pLog,
                                     LogFileIndexData,
                                     pSystemTime,
                                     lCurPosition,
                                     iNumSystems) ;
        }
    }
    if ( !WriteOK ) {
        CloseLog (hWnd, pLog) ;
        PrepareMenu (GetMenu (hWndMain)) ;
        UpdateLogDisplay (hWnd) ;
        DlgErrorBox (hWnd, ERR_LOG_FILE, pLog->szFilePath) ;
    }
    return (WriteOK) ;
}


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


void static OnSize (HWND hDlg,
                    int xWidth,
                    int yHeight)
/*
   Effect:        Perform any actions necessary when the log window (dialog)
                  is resized. In particular, move and resize some of the
                  dialogs controls.

   Internals:     The rightmost control, the log status, contains one of
                  only several values. These values are all within
                  xStatusWidth, computed at init time. Put this control
                  one scroll width away from the right edge at fixed
                  width. Move its associated text prompt with it. Then
                  use the remaining space for the filename control, which
                  can probably use it.

   To Do:         Need to consider minimum first.
*/
{
    int            xStatusPos ;
    int            xStatusTextPos ;
    int            xNameWidth ;
    int            xMinWidth ;

    //=============================//
    // Enough space for minimums?  //
    //=============================//

    xMinWidth =
    xScrollWidth +                         // margin before prompt
    DialogWidth (hDlg, IDD_LOGFILETEXT) +  // width of prompt
    xNameMinWidth +                        // width of name
    xScrollWidth +
    DialogWidth (hDlg, IDD_LOGSTATUSTEXT) +
    DialogWidth (hDlg, IDD_LOGSTATUS) +
    xScrollWidth ;


    xStatusPos = xWidth - xStatusWidth - xScrollWidth ;
    DialogMove (hDlg, IDD_LOGSTATUS,
                xStatusPos, NOCHANGE,
                xStatusWidth, NOCHANGE) ;

    xStatusTextPos = xStatusPos -
                     DialogWidth (hDlg, IDD_LOGSTATUSTEXT) -
                     xScrollWidth ;
    DialogMove (hDlg, IDD_LOGSTATUSTEXT,
                xStatusTextPos, NOCHANGE,
                NOCHANGE, NOCHANGE) ;

    xNameWidth = xStatusTextPos -
                 DialogWidth (hDlg, IDD_LOGFILETEXT) -
                 2 * xScrollWidth ;
    DialogMove (hDlg, IDD_LOGFILE,
                NOCHANGE, NOCHANGE,
                xNameWidth, NOCHANGE) ;

    DialogMove (hDlg, IDD_LOGSIZE,
                DialogXPos (hDlg, IDD_LOGFILE), NOCHANGE,
                DialogWidth (hDlg, IDD_LOGFILE), NOCHANGE) ;

    DialogMove (hDlg, IDD_LOGINTERVALTEXT,
                DialogXPos (hDlg, IDD_LOGSTATUSTEXT), NOCHANGE,
                DialogWidth (hDlg, IDD_LOGSTATUSTEXT), NOCHANGE) ;

    DialogMove (hDlg, IDD_LOGINTERVAL,
                DialogXPos (hDlg, IDD_LOGSTATUS), NOCHANGE,
                DialogWidth (hDlg, IDD_LOGSTATUS), NOCHANGE) ;

    DialogMove (hDlg, IDD_LOGENTRIESTEXT,
                xScrollWidth, NOCHANGE, NOCHANGE, NOCHANGE) ;

    DialogMove (hDlg, IDD_LOGENTRIES,
                xScrollWidth, NOCHANGE,
                xWidth - 2 * xScrollWidth,
                yHeight - DialogYPos (hDlg, IDD_LOGENTRIES) - yScrollHeight) ;
    WindowInvalidate (hDlg) ;
}


INT_PTR
OnCtlColor (
           HWND hDlg,
           HDC hDC
           )
{
    SetTextColor (hDC, crBlack) ;
    //   SetBkColor (hDC, crLightGray) ;
    //   return ((int) hbLightGray) ;
    SetBkColor (hDC, ColorBtnFace) ;
    return ((INT_PTR) hBrushFace) ;
}


void static OnInitDialog (HWND hDlg)
{
    HDC            hDC ;
    PLOG           pLog ;

    hWndLogEntries = DialogControl (hDlg, IDD_LOGENTRIES) ;

    pLog = AllocateLogData (hDlg) ;
    if (!pLog)
        return ;

    StringLoad (IDS_CLOSED, szClosed) ;
    //   StringLoad (IDS_PAUSED, szPaused) ;
    StringLoad (IDS_COLLECTING, szCollecting) ;
    UpdateLogDisplay (hDlg) ;

    hDC = GetDC (hDlg) ;
    xStatusWidth = max (TextWidth (hDC, szClosed),
                        TextWidth (hDC, szCollecting)) ;
    //                       max (TextWidth (hDC, szPaused),
    //                            TextWidth (hDC, szCollecting))) ;
    xStatusWidth += xScrollWidth ;

    xNameMinWidth = TextAvgWidth (hDC, LogNameMinLen) ;
    ReleaseDC (hDlg, hDC) ;
}



void static OnDestroy (HWND hWnd)
/*
   Effect:        Perform any actions necessary when a LogDisplay window
                  is being destroyed. In particular, free the instance
                  data for the log.

                  Since we really only have one log window and one global
                  log data structure, we don't free the structure. We do,
                  however, delete the objects allocated within the structure.
*/
{
    PLOG           pLog ;

    pLog = LogData (hWnd) ;
    FreeLogData (pLog) ;
}


void static OnDrawItem (HWND hWnd, LPDRAWITEMSTRUCT lpDI)
{
    HDC            hDC ;
    RECT           rectComputer, rectObject ;
    PLOGENTRY      pLogEntry ;
    PLOG           pLog ;
    COLORREF       preBkColor = 0;
    COLORREF       preTextColor = 0;

    pLog = LogData (hWnd) ;

    pLogEntry = LogEntryN (hWndLogEntries, DIIndex (lpDI)) ;

    // LogEntryN (SendMessage) will return LB_ERR for error, have to
    // check for that case
    if (!pLogEntry || pLogEntry == (PLOGENTRY)LB_ERR) {
        return ;
    }

    hDC = lpDI->hDC ;

    SelectFont (hDC, hFontScales) ;

    if (DISelected (lpDI)) {
        preTextColor = SetTextColor (hDC, GetSysColor (COLOR_HIGHLIGHTTEXT)) ;
        preBkColor = SetBkColor (hDC, GetSysColor (COLOR_HIGHLIGHT)) ;
    }

    rectObject.left = lpDI->rcItem.left ;
    rectObject.top = lpDI->rcItem.top ;
    rectObject.right = rectObject.left + pLog->xCol1Width ;
    rectObject.bottom = lpDI->rcItem.bottom ;

    ExtTextOut (hDC,
                rectObject.left + xScrollWidth, rectObject.top,
                ETO_OPAQUE,
                &rectObject,
                pLogEntry->szObject,
                lstrlen (pLogEntry->szObject),
                NULL) ;


    rectComputer.left = rectObject.right ;
    rectComputer.top = lpDI->rcItem.top ;
    rectComputer.right = lpDI->rcItem.right ;
    rectComputer.bottom = lpDI->rcItem.bottom ;

    ExtTextOut (hDC,
                rectComputer.left, rectComputer.top,
                ETO_OPAQUE,
                &rectComputer,
                pLogEntry->szComputer,
                lstrlen (pLogEntry->szComputer),
                NULL) ;

    if (DIFocus (lpDI))
        DrawFocusRect (hDC, &(lpDI->rcItem)) ;

    if (DISelected (lpDI)) {
        preTextColor = SetTextColor (hDC, preTextColor) ;
        preBkColor = SetBkColor (hDC, preBkColor) ;
    }
    //   RestoreDC (hDC, -1) ;
}



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


INT_PTR
APIENTRY
LogDisplayDlgProc (
                   HWND hDlg,
                   UINT iMessage,
                   WPARAM wParam,
                   LPARAM lParam)
/*
   Note:          This function must be exported in the application's
                  linker-definition file, perfmon.def.
*/
{
    switch (iMessage) {
        case WM_INITDIALOG:
            OnInitDialog (hDlg) ;
            break ;

        case WM_CTLCOLORDLG:
        case WM_CTLCOLOREDIT:
        case WM_CTLCOLORBTN:
        case WM_CTLCOLORSTATIC:
            return (OnCtlColor (hDlg, (HDC) wParam)) ;
            break ;

        case WM_DRAWITEM:
            OnDrawItem (hDlg, (LPDRAWITEMSTRUCT) lParam) ;
            break ;

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

        case WM_LBUTTONDOWN:
            DoWindowDrag (hDlg, lParam) ;
            break ;

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

        case WM_TIMER:
            LogTimer (hDlg, FALSE) ;
            break ;

        case WM_SETFOCUS:
            SetFocus (hWndLogEntries) ;
            break ;

        case WM_START_LOGGING:
            {
                PLOG        pLog ;

                pLog = LogData (hDlg) ;
                if (StartLog (hDlg, pLog, FALSE)) {
                    UpdateLogDisplay (hDlg) ;
                    PrepareMenu (GetMenu (hWndMain)) ;
                }
            }
            break ;

        case WM_DESTROY:
            OnDestroy (hDlg) ;
            return (FALSE) ;
            break ;

        default:
            return (FALSE) ;
    }

    return (TRUE) ;
}


HWND CreateLogWindow (HWND hWndParent)
/*
   Effect:        Create the Log window. This window is a child of
                  hWndMain.

   Note:          We dont worry about the size here, as this window
                  will be resized whenever the main window is resized.

*/
{
    HWND           hWnd ;
    hWnd = CreateDialog (hInstance,
                         MAKEINTRESOURCE (idDlgLogDisplay),
                         hWndParent,
                         LogDisplayDlgProc) ;

    return (hWnd) ;
}



void UpdateLogDisplay (HWND hWnd)
/*
   Effect:        Set the values for the various controls in the log
                  display.

   Called By:     OnInitDialog, any other routines that change these
                  values.
*/
{
    PLOG           pLog ;
    WCHAR          szSize [MiscTextLen + 1] ;

    pLog = LogData (hWnd) ;

    DialogSetString (hWnd, IDD_LOGFILE, pLog->szFilePath) ;

    // position the cursor at the end of the text
    EditSetTextEndPos (hWnd, IDD_LOGFILE) ;


    DialogSetString (hWnd, IDD_LOGSTATUS, StatusText (pLog->iStatus)) ;

    LongToCommaString (pLog->lFileSize, szSize) ;
    DialogSetString (hWnd, IDD_LOGSIZE, szSize) ;

    DialogSetInterval (hWnd, IDD_LOGINTERVAL, pLog->iIntervalMSecs) ;
}


BOOL LogInitializeApplication (void)
{
    return (TRUE) ;
}


void SetLogTimer (HWND hWnd,
                  int iIntervalMSecs)
{
    PLOG           pLog ;

    pLog = LogData (hWnd) ;
    pLog->iIntervalMSecs = iIntervalMSecs ;

    KillTimer (hWnd, LogTimerID) ;
    SetTimer (hWnd, LogTimerID, pLog->iIntervalMSecs, NULL) ;
}


void ClearLogTimer (HWND hWnd)
{
    KillTimer (hWnd, LogTimerID) ;
}



BOOL CloseLogStopTimer (HWND hWnd, PLOG pLog)
{
    CloseHandle (pLog->hFile) ;

    pLog->hFile = 0 ;
    pLog->iStatus = iPMStatusClosed ;

    ClearLogTimer (hWnd) ;

    return (TRUE) ;
}


BOOL CloseLog (HWND hWnd, PLOG pLog)
{
    LogWriteIndexBlock (pLog) ;
    CloseLogStopTimer (hWnd, pLog) ;
    WindowInvalidate (hWndStatus) ;
    return (TRUE) ;
}

BOOL StartLog (HWND hWnd, PLOG pLog, BOOL bSameFile)
{
    int            RetCode ;
    SYSTEMTIME     SystemTime ;

    if ((RetCode = CreateLogFile (pLog, TRUE, bSameFile)) == 0) {
        pLog->iStatus = iPMStatusCollecting ;

        GetLocalTime (&SystemTime) ;

        // write a dummy record.
        // this is needed because when playingback log
        // it will skip the first index from the first
        // index block.
        LogWriteIndex (pLog, 0, &SystemTime, 0, 0) ;

        if (!PlayingBackLog()) {
            // write out a bookmark to indicate start of new data
            if (!LogWriteStartBookmark (hWnd, &SystemTime)) {
                RetCode = 0 ;
                goto ErrorExit ;
            }

            if (!(pLog->bManualRefresh)) {
                SetLogTimer (hWnd, pLog->iIntervalMSecs) ;
                WindowInvalidate (hWndStatus) ;
            }
        } else {
            // check if time if OK
            LOGPOSITION    LP ;
            SYSTEMTIME     FirstSystemTime ;
            int            TimeDiff ;

            LP = PlaybackLog.StartIndexPos ;

            if (LogPositionSystemTime (&LP, &FirstSystemTime)) {
                // we don't want to append data to the log file if
                // the time is not in order.  So, forget it if the
                // last log time in the Log file is greater than the First
                // log time of the playback log file.
                TimeDiff = SystemTimeDifference (&(pLog->LastLogTime),
                                                 &(FirstSystemTime), FALSE) ;
                if (TimeDiff < 0) {
                    // error , time not in order
                    CloseHandle (pLog->hFile) ;
                    RetCode = ERR_CANT_RELOG_DATA ;
                }
            }
        }

        if (RetCode == 0) {
            // write counter names if needed
            LogWriteSystemCounterNames (hWnd, pLog) ;
            return (TRUE) ;
        }
    }

    ErrorExit:
    pLog->hFile = 0 ;
    CloseLogStopTimer(hWnd, pLog);
    PrepareMenu (GetMenu (hWndMain)) ;
    UpdateLogDisplay (hWnd) ;
    if (RetCode) {
        DlgErrorBox (hWnd, RetCode, pLog->szFilePath);
    }
    return (FALSE) ;
}



DWORD LogFindEntry(LPTSTR lpszComputer, DWORD ObjectTitleIndex)
/*
   Effect:         Returns the index of the specified Computer/Object
                   if it already exists in the Entries List Box,
                   otherwise returns LOG_ENTRY_NOT_FOUND
*/
{
    DWORD          iLogEntry ;
    DWORD          iLogNum ;
    PLOGENTRY      pLogEntry ;

    iLogNum = (DWORD) LBNumItems(hWndLogEntries) ;
    for (iLogEntry = 0;
        iLogEntry < iLogNum ;
        iLogEntry++) {
        pLogEntry = (PLOGENTRY) LBData(hWndLogEntries, iLogEntry) ;
        if (pLogEntry->ObjectTitleIndex == ObjectTitleIndex &&
            strsamei(pLogEntry->szComputer, lpszComputer)) {
            return iLogEntry ;
        }
    }
    return (DWORD) LOG_ENTRY_NOT_FOUND;
}



BOOL LogAddEntry (HWND hWndLog,
                  LPTSTR lpszComputer,
                  LPTSTR lpszObject,
                  DWORD ObjectTitleIndex,
                  BOOL  bGetObjectTitleIndex)
/*
   Effect:        Add an entry in the log structure for the computer and
                  object to be logged.

   Returns:       Whether the operation could be performed.
*/
{
    PLOG           pLog ;
    PLOGENTRY      pLogEntry ;
    SIZE_T         iIndex ;
    PPERFSYSTEM    pCurrentSystem = NULL ;
    DWORD          CurrentObjectTitleIndex ;


    pLog = LogData (hWndLog) ;

    pCurrentSystem = SystemAdd (&(pLog->pSystemFirst), lpszComputer, hWndLog) ;

    pLogEntry = MemoryAllocate (sizeof (LOGENTRY)) ;
    if (!pLogEntry)
        return (FALSE) ;

    lstrcpy (pLogEntry->szComputer, lpszComputer) ;
    lstrcpy (pLogEntry->szObject, lpszObject) ;

    pLogEntry->ObjectTitleIndex = ObjectTitleIndex ;

    // if reading from a log setting file, get the
    // latest Object index by the perfdata itself.
    // There may be case that the id has been changed
    if (bGetObjectTitleIndex &&
        pCurrentSystem &&
        pCurrentSystem->pSystemPerfData) {
        if (pCurrentSystem->pSystemPerfData->Signature[0] == TEXT('\0')) {
            UpdateSystemData (
                             pCurrentSystem,
                             &(pCurrentSystem->pSystemPerfData)) ;
        }

        if (CurrentObjectTitleIndex = GetObjectIdByName(
                                                       pCurrentSystem,
                                                       pCurrentSystem->pSystemPerfData,
                                                       lpszObject)) {
            pLogEntry->ObjectTitleIndex = CurrentObjectTitleIndex ;
        }
    }

    iIndex = LBAdd (hWndLogEntries, pLogEntry) ;

    if (!bDelayAddAction) {
        if (iIndex == LB_ERR) {
            iIndex = 0 ;
        }

        LBSetSelection (hWndLogEntries, iIndex) ;
        LBSetVisible (hWndLogEntries, iIndex) ;

        LogEntriesChanged (hWndLogEntries) ;
    }

    LogAddEntryToList (&(pLog->pLogEntryFirst), pLogEntry) ;

    return TRUE;
}




BOOL ToggleLogRefresh (HWND hWnd)
{
    PLOG        pLog ;

    pLog = LogData (hWnd) ;

    if (pLog->bManualRefresh)
        SetLogTimer (hWnd, pLog->iIntervalMSecs) ;
    else
        ClearLogTimer (hWnd) ;

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

BOOL LogRefresh (HWND hWnd)
{
    PLOG        pLog ;

    pLog = LogData (hWnd) ;

    return (pLog->bManualRefresh) ;
}

BOOL  CheckUnusedSystem (LPTSTR      lpszComputer)
{
    BOOL  bStillUse = FALSE ;
    PLOGENTRY      pLogEntry ;
    PLOG           pLog ;

    pLog = LogData (hWndLog) ;

    for (pLogEntry = pLog->pLogEntryFirst; pLogEntry; pLogEntry = pLogEntry->pNextLogEntry)
    {
        if (strsamei(pLogEntry->szComputer, lpszComputer)) {
            bStillUse = TRUE ;
            break ;
        }
    }
    return (bStillUse) ;
}

int SelectLogObjects(LPTSTR      lpszComputer,
                     PPERFDATA   pPerfData,
                     PPERFDATA   *ppLogData)
/*
   Effect:        This routine copies the header from pPerfData
                  to pLogData and initializes the byte length and the
                  number of objects.  It then copies the previously
                  selected objects from pPerfData to pLogData.  If
                  pLogData must be enlarged to accomodate the new data,
                  this routine will enlarge it.

   Returns:       An updated pLogData, and TRUE if at least one object
                  was copied.

*/

{
    PLOGENTRY      pLogEntry ;
    PPERFOBJECT    pObject ;
    DWORD          TotalBytes ;
    DWORD          NumObjects ;
    PBYTE          pNextObject ;
    DWORD          MaxLogDataSize ;
    PLOG           pLog ;

    if (!*ppLogData || !pPerfData)
        return -1 ;

    memcpy ((LPVOID)*ppLogData, (LPVOID)pPerfData, pPerfData->HeaderLength) ;
    TotalBytes = pPerfData->HeaderLength ;
    MaxLogDataSize = MemorySize((LPMEMORY)*ppLogData) ;
    NumObjects = 0;


    pLog = LogData (hWndLog) ;

    for (pLogEntry = pLog->pLogEntryFirst ;
        pLogEntry ;
        pLogEntry = pLogEntry->pNextLogEntry)
    {
        if (strsamei(pLogEntry->szComputer, lpszComputer)) {
            pObject = GetObjectDefByTitleIndex(pPerfData,
                                               pLogEntry->ObjectTitleIndex) ;

            if (pObject) {
                if (MaxLogDataSize < TotalBytes + pObject->TotalByteLength) {
                    *ppLogData = MemoryResize((LPMEMORY)*ppLogData,
                                              TotalBytes + pObject->TotalByteLength) ;
                    if (!*ppLogData)
                        return -1 ;

                }

                pNextObject = (PBYTE) *ppLogData + TotalBytes ;
                memcpy ((LPVOID)pNextObject, (LPVOID)pObject, pObject->TotalByteLength);
                TotalBytes += pObject->TotalByteLength ;
                NumObjects++;
            } else {
            }
        }
    }

    if (!NumObjects)
        return 1 ;

    (*ppLogData)->TotalByteLength = TotalBytes ;
    (*ppLogData)->NumObjectTypes = NumObjects ;

    return 0 ;
}


void LogTimer (HWND hWnd, BOOL bForce)
/*
   Effect:        Perform all actions necessary when the log window
                  receives a timer tic. In particular, if we are
                  collecting data, get a new perf_data_block and add a
                  header entry. If the header block is full, write the
                  data to disk.

   Called By:     LogDisplayDlgProc, in response to a WM_TIMER message.
*/
{
    PLOG           pLog ;
    PPERFSYSTEM       pSystem ;
    BOOL           bWriteIndex ;
    DWORD          iNumSystems ;
    SYSTEMTIME     SystemTime ;
    int            iNoUseSystemDetected = 0 ;

    int               NumberOfSystems = 0 ;
    DWORD             WaitStatus ;
    BOOL              bNeedToStoreName = FALSE ;
    HANDLE            *lpPacketHandles ;


    pLog = LogData (hWnd) ;

    if (pLog->iStatus != iPMStatusCollecting)
        return ;

    if (bForce || !pLog->bManualRefresh) {
        if (pLog->NumberOfHandles == 0) {
            pLog->NumberOfHandles = MAXIMUM_WAIT_OBJECTS ;
            pLog->lpHandles = (HANDLE *) MemoryAllocate (pLog->NumberOfHandles * sizeof (HANDLE)) ;
            if (!pLog->lpHandles) {
                // out of memory, can't go on
                pLog->NumberOfHandles = 0 ;
                return ;
            }
        }

        iNumSystems = SystemCount(pLog->pSystemFirst) ;
        bWriteIndex = TRUE ;

        for (pSystem = pLog->pSystemFirst; pSystem; pSystem = pSystem->pSystemNext) {

            if (pSystem->hStateDataMutex == 0)
                continue ;

            // lock the state data mutex
            WaitStatus = WaitForSingleObject(pSystem->hStateDataMutex, 100L);
            if (WaitStatus == WAIT_OBJECT_0) {
                ResetEvent (pSystem->hPerfDataEvent) ;
                pSystem->StateData = WAIT_FOR_PERF_DATA ;

                if (NumberOfSystems >= pLog->NumberOfHandles) {
                    pLog->NumberOfHandles += MAXIMUM_WAIT_OBJECTS ;
                    pLog->lpHandles = (HANDLE *) MemoryResize (
                                                              pLog->lpHandles,
                                                              pLog->NumberOfHandles * sizeof (HANDLE)) ;
                    if (!pLog->lpHandles) {
                        // out of memory, can't go on
                        pLog->NumberOfHandles = 0 ;
                        return ;
                    }
                }

                // add this to the wait
                pLog->lpHandles [NumberOfSystems] = pSystem->hPerfDataEvent ;
                NumberOfSystems++ ;
            }

            // Send Message to thread to take a data sample
            PostThreadMessage (
                              pSystem->dwThreadID,
                              WM_GET_PERF_DATA,
                              (WPARAM)0,
                              (LPARAM)0) ;

            ReleaseMutex(pSystem->hStateDataMutex);
        }

	Sleep (50);

        // wait for all the data
        if (NumberOfSystems) {
            // increase timeout if we are monitoring lots of systems
            // For every additional 5 systems, add five more seconds
            lpPacketHandles = pLog->lpHandles ;
            do {
                WaitStatus = WaitForMultipleObjects (
                                                    min (NumberOfSystems, MAXIMUM_WAIT_OBJECTS),
                                                    lpPacketHandles,
                                                    TRUE,       // wait for all objects
                                                    DataTimeOut + (NumberOfSystems / 5) * DEFAULT_DATA_TIMEOUT);

                if (WaitStatus == WAIT_TIMEOUT ||
                    NumberOfSystems <= MAXIMUM_WAIT_OBJECTS) {
                    //if (WaitStatus == WAIT_TIMEOUT)
                    //mike2(TEXT("WaitTimeOut for %ld systems\n"), NumberOfSystems) ;
                    break ;
                }

                // more systems --> more to wait
                NumberOfSystems -= MAXIMUM_WAIT_OBJECTS ;
                lpPacketHandles += MAXIMUM_WAIT_OBJECTS ;
            } while (TRUE) ;


            for (pSystem = pLog->pSystemFirst ;
                pSystem ;
                pSystem = pSystem->pSystemNext)
            {
                if (pSystem->hStateDataMutex == 0)
                    continue ;

                // lock the state data mutex
                WaitStatus = WaitForSingleObject(pSystem->hStateDataMutex, 100L);
                if (WaitStatus == WAIT_OBJECT_0) {
                    // check for system disconnect/reconnect
                    if (pSystem->dwSystemState == SYSTEM_DOWN ||
                        pSystem->dwSystemState == SYSTEM_RECONNECT) {
                        BOOL  bDisconnected ;

                        GetLocalTime (&SystemTime) ;
                        if (bDisconnected = (pSystem->dwSystemState == SYSTEM_DOWN)) {
                            pSystem->dwSystemState = SYSTEM_DOWN_RPT ;
                        } else {
                            pSystem->dwSystemState = SYSTEM_RECONNECT_RPT ;
                        }
                        if (!LogWriteSystemBookmark (
                                                    hWnd,
                                                    pSystem->sysName,
                                                    bDisconnected,
                                                    &SystemTime)) {
                            pSystem->StateData = IDLE_STATE ;
                            ReleaseMutex(pSystem->hStateDataMutex);
                            return ;
                        }
                    }

                    if (pSystem->StateData == PERF_DATA_READY) {
                        if (pSystem->bSystemCounterNameSaved == FALSE) {
                            // we have not written the system name to log file.  This
                            // is the case when this system is down when we first
                            // start logging data...
                            bNeedToStoreName = TRUE ;
                        }

                        if (bWriteIndex) {
                            GetLocalTime (&SystemTime) ;
                        }

                        if (SelectLogObjects(pSystem->sysName,
                                             pSystem->pSystemPerfData,
                                             &pLog->pLogData) == 0) {
                            if ( !LogWritePerfData (hWnd, pLog, pLog->pLogData, &SystemTime,
                                                    iNumSystems, bWriteIndex) ) {
                                CloseLogStopTimer(hWnd, pLog) ;

                                pSystem->StateData = IDLE_STATE ;
                                ReleaseMutex(pSystem->hStateDataMutex);

                                return ;
                            }
                            // write an index for only the first system
                            bWriteIndex = FALSE ;
                        } else {
                            if (!bAddLineInProgress) {
                                pSystem->bSystemNoLongerNeeded = TRUE ;
                                iNoUseSystemDetected ++ ;
                            }
                        }
                    }  // if PERF_DATA_READY
                    else if (!bAddLineInProgress &&
                             CheckUnusedSystem (pSystem->sysName) == FALSE) {
                        // we don't need this system any more
                        pSystem->bSystemNoLongerNeeded = TRUE ;
                        iNoUseSystemDetected ++ ;
                    }

                    pSystem->StateData = IDLE_STATE ;
                    ReleaseMutex(pSystem->hStateDataMutex);
                }  // wait for StateDataMutex
            }  // For each system
        }  // if NumberOfSystems

        if (!bWriteIndex) {
            UpdateLogSize (hWnd) ;
        }
    }

    if (iNoUseSystemDetected) {
        DeleteUnusedSystems (&(pLog->pSystemFirst), iNoUseSystemDetected) ;
    }

    if (bNeedToStoreName == TRUE) {
        LogWriteSystemCounterNames (hWnd, pLog) ;
    }
}



BOOL NextIntervalIndexPosition (PLOG pLog, PLOGPOSITION pLP, int *pNumTics)
{
    SYSTEMTIME     SystemTime1 ;
    SYSTEMTIME     SystemTime2 ;
    LOGPOSITION    LP ;
    PLOGINDEX      pIndex ;
    DWORD          TimeDiff ;

    LogPositionSystemTime (pLP, &SystemTime1) ;

    LP = *pLP ;

    while (NextReLogIndexPosition (&LP)) {

        *pNumTics = *pNumTics - 1 ;

        pIndex = IndexFromPosition (&LP) ;
        if (pIndex && IsBookmarkIndex (pIndex)) {
            *pLP = LP ;
            return TRUE ;
        }
        LogPositionSystemTime (&LP, &SystemTime2) ;
        TimeDiff = (DWORD) SystemTimeDifference (&SystemTime1,
                                                 &SystemTime2, TRUE) ;
        if (TimeDiff * 1000 >= pLog->iIntervalMSecs) {
            *pLP = LP ;
            return (TRUE) ;
        }
    }

    return (FALSE) ;
}



BOOL ReLogTimer (HWND hWnd,
                 PLOG pLog,
                 LOGPOSITION lp,
                 BOOL *pWriteBookmark)
{
    PPERFSYSTEM    pSystem ;
    BOOL           bWriteIndex ;
    DWORD          iNumSystems ;
    SYSTEMTIME     SystemTime ;
    PPERFDATA      pPerfData ;

    bWriteIndex = TRUE ;

    // First count number of systems to be logged

    iNumSystems = 0;

    for (pSystem = pLog->pSystemFirst; pSystem; pSystem = pSystem->pSystemNext) {
        pPerfData = LogDataFromPosition (pSystem, &lp) ;
        if (pPerfData) {
            if (SelectLogObjects(pSystem->sysName,
                                 pPerfData,
                                 &pLog->pLogData) == 0) {
                iNumSystems++;
            }
        }
    }

    // Now we can log the data

    for (pSystem = pLog->pSystemFirst ;
        pSystem ;
        pSystem = pSystem->pSystemNext) {  // for
        pPerfData = LogDataFromPosition (pSystem, &lp) ;
        if (pPerfData) {
            // write an index for only the first system
            LogPositionSystemTime (&lp, &SystemTime) ;
            if (SelectLogObjects(pSystem->sysName,
                                 pPerfData,
                                 &pLog->pLogData) == 0) {
                if (*pWriteBookmark) {
                    // only need to write the start bookmark once.
                    *pWriteBookmark = FALSE ;
                    LogWriteStartBookmark (hWnd, &SystemTime) ;
                }
                if ( !LogWritePerfData (hWnd, pLog, pLog->pLogData, &SystemTime,
                                        iNumSystems, bWriteIndex) ) {
                    CloseLogStopTimer(hWnd, pLog) ;
                    return FALSE ;
                } else {
                    // write the index for only the first system logged
                    bWriteIndex = FALSE ;
                }
            }
        }
    }

    return TRUE ;
}


void ReLog (HWND hWndLog, BOOL bSameFile)
{
    PLOG           pLog ;
    LOGPOSITION    lp ;
    //   SYSTEMTIME     SystemTime ;
    PLOGINDEX      pIndex ;
    PBOOKMARK      pBookmark;
    int            iDisplayTics ;

    // bWriteBookmark tell relogtimer to write start bookmark
    BOOL           bWriteBookmark = TRUE ;

    pLog = LogData (hWndLog) ;
    if (StartLog (hWndLog, pLog, bSameFile) == FALSE) {
        return ;
    }

    lp = PlaybackLog.StartIndexPos ;
    iDisplayTics = PlaybackLog.iSelectedTics;

    while (iDisplayTics > 0) {
        pIndex = IndexFromPosition (&lp) ;
        if (pIndex) {
            if (IsBookmarkIndex (pIndex)) {
                pBookmark = (PBOOKMARK) PlaybackSeek (pIndex->lDataOffset) ;
                if (!LogWriteBookmarkData (hWndLog, pBookmark))
                    break;
            } else if (!ReLogTimer (hWndLog, pLog, lp, &bWriteBookmark))
                break ;
        }

        if (!NextIntervalIndexPosition (pLog, &lp, &iDisplayTics))
            break ;

    }
    UpdateLogSize (hWndLog) ;
    CloseLog (hWndLog, pLog) ;
}

// SaveLog is diff than other because we are not saving a "Line"
// We are actually saving an entry in the hWndLogEntries listbox.
// It only contains the system & object name.
BOOL SaveLog (HWND hWndLog, HANDLE hInputFile, BOOL bGetFileName)
{
    int         iIndex, iIndexNum ;
    PLOG        pLog ;
    PLOGENTRY   pLogEntry ;
    LOGENTRY       tempLogEntry ;
    HANDLE         hFile ;
    DISKLOG        DiskLog ;
    PERFFILEHEADER FileHeader ;
    TCHAR          szFileName [256] ;
    BOOL           newFileName = FALSE ;

    pLog = LogData (hWndLog) ;
    if (!pLog) {
        return (FALSE) ;
    }

    if (hInputFile) {
        // use the input file handle if it is available
        // this is the case for saving workspace data
        hFile = hInputFile ;
    } else {
        if (pLogFullFileName) {
            lstrcpy (szFileName, pLogFullFileName) ;
        }
        if (bGetFileName || pLogFullFileName == NULL) {
            //         if (pLogFullFileName == NULL)
            //            {
            //            StringLoad (IDS_LOG_FNAME, szFileName) ;
            //            }

            if (!FileGetName (hWndLog, IDS_LOGFILE, szFileName)) {
                return (FALSE) ;
            }
            newFileName = TRUE ;
        }

        hFile = FileHandleCreate (szFileName) ;

        if (hFile && hFile != INVALID_HANDLE_VALUE && newFileName) {
            ChangeSaveFileName (szFileName, IDM_VIEWLOG) ;
        } else if (!hFile) {
            DlgErrorBox (hWndLog, ERR_CANT_OPEN, szFileName) ;
        }
    }

    if (!hFile || hFile == INVALID_HANDLE_VALUE)
        return (FALSE) ;

    iIndexNum = LBNumItems (hWndLogEntries) ;

    if (!hInputFile) {
        memset (&FileHeader, 0, sizeof (FileHeader)) ;
        lstrcpy (FileHeader.szSignature, szPerfLogSignature) ;
        FileHeader.dwMajorVersion = LogMajorVersion ;
        FileHeader.dwMinorVersion = LogMinorVersion ;

        if (!FileWrite (hFile, &FileHeader, sizeof (PERFFILEHEADER))) {
            goto Exit0 ;
        }
    }

    DiskLog.dwIntervalSecs = pLog->iIntervalMSecs ;
    DiskLog.dwNumLines = iIndexNum ;
    DiskLog.bManualRefresh = pLog->bManualRefresh ;
    DiskLog.perfmonOptions = Options ;
    lstrcpy(DiskLog.LogFileName, pLog->szFilePath) ;

    if (!FileWrite (hFile, &DiskLog, sizeof (DISKLOG))) {
        goto Exit0 ;
    }

    for (iIndex = 0; iIndex < iIndexNum; iIndex++) {
        pLogEntry = LogEntryN (hWndLogEntries, iIndex) ;
        if (pstrsamei (pLogEntry->szComputer, LocalComputerName)) {
            tempLogEntry = *pLogEntry ;
            lstrcpy (tempLogEntry.szComputer, LOCAL_SYS_CODE_NAME) ;
            if (!FileWrite (hFile,
                            &tempLogEntry,
                            sizeof(LOGENTRY)-sizeof(pLogEntry->pNextLogEntry))) {
                goto Exit0 ;
            }
        } else {
            if (!FileWrite (hFile,
                            pLogEntry,
                            sizeof(LOGENTRY)-sizeof(pLogEntry->pNextLogEntry))) {
                goto Exit0 ;
            }
        }
    }

    if (!hInputFile) {
        CloseHandle (hFile) ;
    }

    return (TRUE) ;

    Exit0:
    if (!hInputFile) {
        CloseHandle (hFile) ;

        // only need to report error if not workspace
        DlgErrorBox (hWndLog, ERR_SETTING_FILE, szFileName) ;
    }
    return (FALSE) ;
}

BOOL OpenLogVer1 (HWND hWndLog, HANDLE hFile, DISKLOG *pDiskLog, PLOG
                  pLog, DWORD dwMinorVersion)
{
    int            iIndex, iIndexNum ;
    PLOGENTRY      pLogEntry ;
    LOGENTRY       LogEntry ;
    PPERFSYSTEM    pSystem;

    pLog->iIntervalMSecs = pDiskLog->dwIntervalSecs ;
    if (dwMinorVersion < 3) {
        pLog->iIntervalMSecs *= 1000 ;
    }

    pLog->lFileSize = 0L ;
    if (dwMinorVersion >= 5) {
        lstrcpy (pLog->szFilePath, pDiskLog->LogFileName) ;
    } else {
        strclr (pLog->szFilePath) ;

        // fixed the file pointer for backward compatible with older version.
        //      FileSeekCurrent (hFile, -((int) (sizeof (pDiskLog->LogFileName)))) ;
    }

    pLog->bManualRefresh = pDiskLog->bManualRefresh ;
    iIndexNum = pDiskLog->dwNumLines ;

    LBSetRedraw (hWndLogEntries, FALSE) ;

    bDelayAddAction = TRUE ;

    for (iIndex = 0 ; iIndex < iIndexNum ; iIndex++) {
        if (!FileRead (hFile,
                       &LogEntry,
                       sizeof(LOGENTRY)-sizeof(LogEntry.pNextLogEntry))) {
            break ;
        }

        if (pstrsame (LogEntry.szComputer, LOCAL_SYS_CODE_NAME)) {
            // convert it back to the local name
            lstrcpy (LogEntry.szComputer, LocalComputerName) ;
        }

        LogAddEntry (hWndLog,
                     LogEntry.szComputer,
                     LogEntry.szObject,
                     LogEntry.ObjectTitleIndex,
                     TRUE) ;
    }

    bDelayAddAction = FALSE ;

    LBSetSelection (hWndLogEntries, 0) ;
    LBSetVisible (hWndLogEntries, 0) ;

    LogEntriesChanged (hWndLogEntries) ;

    LBSetRedraw (hWndLogEntries, TRUE) ;

    for (pSystem = pLog->pSystemFirst ;
        pSystem ;
        pSystem = pSystem->pSystemNext) {
        if (pSystem) {
            RemoveObjectsFromSystem (pSystem);
        }
    }


    for (iIndex = 0 ;
        iIndex < iIndexNum ;
        iIndex++)
    {
        pLogEntry = LogEntryN (hWndLogEntries, iIndex) ;

        pSystem = SystemGet (pLog->pSystemFirst, pLogEntry->szComputer);
        if (pSystem) {
            AppendObjectToValueList (
                                    pLogEntry->ObjectTitleIndex,
                                    pSystem->lpszValue);
        }
    }

    if (!strempty(pLog->szFilePath)) {
        if (pLog->pLogEntryFirst &&
            pLog->pSystemFirst) {
            // PostMessage so it will start logging
            PostMessage (
                        hWndLog,
                        WM_START_LOGGING,
                        0,
                        0) ;
        } else {
            HANDLE   hLogFile ;

            // get the file size.
            hLogFile = FileHandleOpen (pLog->szFilePath) ;

            if (hLogFile && hLogFile != INVALID_HANDLE_VALUE) {
                pLog->lFileSize = GetFileSize (hLogFile, NULL);
                CloseHandle (hLogFile) ;
            }
        }
    }

    return (TRUE) ;
}

BOOL OpenLog (HWND hWndLog,
              HANDLE hFile,
              DWORD dwMajorVersion,
              DWORD dwMinorVersion,
              BOOL bLogFile)
{
    PLOG        pLog ;
    DISKLOG     DiskLog ;
    BOOL        bSuccess = TRUE ;

    pLog = LogData (hWndLog) ;
    if (!pLog) {
        bSuccess = FALSE ;
        goto Exit0 ;
    }

    if (!FileRead (hFile, &DiskLog, sizeof (DISKLOG) - sizeof(DiskLog.LogFileName))) {
        bSuccess = FALSE ;
        goto Exit0 ;
    }

    if (dwMajorVersion == 1 && dwMinorVersion >= 5 ||
        dwMajorVersion > 1) {
        // read LogFileName
        if (!FileRead (hFile, DiskLog.LogFileName, sizeof (DiskLog.LogFileName))) {
            bSuccess = FALSE ;
            goto Exit0 ;
        }
    }

    switch (dwMajorVersion) {
        case (1):

            SetHourglassCursor() ;

            ResetLogView (hWndLog) ;

            OpenLogVer1 (hWndLog, hFile, &DiskLog, pLog, dwMinorVersion) ;

            // change to log view if we are opening a
            // log file
            if (bLogFile && iPerfmonView != IDM_VIEWLOG) {
                SendMessage (hWndMain, WM_COMMAND, (LONG)IDM_VIEWLOG, 0L) ;
            }

            if (iPerfmonView == IDM_VIEWLOG) {
                SetPerfmonOptions (&DiskLog.perfmonOptions) ;
            }

            UpdateLogDisplay (hWndLog) ;

            SetArrowCursor() ;

            break ;
    }

    Exit0:

    if (bLogFile) {
        CloseHandle (hFile) ;
    }

    return (bSuccess) ;
}


BOOL LogCollecting (HWND hWndLog)
/*
   Effect:        Return whether the log associated with hWndLog is currently
                  collecting data (writing performance values to disk).
*/
{
    PLOG           pLog ;

    pLog = LogData (hWndLog) ;

    return (pLog->iStatus == iPMStatusCollecting) ;
}


int LogFileSize (HWND hWndLog)
{
    PLOG           pLog ;

    pLog = LogData (hWndLog) ;

    return (pLog->lFileSize) ;
}

BOOL LogWriteSystemBookmark (
                            HWND     hWnd,
                            LPTSTR   lpSystemName,
                            BOOL     bDisconnected,
                            SYSTEMTIME *pSystemTime)
{
    BOOKMARK       Bookmark ;
    TCHAR    NewSystemBookmark [MiscTextLen * 2] ;

    memset (&Bookmark, 0, sizeof (BOOKMARK)) ;

    NewSystemBookmark [0] = TEXT('\0') ;
    StringLoad (
               bDisconnected ?
               IDS_SYSTEM_DOWN :
               IDS_SYSTEM_UP,
               NewSystemBookmark) ;

    lstrcat (NewSystemBookmark, TEXT(" - ")) ;
    lstrcat (NewSystemBookmark, lpSystemName) ;
    Bookmark.SystemTime = *pSystemTime ;
    lstrcpy (Bookmark.szComment, NewSystemBookmark) ;

    return (LogWriteBookmarkData (hWndLog, &Bookmark)) ;
}

BOOL LogWriteStartBookmark (HWND hWnd, SYSTEMTIME *pSystemTime)
{
    BOOKMARK       Bookmark ;
    TCHAR    NewDataBookmark [MiscTextLen] ;

    memset (&Bookmark, 0, sizeof (BOOKMARK)) ;

    NewDataBookmark [0] = TEXT('\0') ;
    StringLoad (IDS_NEWDATA_BOOKMARK, NewDataBookmark) ;
    Bookmark.SystemTime = *pSystemTime ;
    lstrcpy (Bookmark.szComment, NewDataBookmark) ;

    return (LogWriteBookmarkData (hWndLog, &Bookmark)) ;
}

BOOL LogWriteBookmarkData (HWND hWnd, PBOOKMARK pBookmark)
{
    PLOG           pLog ;
    LONG           lDataOffset ;
    BOOL           WriteOK ;

    pLog = LogData (hWndLog) ;
    if (!pLog)
        return (FALSE) ;

    lDataOffset = FileTell (pLog->hFile) ;
    WriteOK = FileWrite (pLog->hFile, pBookmark, sizeof (BOOKMARK)) ;
    if ( WriteOK ) {
        pLog->lFileSize += sizeof (BOOKMARK) ;
        UpdateLogSize (hWndLog) ;

        WriteOK = LogWriteIndex (pLog, LogFileIndexBookmark,
                                 &(pBookmark->SystemTime),
                                 lDataOffset,
                                 0) ;
    }
    if ( !WriteOK ) {
        CloseLog (hWndLog, pLog) ;
        PrepareMenu (GetMenu (hWndMain)) ;
        UpdateLogDisplay (hWndLog) ;
        DlgErrorBox (hWndLog, ERR_LOG_FILE, pLog->szFilePath);
    }
    return WriteOK ;
}



BOOL LogWriteBookmark (HWND hWndLog,
                       LPCTSTR lpszComment)
{
    BOOKMARK       Bookmark ;

    memset (&Bookmark, 0, sizeof (BOOKMARK)) ;

    GetLocalTime (&Bookmark.SystemTime) ;
    lstrcpy (Bookmark.szComment, lpszComment) ;

    return (LogWriteBookmarkData (hWndLog, &Bookmark)) ;
}


BOOL AnyLogLine (void)
{
    if (LBSelection (hWndLogEntries) == LB_ERR) {
        return (FALSE) ;
    } else {
        return (TRUE) ;
    }
}

void ResetLogView (HWND hWndLog)
{
    PLOG        pLog ;

    pLog = LogData (hWndLog) ;

    ChangeSaveFileName (NULL, IDM_VIEWLOG) ;

    if (pLog && pLog->pSystemFirst) {
        ResetLog (hWndLog) ;
    }
}

BOOL ResetLog (HWND hWndLog)
{
    INT_PTR     iIndex ;
    PLOG        pLog ;
    INT_PTR     iEntriesNum ;

    pLog = LogData (hWndLog) ;

    if (LogCollecting (hWndLog)) {
        CloseLog (hWndLog, pLog) ;
    }

    LBSetRedraw (hWndLogEntries, FALSE) ;
    iEntriesNum = LBNumItems (hWndLogEntries) ;

    // only need to zero out the list head
    // each item will be deleted by LogDeleteIndex via the listbox
    pLog->pLogEntryFirst = NULL ;

    // delete each line
    for (iIndex = iEntriesNum - 1; iIndex >= 0; iIndex-- )
    {
        LogDeleteIndex (hWndLogEntries, iIndex) ;
    }

    LBSetRedraw (hWndLogEntries, TRUE) ;

    if (pLog->pSystemFirst) {
        FreeSystems (pLog->pSystemFirst) ;
        pLog->pSystemFirst = NULL ;
    }

    MemoryFree ((LPMEMORY)pLog->pLogData) ;

    pLog->pLogData = (PPERFDATA) MemoryAllocate (STARTING_SYSINFO_SIZE) ;

    LogEntriesChanged (hWndLogEntries) ;

    pLog->iStatus = iPMStatusClosed ;
    UpdateLogDisplay (hWndLog) ;

    return (TRUE) ;
}

BOOL LogDeleteEntry (HWND hWndLog)
{
    INT_PTR     iIndex ;
    PLOG        pLog ;
    BOOL        retCode ;
    int         iEntriesNum ;

    pLog = LogData (hWndLog) ;

    iIndex = LBSelection (hWndLogEntries) ;

    if (iIndex == LB_ERR) {
        retCode = FALSE ;
    } else {
        // remove the current selection
        LogDeleteIndex (hWndLogEntries, iIndex) ;

        iEntriesNum = LBNumItems (hWndLogEntries) ;

        if (iEntriesNum == 0 || iEntriesNum == LB_ERR) {
            // delete the last line or something bad happened,
            // then reset the window.
            ResetLog (hWndLog) ;
        } else {
            // set selection on the item above the deleted item.
            iIndex-- ;
            if (iIndex < 0) {
                iIndex = 0 ;
            }
            LBSetSelection (hWndLogEntries, iIndex) ;
            LBSetVisible (hWndLogEntries, iIndex) ;
        }

        LogEntriesChanged (hWndLogEntries) ;
        retCode = TRUE ;
    }
    return (retCode) ;
}


void ExportLog (void)
{
    HANDLE      hFile ;
    PLOG        pLog ;
    PLOGENTRY   pLogEntry ;
    int         iIndex ;
    int         iIndexNum ;
    CHAR        TempBuff [LongTextLen * 2] ;
    TCHAR       UnicodeBuff [LongTextLen] ;
    TCHAR       UnicodeBuff1 [MiscTextLen] ;
    int         StringLen ;
    LPTSTR      pFileName = NULL ;
    INT         ErrCode = 0 ;

    if (!(pLog = LogData (hWndLog))) {
        return ;
    }

    // see if there is anything to export..
    iIndexNum = LBNumItems (hWndLogEntries) ;
    if (iIndexNum == 0 || iIndexNum == LB_ERR) {
        return ;
    }

    if (!FileGetName (hWndLog, IDS_EXPORTFILE, UnicodeBuff)) {
        // user cancel
        return ;
    }

    pFileName = StringAllocate (UnicodeBuff) ;

    // open the file..
    hFile = FileHandleCreate (UnicodeBuff);

    if (hFile == INVALID_HANDLE_VALUE) {
        // can't open the file
        ErrCode = ERR_CANT_OPEN ;
        return ;
    }

    SetHourglassCursor() ;

    // get header
    StringLoad (IDS_REPORT_HEADER, UnicodeBuff) ;
    ConvertUnicodeStr (TempBuff, UnicodeBuff) ;
    StringLen = strlen (TempBuff) ;
    ConvertUnicodeStr (&TempBuff[StringLen], LocalComputerName) ;
    strcat (TempBuff, LineEndStr) ;

    if (!FileWrite (hFile, TempBuff, strlen(TempBuff))) {
        ErrCode = ERR_EXPORT_FILE ;
        goto Exit0 ;
    }

    if (!(strempty(pLog->szFilePath))) {
        // export filename is there is one
        StringLoad (IDS_REPORT_LOGFILE, UnicodeBuff) ;
        ConvertUnicodeStr (TempBuff, UnicodeBuff) ;
        StringLen = strlen (TempBuff) ;
        ConvertUnicodeStr (&TempBuff[StringLen], pLog->szFilePath) ;
        strcat (TempBuff, LineEndStr) ;

        if (!FileWrite (hFile, TempBuff, strlen(TempBuff))) {
            ErrCode = ERR_EXPORT_FILE ;
            goto Exit0 ;
        }
    }

    // export interval
    StringLoad (IDS_CHARTINT_FORMAT, UnicodeBuff1) ;
    TSPRINTF (UnicodeBuff, UnicodeBuff1,
              (FLOAT) pLog->iIntervalMSecs / (FLOAT) 1000.0) ;
    ConvertDecimalPoint (UnicodeBuff) ;
    ConvertUnicodeStr (TempBuff, UnicodeBuff) ;
    strcat (TempBuff, LineEndStr) ;
    strcat (TempBuff, LineEndStr) ;

    if (!FileWrite (hFile, TempBuff, strlen(TempBuff))) {
        ErrCode = ERR_EXPORT_FILE ;
        goto Exit0 ;
    }

    // export Labels
    StringLoad (IDS_LABELOBJECT, UnicodeBuff) ;
    ConvertUnicodeStr (TempBuff, UnicodeBuff) ;
    strcat (TempBuff, pDelimiter) ;

    if (!FileWrite (hFile, TempBuff, strlen(TempBuff))) {
        ErrCode = ERR_EXPORT_FILE ;
        goto Exit0 ;
    }

    StringLoad (IDS_LABELSYSTEM, UnicodeBuff) ;
    ConvertUnicodeStr (TempBuff, UnicodeBuff) ;
    strcat (TempBuff, LineEndStr) ;

    if (!FileWrite (hFile, TempBuff, strlen(TempBuff))) {
        ErrCode = ERR_EXPORT_FILE ;
        goto Exit0 ;
    }


    // export each counter
    for (iIndex = 0 ; iIndex < iIndexNum ; iIndex++) {  // for

        pLogEntry = LogEntryN (hWndLogEntries, iIndex) ;

        if (!pLogEntry || pLogEntry == (PLOGENTRY)LB_ERR) {
            continue ;
        }

        ConvertUnicodeStr (TempBuff, pLogEntry->szObject) ;
        strcat (TempBuff, pDelimiter) ;

        if (!FileWrite (hFile, TempBuff, strlen(TempBuff))) {
            ErrCode = ERR_EXPORT_FILE ;
            break ;
        }

        ConvertUnicodeStr (TempBuff, pLogEntry->szComputer) ;
        strcat (TempBuff, LineEndStr) ;

        if (!FileWrite (hFile, TempBuff, strlen(TempBuff))) {
            ErrCode = ERR_EXPORT_FILE ;
            break ;
        }
    }

    Exit0:

    SetArrowCursor() ;
    CloseHandle (hFile) ;

    if (pFileName) {
        if (ErrCode) {
            DlgErrorBox (hWndGraph, ErrCode, pFileName) ;
        }
        MemoryFree (pFileName) ;
    }
}


LPTSTR   MatchSystemCounters (LPTSTR pBaseSysCounter,
                              long   lBaseSysSize,
                              LPTSTR pSysCounter,
                              long   lSysSize,
                              long   *pMatchPortion)
{
    LPTSTR   pNotMatch = NULL ;
    long     i, lSizeToCompare ;

    *pMatchPortion = 0 ;
    lSizeToCompare = min (lBaseSysSize, lSysSize) / sizeof (TCHAR) ;

    for (i = 0 ; i < lSizeToCompare ; i++, pBaseSysCounter++, pSysCounter++) {
        if (*pBaseSysCounter != *pSysCounter) {
            pNotMatch = pSysCounter ;
            break ;
        }
    }

    if (pNotMatch == NULL) {
        if (lBaseSysSize < lSysSize) {
            // the new system has longer counter names than base system
            // setup the extra portion.
            pNotMatch = pSysCounter ;
        } else {
            // new system counter name is shorter than or equal to
            // the base system counter names
            *pMatchPortion = lSysSize ;
        }
    }

    return (pNotMatch) ;

}

void LogWriteSystemCounterNames (HWND hWnd, PLOG pLog)
{
    long           dwArraySize ;
    PPERFSYSTEM    pSystem = pLog->pSystemFirst ;
    LPTSTR         pMatchLen ;
    LPTSTR         pCounterName ;
    long           lMatchLen, lMatchPortion ;

    for (pSystem = pLog->pSystemFirst ;
        pSystem ;
        pSystem = pSystem->pSystemNext) {
        if (pSystem->bSystemCounterNameSaved == TRUE ||
            pSystem->CounterInfo.dwLastId == 0) {
            // we have either wrote out the counter name for
            // this system, or this system is not connect when
            // reading in the setting file,  skip it then.
            continue ;
        }

        dwArraySize = (pSystem->CounterInfo.dwLastId + 1 ) ;

        if (!pLog->lBaseCounterNameOffset) {
            LogWriteCounterName (hWnd, pSystem, pLog,
                                 (LPTSTR)(pSystem->CounterInfo.TextString + dwArraySize),
                                 0,
                                 pSystem->CounterInfo.dwCounterSize,
                                 0 ) ;
        } else {
            // check for matched characters between this system and the
            // base system
            pCounterName = (LPTSTR)(pSystem->CounterInfo.TextString + dwArraySize) ;
            pMatchLen = MatchSystemCounters (pLog->pBaseCounterName,
                                             pLog->lBaseCounterNameSize,
                                             pCounterName,
                                             pSystem->CounterInfo.dwCounterSize,
                                             &lMatchPortion) ;

            if (pMatchLen) {
                // This system matches part of the base system
                // (all if it has more names)
                lMatchLen = (long) (pMatchLen - pCounterName) * sizeof (TCHAR) ;
                LogWriteCounterName (hWnd, pSystem, pLog,
                                     pMatchLen,
                                     lMatchLen,
                                     pSystem->CounterInfo.dwCounterSize - lMatchLen,
                                     0 ) ;
            } else {
                // This system matches the based system
                LogWriteCounterName (hWnd, pSystem, pLog,
                                     NULL,
                                     lMatchPortion,
                                     0,
                                     0 ) ;
            }
        }
    }
}


BOOL LogWriteCounterName (HWND hWnd,
                          PPERFSYSTEM pSystem,
                          PLOG   pLog,
                          LPTSTR pCounterName,
                          long sizeMatched,
                          long sizeOfData,
                          BOOL bBaseCounterName)
{
    BOOL                 ReadOK ;
    BOOL                 WriteOK ;
    SYSTEMTIME           SystemTime ;
    LOGFILECOUNTERNAME   CounterNameRecord ;
    LOGHEADER            LogFileHeader ;
    long                 lDataOffset, lCurPosition ;
    TCHAR                Dummy [sizeof(DWORD)] ;
    int                  PatchBytes = 0;

    if (pSystem->bSystemCounterNameSaved == TRUE)
        return FALSE ;

    GetLocalTime (&SystemTime) ;

    lCurPosition = FileTell (pLog->hFile) ;

    lstrcpy (CounterNameRecord.szComputer, pSystem->sysName) ;
    CounterNameRecord.lBaseCounterNameOffset = pLog->lBaseCounterNameOffset ;
    CounterNameRecord.lCurrentCounterNameOffset =
    lCurPosition + sizeof (LOGFILECOUNTERNAME) ;
    CounterNameRecord.lMatchLength = sizeMatched ;
    CounterNameRecord.lUnmatchCounterNames = sizeOfData ;
    CounterNameRecord.dwLastCounterId = pSystem->CounterInfo.dwLastId ;
    CounterNameRecord.dwLangId = pSystem->CounterInfo.dwLangId ;
    WriteOK = FileWrite (pLog->hFile, &CounterNameRecord,
                         sizeof (CounterNameRecord)) ;

    if (WriteOK) {
        pLog->lFileSize += sizeof (LOGFILECOUNTERNAME) ;

        if (sizeOfData) {

            WriteOK = FileWrite (pLog->hFile, pCounterName, sizeOfData) ;

            if (WriteOK && (PatchBytes = sizeOfData % sizeof(DWORD)) > 0) {
                // ensure the file is in DWORD boundary.
                WriteOK = FileWrite (pLog->hFile, Dummy, PatchBytes) ;
            }

            if (WriteOK) {
                pLog->lFileSize += sizeOfData + PatchBytes ;

                if (!pLog->lBaseCounterNameOffset) {
                    // this is the first counter name data block
                    // then update the log file header
                    lDataOffset = FileTell (pLog->hFile) ;

                    FileSeekBegin (pLog->hFile, 0L) ;

                    ReadOK = FileRead (pLog->hFile,
                                       &LogFileHeader,
                                       sizeof (LogFileHeader)) ;

                    if (ReadOK) {
                        LogFileHeader.lBaseCounterNameOffset = lCurPosition ;
                        FileSeekBegin (pLog->hFile, 0L) ;
                        WriteOK = FileWrite (pLog->hFile,
                                             &LogFileHeader,
                                             sizeof (LogFileHeader)) ;
                    } else {
                        // flag an error
                        WriteOK = FALSE ;
                    }

                    // retore back to current file position
                    FileSeekBegin (pLog->hFile, lDataOffset) ;

                    if (ReadOK && WriteOK) {
                        // allocate memory to save the base system counter names
                        if (pLog->pBaseCounterName) {
                            MemoryFree (pLog->pBaseCounterName) ;
                        }
                        if (pLog->pBaseCounterName = MemoryAllocate (sizeOfData)) {
                            memcpy (pLog->pBaseCounterName,
                                    pCounterName,
                                    sizeOfData) ;
                            pLog->lBaseCounterNameOffset = lCurPosition ;
                            pLog->lBaseCounterNameSize = sizeOfData ;
                        }
                    }
                }
            }
        }
    }

    if ( WriteOK ) {
        WriteOK = LogWriteIndex (pLog, LogFileIndexCounterName,
                                 &SystemTime,
                                 lCurPosition,
                                 0) ;
    }

    if ( !WriteOK ) {
        CloseLog (hWndLog, pLog) ;
        PrepareMenu (GetMenu (hWndMain)) ;
        UpdateLogDisplay (hWndLog) ;
        DlgErrorBox (hWndLog, ERR_LOG_FILE, pLog->szFilePath);
    } else {
        UpdateLogSize (hWnd) ;
        pSystem->bSystemCounterNameSaved = TRUE ;
    }

    return (TRUE) ;
}