//==========================================================================//
// Includes //
//==========================================================================//
#include "setedit.h" // included by all source files
#include "line.h" // external declarations for this file
//#include <tchar.h> // for _tcsncpy
#include "fileutil.h" // for FileRead, FileWrite
#include "pmemory.h" // for MemoryXXX (mallloc-type) routines
#include "perfdata.h" // for UpdateSystemData, et al
#include "perfmops.h" // for InsertLine
#include "system.h" // for SystemAdd
#include "utils.h"
#include "counters.h" // CounterEntry
#include <string.h> // for strncpy
#ifdef UNICODE
#define _tcsncpy wcsncpy
#else
#define _tcsncpy strncpy
#endif
TCHAR LOCAL_SYS_CODE_NAME[] = TEXT("....") ;
#define sizeofCodeName sizeof(LOCAL_SYS_CODE_NAME) / sizeof(TCHAR) - 1
// Local Function prototype
PLINE ReadLine (PPERFSYSTEM *ppSystem,
PPPERFSYSTEM ppSystemFirst,
PPERFDATA *ppPerfData,
HANDLE hFile,
int LineType,
PDISKLINE *ppDiskLine,
DWORD *pSizeofDiskLine) ;
//==========================================================================//
// Exported Functions //
//==========================================================================//
PLINE LineAllocate (void)
/*
Effect: Allocate and initialize a Line data structure. Lines
are used as the primary elements of both charts and
alerts.
Establish any representation invariants for the Line
type.
Also alllocate another structure, an array of data
elements, iNumDataValues long.
*/
{ // LineAllocate
PLINE pLine ;
pLine = MemoryAllocate (sizeof (LINESTRUCT)) ;
if (pLine) {
// don't need to zero these again since MemoryAllocate is using
// GMEM_ZEROPOINT
// pLine->pLineNext = NULL ;
// pLine->pLineCounterNext = NULL ;
// do want to do this since (FLOAT)0.0 is not 0
pLine->lnMinValue =
pLine->lnMaxValue =
pLine->lnAveValue = (FLOAT) 0.0 ;
// we want to take 2 samples before plotting the first data
pLine->bFirstTime = 2 ;
} // if
return (pLine) ;
} // LineAllocate
void LineFree (PLINE pLine)
{ // LineFree
// free any memory allocated by this line
if (pLine->lnSystemName)
MemoryFree (pLine->lnSystemName) ;
if (pLine->lnObjectName)
MemoryFree (pLine->lnObjectName) ;
if (pLine->lnCounterName)
MemoryFree (pLine->lnCounterName) ;
if (pLine->lnInstanceName)
MemoryFree (pLine->lnInstanceName) ;
if (pLine->lnParentObjName)
MemoryFree (pLine->lnParentObjName) ;
if (pLine->lnPINName)
MemoryFree (pLine->lnPINName) ;
if (pLine->lpszAlertProgram)
MemoryFree (pLine->lpszAlertProgram) ;
if (pLine->hPen)
DeletePen(pLine->hPen);
if (pLine->hBrush)
DeletePen(pLine->hBrush);
#if 0
if (pLine->lnValues)
MemoryFree (pLine->lnValues) ;
if (pLine->aiLogIndexes)
MemoryFree (pLine->aiLogIndexes) ;
#endif
MemoryFree (pLine) ;
} // LineFree
void LineAppend (PPLINE ppLineFirst,
PLINE pLineNew)
{
PLINE pLine ;
if (!*ppLineFirst)
*ppLineFirst = pLineNew ;
else { // else
for (pLine = *ppLineFirst ;
pLine->pLineNext ;
pLine = pLine->pLineNext)
/* nothing */ ;
pLine->pLineNext = pLineNew ;
} // else
}
BOOL LineRemove (PPLINE ppLineFirst,
PLINE pLineRemove)
{
PLINE pLine ;
if (*ppLineFirst == pLineRemove) {
*ppLineFirst = (*ppLineFirst)->pLineNext ;
return (TRUE) ;
}
for (pLine = *ppLineFirst ;
pLine->pLineNext ;
pLine = pLine->pLineNext) { // for
if (pLine->pLineNext == pLineRemove) {
pLine->pLineNext = pLineRemove->pLineNext ;
return (TRUE) ;
} // if
} // for
return (FALSE) ;
} // LineRemove
int NumLines (PLINE pLineFirst)
{ // NumLines
PLINE pLine ;
int iNumLines ;
if (!pLineFirst)
return (0) ;
iNumLines = 0 ;
for (pLine = pLineFirst ;
pLine ;
pLine = pLine->pLineNext) { // for
iNumLines++ ;
} // for
return (iNumLines) ;
} // NumLines
LPTSTR LineInstanceName (PLINE pLine)
{
if (pLine->lnObject.NumInstances <= 0)
return (NULL) ;
else
return (pLine->lnInstanceName) ;
}
LPTSTR LineParentName (PLINE pLine)
{
if (pLine->lnObject.NumInstances <= 0)
return (NULL) ;
else if (pLine->lnInstanceDef.ParentObjectTitleIndex)
return (pLine->lnPINName) ;
else
return (NULL) ;
}
void LineCounterAppend (PPLINE ppLineFirst,
PLINE pLineNew)
{
PLINE pLine ;
if (!*ppLineFirst)
*ppLineFirst = pLineNew ;
else { // else
for (pLine = *ppLineFirst ;
pLine->pLineCounterNext ;
pLine = pLine->pLineCounterNext)
/* nothing */ ;
pLine->pLineCounterNext = pLineNew ;
} // else
}
BOOL EquivalentLine (PLINE pLine1,
PLINE pLine2)
{ // LineEquivalent
return (pstrsame (pLine1->lnCounterName, pLine2->lnCounterName) &&
pstrsame (pLine1->lnInstanceName, pLine2->lnInstanceName) &&
pstrsame (pLine1->lnPINName, pLine2->lnPINName) &&
pstrsame (pLine1->lnObjectName, pLine2->lnObjectName) &&
pstrsamei (pLine1->lnSystemName, pLine2->lnSystemName)) ;
} // LineEquivalent
PLINE FindEquivalentLine (PLINE pLineToFind,
PLINE pLineFirst)
{
PLINE pLine ;
for (pLine = pLineFirst ;
pLine ;
pLine = pLine->pLineNext) { // for
if (EquivalentLine (pLine, pLineToFind))
return (pLine) ;
} // for
return (NULL) ;
} // FindEquivalentLine
// This routine is used only to read the system name from a disk string
// It is mainly for performance improvement.
LPTSTR DiskStringReadSys (PDISKSTRING pDS)
{ // DiskStringReadSys
LPTSTR lpszText ;
LPTSTR pDiskSysName ;
int iIndex ;
BOOL bLocalSysName = FALSE ;
if (pDS->dwLength == 0) {
return (NULL) ;
}
if (pDS->dwLength == sizeofCodeName) {
// check for LOCAL_SYS_CODE_NAME
bLocalSysName = TRUE ;
pDiskSysName = (LPTSTR)((PBYTE) pDS + pDS->dwOffset) ;
for (iIndex = 0 ; iIndex < sizeofCodeName; iIndex++, pDiskSysName++) {
if (*pDiskSysName != LOCAL_SYS_CODE_NAME[iIndex]) {
bLocalSysName = FALSE ;
break ;
}
}
}
if (bLocalSysName) {
lpszText =
MemoryAllocate ((lstrlen(LocalComputerName)+1) * sizeof(TCHAR)) ;
if (lpszText) {
lstrcpy (lpszText, LocalComputerName) ;
}
} else {
lpszText = MemoryAllocate (sizeof (TCHAR) * (pDS->dwLength + 1)) ;
if (lpszText) {
_tcsncpy ((WCHAR *)lpszText, (WCHAR *)((PBYTE) pDS + pDS->dwOffset),
pDS->dwLength) ;
}
}
return (lpszText) ;
} // DiskStringReadSys
LPTSTR DiskStringRead (PDISKSTRING pDS)
{ // DiskStringRead
LPTSTR lpszText ;
if (pDS->dwLength == 0) {
return (NULL) ;
}
lpszText = MemoryAllocate (sizeof (TCHAR) * (pDS->dwLength + 1)) ;
if (!lpszText) {
return (NULL) ;
}
_tcsncpy ((WCHAR *)lpszText, (WCHAR *)((PBYTE) pDS + pDS->dwOffset),
pDS->dwLength) ;
return (lpszText) ;
} // DiskStringRead
int DiskStringLength (LPTSTR lpszText)
{
if (!lpszText)
return (0) ;
else
return (lstrlen (lpszText)) ;
}
PBYTE DiskStringCopy (PDISKSTRING pDS, LPTSTR lpszText, PBYTE pNextFree)
{
if (!lpszText) {
pDS->dwOffset = 0 ;
pDS->dwLength = 0 ;
return (pNextFree) ;
} else {
pDS->dwOffset = (DWORD)(pNextFree - (PBYTE) pDS) ;
pDS->dwLength = DiskStringLength (lpszText) ;
_tcsncpy ((WCHAR *)pNextFree, (WCHAR *)lpszText, pDS->dwLength) ;
return (pNextFree + pDS->dwLength * sizeof(TCHAR)) ;
}
} // DiskStringCopy
void CounterName (PPERFSYSTEM pSystem,
PPERFCOUNTERDEF pCounter,
LPTSTR lpszCounter)
{ // CounterName
//!! strclr (lpszCounter) ;
lpszCounter [0] = TEXT('\0') ;
QueryPerformanceName (pSystem,
pCounter->CounterNameTitleIndex,
0, 256,
lpszCounter,
FALSE) ;
} // CounterName
PERF_OBJECT_TYPE UNALIGNED *
LineFindObject (PPERFSYSTEM pSystem,
PPERFDATA pPerfData,
PLINE pLine)
/*
Effect: Set the lnObject field of pLine to the object with the
name of lnObjectName, and return TRUE. Return FALSE if
there is no such object.
*/
{ // LineFindObject
PERF_OBJECT_TYPE UNALIGNED *pObject ;
pObject = (PERF_OBJECT_TYPE UNALIGNED *)GetObjectDefByName (pSystem, pPerfData, pLine->lnObjectName) ;
if (pObject) {
pLine->lnObject = *pObject ;
return (pObject) ;
} else
return (NULL) ;
} // LineFindObject
PPERFCOUNTERDEF LineFindCounter (PPERFSYSTEM pSystem,
PERF_OBJECT_TYPE UNALIGNED *pObject,
PPERFDATA pPerfData,
PLINE pLine)
{ // LineFindCounter
UINT i ;
PPERFCOUNTERDEF pCounter ;
TCHAR szCounter [256] ;
for (i = 0, pCounter = FirstCounter (pObject) ;
i < pObject->NumCounters ;
i++, pCounter = NextCounter (pCounter)) { // for
CounterName (pSystem, pCounter, szCounter) ;
if (strsame (szCounter, pLine->lnCounterName)) {
pLine->lnCounterDef = *pCounter ;
return (pCounter) ;
} // if
} // for
return (NULL) ;
} // LineFindCounter
PPERFINSTANCEDEF LineFindInstance (PPERFDATA pPerfData,
PERF_OBJECT_TYPE UNALIGNED *pObject,
PLINE pLine)
{ // LineFindInstance
PPERFINSTANCEDEF pInstance = NULL ;
if ((pObject->NumInstances > 0) && pLine->lnInstanceName) {
// instances exist, find the right one
if (pLine->lnUniqueID != PERF_NO_UNIQUE_ID) {
pInstance = GetInstanceByUniqueID(pObject, pLine->lnUniqueID,
pLine->dwInstanceIndex) ;
} else {
pInstance = GetInstanceByName(pPerfData, pObject,
pLine->lnInstanceName, pLine->lnPINName,
pLine->dwInstanceIndex) ;
}
}
if (pInstance) {
pLine->lnInstanceDef = *pInstance ;
}
return (pInstance) ;
} // LineFindInstance
void ReadLines (HANDLE hFile,
DWORD dwNumLines,
PPPERFSYSTEM ppSystemFirst,
PPLINE ppLineFirst,
int LineType)
{
DWORD i ;
PPERFDATA pPerfData ;
PLINE pLine ;
PPERFSYSTEM pSystem ;
PDISKLINE pDiskLine = NULL ;
DWORD SizeofDiskLine = 0 ; // bytes in pDiskLine
pPerfData = AllocatePerfData () ;
pSystem = *ppSystemFirst ;
#if 0
if (!pSystem) {
pSystem = SystemAdd (ppSystemFirst, LocalComputerName, NULL) ;
pSystem = *ppSystemFirst ; //!!
}
UpdateSystemData (pSystem, &pPerfData) ;
#endif
pDiskLine = MemoryAllocate (FilePathLen) ;
if (!pDiskLine) {
// no memory to begin with, forget it
DlgErrorBox (hWndMain, ERR_NO_MEMORY) ;
return ;
}
SizeofDiskLine = FilePathLen ;
for (i = 0 ;
i < dwNumLines ;
i++) {
pLine = ReadLine (&pSystem, ppSystemFirst, &pPerfData, hFile,
LineType, &pDiskLine, &SizeofDiskLine) ;
if (pLine)
InsertLine (pLine) ;
}
if (pDiskLine) {
MemoryFree (pDiskLine);
}
MemoryFree (pPerfData) ;
} // ReadLines
void LineSetCounter (PLINE pLine,
PPERFSYSTEM pSystem,
PPERFCOUNTERDEF pCounter,
PPERFINSTANCEDEF pInstance)
/*
Effect: Set the counter-specific portions of pLine to point to
the desired counter.
Called By: AddLine, ReadLine.
*/
{
}
PLINE ReadLine (PPERFSYSTEM *ppSystem,
PPPERFSYSTEM ppSystemFirst,
PPERFDATA *ppPerfData,
HANDLE hFile,
int LineType,
PDISKLINE *ppDiskLine,
DWORD *pSizeofDiskLine)
/*
Effect: Read in a line from the file hFile, at the current file
position.
Internals: The very first characters are a line signature, then a
length integer. If the signature is correct, then allocate
the length amount, and work with that.
*/
{ // ReadLine
PLINE pLine ;
struct {
DWORD dwSignature ;
DWORD dwLength ;
} LineHeader ;
PERF_OBJECT_TYPE UNALIGNED *pObject ;
PPERFCOUNTERDEF pCounter ;
PDISKLINE pDiskLine ; // Local copy of the pointer
#ifdef KEEP_IT
int i ;
int iCounterIndex ;
int j ;
PERF_COUNTER_BLOCK *pCounterBlock ;
#endif
PPERFINSTANCEDEF pInstance ;
// PPERFINSTANCEDEF pInstanceParent ;
// TCHAR szInstanceParent [256] ;
// TCHAR szObjectParent [PerfObjectLen] ;
pLine = NULL ;
//=============================//
// read and compare signature //
//=============================//
if (!FileRead (hFile, &LineHeader, sizeof (LineHeader)))
return (NULL) ;
if (LineHeader.dwSignature != dwLineSignature ||
LineHeader.dwLength == 0) {
SetLastError (ERROR_BAD_FORMAT) ;
return (NULL) ;
}
//=============================//
// read and allocate length //
//=============================//
// if (!FileRead (hFile, &dwLength, sizeof (dwLength)) || dwLength == 0)
// return (NULL) ;
// check if we need a bigger buffer,
// normally, it should be the same except the first time...
if (LineHeader.dwLength > *pSizeofDiskLine) {
if (*ppDiskLine) {
// free the previous buffer
MemoryFree (*ppDiskLine);
*pSizeofDiskLine = 0 ;
}
// re-allocate a new buffer
*ppDiskLine = (PDISKLINE) MemoryAllocate (LineHeader.dwLength) ;
if (!(*ppDiskLine)) {
// no memory, should flag an error...
return (NULL) ;
}
*pSizeofDiskLine = LineHeader.dwLength ;
}
pDiskLine = *ppDiskLine ;
//=============================//
// copy diskline, alloc line //
//=============================//
if (!FileRead (hFile, pDiskLine, LineHeader.dwLength))
return (NULL) ;
pLine = LineAllocate () ;
if (!pLine) {
return (NULL) ;
}
pLine->iLineType = pDiskLine->iLineType ;
//=============================//
// convert system information //
//=============================//
pLine->lnSystemName = DiskStringReadSys (&(pDiskLine->dsSystemName)) ;
if (!pLine->lnSystemName)
goto ErrorBadLine ;
if (!*ppSystem || !strsamei (pLine->lnSystemName, (*ppSystem)->sysName)) {
*ppSystem = SystemAdd (ppSystemFirst, pLine->lnSystemName, NULL) ;
if (!*ppSystem) {
SetLastError (ERROR_BAD_FORMAT) ;
goto ErrorBadLine ;
}
UpdateSystemData (*ppSystem, ppPerfData) ;
} // if
//=============================//
// convert object information //
//=============================//
pLine->lnObjectName = DiskStringRead (&(pDiskLine->dsObjectName)) ;
if (!pLine->lnObjectName)
goto ErrorBadLine ;
pObject = LineFindObject (*ppSystem, *ppPerfData, pLine) ;
if (!pObject) {
SetLastError (ERROR_BAD_FORMAT) ;
goto ErrorBadLine ;
}
//=============================//
// convert counter information //
//=============================//
pLine->lnCounterName = DiskStringRead (&(pDiskLine->dsCounterName)) ;
if (!pLine->lnCounterName)
goto ErrorBadLine ;
pCounter = LineFindCounter (*ppSystem, pObject, *ppPerfData, pLine) ;
if (!pCounter) {
SetLastError (ERROR_BAD_FORMAT) ;
goto ErrorBadLine ;
}
//=============================//
// convert instance info //
//=============================//
pLine->lnUniqueID = pDiskLine->dwUniqueID ;
pLine->lnInstanceName = DiskStringRead (&(pDiskLine->dsInstanceName)) ;
pLine->lnPINName = DiskStringRead (&(pDiskLine->dsPINName)) ;
if (pLine->lnObject.NumInstances > 0 &&
pLine->lnInstanceName == NULL) {
goto ErrorBadLine ;
}
pInstance = LineFindInstance (*ppPerfData, pObject, pLine) ;
if (pInstance) {
pLine->lnParentObjName = DiskStringRead (&(pDiskLine->dsParentObjName)) ;
} else {
pLine->bUserEdit = TRUE ;
pLine->lnParentObjName = DiskStringRead (&(pDiskLine->dsParentObjName)) ;
}
//=============================//
// convert chart information //
//=============================//
if (LineType == IDM_VIEWCHART) {
pLine->Visual = pDiskLine->Visual ;
pLine->hPen = CreatePen (pLine->Visual.iStyle,
pLine->Visual.iWidth,
pLine->Visual.crColor) ;
pLine->iScaleIndex = pDiskLine->iScaleIndex ;
pLine->eScale = pDiskLine->eScale ;
}
//=============================//
// convert alert information //
//=============================//
if (LineType == IDM_VIEWALERT) {
pLine->Visual = pDiskLine->Visual ;
pLine->hBrush = CreateSolidBrush (pLine->Visual.crColor) ;
pLine->bAlertOver = pDiskLine->bAlertOver ;
pLine->eAlertValue = pDiskLine->eAlertValue ;
pLine->lpszAlertProgram = DiskStringRead (&(pDiskLine->dsAlertProgram)) ;
pLine->bEveryTime = pDiskLine->bEveryTime ;
pLine->bAlerted = FALSE ;
}
//=============================//
// Convert the nasty stuff //
//=============================//
pLine->lnCounterType = pCounter->CounterType;
pLine->lnCounterLength = pCounter->CounterSize;
// we don't need these line info since we will get it
// from the first couple clock ticks...
// If we decide to keep these line, just define KEEP_IT
#ifdef KEEP_IT
pLine->lnOldTime = (*ppPerfData)->PerfTime ;
pLine->lnNewTime = (*ppPerfData)->PerfTime ;
pLine->lnOldTime100Ns = (*ppPerfData)->PerfTime100nSec ;
pLine->lnNewTime100Ns = (*ppPerfData)->PerfTime100nSec;
pLine->lnPerfFreq = (*ppPerfData)->PerfFreq ;
for (j = 0 ; j < 2 ; j++) {
pLine->lnaCounterValue[j].LowPart = 0 ;
pLine->lnaCounterValue[j].HighPart = 0 ;
}
if (pObject->NumInstances > 0 && pInstance) {
pCounterBlock = (PERF_COUNTER_BLOCK *) ( (PBYTE) pInstance +
pInstance->ByteLength);
} else {
pCounterBlock = (PERF_COUNTER_BLOCK *) ( (PBYTE) pObject +
pObject->DefinitionLength);
}
if (pLine->lnCounterLength <= 4)
pLine->lnaOldCounterValue[0].LowPart =
* ( (DWORD FAR *) ( (PBYTE)pCounterBlock +
pCounter[0].CounterOffset));
else {
pLine->lnaOldCounterValue[0] =
* ( (LARGE_INTEGER *) ( (PBYTE)pCounterBlock +
pCounter[0].CounterOffset));
}
// Get second counter, only if we are not at
// the end of the counters; some computations
// require a second counter
iCounterIndex = CounterIndex (pCounter, pObject) ;
if ((UINT) iCounterIndex < pObject->NumCounters - 1 &&
iCounterIndex != -1) {
if (pLine->lnCounterLength <= 4)
pLine->lnaOldCounterValue[1].LowPart =
* ( (DWORD FAR *) ( (PBYTE)pCounterBlock +
pCounter[1].CounterOffset));
else
pLine->lnaOldCounterValue[1] =
* ( (LARGE_INTEGER *) ( (PBYTE)pCounterBlock +
pCounter[1].CounterOffset));
}
// pLine->valNext = CounterFuncEntry ;
pLine->valNext = CounterEntry ;
pLine->lnaOldCounterValue[0] = pLine->lnaCounterValue[0];
pLine->lnaOldCounterValue[1] = pLine->lnaCounterValue[1];
#endif // KEEP_IT
// pLine->valNext = CounterFuncEntry ;
pLine->valNext = CounterEntry ;
return (pLine) ;
ErrorBadLine:
if (!pLine) {
LineFree (pLine) ;
}
return (NULL) ;
} // ReadLine
BOOL WriteLine (PLINE pLine,
HANDLE hFile)
{ // WriteLine
PDISKLINE pDiskLine ;
DWORD dwSignature ;
DWORD dwLength ;
PBYTE pNextFree ;
BOOL bConvertName ;
//=============================//
// write signature //
//=============================//
dwSignature = dwLineSignature ;
if (!FileWrite (hFile, &dwSignature, sizeof (dwSignature)))
return (FALSE) ;
if (IsLocalComputer(pLine->lnSystemName)) {
bConvertName = TRUE ;
} else {
bConvertName = FALSE ;
}
//=============================//
// compute and allocate length //
//=============================//
dwLength = sizeof (DISKLINE) ;
if (bConvertName) {
dwLength += DiskStringLength (LOCAL_SYS_CODE_NAME) * sizeof (TCHAR) ;
} else {
dwLength += DiskStringLength (pLine->lnSystemName) * sizeof (TCHAR) ;
}
dwLength += DiskStringLength (pLine->lnObjectName) * sizeof (TCHAR) ;
dwLength += DiskStringLength (pLine->lnCounterName) * sizeof (TCHAR) ;
dwLength += DiskStringLength (pLine->lnInstanceName) * sizeof (TCHAR) ;
dwLength += DiskStringLength (pLine->lnPINName) * sizeof (TCHAR) ;
dwLength += DiskStringLength (pLine->lnParentObjName) * sizeof (TCHAR) ;
dwLength += DiskStringLength (pLine->lpszAlertProgram) * sizeof (TCHAR) ;
if (!FileWrite (hFile, &dwLength, sizeof (dwLength)))
return (FALSE) ;
pDiskLine = (PDISKLINE) MemoryAllocate (dwLength) ;
if (!pDiskLine)
return (FALSE) ;
pNextFree = (PBYTE) pDiskLine + sizeof (DISKLINE) ;
//=============================//
// convert fixed size fields //
//=============================//
pDiskLine->iLineType = pLine->iLineType ;
pDiskLine->dwUniqueID = pLine->lnUniqueID ;
pDiskLine->Visual = pLine->Visual ;
pDiskLine->iScaleIndex = pLine->iScaleIndex ;
pDiskLine->eScale = pLine->eScale ;
pDiskLine->bAlertOver = pLine->bAlertOver ;
pDiskLine->eAlertValue = pLine->eAlertValue ;
pDiskLine->bEveryTime = pLine->bEveryTime ;
//=============================//
// copy disk string fields //
//=============================//
if (bConvertName) {
pNextFree = DiskStringCopy (&pDiskLine->dsSystemName,
LOCAL_SYS_CODE_NAME,
pNextFree) ;
} else {
pNextFree = DiskStringCopy (&pDiskLine->dsSystemName,
pLine->lnSystemName,
pNextFree) ;
}
pNextFree = DiskStringCopy (&pDiskLine->dsObjectName,
pLine->lnObjectName,
pNextFree) ;
pNextFree = DiskStringCopy (&pDiskLine->dsCounterName,
pLine->lnCounterName,
pNextFree) ;
pNextFree = DiskStringCopy (&pDiskLine->dsParentObjName,
pLine->lnParentObjName,
pNextFree) ;
pNextFree = DiskStringCopy (&pDiskLine->dsInstanceName,
pLine->lnInstanceName,
pNextFree) ;
pNextFree = DiskStringCopy (&pDiskLine->dsPINName,
pLine->lnPINName,
pNextFree) ;
pNextFree = DiskStringCopy (&pDiskLine->dsAlertProgram,
pLine->lpszAlertProgram,
pNextFree) ;
FileWrite (hFile, pDiskLine, dwLength) ;
MemoryFree (pDiskLine) ;
return (TRUE) ;
//ErrorBadLine:
MemoryFree (pDiskLine) ;
return (FALSE) ;
} // WriteLine
// we are not doing printing. In case we need this
// later, then define DO_PRINTING
#ifdef DO_PRINTING
int aiPrinterLineStyles [] =
{
PS_SOLID,
PS_DASH,
PS_DOT,
PS_DASHDOT,
PS_DASHDOTDOT
} ;
#define NumPrinterLineStyles() \
(sizeof (aiPrinterLineStyles) / sizeof (aiPrinterLineStyles [0]))
COLORREF acrPrinterLineColors [] =
{
RGB (192, 192, 192),
RGB (128, 128, 128),
RGB (64, 64, 64),
RGB (0, 0, 0)
} ;
#define NumPrinterLineColors() \
(sizeof (acrPrinterLineColors) / sizeof (acrPrinterLineColors [0]))
#endif // DO_PRINTING
HPEN LineCreatePen (HDC hDC,
PLINEVISUAL pVisual,
BOOL bForPrint)
{ // LineCreatePen
HPEN hPen ;
hPen = CreatePen (pVisual->iStyle,
pVisual->iWidth,
pVisual->crColor) ;
return (hPen) ;
} // LineCreatePen
VOID FreeLines (PLINESTRUCT pLineFirst)
{ // FreeLines
PLINESTRUCT pLine,next_line;
for (pLine = pLineFirst; pLine; pLine = next_line) {
next_line = pLine->pLineNext;
LineFree (pLine) ;
}
} // FreeLines