Windows编程

开发平台：
Visual C++

LOG.C：源码内容
							/*****************************************************************************
 *
 *  Log.c - This module handles the Logging.
 *
 *  Microsoft Confidential
 *  Copyright (c) 1992-1997 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 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.
*/
   {  // LogEntriesChanged
   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++)
      {  // for all items in the list
      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);
         } 
      }  // for
   xCol1Width += 2 * xScrollWidth ;
   xCol1Width = max (xCol1Width, 
                     TextAvgWidth (hDC, LogObjectMinLen)) ;
   if (xCol1Width != pLog->xCol1Width)
      {
      pLog->xCol1Width = xCol1Width ;
      WindowInvalidate (hWndLogEntries) ;
      }
   ReleaseDC (hWndLog, hDC) ;
   }  // LogEntriesChanged
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)
      {  // switch
      case iPMStatusClosed:
         return (szClosed) ;
      case iPMStatusCollecting:
         return (szCollecting) ;
//      case iPMStatusPaused:
//         return (szPaused) ;
      default:
         return (szClosed) ;
      }  // switch
   }  // StatusText
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) ;
   }  // AllocateLogData
void FreeLogData (PLOG pLog)
   {  // FreeLogData
   MemoryFree (pLog->pLogData) ;
   }  // FreeLogData
void UpdateLogSize (HWND hWnd)
/*
   Effect:        Set the size value to the current size.  Also change the
                  size entry in the status line.
*/
   {  // UpdateLogSize
   PLOG           pLog ;
   TCHAR          szSize [ShortTextLen + 1] ;
   pLog = LogData (hWnd) ;
   
   LongToCommaString (pLog->lFileSize, szSize) ;
   SetDlgItemText (hWnd, IDD_LOGSIZE, szSize) ;
   if (!PlayingBackLog())
      {
      StatusUpdateIcons (hWndStatus) ;
      }
   }  // UpdateLogSize
HANDLE LogAppendSetup(PLOG pLog, PLOGHEADER pLogFileHeader)
   {  // LogAppendSetup
   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)) ;
      }
   *pLogIndexBlock = *LP.pIndexBlock ;
   pLog->lIndexBlockOffset = lPreviousIndexBlock ;
   pLog->iIndex = ++LP.iIndex ;
   pLog->lFileSize = FileSeekEnd(pLog->hFile, 0) ;
   FileUnMap((LPVOID)pHeader, hMapHandle) ;
   return pLog->hFile ;
   }  // LogAppendSetup
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)
   {  // CreateLogFile
   HANDLE               returnHandle ;
   LOGHEADER            LogFileHeader ;
   long                 lCurPosition ;
   LOGFILECOUNTERNAME   CounterNameRecord ;
   pLog->lFileSize = 0 ;
   memset (&(pLog->LastLogTime), 0, sizeof(SYSTEMTIME)) ;
   if (!pLogIndexBlock)
      {
      pLogIndexBlock = (LOGINDEXBLOCK *) MemoryAllocate (sizeof(LOGINDEXBLOCK)) ;
      }
   lstrcpy (pLogIndexBlock->szSignature, LogIndexSignature) ;
   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) ;
   }  // CreateLogFile
void LogWriteIndexBlock (PLOG pLog)
   {
   FileSeekBegin (pLog->hFile, 
                  pLog->lIndexBlockOffset) ;
   pLogIndexBlock->lNextBlockOffset = 0 ;
   FileWrite (pLog->hFile,
              (LPSTR) pLogIndexBlock,
              sizeof (LOGINDEXBLOCK)) ;
   }  // LogWriteIndexBlock
BOOL LogWriteIndex (PLOG pLog,
                    UINT uFlags,
                    SYSTEMTIME *pSystemTime,
                    LONG lDataOffset,
                    int iSystemsLogged) 
   {  // LogWriteIndex
   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) ;
            }
         }
      }  // if
   //=============================//
   // 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) ;
   }  // LogWriteIndex
BOOL LogWritePerfData (HWND hWnd,
                       PLOG pLog,
                       PPERFDATA pPerfData,
                       SYSTEMTIME *pSystemTime,
                       DWORD iNumSystems,
                       BOOL bWriteIndex)
   {  // LogWritePerfData
   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) ;
   }  // LogWritePerfData
//==========================================================================//
//                              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.
*/
   {  // OnSize
   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) ;
   }  // OnSize
int OnCtlColor (HWND hDlg,
                       HDC hDC)
   {
   SetTextColor (hDC, crBlack) ;
   SetBkColor (hDC, crLightGray) ;
   return ((int) hbLightGray) ;
   }
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.
*/
   {  // OnDestroy
   PLOG           pLog ;
   pLog = LogData (hWnd) ;
   FreeLogData (pLog) ;
   }  // OnDestroy
