able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/controls/smonctrl/grphitem.cpp

1741 lines
41 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (C) 1996-1999 Microsoft Corporation
Module Name:
grphitem.cpp
Abstract:
<abstract>
--*/
#ifndef _LOG_INCLUDE_DATA
#define _LOG_INCLUDE_DATA 0
#endif
#include <math.h>
#include <limits.h> // for INT_MAX
#include <pdhp.h>
#include "polyline.h"
#include "visuals.h"
#include "grphitem.h"
#include "unihelpr.h"
#include "utils.h"
#include "pdhmsg.h"
#define MAX_DOUBLE_TEXT_SIZE (64)
// Construction/Destruction
CGraphItem::CGraphItem (
CSysmonControl *pCtrl )
: m_cRef ( 0 ),
m_pCtrl ( pCtrl ),
m_hCounter ( NULL ),
m_hPen ( NULL ),
m_hBrush ( NULL ),
m_pCounter ( NULL ),
m_pInstance ( NULL),
m_pRawCtr ( NULL ),
m_pFmtCtr ( NULL ),
m_dFmtMax ( 0 ),
m_dFmtMin ( 0 ),
m_dFmtAvg ( 0 ),
m_lFmtStatus ( 0 ),
m_pLogData ( NULL ),
m_pImpIDispatch ( NULL ),
m_rgbColor ( RGB(0,0,0) ),
m_iWidth ( 1 ),
m_iStyle ( 0 ),
m_iScaleFactor ( INT_MAX ),
m_dScale ( (double)1.0 ),
m_pNextItem ( NULL ),
m_bUpdateLog ( TRUE ),
m_fGenerated ( FALSE )
/*++
Routine Description:
Constructor for the CGraphItem class. It initializes the member variables.
Arguments:
None.
Return Value:
None.
--*/
{
ZeroMemory ( &m_CounterInfo, sizeof (m_CounterInfo ) );
m_CounterInfo.CStatus = PDH_CSTATUS_INVALID_DATA;
return;
}
CGraphItem::~CGraphItem (
VOID
)
/*++
Routine Description:
Destructor for the CGraphItem class. It frees any objects, storage, and
interfaces that were created. If the item is part of a query it is removed
from the query.
Arguments:
None.
Return Value:
None.
--*/
{
if (m_hCounter != NULL)
RemoveFromQuery();
if (m_hPen != NULL)
DeleteObject(m_hPen);
if (m_hBrush != NULL)
DeleteObject(m_hBrush);
if (m_pImpIDispatch != NULL)
delete m_pImpIDispatch;
}
HRESULT
CGraphItem::SaveToStream (
IN LPSTREAM pIStream,
IN BOOL fWildCard,
IN INT iVersMaj,
IN INT // iVersMin
)
/*++
Routine Description:
SaveToStream writes the graph item's properties to the provided stream.
Arguments:
pIStream - Pointer to stream interface
pszPath - Path name to save item under
Return Value:
HRESULT - S_OK or stream error
--*/
{
LPWSTR pszWidePath;
TCHAR szPath[MAX_PATH];
LPTSTR szEnglishBuf = NULL;
DWORD dwEnglishBufSize = 0;
LPTSTR pNewBuf;
DWORD dwBufSize;
LPTSTR pszPath;
HRESULT hr = S_OK;
PDH_STATUS pdhStatus;
USES_CONVERSION
// Get Ansi path name
FormPath(szPath, fWildCard );
pszPath = szPath;
//
// Initialize the locale path buffer
//
if (dwEnglishBufSize == 0) {
dwEnglishBufSize = (MAX_PATH + 1) * sizeof(TCHAR);
szEnglishBuf = (LPTSTR) malloc(dwEnglishBufSize);
if (szEnglishBuf == NULL) {
dwEnglishBufSize = 0;
}
}
if (szEnglishBuf != NULL) {
//
// Translate counter name from Localization into English
//
dwBufSize = dwEnglishBufSize;
pdhStatus = PdhTranslate009Counter(
szPath,
szEnglishBuf,
&dwBufSize);
if (pdhStatus == PDH_MORE_DATA) {
pNewBuf = (LPTSTR)realloc(szEnglishBuf, dwBufSize);
if (pNewBuf != NULL) {
szEnglishBuf = pNewBuf;
dwEnglishBufSize = dwBufSize;
pdhStatus = PdhTranslate009Counter(
szPath,
szEnglishBuf,
&dwBufSize);
}
}
if (pdhStatus == ERROR_SUCCESS) {
pszPath = szEnglishBuf;
}
}
pszWidePath = T2W(pszPath);
if ( SMONCTRL_MAJ_VERSION == iVersMaj ) {
GRAPHITEM_DATA3 ItemData;
// Move properties to storage structure
ItemData.m_rgbColor = m_rgbColor;
ItemData.m_iWidth = m_iWidth;
ItemData.m_iStyle = m_iStyle;
ItemData.m_iScaleFactor = m_iScaleFactor;
assert( 0 < lstrlen(pszWidePath ) );
ItemData.m_nPathLength = lstrlen(pszWidePath);
// Write structure to stream
hr = pIStream->Write(&ItemData, sizeof(ItemData), NULL);
if (FAILED(hr)) {
goto ErrorOut;
}
// Write path name to stream
hr = pIStream->Write(pszWidePath, ItemData.m_nPathLength*sizeof(WCHAR), NULL);
if (FAILED(hr)) {
goto ErrorOut;
}
}
ErrorOut:
if (szEnglishBuf != NULL) {
free(szEnglishBuf);
}
return hr;
}
HRESULT
CGraphItem::NullItemToStream (
IN LPSTREAM pIStream,
IN INT,// iVersMaj,
IN INT // iVersMin
)
/*++
Routine Description:
NulItemToStream writes a graph item structiure with a null path name
to the stream. This is used to marked the end of the counter data in
the control's saved state.
Arguments:
pIStream - Pointer to stream interface
Return Value:
HRESULT - S_OK or stream error
--*/
{
GRAPHITEM_DATA3 ItemData;
// Zero path length, other fields needn't be initialized
ItemData.m_nPathLength = 0;
// Write structure to stream
return pIStream->Write(&ItemData, sizeof(ItemData), NULL);
}
HRESULT
CGraphItem::SaveToPropertyBag (
IN IPropertyBag* pIPropBag,
IN INT iIndex,
IN BOOL bUserMode,
IN INT, // iVersMaj,
IN INT // iVersMin
)
/*++
Routine Description:
SaveToPropertyBag writes the graph item's properties to the provided property bag
interface. The history data is saved as part of the properties.
Arguments:
pIPropBag - Pointer to property bag interface
fWildCard
iVersMaj
iVersMin
Return Value:
HRESULT - S_OK or property bag error
--*/
{
HRESULT hr = S_OK;
TCHAR szPath[MAX_PATH];
PHIST_CONTROL pHistCtrl;
VARIANT vValue;
TCHAR szCounterName[16];
TCHAR szPropertyName[16+16];
DWORD dwCounterNameBytes;
DWORD dwCounterNameLength;
LPTSTR pszNext;
LPTSTR szEnglishBuf = NULL;
DWORD dwEnglishBufSize = 0;
LPTSTR pszPath;
DWORD dwBufSize;
LPTSTR pNewBuf;
PDH_STATUS pdhStatus;
USES_CONVERSION
// Write properties
// Write path name
_stprintf ( szCounterName, _T("%s%05d."), _T("Counter"), iIndex );
dwCounterNameLength = lstrlen (szCounterName);
dwCounterNameBytes = dwCounterNameLength * sizeof (TCHAR);
//
// Generate full path name. (machine\object\instance\counter format)
//
FormPath(szPath, FALSE);
pszPath = szPath;
//
// Initialize the locale path buffer
//
if (dwEnglishBufSize == 0) {
dwEnglishBufSize = (MAX_PATH + 1) * sizeof(TCHAR);
szEnglishBuf = (LPTSTR) malloc(dwEnglishBufSize);
if (szEnglishBuf == NULL) {
dwEnglishBufSize = 0;
}
}
if (szEnglishBuf != NULL) {
//
// Translate counter name from Localization into English
//
dwBufSize = dwEnglishBufSize;
pdhStatus = PdhTranslate009Counter(
szPath,
szEnglishBuf,
&dwBufSize);
if (pdhStatus == PDH_MORE_DATA) {
pNewBuf = (LPTSTR)realloc(szEnglishBuf, dwBufSize);
if (pNewBuf != NULL) {
szEnglishBuf = pNewBuf;
dwEnglishBufSize = dwBufSize;
pdhStatus = PdhTranslate009Counter(
szPath,
szEnglishBuf,
&dwBufSize);
}
}
if (pdhStatus == ERROR_SUCCESS) {
pszPath = szEnglishBuf;
}
}
//
// Save the counter path into property bag
//
memcpy ( szPropertyName, szCounterName, dwCounterNameBytes );
pszNext = szPropertyName + dwCounterNameLength;
lstrcpy ( pszNext, _T("Path") );
hr = StringToPropertyBag (
pIPropBag,
szPropertyName,
pszPath );
if (szEnglishBuf != NULL) {
free(szEnglishBuf);
}
// Write visual properties
if ( SUCCEEDED( hr ) ){
lstrcpy ( pszNext, _T("Color") );
hr = IntegerToPropertyBag ( pIPropBag, szPropertyName, m_rgbColor );
}
if ( SUCCEEDED( hr ) ){
lstrcpy ( pszNext, _T("Width") );
hr = IntegerToPropertyBag ( pIPropBag, szPropertyName, m_iWidth );
}
if ( SUCCEEDED( hr ) ){
lstrcpy ( pszNext, _T("LineStyle") );
hr = IntegerToPropertyBag ( pIPropBag, szPropertyName, m_iStyle );
}
if ( SUCCEEDED( hr ) ){
INT iLocalFactor = m_iScaleFactor;
lstrcpy ( pszNext, _T("ScaleFactor") );
if ( INT_MAX == iLocalFactor ) {
// Save actual scale factor in case the counter cannot be
// validated when the property bag file is opened.
// lDefaultScale is 0 if never initialized.
iLocalFactor = m_CounterInfo.lDefaultScale;
}
hr = IntegerToPropertyBag ( pIPropBag, szPropertyName, iLocalFactor );
}
// Write history data only if live display, data exists and not in design mode.
// Log data is rebuilt from the log file.
pHistCtrl = m_pCtrl->HistoryControl();
if ( ( pHistCtrl->nSamples > 0)
#if !_LOG_INCLUDE_DATA
&& ( !pHistCtrl->bLogSource )
#endif
&& bUserMode ) {
LPTSTR pszData = NULL;
DWORD dwMaxStrLen = ( pHistCtrl->nMaxSamples * MAX_DOUBLE_TEXT_SIZE ) + 1;
pszData = new TCHAR[ dwMaxStrLen ];
if ( NULL == pszData ) {
hr = E_OUTOFMEMORY;
}
// Write the current statistics.
if ( SUCCEEDED(hr) ) {
double dMin;
double dMax;
double dAvg;
LONG lStatus;
hr = GetStatistics ( &dMax, &dMin, &dAvg, &lStatus );
if (SUCCEEDED(hr) && IsSuccessSeverity(lStatus)) {
lstrcpy ( pszNext, _T("Minimum") );
hr = DoubleToPropertyBag ( pIPropBag, szPropertyName, dMin );
if ( SUCCEEDED(hr) ) {
lstrcpy ( pszNext, _T("Maximum") );
hr = DoubleToPropertyBag ( pIPropBag, szPropertyName, dMax );
}
if ( SUCCEEDED(hr) ) {
lstrcpy ( pszNext, _T("Average") );
hr = DoubleToPropertyBag ( pIPropBag, szPropertyName, dAvg );
}
if ( SUCCEEDED(hr) ) {
lstrcpy ( pszNext, _T("StatisticStatus") );
hr = IntegerToPropertyBag ( pIPropBag, szPropertyName, lStatus );
}
}
}
if ( SUCCEEDED(hr) ) {
INT i;
LPTSTR pszTemp;
HRESULT hrConvert = S_OK;
double dblValue;
DWORD dwTmpStat;
DWORD dwCurrentDataLength;
DWORD dwTempLength;
LPTSTR pszDataNext;
lstrcpy ( pszData, _T("") );
dwCurrentDataLength = 0;
pszDataNext = pszData;
for ( i = 0;
( S_OK == hrConvert ) && ( i < pHistCtrl->nSamples );
i++ ) {
if ( ERROR_SUCCESS != HistoryValue(i, &dblValue, &dwTmpStat) ) {
dblValue = -1.0;
} else if (!IsSuccessSeverity(dwTmpStat)) {
dblValue = -1.0;
}
VariantInit( &vValue );
vValue.vt = VT_R8;
vValue.dblVal = dblValue;
hrConvert = VariantChangeTypeEx( &vValue, &vValue, LCID_SCRIPT, VARIANT_NOUSEROVERRIDE, VT_BSTR );
pszTemp = W2T( vValue.bstrVal);
dwTempLength = lstrlen ( pszTemp );
// Extra TCHAR for NULL terminator
if ( dwTempLength + dwCurrentDataLength + sizeof(TCHAR) > dwMaxStrLen ) {
TCHAR* pszNewData;
dwMaxStrLen *= 2;
// Allocate a new buffer
pszNewData = new TCHAR[ dwMaxStrLen ];
if ( NULL != pszNewData ) {
memcpy ( pszNewData, pszData, dwCurrentDataLength * sizeof (TCHAR) );
delete pszData;
pszData = pszNewData;
pszDataNext = pszData;
} else {
hr = E_OUTOFMEMORY;
}
}
if ( SUCCEEDED(hr)) {
if ( i > 0 ) {
lstrcpy ( pszDataNext, _T("\t") );
dwCurrentDataLength += 1; // char count for _T("\t");
pszDataNext += 1;
}
memcpy ( pszDataNext, pszTemp, dwTempLength * sizeof(TCHAR) );
dwCurrentDataLength += dwTempLength;
pszDataNext += dwTempLength;
}
VariantClear( &vValue );
}
lstrcpy ( pszDataNext, _T("") );
}
lstrcpy ( pszNext, _T("Data") );
hr = StringToPropertyBag (
pIPropBag,
szPropertyName,
pszData );
if ( NULL != pszData ) {
delete ( pszData );
}
}
return hr;
}
HRESULT
CGraphItem::LoadFromPropertyBag (
IN IPropertyBag* pIPropBag,
IN IErrorLog* pIErrorLog,
IN INT iIndex,
IN INT, // iVersMaj,
IN INT, // iVersMin
IN INT iSampleCount
)
/*++
Routine Description:
LoadFromPropertyBag loads the graph item's properties from the provided property bag
interface.
Arguments:
pIPropBag - Pointer to property bag interface
iVersMaj
iVersMin
Return Value:
HRESULT - S_OK or property bag error
--*/
{
HRESULT hr = S_OK;
TCHAR szCounterName[16];
TCHAR szPropertyName[16+16];
OLE_COLOR clrValue;
INT iValue;
LPTSTR pszData = NULL;
int iBufSizeCurrent = 0;
int iBufSize;
USES_CONVERSION
_stprintf ( szCounterName, _T("%s%05d."), _T("Counter"), iIndex );
// Read visual properties
lstrcpy ( szPropertyName, szCounterName );
lstrcat ( szPropertyName, _T("Color") );
hr = OleColorFromPropertyBag ( pIPropBag, pIErrorLog, szPropertyName, clrValue );
if ( SUCCEEDED(hr) ) {
hr = put_Color ( clrValue );
}
lstrcpy ( szPropertyName, szCounterName );
lstrcat ( szPropertyName, _T("Width") );
hr = IntegerFromPropertyBag ( pIPropBag, pIErrorLog, szPropertyName, iValue );
if ( SUCCEEDED(hr) ) {
hr = put_Width ( iValue );
}
lstrcpy ( szPropertyName, szCounterName );
lstrcat ( szPropertyName, _T("LineStyle") );
hr = IntegerFromPropertyBag ( pIPropBag, pIErrorLog, szPropertyName, iValue );
if ( SUCCEEDED(hr) ) {
hr = put_LineStyle ( iValue );
}
lstrcpy ( szPropertyName, szCounterName );
lstrcat ( szPropertyName, _T("ScaleFactor") );
hr = IntegerFromPropertyBag ( pIPropBag, pIErrorLog, szPropertyName, iValue );
if ( SUCCEEDED(hr) ) {
hr = put_ScaleFactor ( iValue );
}
if ( 0 < iSampleCount ) {
if ( NULL != m_pFmtCtr )
delete m_pFmtCtr;
m_pFmtCtr = new double[MAX_GRAPH_SAMPLES];
if ( NULL == m_pFmtCtr ) {
hr = E_OUTOFMEMORY;
} else {
INT iFmtIndex;
for (iFmtIndex = 0; iFmtIndex < MAX_GRAPH_SAMPLES; iFmtIndex++ ) {
m_pFmtCtr[iFmtIndex] = -1.0;
}
}
if ( SUCCEEDED(hr) ) {
lstrcpy ( szPropertyName, szCounterName );
lstrcat ( szPropertyName, _T("Data") );
iBufSize = iBufSizeCurrent;
hr = StringFromPropertyBag (
pIPropBag,
pIErrorLog,
szPropertyName,
pszData,
iBufSize );
if ( SUCCEEDED(hr) &&
iBufSize > iBufSizeCurrent ) {
if ( NULL != pszData ) {
delete pszData;
}
pszData = new TCHAR[ iBufSize ];
if ( NULL == pszData ) {
hr = E_OUTOFMEMORY;
} else {
lstrcpy ( pszData, _T("") );
iBufSizeCurrent = iBufSize;
hr = StringFromPropertyBag (
pIPropBag,
pIErrorLog,
szPropertyName,
pszData,
iBufSize );
}
}
}
// Read the samples in buffer order.
if ( NULL != pszData && SUCCEEDED ( hr ) ) {
INT iDataIndex;
double dValue = 0;
TCHAR* pNextData;
TCHAR* pDataEnd;
pNextData = pszData;
pDataEnd = pszData + lstrlen(pszData);
for ( iDataIndex = 0; iDataIndex < iSampleCount; iDataIndex++ ) {
if ( pNextData < pDataEnd ) {
hr = GetNextValue ( pNextData, dValue );
} else {
hr = E_FAIL;
}
if ( SUCCEEDED(hr) ) {
SetHistoryValue ( iDataIndex, dValue );
} else {
SetHistoryValue ( iDataIndex, -1.0 );
// iSampleCount = 0;
// Control loaded fine, just no data.
hr = NOERROR;
}
}
}
if ( NULL != pszData ) {
delete pszData;
}
// Read the current statistics.
lstrcpy ( szPropertyName, szCounterName );
lstrcat ( szPropertyName, _T("Maximum") );
hr = DoubleFromPropertyBag ( pIPropBag, pIErrorLog, szPropertyName, m_dFmtMax );
lstrcpy ( szPropertyName, szCounterName );
lstrcat ( szPropertyName, _T("Minimum") );
hr = DoubleFromPropertyBag ( pIPropBag, pIErrorLog, szPropertyName, m_dFmtMin );
lstrcpy ( szPropertyName, szCounterName );
lstrcat ( szPropertyName, _T("Average") );
hr = DoubleFromPropertyBag ( pIPropBag, pIErrorLog, szPropertyName, m_dFmtAvg );
lstrcpy ( szPropertyName, szCounterName );
lstrcat ( szPropertyName, _T("StatisticStatus") );
hr = IntegerFromPropertyBag ( pIPropBag, pIErrorLog, szPropertyName, (INT&)m_lFmtStatus );
}
return hr;
}
HRESULT
CGraphItem::AddToQuery (
IN HQUERY hQuery
)
/*++
Routine Description:
AddToQuery adds a counter to the provided query based on the item's
pathname. It also allocates an array of raw counter value structures for
holding the counter's sample history.
Arguments:
hQuery - Handle to query
Return Value:
Boolean status - TRUE = success
--*/
{
HCOUNTER hCounter;
INT i;
HRESULT hr;
TCHAR achPath[MAX_PATH];
PDH_COUNTER_INFO ci;
DWORD size;
PHIST_CONTROL pHistCtrl = m_pCtrl->HistoryControl();
// Can't add if already in query
if (m_hCounter != NULL)
return E_FAIL;
// Allocate memory for maximum sample count
if (pHistCtrl->nMaxSamples > 0) {
// if log data
if (pHistCtrl->bLogSource) {
// allocate space for formatted values
m_pLogData = new LOG_ENTRY_DATA[pHistCtrl->nMaxSamples];
if (m_pLogData == NULL)
return E_OUTOFMEMORY;
// Clear the statistics
m_dLogMax = 0.0;
m_dLogMin = 0.0;
m_dLogAvg = 0.0;
}
else {
// else allocate raw value space
m_pRawCtr = new PDH_RAW_COUNTER[pHistCtrl->nMaxSamples];
if ( NULL == m_pRawCtr )
return E_OUTOFMEMORY;
// Clear all status flags
for (i=0; i < pHistCtrl->nMaxSamples; i++)
m_pRawCtr[i].CStatus = PDH_CSTATUS_INVALID_DATA;
}
}
// Create the counter object
FormPath(achPath, FALSE);
hr = PdhAddCounter(hQuery, achPath, 0, &hCounter);
if (IsErrorSeverity(hr)) {
delete m_pRawCtr;
m_pRawCtr = NULL;
return hr;
}
size = sizeof(ci);
hr = PdhGetCounterInfo (
hCounter,
FALSE,
&size,
&ci);
if (hr == ERROR_SUCCESS) {
m_CounterInfo = ci;
if ( INT_MAX == m_iScaleFactor ) {
m_dScale = pow ((double)10.0f, (double)ci.lDefaultScale);
}
}
m_hCounter = hCounter;
return NOERROR;
}
HRESULT
CGraphItem::RemoveFromQuery (
VOID
)
/*++
Routine Description:
RemoveFromQuery deletes the item's counter and releases its history array.
Arguments:
None.
Return Value:
Boolean status - TRUE = success
--*/
{
// If no counter handle, not attached to query
if (m_hCounter == NULL)
return S_FALSE;
// Delete the counter
PdhRemoveCounter(m_hCounter);
m_hCounter = NULL;
// Free the buffers
if (m_pLogData) {
delete m_pLogData;
m_pLogData = NULL;
}
if (m_pRawCtr) {
delete m_pRawCtr;
m_pRawCtr = NULL;
}
if (m_pFmtCtr) {
delete m_pFmtCtr;
m_pFmtCtr = NULL;
}
return NOERROR;
}
void
CGraphItem::ClearHistory ( void )
/*++
Routine Description:
ClearHistory resets the raw counter buffer values to Invalid.
Arguments:
None.
Return Value:
None.
--*/
{
INT i;
// Clear all status flags
if ( NULL != m_pRawCtr ) {
for (i=0; i < m_pCtrl->HistoryControl()->nMaxSamples; i++) {
m_pRawCtr[i].CStatus = PDH_CSTATUS_INVALID_DATA;
}
}
}
VOID
CGraphItem::UpdateHistory (
IN BOOL bValidSample
)
/*++
Routine Description:
UpdateHistory reads the raw value for the counter and stores it in the
history slot specified by the history control.
Arguments:
bValidSample - True if raw value is available, False if missed sample
Return Value:
None.
--*/
{
DWORD dwCtrType;
// Make sure there is a counter handle
if (m_hCounter == NULL)
return;
if (bValidSample) {
// Read the raw value
if ( NULL != m_pRawCtr ) {
PdhGetRawCounterValue(m_hCounter, &dwCtrType,
&m_pRawCtr[m_pCtrl->HistoryControl()->iCurrent]);
}
} else {
// Mark value failed
if ( NULL != m_pRawCtr ) {
m_pRawCtr[m_pCtrl->HistoryControl()->iCurrent].CStatus = PDH_CSTATUS_INVALID_DATA;
}
}
}
PDH_STATUS
CGraphItem::HistoryValue (
IN INT iIndex,
OUT double *pdValue,
OUT DWORD *pdwStatus
)
/*++
Routine Description:
HistoryValue computes a formated sample value from the selected raw history
sample. The calculation is actually based on the the specified sample plus
the preceding sample.
Arguments:
iIndex - Index of desired sample (0 = current, 1 = previous, ...)
pdValue - Pointer to return value
pdwStatus - Pointer to return counter status (PDH_CSTATUS_...)
Return Value:
Error status
--*/
{
PDH_STATUS stat = ERROR_INVALID_PARAMETER;
INT iPrevIndex;
INT iCurrIndex;
PDH_FMT_COUNTERVALUE FmtValue;
PHIST_CONTROL pHistCtrl = m_pCtrl->HistoryControl();
// Check for negative index
if ( iIndex >= 0 ) {
// If sample not available from cache or data, return invalid data status
if ( NULL == m_pFmtCtr
&& ( m_hCounter == NULL || iIndex + 1 >= pHistCtrl->nSamples ) )
{
*pdwStatus = PDH_CSTATUS_INVALID_DATA;
*pdValue = 0.0;
stat = ERROR_SUCCESS;
} else {
// if log source, index back from last sample
if (m_pCtrl->IsLogSource()) {
*pdValue = m_pLogData[pHistCtrl->nSamples - iIndex - 1].m_dAvg;
*pdwStatus = (*pdValue >= 0.0) ? PDH_CSTATUS_VALID_DATA : PDH_CSTATUS_INVALID_DATA;
stat = ERROR_SUCCESS;
} else {
// Determine history array index of sample
iCurrIndex = pHistCtrl->iCurrent - iIndex;
if (iCurrIndex < 0)
iCurrIndex += pHistCtrl->nMaxSamples;
// Check to determine if loading from property bag
if ( NULL == m_pFmtCtr ) {
// Need previous sample as well
if (iCurrIndex > 0)
iPrevIndex = iCurrIndex - 1;
else
iPrevIndex = pHistCtrl->nMaxSamples - 1;
// Compute the formatted value
if ( NULL != m_pRawCtr ) {
stat = PdhCalculateCounterFromRawValue(m_hCounter, PDH_FMT_DOUBLE | PDH_FMT_NOCAP100,
&m_pRawCtr[iCurrIndex], &m_pRawCtr[iPrevIndex],
&FmtValue);
// Return value and status
*pdValue = FmtValue.doubleValue;
*pdwStatus = FmtValue.CStatus;
} else {
stat = ERROR_GEN_FAILURE; // Todo: More specific error
}
} else {
// Loading from property bag
*pdValue = m_pFmtCtr[iCurrIndex];
if ( 0 <= m_pFmtCtr[iCurrIndex] ) {
*pdwStatus = ERROR_SUCCESS;
} else {
*pdwStatus = PDH_CSTATUS_INVALID_DATA;
}
stat = ERROR_SUCCESS;
}
}
}
}
return stat;
}
void
CGraphItem::SetHistoryValue (
IN INT iIndex,
OUT double dValue
)
/*++
Routine Description:
SetHistoryValue loads a formated sample value for the specified sample index.
This method is used when loading the control from a property bag.
Arguments:
iIndex - Index of desired sample (0 = current, 1 = previous, ...)
dValue - Value
Return Value:
Error status
--*/
{
PHIST_CONTROL pHistCtrl = m_pCtrl->HistoryControl();
INT iRealIndex;
// Check for negative index
if ( (iIndex < 0) || ( iIndex >= pHistCtrl->nMaxSamples) ) {
return;
}
if ( NULL == m_pFmtCtr ) {
return;
}
// if log source, index back from last sample
if (m_pCtrl->IsLogSource()) {
return;
} else {
// Determine history array index of sample
iRealIndex = pHistCtrl->iCurrent - iIndex;
if (iRealIndex < 0)
iRealIndex += pHistCtrl->nSamples;
m_pFmtCtr[iRealIndex] = dValue;
}
return;
}
PDH_STATUS
CGraphItem::GetLogEntry(
const INT iIndex,
double *dMin,
double *dMax,
double *dAvg,
DWORD *pdwStatus
)
{
INT iLocIndex = iIndex;
*dMin = -1.0;
*dMax = -1.0;
*dAvg = -1.0;
*pdwStatus = PDH_CSTATUS_INVALID_DATA;
if (m_pLogData == NULL)
return PDH_NO_DATA;
if (iLocIndex < 0 || iLocIndex >= m_pCtrl->HistoryControl()->nMaxSamples)
return PDH_INVALID_ARGUMENT;
// Subtract 1 because array is zero-based
// Subtract another 1 because ??
iLocIndex = ( m_pCtrl->HistoryControl()->nMaxSamples - 2 ) - iIndex;
if (m_pLogData[iLocIndex].m_dMax < 0.0) {
*pdwStatus = PDH_CSTATUS_INVALID_DATA;
} else {
*dMin = m_pLogData[iLocIndex].m_dMin;
*dMax = m_pLogData[iLocIndex].m_dMax;
*dAvg = m_pLogData[iLocIndex].m_dAvg;
*pdwStatus = PDH_CSTATUS_VALID_DATA;
}
return ERROR_SUCCESS;
}
PDH_STATUS
CGraphItem::GetLogEntryTimeStamp(
const INT iIndex,
LONGLONG& rLastTimeStamp,
DWORD *pdwStatus
)
{
INT iLocIndex = iIndex;
rLastTimeStamp = 0;
*pdwStatus = PDH_CSTATUS_INVALID_DATA;
if (m_pLogData == NULL)
return PDH_NO_DATA;
if (iIndex < 0 || iIndex >= m_pCtrl->HistoryControl()->nMaxSamples)
return PDH_INVALID_ARGUMENT;
if ( ( MIN_TIME_VALUE == *((LONGLONG*)&m_pLogData[iLocIndex].m_LastTimeStamp) )
|| ( 0 > *((LONGLONG*)&m_pLogData[iLocIndex].m_dMax) ) ) {
*pdwStatus = PDH_CSTATUS_INVALID_DATA;
} else {
*pdwStatus = PDH_CSTATUS_VALID_DATA;
}
rLastTimeStamp = *((LONGLONG*)&m_pLogData[iLocIndex].m_LastTimeStamp);
return ERROR_SUCCESS;
}
void
CGraphItem::SetLogEntry(
const INT iIndex,
const double dMin,
const double dMax,
const double dAvg )
{
if (m_pLogData) {
m_pLogData[iIndex].m_dMin = dMin;
m_pLogData[iIndex].m_dMax = dMax;
m_pLogData[iIndex].m_dAvg = dAvg;
}
}
void
CGraphItem::SetLogEntryTimeStamp (
const INT iIndex,
const FILETIME& rLastTimeStamp )
{
if (m_pLogData) {
m_pLogData[iIndex].m_LastTimeStamp.dwLowDateTime = rLastTimeStamp.dwLowDateTime;
m_pLogData[iIndex].m_LastTimeStamp.dwHighDateTime = rLastTimeStamp.dwHighDateTime;
}
}
HRESULT
CGraphItem::GetValue(
OUT double *pdValue,
OUT long *plStat
)
/*++
Routine Description:
get_Value returns the most recent sample value for the counter.
Arguments:
pdValue - Pointer to returned value
dlStatus - Pointer to returned counter status (PDH_CSTATUS_...)
Return Value:
HRESULT
--*/
{
DWORD dwTmpStat;
// Convert PDH status to HRESULT
if (HistoryValue(0, pdValue, &dwTmpStat) != 0)
return E_FAIL;
*plStat = dwTmpStat;
return NOERROR;
}
HRESULT
CGraphItem::GetStatistics (
OUT double *pdMax,
OUT double *pdMin,
OUT double *pdAvg,
OUT LONG *plStatus
)
/*++
Routine Description:
GetStatistics computes the max, min, and average values for the sample
history.
Arguments:
pdMax - Pointer to returned max value
pdMax - Pointer to returned min value
pdMax - Pointer to returned average value
plStatus - Pointer to return counter status (PDH_CSTATUS_...)
Return Value:
HRESULT
--*/
{
HRESULT hr = NOERROR;
PDH_STATUS stat = ERROR_SUCCESS;
PDH_STATISTICS StatData;
INT iFirst;
PHIST_CONTROL pHistCtrl;
// If no data collected, return invalid data status
if ( NULL == m_hCounter ) {
*plStatus = PDH_CSTATUS_INVALID_DATA;
} else {
if (m_pCtrl->IsLogSource()) {
if (m_pLogData) {
*pdMax = m_dLogMax;
*pdMin = m_dLogMin;
*pdAvg = m_dLogAvg;
*plStatus = PDH_CSTATUS_VALID_DATA;
} else {
*plStatus = PDH_CSTATUS_INVALID_DATA;
}
} else {
if ( NULL == m_pFmtCtr ) {
pHistCtrl = m_pCtrl->HistoryControl();
ZeroMemory ( &StatData, sizeof ( PDH_STATISTICS ) );
// Determine index of oldest sample
if (pHistCtrl->iCurrent < pHistCtrl->nSamples - 1) {
iFirst = pHistCtrl->iCurrent + 1;
} else {
iFirst = 0;
}
// Compute statistics over all samples
// Note that max sample count is passed (i.e., buffer length)
// not the number of actual samples
if ( NULL != m_pRawCtr ) {
stat = PdhComputeCounterStatistics (m_hCounter, PDH_FMT_DOUBLE | PDH_FMT_NOCAP100,
iFirst, pHistCtrl->nMaxSamples, m_pRawCtr, &StatData );
if ( 0 != stat )
hr = E_FAIL;
} else {
hr = E_FAIL;
}
if ( SUCCEEDED ( hr ) ) {
*plStatus = StatData.mean.CStatus;
*pdMin = StatData.min.doubleValue;
*pdMax = StatData.max.doubleValue;
*pdAvg = StatData.mean.doubleValue;
}
} else {
// Data is cached from property bag.
*pdMax = m_dFmtMax;
*pdMin = m_dFmtMin;
*pdAvg = m_dFmtAvg;
*plStatus = m_lFmtStatus;
}
}
}
return hr;
}
void
CGraphItem::SetStatistics (
IN double dMax,
IN double dMin,
IN double dAvg,
IN LONG lStatus
)
/*++
Routine Description:
SetStatistics sets the max, min, and average values for the sample
history. It is used by LoadFromPropertyBag only.
Arguments:
dMax - max value
dMin - min value
dAvg - average value
lStatus - counter status (PDH_CSTATUS_...)
Return Value:
HRESULT
--*/
{
if (!m_pCtrl->IsLogSource()) {
m_dFmtMax = dMax;
m_dFmtMin = dMin;
m_dFmtAvg = dAvg;
m_lFmtStatus = lStatus;
}
}
/*
* CGraphItem::QueryInterface
* CGraphItem::AddRef
* CGraphItem::Release
*/
STDMETHODIMP CGraphItem::QueryInterface(REFIID riid
, LPVOID *ppv)
{
*ppv = NULL;
if (riid == IID_ICounterItem || riid == IID_IUnknown)
{
*ppv = this;
}
else if (riid == DIID_DICounterItem)
{
if (m_pImpIDispatch == NULL)
{
m_pImpIDispatch = new CImpIDispatch(this, this);
if (m_pImpIDispatch == NULL)
return E_OUTOFMEMORY;
m_pImpIDispatch->SetInterface(DIID_DICounterItem, this);
*ppv = m_pImpIDispatch;
}
else
{
*ppv = m_pImpIDispatch;
}
}
else
{
return E_NOINTERFACE;
}
((LPUNKNOWN)*ppv)->AddRef();
return NOERROR;
}
STDMETHODIMP_(ULONG) CGraphItem::AddRef(void)
{
return ++m_cRef;
}
STDMETHODIMP_(ULONG) CGraphItem::Release(void)
{
if (--m_cRef == 0)
{
delete this;
return 0;
}
return m_cRef;
}
// Get/Put Color
STDMETHODIMP CGraphItem::put_Color (
IN OLE_COLOR Color
)
{
COLORREF rgbColor;
HRESULT hReturn;
hReturn = OleTranslateColor(Color, NULL, &rgbColor);
if ( S_OK == hReturn ) {
m_rgbColor = rgbColor;
InvalidatePen();
InvalidateBrush();
}
return hReturn;
}
STDMETHODIMP CGraphItem::get_Color (
OUT OLE_COLOR *pColor
)
{
*pColor = m_rgbColor;
return NOERROR;
}
// Get/Put Width
STDMETHODIMP CGraphItem::put_Width (
IN INT iWidthInPixels)
{
if ( ( iWidthInPixels > 0 ) && (iWidthInPixels <= NumWidthIndices() ) ) {
m_iWidth = iWidthInPixels;
InvalidatePen();
return NOERROR;
} else {
return E_INVALIDARG;
}
}
STDMETHODIMP CGraphItem::get_Width (
OUT INT* piWidthInPixels
)
{
*piWidthInPixels = m_iWidth;
return NOERROR;
}
// Get/Put Line Style
STDMETHODIMP CGraphItem::put_LineStyle (
IN INT iLineStyle
)
{
if ( ( iLineStyle >= 0 ) && (iLineStyle < NumStyleIndices() ) ) {
m_iStyle = iLineStyle;
InvalidatePen();
return NOERROR;
} else {
return E_INVALIDARG;
}
}
STDMETHODIMP CGraphItem::get_LineStyle (
OUT INT* piLineStyle
)
{
*piLineStyle = m_iStyle;
return NOERROR;
}
// Get/Put Scale
STDMETHODIMP CGraphItem::put_ScaleFactor (
IN INT iScaleFactor
)
{
HRESULT hr = NOERROR;
if ( ( INT_MAX == iScaleFactor )
|| ( ( iScaleFactor >= PDH_MIN_SCALE ) && (iScaleFactor <= PDH_MAX_SCALE) ) ) {
PDH_COUNTER_INFO ci;
DWORD size;
m_iScaleFactor = iScaleFactor;
if ( INT_MAX == iScaleFactor )
{
if ( NULL != Handle() ) {
size = sizeof(ci);
hr = PdhGetCounterInfo (
Handle(),
FALSE,
&size,
&ci);
if (hr == ERROR_SUCCESS) {
m_dScale = pow ((double)10.0f, (double)ci.lDefaultScale);
m_CounterInfo = ci;
}
} else {
// m_dScale remains at previous value (default=1)
hr = PDH_INVALID_HANDLE;
}
}
else
{
m_dScale = pow ((double)10.0, (double)iScaleFactor);
hr = NOERROR;
}
} else {
hr = E_INVALIDARG;
}
return hr;
}
STDMETHODIMP CGraphItem::get_ScaleFactor (
OUT INT* piScaleFactor
)
{
*piScaleFactor = m_iScaleFactor;
return NOERROR;
}
STDMETHODIMP CGraphItem::get_Path (
OUT BSTR* pstrPath
)
{
TCHAR achPath[MAX_PATH];
USES_CONVERSION
FormPath(achPath, FALSE);
*pstrPath = SysAllocString(T2W(achPath));
if ( NULL == *pstrPath ) {
return E_OUTOFMEMORY;
} else {
return NOERROR;
}
}
STDMETHODIMP CGraphItem::get_Value (
OUT double* pdValue
)
{
DWORD dwTmpStat;
double dValue;
// Convert PDH status to HRESULT
if (HistoryValue(0, &dValue, &dwTmpStat) != 0) {
dValue = -1.0;
}
else
if (!IsSuccessSeverity(dwTmpStat)) {
dValue = -1.0;
}
*pdValue = dValue;
return NOERROR;
}
HPEN CGraphItem::Pen(void)
{
// if pen not valid
if (m_hPen == NULL)
{
// create a new one based on current attributes
m_hPen = CreatePen(m_iStyle, m_iWidth, m_rgbColor);
// if can't do it, use a stock object (this can't fail)
if (m_hPen == NULL)
m_hPen = (HPEN)GetStockObject(BLACK_PEN);
}
return m_hPen;
}
HBRUSH CGraphItem::Brush(void)
{
// if brush is not valid
if (m_hBrush == NULL)
{
m_hBrush = CreateSolidBrush(m_rgbColor);
if (m_hBrush == NULL)
m_hBrush = (HBRUSH)GetStockObject(BLACK_BRUSH);
}
return m_hBrush;
}
void CGraphItem::InvalidatePen(void)
{
if (m_hPen != NULL)
{
DeleteObject(m_hPen);
m_hPen = NULL;
}
}
void CGraphItem::InvalidateBrush(void)
{
if (m_hBrush != NULL)
{
DeleteObject(m_hBrush);
m_hBrush = NULL;
}
}
CGraphItem*
CGraphItem::Next (
void
)
{
PCInstanceNode pInstance;
PCObjectNode pObject;
PCMachineNode pMachine;
if (m_pNextItem)
return m_pNextItem;
else if ( NULL != m_pInstance->Next()) {
pInstance = m_pInstance->Next();
return pInstance->FirstItem();
} else if ( NULL != m_pInstance->m_pObject->Next()) {
pObject = m_pInstance->m_pObject->Next();
return pObject->FirstInstance()->FirstItem();
} else if ( NULL != m_pInstance->m_pObject->m_pMachine->Next()) {
pMachine = m_pInstance->m_pObject->m_pMachine->Next();
return pMachine->FirstObject()->FirstInstance()->FirstItem();
} else {
return NULL;
}
}
void
CGraphItem::FormPath (
LPTSTR pszPath,
BOOL fWildCard
)
{
LPTSTR pszNext = pszPath;
if ( m_fLocalMachine )
pszPath[0] = 0;
else
lstrcpy ( pszPath, Machine()->Name() );
pszNext = pszNext + lstrlen ( pszPath );
lstrcpy ( pszNext, _T("\\") );
pszNext += 1; // Length of _T("\\");
lstrcpy ( pszNext, Object()->Name() );
pszNext += lstrlen ( Object()->Name() );
if (fWildCard) {
lstrcpy ( pszNext,_T("(*)") );
pszNext += 3; // Length of _T("(*)");
}
else if ( Instance()->Name()[0] ) {
lstrcpy ( pszNext,_T("("));
pszNext += 1; // Length of _T("(");
lstrcpy ( pszNext,Instance()->Name() );
pszNext += lstrlen ( Instance()->Name() );
lstrcpy ( pszNext,_T(")") );
pszNext += 1; // Length of _T("(");
}
lstrcpy ( pszNext, _T("\\") );
pszNext += 1; // Length of _T("\\");
lstrcpy ( pszNext,Counter()->Name() );
}
void
CGraphItem::Delete (
BOOL bPropogateUp
)
//
// This method just provides a convenient access to the DeleteCounter method
// of the control when you only have a pointer to the graph item.
//
{
m_pCtrl->DeleteCounter(this, bPropogateUp);
}
HRESULT
CGraphItem::GetNextValue (
TCHAR*& pszNext,
double& rdValue )
{
HRESULT hr = NOERROR;
TCHAR szValue[MAX_DOUBLE_TEXT_SIZE + 1];
INT iDataLen;
INT iLen;
VARIANT vValue;
rdValue = -1.0;
iDataLen = wcscspn (pszNext, L"\t");
iLen = min ( iDataLen, MAX_DOUBLE_TEXT_SIZE );
lstrcpyn ( szValue, pszNext, iLen + 1 );
szValue[iLen] = L'\0';
VariantInit( &vValue );
vValue.vt = VT_BSTR;
vValue.bstrVal = SysAllocString ( szValue );
hr = VariantChangeTypeEx( &vValue, &vValue, LCID_SCRIPT, VARIANT_NOUSEROVERRIDE, VT_R8 );
if ( SUCCEEDED(hr) ) {
rdValue = vValue.dblVal;
}
pszNext += iDataLen + 1 ;
VariantClear( &vValue );
return hr;
}
BOOL
CGraphItem::IsRateCounter ( void )
{
BOOL bReturn = FALSE;
DWORD dwRateMask = PERF_TYPE_COUNTER | PERF_COUNTER_RATE;
DWORD dwFractionMask = PERF_TYPE_COUNTER | PERF_COUNTER_FRACTION;
if ( dwRateMask == ( m_CounterInfo.dwType & dwRateMask ) ) {
bReturn = TRUE;
}
else if ( dwFractionMask == ( m_CounterInfo.dwType & dwFractionMask ) ) {
bReturn = TRUE;
}
return bReturn;
}
Reference in a new issue Copy permalink