void static OnDrawItem (HWND hWnd, LPDRAWITEMSTRUCT lpDI)
   {  // OnDrawItem
   HDC            hDC ;
   RECT           rectComputer, rectObject ;
   PLOGENTRY      pLogEntry ;
   PLOG           pLog ;
   COLORREF       preBkColor ;
   COLORREF       preTextColor ;
   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)) 
      {  // if
      preTextColor = SetTextColor (hDC, GetSysColor (COLOR_HIGHLIGHTTEXT)) ;
      preBkColor = SetBkColor (hDC, GetSysColor (COLOR_HIGHLIGHT)) ;
      }  // if
   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))
      {  // if
      preTextColor = SetTextColor (hDC, preTextColor) ;
      preBkColor = SetBkColor (hDC, preBkColor) ;
      }  // if
//   RestoreDC (hDC, -1) ;
   }  // OnDrawItem
   
//==========================================================================//
//                             Exported Functions                           //
//==========================================================================//
int APIENTRY LogDisplayDlgProc (HWND hDlg,
                                unsigned iMessage,
                                WPARAM wParam,
                                LONG lParam)
/*
   Note:          This function must be exported in the application's
                  linker-definition file, perfmon.def.
*/
   {  // LogDisplayDlgProc
//   HDC            hDC ;
   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) ;
      } // switch
   return (TRUE) ;
   }  // LogDisplayDlgProc
#if 0
PLOG LogData (HWND hWndLog)
   {
   return (&Log) ;
   }
#endif
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.
*/
   {  // CreateLogWindow
   HWND           hWnd ;
   hWnd = CreateDialog (hInstance,
                        MAKEINTRESOURCE (idDlgLogDisplay),
                        hWndParent,
                        (DLGPROC) LogDisplayDlgProc) ;
   return (hWnd) ;
   }  // CreateLogWindow
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.
*/
   {  // UpdateLogDisplay
   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) ;
   }  // UpdateLogDisplay
BOOL LogInitializeApplication (void)
   {
   return (TRUE) ;
   }  // LogInitializeApplication
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)
   {  // CloseLog
   LogWriteIndexBlock (pLog) ;
   CloseLogStopTimer (hWnd, pLog) ;
   WindowInvalidate (hWndStatus) ;
   return (TRUE) ;
   } // CloseLog
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 (&(FirstSystemTime),
                                             &(pLog->LastLogTime)) ;
            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.
*/
   {  // LogAddEntry
   PLOG           pLog ;
   PLOGENTRY      pLogEntry ;
   UINT           iIndex ;
   PPERFSYSTEM    pCurrentSystem = NULL ;
   DWORD          CurrentObjectTitleIndex ;
   pLog = LogData (hWndLog) ;
   
   pCurrentSystem = SystemAdd (&(pLog->pSystemFirst), lpszComputer) ;
   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(''))
         {
         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) ;
   }  // LogAddEntry
BOOL ToggleLogRefresh (HWND hWnd)
   {  // ToggleLogRefresh
   PLOG        pLog ;
   pLog = LogData (hWnd) ;
   if (pLog->bManualRefresh)
      SetLogTimer (hWnd, pLog->iIntervalMSecs) ;
   else
      ClearLogTimer (hWnd) ;
   pLog->bManualRefresh = !pLog->bManualRefresh ;
   return (pLog->bManualRefresh) ;
   }  // ToggleLogRefresh
BOOL LogRefresh (HWND hWnd)
   {  // LogRefresh
   PLOG        pLog ;
   pLog = LogData (hWnd) ;
   return (pLog->bManualRefresh) ;
   }  // LogRefresh
BOOL  CheckUnusedSystem (LPTSTR      lpszComputer)
{
   BOOL  bStillUse = FALSE ;
   PLOGENTRY      pLogEntry ;
   PLOG           pLog ;
   pLog = LogData (hWndLog) ;
   for (pLogEntry = pLog->pLogEntryFirst ;
        pLogEntry ;
        pLogEntry = pLogEntry->pNextLogEntry)
      { // for
      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 ;
   PPERF_OBJECT_TYPE
                  pObject ;
   DWORD          TotalBytes ;
   DWORD          NumObjects ;
   PBYTE          pNextObject ;
   DWORD          MaxLogDataSize ;
   PLOG           pLog ;
   if (!*ppLogData || !pPerfData)
      return -1 ;
   memcpy (*ppLogData, pPerfData, pPerfData->HeaderLength) ;
   TotalBytes = pPerfData->HeaderLength ;
   MaxLogDataSize = MemorySize(*ppLogData) ;
   NumObjects = 0;
   
   pLog = LogData (hWndLog) ;
   for (pLogEntry = pLog->pLogEntryFirst ;
        pLogEntry ;
        pLogEntry = pLogEntry->pNextLogEntry)
      { // for
      if (strsamei(pLogEntry->szComputer, lpszComputer))
         {
         pObject = GetObjectDefByTitleIndex(pPerfData,
            pLogEntry->ObjectTitleIndex) ;
         if (pObject)
            {
            if (MaxLogDataSize < TotalBytes + pObject->TotalByteLength)
               {
               *ppLogData = MemoryResize(*ppLogData,
                                         TotalBytes + pObject->TotalByteLength) ;
               if (!*ppLogData)
                  return -1 ;
               }
            pNextObject = (PBYTE) *ppLogData + TotalBytes ;
            memcpy (pNextObject, pObject, pObject->TotalByteLength);
            TotalBytes += pObject->TotalByteLength ;
            NumObjects++;
            }
         else
            {
            }
         }
      } // for
   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.
*/
   {  // OnTimer
   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)
         {  // for
      
         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);
         }  // for each system
      // 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 systemsn"), 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)
            {  // for
      
            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
   if (iNoUseSystemDetected)
      {
      DeleteUnusedSystems (&(pLog->pSystemFirst), iNoUseSystemDetected) ;
      }
   if (bNeedToStoreName == TRUE)
      {
      LogWriteSystemCounterNames (hWnd, pLog) ;
      }
   }  // LogTimer
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))
      {  // while
      *pNumTics = *pNumTics - 1 ;
      pIndex = IndexFromPosition (&LP) ;
      if (pIndex && IsBookmarkIndex (pIndex))
         {
         *pLP = LP ;
         return TRUE ;
         }
      LogPositionSystemTime (&LP, &SystemTime2) ;
      TimeDiff = (DWORD) SystemTimeDifference (&SystemTime1, &SystemTime2) ;
      if (TimeDiff * 1000 >= pLog->iIntervalMSecs)
         {  // if
         *pLP = LP ;
         return (TRUE) ;
         }  // if
      }  // while
   return (FALSE) ;
   }  // NextIntervalIndexPosition
BOOL ReLogTimer (HWND hWnd,
                 PLOG pLog,
                 LOGPOSITION lp,
                 BOOL *pWriteBookmark)
   {  // ReLogTimer
   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)
      {  // for
      pPerfData = LogDataFromPosition (pSystem, &lp) ;
      if (pPerfData)
         {
         if (SelectLogObjects(pSystem->sysName,
                              pPerfData,
                              &pLog->pLogData) == 0)
            {
            iNumSystems++;
            }
         }
      }  // for
   // 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 ;
               }
            }
         }
      }  // for
   return TRUE ;
   }  // ReLogTimer
void ReLog (HWND hWndLog, BOOL bSameFile)
   {  // PlaybackLog
   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 ;
      
      }  // while
   UpdateLogSize (hWndLog) ;
   CloseLog (hWndLog, pLog) ;
   }  // ReLog
// 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 && newFileName)
         {
         ChangeSaveFileName (szFileName, IDM_VIEWLOG) ;
         }
      else if (!hFile)
         {
         DlgErrorBox (hWndLog, ERR_CANT_OPEN, szFileName) ;
         }
      }
   if (!hFile)
      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++)
      {  // for
      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 ;
            }
         }
      }  // for
   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++)
      {  // for all items in the list
      pLogEntry = LogEntryN (hWndLogEntries, iIndex) ;
      pSystem = SystemGet (pLog->pSystemFirst, pLogEntry->szComputer);
      if (pSystem)
         {
         AppendObjectToValueList (
                pLogEntry->ObjectTitleIndex,
                pSystem->lpszValue);
         } 
      }  // for
   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) ;
   }  // OpenLog
BOOL LogCollecting (HWND hWndLog)
/*
   Effect:        Return whether the log associated with hWndLog is currently
                  collecting data (writing performance values to disk).
*/
   {  // LogCollecting
   PLOG           pLog ;
   pLog = LogData (hWndLog) ;
   return (pLog->iStatus == iPMStatusCollecting) ;
   }  // LogCollecting
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('') ;
   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('') ;
   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)
   {  // LogWriteBookmark
   BOOKMARK       Bookmark ;
   memset (&Bookmark, 0, sizeof (BOOKMARK)) ;
   GetLocalTime (&Bookmark.SystemTime) ;
   lstrcpy (Bookmark.szComment, lpszComment) ;
   return (LogWriteBookmarkData (hWndLog, &Bookmark)) ;
   }  // LogWriteBookmark
   
BOOL AnyLogLine (void)
{  // CurrentLogLine
   int iIndex ;
   iIndex = LBSelection (hWndLogEntries) ;
   if (iIndex == 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) ;
      }
}  // ResetLogView
BOOL ResetLog (HWND hWndLog)
{
   int         iIndex ;
   PLOG        pLog ;
   int         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 (pLog->pLogData) ;
   pLog->pLogData = (PPERFDATA) MemoryAllocate (STARTING_SYSINFO_SIZE) ;
   LogEntriesChanged (hWndLogEntries) ;
   pLog->iStatus = iPMStatusClosed ;
   UpdateLogDisplay (hWndLog) ;
   return (TRUE) ;
}
BOOL LogDeleteEntry (HWND hWndLog)
{
   int         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..
   if (!(hFile = FileHandleCreate (UnicodeBuff)))
      {
      // 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) ;
      }
}  // ExportLog
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 ) ;
            }
         }
      }
   } // LogWriteSystemCounterNames
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 ;
   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 (!pLog->lBaseCounterNameOffset)
            }
         }  // if (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) ;
   }
     

						