archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: daad8a087a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'daad8a087a'
${ noResults }
windows-xp/Source/XPSP1/NT/shell/applets/taskmgr/netpage.cpp

3791 lines
93 KiB
Raw Blame History

//+-------------------------------------------------------------------------
//
// TaskMan - NT TaskManager
// Copyright (C) Microsoft
//
// File: netpage.cpp
//
// History: Oct-18-2000 Olaf Miller Created
//
//--------------------------------------------------------------------------
#include "precomp.h"
#define MIN_GRAPH_HEIGHT 120
#define SCROLLBAR_WIDTH 17
#define INVALID_VALUE 0xFFFFFFFF
#define PERCENT_SHIFT 10000000
#define PERCENT_DECIMAL_POINT 7
// Determines how the graphs are drawen (zoomed level)
//
static int g_NetScrollamount = 0;
extern TCHAR g_szG[];
extern TCHAR g_szM[];
extern TCHAR g_szK[];
extern TCHAR g_szZero[];
extern TCHAR g_szPackets[];
extern TCHAR g_szBitsPerSec[];
extern TCHAR g_szScaleFont[];
extern TCHAR g_szPercent[];
extern TCHAR g_szNonOperational[];
extern TCHAR g_szUnreachable[];
extern TCHAR g_szDisconnected[];
extern TCHAR g_szConnecting[];
extern TCHAR g_szConnected[];
extern TCHAR g_szOperational[];
extern TCHAR g_szUnknownStatus[];
extern TCHAR g_szGroupThousSep[];
extern TCHAR g_szDecimal[];
extern ULONG g_ulGroupSep;
static HGDIOBJ hOld2;
// Window Proc the Network Tab
//
INT_PTR CALLBACK NetPageProc(
HWND hwnd, // handle to dialog box
UINT uMsg, // message
WPARAM wParam, // first message parameter
LPARAM lParam // second message parameter
);
// Colors of the pens
//
static const COLORREF aNetColors[] =
{
RGB(255, 000, 0),
RGB(255, 255, 0),
RGB(000, 255, 0),
};
// Default values for the Networking Page's statistics columns
//
struct
{
SHORT Format;
SHORT Width;
} NetColumnDefaults[NUM_NETCOLUMN] =
{
{ LVCFMT_LEFT, 96 }, // COL_ADAPTERNAME
{ LVCFMT_LEFT, 96 }, // COL_ADAPTERDESC
{ LVCFMT_RIGHT, 96 }, // COL_NETWORKUTIL
{ LVCFMT_RIGHT, 60 }, // COL_LINKSPEED
{ LVCFMT_RIGHT, 96 }, // COL_STATE
{ LVCFMT_RIGHT, 70 }, // COL_BYTESSENTTHRU
{ LVCFMT_RIGHT, 70 }, // COL_BYTESRECTHRU
{ LVCFMT_RIGHT, 75 }, // COL_BYTESTOTALTHRU
{ LVCFMT_RIGHT, 70 }, // COL_BYTESSENT
{ LVCFMT_RIGHT, 70 }, // COL_BYTESREC
{ LVCFMT_RIGHT, 50 }, // COL_BYTESTOTAL
{ LVCFMT_RIGHT, 70 }, // COL_BYTESSENTPERINTER
{ LVCFMT_RIGHT, 70 }, // COL_BYTESRECPERINTER
{ LVCFMT_RIGHT, 70 }, // COL_BYTESTOTALPERINTER
{ LVCFMT_RIGHT, 70 }, // COL_UNICASTSSSENT
{ LVCFMT_RIGHT, 70 }, // COL_UNICASTSREC
{ LVCFMT_RIGHT, 50 }, // COL_UNICASTSTOTAL
{ LVCFMT_RIGHT, 70 }, // COL_UNICASTSSENTPERINTER
{ LVCFMT_RIGHT, 70 }, // COL_UNICASTSRECPERINTER
{ LVCFMT_RIGHT, 70 }, // COL_UNICASTSTOTALPERINTER
{ LVCFMT_RIGHT, 70 }, // COL_NONUNICASTSSSENT
{ LVCFMT_RIGHT, 70 }, // COL_NONUNICASTSREC
{ LVCFMT_RIGHT, 50 }, // COL_NONUNICASTSTOTAL
{ LVCFMT_RIGHT, 70 }, // COL_NONUNICASTSSENTPERINTER
{ LVCFMT_RIGHT, 70 }, // COL_NONUNICASTSRECPERINTER
{ LVCFMT_RIGHT, 70 }, // COL_NONUNICASTSTOTALPERINTER
};
// List of the name of the columns. These strings appear in the column header
//
static const _aIDNetColNames[NUM_NETCOLUMN] =
{
IDS_COL_ADAPTERNAME,
IDS_COL_ADAPTERDESC,
IDS_COL_NETWORKUTIL,
IDS_COL_LINKSPEED,
IDS_COL_STATE,
IDS_COL_BYTESSENTTHRU,
IDS_COL_BYTESRECTHRU,
IDS_COL_BYTESTOTALTHRU,
IDS_COL_BYTESSENT,
IDS_COL_BYTESREC,
IDS_COL_BYTESTOTAL,
IDS_COL_BYTESSENTPERINTER,
IDS_COL_BYTESRECPERINTER,
IDS_COL_BYTESTOTALPERINTER,
IDS_COL_UNICASTSSSENT,
IDS_COL_UNICASTSREC,
IDS_COL_UNICASTSTOTAL,
IDS_COL_UNICASTSSENTPERINTER,
IDS_COL_UNICASTSRECPERINTER,
IDS_COL_UNICASTSTOTALPERINTER,
IDS_COL_NONUNICASTSSSENT,
IDS_COL_NONUNICASTSREC,
IDS_COL_NONUNICASTSTOTAL,
IDS_COL_NONUNICASTSSENTPERINTER,
IDS_COL_NONUNICASTSRECPERINTER,
IDS_COL_NONUNICASTSTOTALPERINTER,
};
// List of window checkbox IDs. These check boxes appear in the Select a column diaglog box.
//
const int g_aNetDlgColIDs[] =
{
IDC_ADAPTERNAME,
IDC_ADAPTERDESC,
IDC_NETWORKUTIL,
IDC_LINKSPEED,
IDC_STATE,
IDC_BYTESSENTTHRU,
IDC_BYTESRECTHRU,
IDC_BYTESTOTALTHRU,
IDC_BYTESSENT,
IDC_BYTESREC,
IDC_BYTESTOTAL,
IDC_BYTESSENTPERINTER,
IDC_BYTESRECPERINTER,
IDC_BYTESTOTALPERINTER,
IDC_UNICASTSSSENT,
IDC_UNICASTSREC,
IDC_UNICASTSTOTAL,
IDC_UNICASTSSENTPERINTER,
IDC_UNICASTSRECPERINTER,
IDC_UNICASTSTOTALPERINTER,
IDC_NONUNICASTSSSENT,
IDC_NONUNICASTSREC,
IDC_NONUNICASTSTOTAL,
IDC_NONUNICASTSSENTPERINTER,
IDC_NONUNICASTSRECPERINTER,
IDC_NONUNICASTSTOTALPERINTER,
};
/*++
Routine Description:
Changes the size of an array. Allocates new memory for the array and
copies the data in the old array to the new array. If the new array is
larger then the old array the extra memory is zeroed out.
Arguments:
ppSrc -- Pointer to the source array.
dwNewSize -- The size (in bytes) of the new array.
Return Value:
HRESULT
Revision History:
1-6-2000 Created by omiller
--*/
HRESULT ChangeArraySize(LPVOID *ppSrc, DWORD dwNewSize)
{
if( ppSrc == NULL )
{
return E_INVALIDARG;
}
if( NULL == *ppSrc )
{
// The array is empty. Allocate new space for it,
//
*ppSrc = (LPVOID) HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY, dwNewSize);
if( NULL == *ppSrc )
{
return E_OUTOFMEMORY;
}
}
else
{
LPVOID pTmp;
// The array contains data. Allocate new memory for it and copy over the data in the array.
// If the new array is larger then the old array the extra memory is zeroed out.
//
pTmp = (LPVOID)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,*ppSrc,dwNewSize);
if( pTmp )
{
*ppSrc = pTmp;
}
else
{
return E_OUTOFMEMORY;
}
}
return S_OK;
}
/*++
Routine Description:
Initialize all of the CAdapter class members. The CAdapter class
use the Ip Helper api's to collect information about the Network
adapters on the local system.
Arguments:
NONE
Return Value:
VOID
Revision History:
1-6-2000 Created by omiller
--*/
CAdapter::CAdapter()
{
m_dwAdapterCount = 0;
m_ppaiAdapterStats = NULL;
m_pifTable = NULL;
m_bToggle = 0;
m_dwLastReportedNumberOfAdapters = 0;
}
/*++
Routine Description:
Adds any new adapters reported by the IPHLPAPI and removes any old adapters
that are no longer reported by the IPHLPAPI
Arguments:
void
Return Value:
HRESULT
Revision History:
1-6-2000 Created by omiller
--*/
HRESULT CAdapter::RefreshAdapterTable()
{
DWORD dwSize;
DWORD dwRequiredSize;
DWORD dwRetVal;
DWORD dwOldAdapter;
DWORD dwNewAdapter;
HRESULT hr;
// Get the list of active adapters
//
do
{
// Determine the size of the adapter array
//
dwSize = (DWORD)(m_pifTable == NULL ? 0 : HeapSize(GetProcessHeap(),0,m_pifTable));
// Collect all of the adapter information for all adapters (WAN and LAN)
//
dwRetVal = GetInterfaceInfo(m_pifTable,&dwSize);
switch(dwRetVal)
{
case ERROR_INSUFFICIENT_BUFFER:
// The array is to small. Need to make it bigger and try again.
//
hr = ChangeArraySize((LPVOID *)&m_pifTable,dwSize);
if( FAILED(hr) )
{
// Unable to expand the size of the array
//
return hr;
}
break;
case NO_ERROR:
// Everything is happy
//
break;
case ERROR_MORE_DATA: // Error code 234
// For some reason this error message means that there are no adapters. BUG?
//
m_dwAdapterCount = 0;
return S_FALSE;
default:
// Something went wrong fail.
//
return E_FAIL;
}
}
while(dwRetVal);
// Remove any adapters that are no longer active. i.e. are not in the the refreshed adatrer list m_pifTable
// all adapters up to m_dwAdapterCount already have memory allocated so no need to check m_ppaiAdapterStats[dwOldAdapter] == NULL
//
dwOldAdapter=0;
while( dwOldAdapter < m_dwAdapterCount )
//for(dwOldAdapter=0; dwOldAdapter < m_dwAdapterCount; dwOldAdapter++)
{
BOOLEAN bFound = FALSE;
for(dwNewAdapter=0; dwNewAdapter < (DWORD)m_pifTable->NumAdapters; dwNewAdapter++)
{
if( m_ppaiAdapterStats[dwOldAdapter]->ifRowStartStats.dwIndex == m_pifTable->Adapter[dwNewAdapter].Index )
{
// The adapter is still active. Mark this adapter as invalid to indicate that this adapter is already in our list.
//
m_pifTable->Adapter[dwNewAdapter].Index = INVALID_VALUE;
bFound = TRUE;
break;
}
}
if( !bFound )
{
// Shift the array up to overwrite the unwanted adapter. So we don't have to free memory
// put the adapter we are throwing away at the end of our list. We can reuse its memory.
//
PADAPTER_INFOEX ptr = m_ppaiAdapterStats[dwOldAdapter];
for(DWORD i=dwOldAdapter; i<m_dwAdapterCount-1; i++)
{
m_ppaiAdapterStats[i] = m_ppaiAdapterStats[i+1];
}
m_ppaiAdapterStats[m_dwAdapterCount-1] = ptr;
m_dwAdapterCount--;
}
else
{
dwOldAdapter++;
}
}
dwSize = (DWORD)(m_ppaiAdapterStats == NULL ? 0 : HeapSize(GetProcessHeap(),0,m_ppaiAdapterStats));
dwRequiredSize = (DWORD)(sizeof(PADAPTER_INFOEX) * (m_pifTable->NumAdapters < MAX_ADAPTERS ? m_pifTable->NumAdapters : MAX_ADAPTERS));
if( dwSize < dwRequiredSize )
{
// Resize our adapter list, incase new adapters have been added. Do not add more than 32 adapters.
//
hr = ChangeArraySize((LPVOID *)&m_ppaiAdapterStats,dwRequiredSize);
//sizeof(PADAPTER_INFOEX) * (m_pifTable->NumAdapters < MAX_ADAPTERS ? m_pifTable->NumAdapters : MAX_ADAPTERS));
if( FAILED(hr) )
{
// Unable to resize, out of memory?
//
return hr;
}
}
// Count the number of adapters in our list.
//
m_dwAdapterCount = 0;
// Append the new adapters to the end of our adapter list
//
for(dwNewAdapter=0; dwNewAdapter < (DWORD)m_pifTable->NumAdapters && m_dwAdapterCount < MAX_ADAPTERS; dwNewAdapter++)
{
if( m_pifTable->Adapter[dwNewAdapter].Index != INVALID_VALUE )
{
// Initialize the adapter information and add it to our list
//
hr = InitializeAdapter(&m_ppaiAdapterStats[m_dwAdapterCount],&m_pifTable->Adapter[dwNewAdapter]);
if( SUCCEEDED(hr) )
{
m_dwAdapterCount++;
}
}
else
{
// The adapter is already in our list
//
m_dwAdapterCount++;
}
}
return S_OK;
}
/*++
Routine Description:
Update the connection names of the network adapter. This function is only called when the
user selects the refresh menu item. The connection rarely change, so it would be a waste of
time to update the connection name every time the get the adapter statistics.
Arguments:
void
Return Value:
HRESULT
Revision History:
1-6-2000 Created by omiller
--*/
void CAdapter::RefreshConnectionNames()
{
// Update the connection name for each adapter in out list
//
for(DWORD dwAdapter=0; dwAdapter < m_dwAdapterCount; dwAdapter++)
{
(void)GetConnectionName(m_ppaiAdapterStats[dwAdapter]->wszGuid,m_ppaiAdapterStats[dwAdapter]->wszConnectionName);
}
}
/*++
Routine Description:
Get the connection name of an adapter.
Arguments:
pwszAdapterGuid -- The guid of the adapter
pwszConnectionName -- returns the connection name of the adapter
Return Value:
HRESULT
Revision History:
1-6-2000 Created by omiller
--*/
HRESULT CAdapter::GetConnectionName(LPWSTR pwszAdapterGuid, LPWSTR pwszConnectionName)
{
GUID IfGuid;
WCHAR wszConnName[MAXLEN_IFDESCR];
DWORD Size;
DWORD dwRetVal;
HRESULT hr;
Size = sizeof(wszConnName);
// Convert the GUID into a string
//
hr = CLSIDFromString(pwszAdapterGuid,&IfGuid);
if( SUCCEEDED(hr) )
{
// Use the private IPHLPAPI to get the connection name of the device
//
dwRetVal = NhGetInterfaceNameFromDeviceGuid(&IfGuid, wszConnName, &Size, FALSE, TRUE);
if( NO_ERROR == dwRetVal )
{
lstrcpyn(pwszConnectionName, wszConnName, MAXLEN_IFDESCR);
return S_OK;
}
}
return E_FAIL;
}
/*++
Routine Description:
Initialize the adapter information. i.e. get the adapter name, guid, adapter description and the initial
adapter statistics (bytes sent, bytes recieved etc)
Arguments:
ppaiAdapterStats -- Adapter to initialize
pAdapterDescription -- Information about the adapter (Index and Adapter GUID)
Return Value:
HRESULT
Revision History:
1-6-2000 Created by omiller
--*/
HRESULT CAdapter::InitializeAdapter(PPADAPTER_INFOEX ppaiAdapterStats, PIP_ADAPTER_INDEX_MAP pAdapterDescription)
{
DWORD dwRetVal;
HRESULT hr;
INT iAdapterNameLength;
if( !ppaiAdapterStats || !pAdapterDescription)
{
return E_INVALIDARG;
}
if( NULL == *ppaiAdapterStats )
{
// This slot was never used before, we need to allocate memory for it
//
*ppaiAdapterStats = (PADAPTER_INFOEX)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ADAPTER_INFOEX));
}
if( *ppaiAdapterStats )
{
// Initialize the adapter by filling in all the adapter values.
//
(*ppaiAdapterStats)->ifRowStartStats.dwIndex = (DWORD)pAdapterDescription->Index;
// Get the initial statistics for this adapter
//
dwRetVal = GetIfEntry(&(*ppaiAdapterStats)->ifRowStartStats);
if( NO_ERROR == dwRetVal )
{
if( (*ppaiAdapterStats)->ifRowStartStats.dwType == MIB_IF_TYPE_PPP ||
(*ppaiAdapterStats)->ifRowStartStats.dwType == MIB_IF_TYPE_SLIP)
{
// We only need to adjust the link speed of modems since they compress data causing
// network utilization to exceed 100%. The link speed of modems also changes during a
// connection but the IPHLPAPIs do not report this change.
//
(*ppaiAdapterStats)->bAdjustLinkSpeed = TRUE;
}
else
{
(*ppaiAdapterStats)->bAdjustLinkSpeed = FALSE;
}
// Initialize the adapter values. The start current and last stats are all the same at the start
//
memcpy(&(*ppaiAdapterStats)->ifRowStats[0],&(*ppaiAdapterStats)->ifRowStartStats,sizeof(MIB_IFROW));
memcpy(&(*ppaiAdapterStats)->ifRowStats[1],&(*ppaiAdapterStats)->ifRowStartStats,sizeof(MIB_IFROW));
memset(&(*ppaiAdapterStats)->ulHistory[0],INVALID_VALUE, sizeof(ULONG) * HIST_SIZE);
memset(&(*ppaiAdapterStats)->ulHistory[1],INVALID_VALUE, sizeof(ULONG) * HIST_SIZE);
mbstowcs((*ppaiAdapterStats)->wszDesc,(LPCSTR)(*ppaiAdapterStats)->ifRowStartStats.bDescr,MAXLEN_IFDESCR);
// Extract the Device guid of the adapter
//
hr = E_FAIL;
iAdapterNameLength = lstrlen(pAdapterDescription->Name);
if( iAdapterNameLength >= GUID_STR_LENGTH )
{
// The Guid is the last GUID_STR_LENGTH chars in the name. Get the guid and from the guid get the connection name
//
lstrcpyn((*ppaiAdapterStats)->wszGuid,&pAdapterDescription->Name[iAdapterNameLength - GUID_STR_LENGTH], GUID_STR_LENGTH + 1);
hr = GetConnectionName((*ppaiAdapterStats)->wszGuid,(*ppaiAdapterStats)->wszConnectionName);
}
if( FAILED(hr) )
{
// We were unable to get the connection name, use the adapter description as the connection name
//
lstrcpyn((*ppaiAdapterStats)->wszConnectionName,(*ppaiAdapterStats)->wszDesc,MAXLEN_IFDESCR);
}
return S_OK;
}
}
return E_OUTOFMEMORY;
}
/*++
Routine Description:
Adjusts the link speed of an adapter. Modems change link speed during a connection and the also
compress data. This often causes taskmgr to report network utilization greater than 100%. To avoid
confusing the user modems use the max link speed that taskmgr sees. If the link speed changes
the adapters graph is adjusted to reflect the change in link speed.
Arguments:
pAdapterInfo -- Adapter whos link speed needs to be adjusted.
Return Value:
void
Revision History:
1-6-2000 Created by omiller
--*/
void CAdapter::AdjustLinkSpeed(PADAPTER_INFOEX pAdapterInfo)
{
if( pAdapterInfo && pAdapterInfo->ullTickCountDiff)
{
ULONGLONG ullBitsPerSecond;
ULONGLONG ullBytesMoved;
// Compute the total number of bits moved in this interval
//
ullBytesMoved = (pAdapterInfo->ifRowStats[m_bToggle].dwInOctets + pAdapterInfo->ifRowStats[m_bToggle].dwOutOctets) -
(pAdapterInfo->ifRowStats[!m_bToggle].dwInOctets + pAdapterInfo->ifRowStats[!m_bToggle].dwOutOctets);
// Compute the real link speed. Modems lie about there link speed based on the number of bytes moved in this interval
//
ullBitsPerSecond = ullBytesMoved * 8 * 1000/ pAdapterInfo->ullTickCountDiff;
// Memorize and use the highest link speed
//
pAdapterInfo->ifRowStats[m_bToggle].dwSpeed = (DWORD)max(max(ullBitsPerSecond,pAdapterInfo->ullLinkspeed),pAdapterInfo->ifRowStats[m_bToggle].dwSpeed);
if( pAdapterInfo->ullLinkspeed == 0 )
{
// First time run, no need to adjust the graphs
//
pAdapterInfo->ullLinkspeed = (DWORD) pAdapterInfo->ifRowStats[m_bToggle].dwSpeed;
}
else if( pAdapterInfo->ullLinkspeed != pAdapterInfo->ifRowStats[m_bToggle].dwSpeed )
{
// Adjust the points on the adapters graphs to reflect the new link speed.
//
for(DWORD dwPoint=0; dwPoint<HIST_SIZE; dwPoint++)
{
if( pAdapterInfo->ulHistory[BYTES_RECEIVED_UTIL][dwPoint] != INVALID_VALUE )
{
pAdapterInfo->ulHistory[BYTES_RECEIVED_UTIL][dwPoint] = (ULONG)(pAdapterInfo->ulHistory[BYTES_RECEIVED_UTIL][dwPoint] * pAdapterInfo->ullLinkspeed / pAdapterInfo->ifRowStats[m_bToggle].dwSpeed);
pAdapterInfo->ulHistory[BYTES_SENT_UTIL][dwPoint] = (ULONG)(pAdapterInfo->ulHistory[BYTES_SENT_UTIL][dwPoint] * pAdapterInfo->ullLinkspeed / pAdapterInfo->ifRowStats[m_bToggle].dwSpeed);
}
}
// Remember the new linkspeed
//
pAdapterInfo->ullLinkspeed = (DWORD) pAdapterInfo->ifRowStats[m_bToggle].dwSpeed;
}
}
}
/*++
Routine Description:
Every few seconds this function is called to collect data about each of active network adapter
(Adapter name, bytes sent, bytes received, unicasts packets sent, unicast packets received etc).
The CAdapter class memorizes the first and last set of data that it collected. It does this so the
user can determine i.e. the number of bytes sent between now and when taskmgr started and the number
of bytes sent between now and the last interval. Furthermore it memorizes the length of the interval
(in milliseconds)
Arguments:
bAdapterListChange -- Indicates if the adapters have been added or removed.
Return Value:
HRESULT
Note:
The current and last data is stored in a two dimentional array. When the data is collected the next
time (i.e. when this function is called again), the Current data becomes the last data. Inorder to save time
Current and last data are stored in a two dimensional array and m_bToggle is used to indicate which dimenstion
is current (m_bToggle) and which is the last set of data (!m_bToggle).
Revision History:
1-6-2000 Created by omiller
--*/
HRESULT CAdapter::Update(BOOLEAN & bAdapterListChange)
{
DWORD dwRetVal;
DWORD dwNumberOfAdaptersReported = 0;
HRESULT hr = S_OK;
bAdapterListChange = FALSE;
if( m_dwAdapterCount < MAX_ADAPTERS )
{
// Check if there are any new adapters. If we already have 32 adapters don't bother, our list is full
// If an Adapter is removed we will catch that later.
//
dwRetVal = GetNumberOfInterfaces(&dwNumberOfAdaptersReported);
if( NO_ERROR == dwRetVal )
{
// Make sure the number of interfaces is still the same. If not we need to update our interface table.
//
if( m_dwLastReportedNumberOfAdapters != dwNumberOfAdaptersReported )
{
// The number of adapters changed, refresh our list
//
hr = RefreshAdapterTable();
bAdapterListChange = TRUE;
m_dwLastReportedNumberOfAdapters = dwNumberOfAdaptersReported;
}
}
else
{
// Unknow error, abort
//
hr = E_FAIL;
}
}
if( SUCCEEDED(hr) )
{
m_bToggle = !m_bToggle;
// Get the statistics for each adapter
//
for(DWORD dwAdapter=0; dwAdapter < m_dwAdapterCount; dwAdapter++)
{
dwRetVal = GetIfEntry(&m_ppaiAdapterStats[dwAdapter]->ifRowStats[m_bToggle]);
if( NO_ERROR == dwRetVal )
{
// Compute the sampling interval for this adapter. If it the first run make sure delta time is 0
// Advance the adapter's throughput history
//
ULONGLONG ullTickCount = GetTickCount();
m_ppaiAdapterStats[dwAdapter]->ullTickCountDiff = ullTickCount - (m_ppaiAdapterStats[dwAdapter]->ullLastTickCount ? m_ppaiAdapterStats[dwAdapter]->ullLastTickCount : ullTickCount);
m_ppaiAdapterStats[dwAdapter]->ullLastTickCount = ullTickCount;
m_ppaiAdapterStats[dwAdapter]->ifRowStartStats.dwSpeed = m_ppaiAdapterStats[dwAdapter]->ifRowStats[m_bToggle].dwSpeed;
if( m_ppaiAdapterStats[dwAdapter]->bAdjustLinkSpeed )
{
AdjustLinkSpeed(m_ppaiAdapterStats[dwAdapter]);
}
AdvanceAdapterHistory(dwAdapter);
}
else if( ERROR_INVALID_DATA == dwRetVal )
{
// The adapter is no longer active. When the list is refreshed the adapter will be removed.
//
bAdapterListChange = TRUE;
}
else
{
// Something went wrong abort
//
hr = E_FAIL;
break;
}
}
}
if( bAdapterListChange )
{
// Our adapter list is not uptodate, adapters that were active are no longer active. Remove them from our list
//
hr = RefreshAdapterTable();
}
return hr;
}
/*++
Routine Description:
Adds commas into a number string to make it more readable
Arguments:
ullValue - Number to simplify
pwsz - Buffer to store resulting string
cchNumber -- size of the buffer pwsz.
Return Value:
String containing the simplified number
Revision History:
1-6-2000 Created by omiller
--*/
WCHAR * CNetPage::CommaNumber(ULONGLONG ullValue, WCHAR *pwsz, int cchNumber)
{
WCHAR wsz[100];
NUMBERFMT nfmt;
nfmt.NumDigits = 0;
nfmt.LeadingZero = 0;
nfmt.Grouping = UINT(g_ulGroupSep);
nfmt.lpDecimalSep = g_szDecimal;
nfmt.lpThousandSep = g_szGroupThousSep;
nfmt.NegativeOrder = 0;
_ui64tow(ullValue,wsz,10);
GetNumberFormat(LOCALE_USER_DEFAULT,
0,
wsz,
&nfmt,
pwsz,
cchNumber);
return pwsz;
}
/*++
Routine Description:
Simplifies a number by converting the number into Giga, Mega or Kilo
Arguments:
ullValue - Number to simplify
psz - Buffer to store resulting string
bBytes - Indicates if the number is in bytes
Return Value:
String containing the simplified number
Revision History:
1-6-2000 Created by omiller
--*/
WCHAR * CNetPage::SimplifyNumber(ULONGLONG ullValue, WCHAR *psz)
{
ULONG ulDivValue=1;
LPWSTR pwszUnit=L"";
// The max value of a ulonglong is 2^64 which is 20 digits so this buffer is big enough to hold the number, commas and M, G, K
WCHAR wsz[100];
// ullValue is not number of bytes so div by 10^X
//
if( ullValue >= 1000000000 )
{
ulDivValue = 1000000000;
pwszUnit = g_szG;
}
else
if( ullValue >= 1000000 )
{
ulDivValue = 1000000;
pwszUnit = g_szM;
}
else
if( ullValue >= 1000 )
{
ulDivValue = 1000;
pwszUnit = g_szK;
}
lstrcpy(psz,CommaNumber(ullValue/ulDivValue,wsz,100));
lstrcat(psz,L" ");
lstrcat(psz,pwszUnit);
return psz;
}
/*++
Routine Description:
Converts a floating point value (Stored as an integer shifted by PERCENT_SHIFT) into a string
Arguments:
ulValue - floating point value to convert
psz - Buffer to store resulting string
bDisplayDecimal - Indicates if the decimal value should be displayed.
Return Value:
String containg the Floating point string
Revision History:
1-6-2000 Created by omiller
--*/
WCHAR * CNetPage::FloatToString(ULONGLONG ullValue, WCHAR *psz, BOOLEAN bDisplayDecimal)
{
ULONGLONG ulDecimal = 0;
ULONGLONG ulNumber = 0;
WCHAR wsz[100];
// Get the integer value of the number
//
ulNumber = ullValue / PERCENT_SHIFT;
if( _ui64tow(ulNumber,wsz,10) )
{
lstrcpy(psz,wsz);
if( ulNumber )
{
ullValue = ullValue - ulNumber * PERCENT_SHIFT;
}
if( !ulNumber || bDisplayDecimal)
{
ulDecimal = ullValue * 100 / PERCENT_SHIFT;
if( ulDecimal && _ui64tow(ulDecimal,wsz,10) )
{
lstrcat(psz,g_szDecimal);
if( ulDecimal < 10 ) lstrcat(psz,g_szZero);
if( wsz[1] == L'0' ) wsz[1] = L'\0';
lstrcat(psz,wsz);
}
}
}
return psz;
}
/*++
Routine Description:
Initialize the networking tab. This function always returns 1. The networking tab
displays all active connections (LAN and WAN). If no connections are present when
taskmgr is started, the Network tab should still be displayed (thus return 1) incase
a connection is established after taskmgr has started. The network tab will detect any
newly established connections.
Arguments:
None
Return Value:
1
Revision History:
1-6-2000 Created by omiller
--*/
BYTE InitNetInfo()
{
// The network page should always appear even if there are no Network Adapters currently present.
//
return 1;
}
/*++
Routine Description:
Uninitialize all CAdapter class members. Frees all memory that
was allocated by the class.
Arguments:
NONE
Return Value:
VOID
Revision History:
1-6-2000 Created by omiller
--*/
CAdapter::~CAdapter()
{
if( m_pifTable )
{
HeapFree(GetProcessHeap(),0,m_pifTable);
}
if( m_dwAdapterCount )
{
DWORD dwSize;
DWORD dwTotalAdapterCount;
// Get the total size of the array and compute the number of entries in the array.
// m_dwAdapterCount only indicates the adapters are active. The array could have been bigger
// at one point. Free the memory for all the entries.
//
dwSize = (DWORD)(m_ppaiAdapterStats == NULL ? 0 : HeapSize(GetProcessHeap(),0,m_ppaiAdapterStats));
dwTotalAdapterCount = dwSize / sizeof(PADAPTER_INFOEX);
for(DWORD dwAdapter=0; dwAdapter < dwTotalAdapterCount; dwAdapter++)
{
if( m_ppaiAdapterStats[dwAdapter] )
{
HeapFree(GetProcessHeap(),0,m_ppaiAdapterStats[dwAdapter]);
}
}
HeapFree(GetProcessHeap(),0,m_ppaiAdapterStats);
}
}
/*++
Routine Description:
Returns the number active adapters. The IP helper functions
provide information about physical and non-physical adapters
(such as the Microsoft TCP loop back adapter).
Arguments:
bEvenHiddenAdapters -- If true return the total number of adapters.
if false return only the number of physical adapters.
Return Value:
Number of active adapters
Revision History:
1-6-2000 Created by omiller
--*/
DWORD CAdapter::GetNumberOfAdapters()
{
return m_dwAdapterCount;
}
/*++
Routine Description:
Resets the initial data for all Network adapters. The CAdapter class collects
information for all active network adapters (Bytes sent, bytes received, unicasts
packets sent, unicast packets received etc). The class memorizes the first set of data
for each adapter. This is done so that the user can determine the number of i.e. bytes
sent from when taskmgr was first started. (i.e. the number of bytes seen now minuse the
number of bytes seen when taskmgr was started). When the user selects the Reset option,
this functions overwrites the initial data, collected when taskmgr started, with the
current data.
Arguments:
NONE
Return Value:
S_OK
Revision History:
1-6-2000 Created by omiller
--*/
HRESULT CAdapter::Reset()
{
for(DWORD dwAdapter=0; dwAdapter < m_dwAdapterCount; dwAdapter++)
{
// Overwrite the Start and Last stats with the Current stats
//
memcpy(&m_ppaiAdapterStats[dwAdapter]->ifRowStartStats,&m_ppaiAdapterStats[dwAdapter]->ifRowStats[m_bToggle],sizeof(MIB_IFROW));
memcpy(&m_ppaiAdapterStats[dwAdapter]->ifRowStats[!m_bToggle],&m_ppaiAdapterStats[dwAdapter]->ifRowStats[m_bToggle],sizeof(MIB_IFROW));
}
return S_OK;
}
/*++
Routine Description:
Extracts the text fields (i.e. connection name and description) from a specified adapter
Arguments:
deAdapter -- Adapter who text the caller wants
nStatValue -- Specifies which field the caller wants i.e. (Name or description)
Return Value:
NULL -- if the adapter index is invalid or nStatValue is invalid
Revision History:
1-6-2000 Created by omiller
--*/
LPWSTR CAdapter::GetAdapterText(DWORD dwAdapter, NETCOLUMNID nStatValue)
{
if( dwAdapter >= m_dwAdapterCount )
{
// Invalid adapter index
//
return 0;
}
switch(nStatValue)
{
case COL_ADAPTERNAME:
// Get adapter name
//
return m_ppaiAdapterStats[dwAdapter]->wszConnectionName;
case COL_ADAPTERDESC:
// Get adapter description
//
return m_ppaiAdapterStats[dwAdapter]->wszDesc;
case COL_STATE:
switch(m_ppaiAdapterStats[dwAdapter]->ifRowStats[m_bToggle].dwOperStatus)
{
case IF_OPER_STATUS_NON_OPERATIONAL:
return g_szNonOperational;
case IF_OPER_STATUS_UNREACHABLE:
return g_szUnreachable;
case IF_OPER_STATUS_DISCONNECTED:
return g_szDisconnected;
case IF_OPER_STATUS_CONNECTING:
return g_szConnecting;
case IF_OPER_STATUS_CONNECTED:
return g_szConnected;
case IF_OPER_STATUS_OPERATIONAL:
return g_szOperational;
default:
return g_szUnknownStatus;
}
}
return NULL;
}
/*++
Routine Description:
Get the Send/Receive Network utilization history for a specified adapter
Arguments:
deAdapter -- Adapter who text the caller wants
nHistoryType -- BYTES_SENT_UTIL for send history
BYTES_RECEIVED_UTIL for receive history
Return Value:
NULL -- if the adapter index is invalid or nStatValue is invalid
Revision History:
1-6-2000 Created by omiller
--*/
ULONG * CAdapter::GetAdapterHistory(DWORD dwAdapter, ADAPTER_HISTORY nHistoryType)
{
if( dwAdapter < m_dwAdapterCount )
{
// Return the history
//
return m_ppaiAdapterStats[dwAdapter]->ulHistory[nHistoryType];
}
return NULL;
}
/*++
Routine Description:
Updates the Send/Received Network Utilization adapter history
Arguments:
dwAdapter -- Adapter Index
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
BOOLEAN CAdapter::AdvanceAdapterHistory(DWORD dwAdapter)
{
ULONG *pulHistory;
if( dwAdapter < m_dwAdapterCount )
{
// Shift the receive adapter history by one and add the new point
//
pulHistory = m_ppaiAdapterStats[dwAdapter]->ulHistory[BYTES_RECEIVED_UTIL];
MoveMemory((LPVOID) (pulHistory + 1),
(LPVOID) (pulHistory),
sizeof(ULONG) * (HIST_SIZE - 1) );
// Get and add the receive network utiliation
//
pulHistory[0] = (ULONG)GetAdapterStat(dwAdapter,COL_BYTESRECTHRU);
// Shift the send adapter history by one and add the new point
//
pulHistory = m_ppaiAdapterStats[dwAdapter]->ulHistory[BYTES_SENT_UTIL];
MoveMemory((LPVOID) (pulHistory + 1),
(LPVOID) (pulHistory),
sizeof(ULONG) * (HIST_SIZE - 1) );
// Get and add the send network utilization
//
pulHistory[0] = (ULONG)GetAdapterStat(dwAdapter, COL_BYTESSENTTHRU);
return TRUE;
}
return FALSE;
}
/*++
Routine Description:
Get the scale. The scale specifies the maximum value that is in the Adapters history.
This value determines how the data is graphed.
Arguments:
dwAdapter -- Adapter Index
Return Value:
Maximum value in history
Revision History:
1-6-2000 Created by omiller
--*/
DWORD CAdapter::GetScale(DWORD dwAdapter)
{
if( dwAdapter < m_dwAdapterCount )
{
return m_ppaiAdapterStats[dwAdapter]->dwScale;
}
return 0;
}
/*++
Routine Description:
Set the scale. The scale specifies the maximum value that is in the Adapters history.
This value determines how the data is graphed.
Arguments:
dwAdapter -- Adapter Index
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
void CAdapter::SetScale(DWORD dwAdapter, DWORD dwScale)
{
if( dwAdapter < m_dwAdapterCount )
{
m_ppaiAdapterStats[dwAdapter]->dwScale = dwScale;
}
}
/*++
Routine Description:
Computes and returns the requested statistiocs value for the specified adapter
Arguments:
dwAdapter -- Adapter Index
nStatValue -- The stat value requested
bAccumulative -- If true the current value is returned
if fale the current - start value is returned.
Return Value:
The requested Statistic value
Revision History:
1-6-2000 Created by omiller
--*/
ULONGLONG CAdapter::GetAdapterStat(DWORD dwAdapter, NETCOLUMNID nStatValue, BOOL bAccumulative)
{
if( dwAdapter >= m_dwAdapterCount )
{
// Invalid adapter index
//
return 0;
}
// Create pointers to the arrays so I do not have to write so much
//
PMIB_IFROW pifrStart = &m_ppaiAdapterStats[dwAdapter]->ifRowStartStats;
PMIB_IFROW pifrLast = &m_ppaiAdapterStats[dwAdapter]->ifRowStats[!m_bToggle];
PMIB_IFROW pifrCurrent = &m_ppaiAdapterStats[dwAdapter]->ifRowStats[m_bToggle];
ULONGLONG ullTickCountDiff = m_ppaiAdapterStats[dwAdapter]->ullTickCountDiff;
// Contains the maximum number of bytes that could have been transimited in the time intrval
// between Last and Current)
//
ULONGLONG ullMaxBytesTransmittedInInterval;
ULONGLONG ull = 0;
// Get the stats value, do the calculation and return the value
//
switch(nStatValue)
{
case COL_NETWORKUTIL:
case COL_BYTESSENTTHRU:
case COL_BYTESRECTHRU:
case COL_BYTESTOTALTHRU:
{
ullMaxBytesTransmittedInInterval = (pifrCurrent->dwSpeed * ullTickCountDiff)/(8 * 1000);
if( ullMaxBytesTransmittedInInterval == 0 )
{
return 0;
}
switch(nStatValue)
{
case COL_BYTESTOTALTHRU:
case COL_NETWORKUTIL:
ull = (pifrCurrent->dwInOctets - pifrLast->dwInOctets) + (pifrCurrent->dwOutOctets - pifrLast->dwOutOctets);
break;
case COL_BYTESSENTTHRU:
ull = (pifrCurrent->dwOutOctets - pifrLast->dwOutOctets);
break;
case COL_BYTESRECTHRU:
ull = (pifrCurrent->dwInOctets - pifrLast->dwInOctets);
break;
}
ull *= 100 * PERCENT_SHIFT;
ull /= ullMaxBytesTransmittedInInterval;
// Make usre we do not exceed 100%, just confuses the user. Davepl inside joke!
//
return ull > 100 * PERCENT_SHIFT ? 99 * PERCENT_SHIFT : ull;
}
case COL_LINKSPEED:
return pifrStart->dwSpeed;
case COL_BYTESSENT:
return (ULONGLONG)(pifrCurrent->dwOutOctets - (bAccumulative ? pifrStart->dwOutOctets : 0));
case COL_BYTESREC:
return (ULONGLONG)(pifrCurrent->dwInOctets - (bAccumulative ? pifrStart->dwInOctets : 0));
case COL_BYTESTOTAL:
return (ULONGLONG)((pifrCurrent->dwInOctets + pifrCurrent->dwOutOctets) - (bAccumulative ? (pifrStart->dwInOctets + pifrStart->dwOutOctets) : 0));
case COL_BYTESSENTPERINTER:
return (ULONGLONG)(pifrCurrent->dwOutOctets - pifrLast->dwOutOctets);
case COL_BYTESRECPERINTER:
return (ULONGLONG)(pifrCurrent->dwInOctets - pifrLast->dwInOctets);
case COL_BYTESTOTALPERINTER:
return (ULONGLONG)((pifrCurrent->dwOutOctets + pifrCurrent->dwInOctets) - (pifrLast->dwOutOctets + pifrLast->dwInOctets));
case COL_UNICASTSSSENT:
return (ULONGLONG)(pifrCurrent->dwInUcastPkts - (bAccumulative ? pifrStart->dwInUcastPkts : 0));
case COL_UNICASTSREC:
return (ULONGLONG)(pifrCurrent->dwOutUcastPkts - (bAccumulative ? pifrStart->dwOutUcastPkts : 0));
case COL_UNICASTSTOTAL:
return (ULONGLONG)((pifrCurrent->dwInUcastPkts + pifrCurrent->dwOutUcastPkts) - (bAccumulative ? (pifrStart->dwInUcastPkts + pifrStart->dwOutUcastPkts) : 0));
case COL_UNICASTSSENTPERINTER:
return (ULONGLONG)(pifrCurrent->dwOutUcastPkts - pifrLast->dwOutUcastPkts);
case COL_UNICASTSRECPERINTER:
return (ULONGLONG)(pifrCurrent->dwInUcastPkts - pifrLast->dwInUcastPkts);
case COL_UNICASTSTOTALPERINTER:
return (ULONGLONG)((pifrCurrent->dwOutUcastPkts + pifrCurrent->dwInUcastPkts) - (pifrLast->dwOutUcastPkts + pifrLast->dwInUcastPkts));
case COL_NONUNICASTSSSENT:
return (ULONGLONG)(pifrCurrent->dwInNUcastPkts - (bAccumulative ? pifrStart->dwInNUcastPkts : 0));
case COL_NONUNICASTSREC:
return (ULONGLONG)(pifrCurrent->dwOutNUcastPkts - (bAccumulative ? pifrStart->dwOutNUcastPkts : 0));
case COL_NONUNICASTSTOTAL:
return (ULONGLONG)((pifrCurrent->dwInNUcastPkts + pifrCurrent->dwOutNUcastPkts) - (bAccumulative ? (pifrStart->dwInNUcastPkts + pifrStart->dwOutNUcastPkts) : 0));
case COL_NONUNICASTSSENTPERINTER:
return (ULONGLONG)(pifrCurrent->dwOutNUcastPkts - pifrLast->dwOutNUcastPkts);
case COL_NONUNICASTSRECPERINTER:
return (ULONGLONG)(pifrCurrent->dwInNUcastPkts - pifrLast->dwInNUcastPkts);
case COL_NONUNICASTSTOTALPERINTER:
return (ULONGLONG)((pifrCurrent->dwOutNUcastPkts + pifrCurrent->dwInNUcastPkts) - (pifrLast->dwOutNUcastPkts + pifrLast->dwInNUcastPkts));
}
return 0;
}
/*++
Routine Description:
Initilize all member variables. The CNetPage class displays the information collected
by the CAdpter class
Arguments:
NONE
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
CNetPage::CNetPage()
{
ZeroMemory((LPVOID) m_hPens, sizeof(m_hPens));
m_bReset = TRUE;
m_hPage = NULL; // Handle to this page's dlg
m_hwndTabs = NULL; // Parent window
m_hdcGraph = NULL; // Inmemory dc for cpu hist
m_hbmpGraph = NULL; // Inmemory bmp for adapter hist
m_bPageActive = FALSE;
m_hScaleFont = NULL;
m_lScaleWidth = 0;
m_lScaleFontHeight = 0;
m_pGraph = NULL;
m_dwGraphCount = 0;
m_dwFirstVisibleAdapter = 0;
m_dwGraphsPerPage = 0;
}
/*++
Routine Description:
Clean up
Arguments:
NONE
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
CNetPage::~CNetPage()
{
DestroyGraphs();
ReleasePens();
ReleaseScaleFont();
};
/*++
Routine Description:
Reset the start Adapter set
Arguments:
NONE
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
void CNetPage::Reset()
{
m_bReset = TRUE;
}
/*++
Routine Description:
Creates the number of required graphs
Arguments:
dwGraphsRequired -- Graphs required
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
HRESULT CNetPage::CreateGraphs(DWORD dwGraphsRequired)
{
DWORD dwSize;
LRESULT lFont;
HRESULT hr = S_OK;
// Create moore graphs if required
//
if( dwGraphsRequired > m_dwGraphCount )
{
// Expand the size of the array so it can hold more graphs
//
dwSize = dwGraphsRequired * sizeof(GRAPH);
hr = ChangeArraySize((LPVOID *)&m_pGraph,dwSize);
if( SUCCEEDED(hr) )
{
// Get the font of the parent window
//
lFont = SendMessage(m_hPage,WM_GETFONT,NULL,NULL);
for(; m_dwGraphCount < dwGraphsRequired; m_dwGraphCount++)
{
// Create the graph window. The graph is drawn in the window
//
m_pGraph[m_dwGraphCount].hwndGraph = CreateWindowEx(WS_EX_CLIENTEDGE,
L"BUTTON",
L"",
WS_CHILDWINDOW | BS_OWNERDRAW | WS_DISABLED,
0,0,0,0,
m_hPage,
(HMENU)ULongToPtr(IDC_NICGRAPH + m_dwGraphCount),
NULL,NULL);
if( m_pGraph[m_dwGraphCount].hwndGraph )
{
if( m_dwGraphCount == 0 )
{
HDC hdc = GetDC(m_pGraph[m_dwGraphCount].hwndGraph);
if(hdc )
{
CreateScaleFont(hdc);
ReleaseDC(m_pGraph[m_dwGraphCount].hwndGraph,hdc);
}
}
// Create the frame window. The window draws a pretty border around the graph
//
m_pGraph[m_dwGraphCount].hwndFrame = CreateWindowEx(WS_EX_NOPARENTNOTIFY,
L"DavesFrameClass",
L"",
0x7 | WS_CHILDWINDOW,
0,0,0,0,
m_hPage,
NULL,NULL,NULL);
if( m_pGraph[m_dwGraphCount].hwndFrame )
{
// Create the graph window. The graph is drawn in the window
//
SendMessage(m_pGraph[m_dwGraphCount].hwndFrame,WM_SETFONT,lFont,FALSE);
}
else
{
// Destroy the graph window and abort
// TODO hr = error and break;
DestroyWindow(m_pGraph[m_dwGraphCount].hwndGraph);
return E_OUTOFMEMORY;
}
}
else
{
// Unable to create the window, abort
//
return E_OUTOFMEMORY;
}
}
}
}
return hr;
}
/*++
Routine Description:
Destroies the History graph windows
Arguments:
NONE
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
void CNetPage::DestroyGraphs()
{
// WHILE loop (--m_dwGraphCount)
for(DWORD dwGraph=0; dwGraph < m_dwGraphCount; dwGraph++)
{
DestroyWindow(m_pGraph[dwGraph].hwndGraph);
DestroyWindow(m_pGraph[dwGraph].hwndFrame);
}
if( m_pGraph )
{
HeapFree(GetProcessHeap(),0,m_pGraph);
m_pGraph = NULL;
}
m_dwGraphCount = 0;
}
/*++
Routine Description:
Restores the order of the Network tab's list view columns. The order is
stored in g_Options. When taskmgr is closed, the order is stored in the registry
Arguments:
hwndList -- Handle to the list view
Return Value:
NONE
Revision History:
1-6-2000 Borrowed by omiller
--*/
void CNetPage::RestoreColumnOrder(HWND hwndList)
{
INT rgOrder[ARRAYSIZE(g_aNetDlgColIDs)];
INT cOrder = 0;
INT iOrder = 0;
// Get the order of the columns
//
for (int i = 0; i < ARRAYSIZE(g_aNetDlgColIDs); i++)
{
iOrder = g_Options.m_NetColumnPositions[i];
if (-1 == iOrder)
break;
rgOrder[cOrder++] = iOrder;
}
if (0 < cOrder)
{
// Setthe order of the columns
//
const HWND hwndHeader = ListView_GetHeader(hwndList);
Header_SetOrderArray(hwndHeader, Header_GetItemCount(hwndHeader), rgOrder);
}
}
/*++
Routine Description:
Remember the order of the Network tab's list view columns. The order is
stored in g_Options. When taskmgr is closed, the order is stored in the registry
Arguments:
hwndList -- Handle to the list view
Return Value:
NONE
Revision History:
1-6-2000 Borrowed by omiller
--*/
void CNetPage::RememberColumnOrder(HWND hwndList)
{
const HWND hwndHeader = ListView_GetHeader(hwndList);
int x;
x = Header_GetItemCount(hwndHeader);
ASSERT(Header_GetItemCount(hwndHeader) <= ARRAYSIZE(g_Options.m_NetColumnPositions));
// Clear the array
//
FillMemory(&g_Options.m_NetColumnPositions, sizeof(g_Options.m_NetColumnPositions), 0xFF);
// Get the order of the columns and store it in the array
//
Header_GetOrderArray(hwndHeader,
Header_GetItemCount(hwndHeader),
g_Options.m_NetColumnPositions);
}
/*++
Routine Description:
The Window Proc for the select a column Dialog box. Allows the user to select the collumns.
Arguments:
hwndDlg -- Handle to the dialog box
uMsg -- Window message
wParam -- Window message
lParam -- WIndows Message
Return Value:
Something
Revision History:
1-6-2000 Borrowed by omiller
--*/
INT_PTR CALLBACK NetColSelectDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static CNetPage * pPage = NULL;
switch(uMsg)
{
case WM_INITDIALOG:
{
// Looks scary, but we're single threaded
pPage = (CNetPage *) lParam;
// Start with none of the boxes checked
for (int i = 0; i < ARRAYSIZE(g_aNetDlgColIDs) /*NUM_NETCOLUMN*/; i++)
{
CheckDlgButton(hwndDlg, g_aNetDlgColIDs[i], BST_UNCHECKED);
}
// Then turn on the ones for the columns we have active
for (i = 0; i < ARRAYSIZE(g_aNetDlgColIDs)/*NUM_NETCOLUMN + 1*/; i++)
{
if (g_Options.m_ActiveNetCol[i] == -1)
{
break;
}
CheckDlgButton(hwndDlg, g_aNetDlgColIDs[g_Options.m_ActiveNetCol[i]], BST_CHECKED);
}
return TRUE;
}
case WM_COMMAND:
{
// If user clicked OK, add the columns to the array and reset the listview
if (LOWORD(wParam) == IDOK)
{
// First, make sure the column width array is up to date
pPage->SaveColumnWidths();
INT iCol = 0;
for (int i = 0; i < NUM_NETCOLUMN && g_aNetDlgColIDs[i] >= 0; i++)
{
if (BST_CHECKED == IsDlgButtonChecked(hwndDlg, g_aNetDlgColIDs[i]))
{
// It is checked
if (g_Options.m_ActiveNetCol[iCol] != (NETCOLUMNID) i)
{
// If the column wasn't already there, insert its column
// width into the column width array
ShiftArray(g_Options.m_NetColumnWidths, iCol, SHIFT_UP);
ShiftArray(g_Options.m_ActiveNetCol, iCol, SHIFT_UP);
g_Options.m_NetColumnWidths[iCol] = NetColumnDefaults[ i ].Width;
g_Options.m_ActiveNetCol[iCol] = (NETCOLUMNID) i;
}
iCol++;
}
else
{
// Not checked, column not active. If it used to be active,
// remove its column width from the column width array
if (g_Options.m_ActiveNetCol[iCol] == (NETCOLUMNID) i)
{
ShiftArray(g_Options.m_NetColumnWidths, iCol, SHIFT_DOWN);
ShiftArray(g_Options.m_ActiveNetCol, iCol, SHIFT_DOWN);
}
}
}
// Terminate the column list
g_Options.m_ActiveNetCol[iCol] = (NETCOLUMNID) -1;
pPage->SetupColumns();
//pPage->TimerEvent();
EndDialog(hwndDlg, IDOK);
}
else if (LOWORD(wParam) == IDCANCEL)
{
EndDialog(hwndDlg, IDCANCEL);
}
}
}
return FALSE;
}
/*++
Routine Description:
Handle the slect a column dialog box
Arguments:
NONE
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
void CNetPage::PickColumns()
{
DialogBoxParam(g_hInstance,
MAKEINTRESOURCE(IDD_SELECTNETCOLS),
g_hMainWnd,
NetColSelectDlgProc,
(LPARAM) this);
}
/*++
Routine Description:
Creates the necessary pens
Arguments:
NONE
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
void CNetPage::CreatePens()
{
for (int i = 0; i < ARRAYSIZE(aNetColors); i++)
{
// Create the pens. If a failure occurs, just substitute
// the white pen
m_hPens[i] = CreatePen(PS_SOLID, 1, aNetColors[i]);
if (NULL == m_hPens[i])
{
m_hPens[i] = (HPEN) GetStockObject(WHITE_PEN);
}
}
}
/*++
Routine Description:
Destroys the pens
Arguments:
NONE
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
void CNetPage::ReleasePens()
{
for (int i = 0; i < NUM_PENS; i++)
{
if (m_hPens[i])
{
DeleteObject(m_hPens[i]);
}
}
}
/*++
Routine Description:
Compute the width (in px) of a string
Arguments:
hdc - DC handle
pszwText - String to determine the width of.
Return Value:
The width of the string
Revision History:
1-6-2000 Created by omiller
--*/
int GetStrWidth(HDC hdc, WCHAR *pszwText)
{
int iWidth;
int iTotalWidth = 0;
if( pszwText )
{
// Sum the width of the chars in the string
//
for(int i=0; pszwText[i]!=L'\0'; i++)
{
if( GetCharWidth32(hdc,pszwText[i],pszwText[i],&iWidth) )
{
iTotalWidth += iWidth;
}
else
{
// GetCharWidth32 failed, return -1 as an error code
return -1;
}
}
}
// Return the total width of the string
//
return iTotalWidth;
}
/*++
Routine Description:
Creates the font for the scale. The font is created when the first graph is created.
The hdc of the raph is used to determine the height of the font and the total with of
the scale.
Arguments:
NONE
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
void CNetPage::CreateScaleFont(HDC hdc)
{
if( !m_hScaleFont && hdc)
{
// The font has not yet been created.
INT FontSize;
NONCLIENTMETRICS ncm = {0};
LOGFONT lf;
HFONT hOldFont = NULL;
ncm.cbSize = sizeof(ncm);
SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
lf = ncm.lfMessageFont;
lf.lfWeight = FW_THIN;
lstrcpy(lf.lfFaceName, g_szScaleFont);
// BUG Localize
FontSize = 8;
lf.lfHeight = 0 - GetDeviceCaps(hdc, LOGPIXELSY) * FontSize / 72;
m_hScaleFont = CreateFontIndirect(&lf);
hOldFont = (HFONT)SelectObject(hdc,(HGDIOBJ)m_hScaleFont);
m_lScaleFontHeight = lf.lfHeight - 2;
m_lScaleWidth = GetStrWidth(hdc,L" 22.5 %"); // 12.5 %");
if( hOldFont )
{
SelectObject(hdc,(HGDIOBJ)hOldFont);
}
}
}
/*++
Routine Description:
Releases the fonts
Arguments:
NONE
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
void CNetPage::ReleaseScaleFont()
{
if( m_hScaleFont )
{
DeleteObject(m_hScaleFont);
m_hScaleFont = NULL;
}
}
/*++
Routine Description:
Draws the scale for the graph
Arguments:
hdcGraph - hdc of the graph
prcGraph - Graph region
dwMaxScaleValue - The highest scale value
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
INT CNetPage::DrawScale(HDC hdcGraph, RECT *prcGraph, DWORD dwMaxScaleValue)
{
HPEN hOldPen = NULL;
HFONT hOldFont = NULL;
INT Leftside = prcGraph->left;
WCHAR sz[100];
RECT rc;
if( g_Options.m_bShowScale )
{
if( m_hScaleFont )
{
// Set the scale font
hOldFont = (HFONT) SelectObject(hdcGraph,(HGDIOBJ)m_hScaleFont);
}
// Set the text attributes
//
SetBkMode(hdcGraph,TRANSPARENT);
SetTextColor(hdcGraph,RGB(255, 255, 0));
// Make room for the scale
//
Leftside += m_lScaleWidth;
rc.left = prcGraph->left;
rc.right = Leftside - 3;
// Draw the upper scale value
//
rc.top = prcGraph->top;
rc.bottom = rc.top - m_lScaleFontHeight;
FloatToString(dwMaxScaleValue*PERCENT_SHIFT,sz,TRUE);
lstrcat(sz,L" ");
lstrcat(sz,g_szPercent);
DrawText(hdcGraph,sz,lstrlen(sz),&rc,DT_RIGHT);
// Draw the middle scale value. multi by PERCENT_SHIFT because FloatToString takes a number shifted by PERCENT_SHIFT
//
rc.top = prcGraph->top + (prcGraph->bottom - prcGraph->top)/2 + m_lScaleFontHeight/2;
rc.bottom = rc.top - m_lScaleFontHeight;
FloatToString((dwMaxScaleValue*PERCENT_SHIFT)/2,sz,TRUE);
lstrcat(sz,L" ");
lstrcat(sz,g_szPercent);
DrawText(hdcGraph,sz,lstrlen(sz),&rc,DT_RIGHT);
// Draw the botton scale value
//
rc.top = prcGraph->bottom + m_lScaleFontHeight;
rc.bottom = rc.top - m_lScaleFontHeight;
// BUG : loc
lstrcpy(sz,g_szZero);
lstrcat(sz,L" ");
lstrcat(sz,g_szPercent);
DrawText(hdcGraph,sz,lstrlen(sz),&rc,DT_RIGHT);
if( hOldFont )
{
SelectObject(hdcGraph,hOldFont);
}
// Draw the scale line. Divides the scale from the graph
//
hOldPen = (HPEN)SelectObject(hdcGraph, m_hPens[1]);
MoveToEx(hdcGraph,
Leftside,
prcGraph->top,
(LPPOINT) NULL);
LineTo(hdcGraph,
Leftside,
prcGraph->bottom);
if( hOldPen)
{
SelectObject(hdcGraph,hOldPen);
}
}
return Leftside;
}
/*++
Routine Description:
Draw the graph paper. The size of the squares depends of the zoom level.
Arguments:
NONE
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
ULONG CNetPage::DrawAdapterGraphPaper(HDC hdcGraph, RECT * prcGraph, int Width, DWORD dwZoom)
{
#define GRAPHPAPERSIZE 12
HPEN hPen;
int Leftside = prcGraph->left;
ULONG ulSquareSize = GRAPHPAPERSIZE + (20 * (100 - 100/dwZoom)) / 100; //28
int nLineCount = 0;
Leftside = DrawScale(hdcGraph,prcGraph,100/dwZoom);
// Bug: keep hPen
hPen = CreatePen(PS_SOLID, 1, RGB(0, 128, 64));
HGDIOBJ hOld = SelectObject(hdcGraph, hPen);
// Draw the vertical lines
//
for (int i = (ulSquareSize) + 1; i < prcGraph->bottom - prcGraph->top; i+= ulSquareSize)
{
MoveToEx(hdcGraph,
Leftside,
prcGraph->bottom - i,
(LPPOINT) NULL);
LineTo(hdcGraph,
prcGraph->right,
prcGraph->bottom - i);
nLineCount++;
}
// Draw the horizontal lines
//
for (i = prcGraph->right - g_NetScrollamount; i > Leftside; i -= GRAPHPAPERSIZE)
{
MoveToEx(hdcGraph,
i,
prcGraph->top,
(LPPOINT) NULL);
LineTo(hdcGraph,
i,
prcGraph->bottom);
}
if (hOld)
{
SelectObject(hdcGraph, hOld);
}
if( hPen )
{
DeleteObject(hPen);
}
return Leftside - prcGraph->left - 3;
}
/*++
Routine Description:
Add the column headers to the Network tab's List view
Arguments:
NONE
Return Value:
HRESULT
Revision History:
1-6-2000 Created by omiller
--*/
HRESULT CNetPage::SetupColumns()
{
// Delete all the items in the list view
//
ListView_DeleteAllItems(m_hListView);
// Remove all existing columns
LV_COLUMN lvcolumn;
while(ListView_DeleteColumn(m_hListView, 0))
{
NULL;
}
// Add all of the new columns
INT iColumn = 0;
while (g_Options.m_ActiveNetCol[iColumn] >= 0)
{
INT idColumn = g_Options.m_ActiveNetCol[iColumn];
TCHAR szTitle[MAX_PATH];
LoadString(g_hInstance, _aIDNetColNames[idColumn], szTitle, ARRAYSIZE(szTitle));
lvcolumn.mask = LVCF_FMT | LVCF_TEXT | LVCF_TEXT | LVCF_WIDTH;
lvcolumn.fmt = NetColumnDefaults[ idColumn ].Format | (idColumn > 1 ? LVCFMT_RIGHT : 0);
// If no width preference has been recorded for this column, use the
// default
if (-1 == g_Options.m_NetColumnWidths[iColumn])
{
lvcolumn.cx = NetColumnDefaults[ idColumn ].Width;
}
else
{
lvcolumn.cx = g_Options.m_NetColumnWidths[iColumn];
}
lvcolumn.pszText = szTitle;
lvcolumn.iSubItem = iColumn;
if (-1 == ListView_InsertColumn(m_hListView, iColumn, &lvcolumn))
{
return E_FAIL;
}
iColumn++;
}
ListView_SetExtendedListViewStyleEx(m_hListView,LVS_EX_HEADERDRAGDROP | LVS_EX_FULLROWSELECT , LVS_EX_HEADERDRAGDROP | LVS_EX_FULLROWSELECT);
return S_OK;
}
/*++
Routine Description:
Save the width of the columns
Arguments:
NONE
Return Value:
HRESULT
Revision History:
1-6-2000 Created by omiller
--*/
void CNetPage::SaveColumnWidths()
{
UINT i = 0;
LV_COLUMN col = { 0 };
while (g_Options.m_ActiveNetCol[i] != (NETCOLUMNID) -1)
{
col.mask = LVCF_WIDTH;
if (ListView_GetColumn(m_hListView, i, &col) )
{
g_Options.m_NetColumnWidths[i] = (SHORT)col.cx;
}
else
{
ASSERT(0 && "Couldn't get the column width");
}
i++;
}
}
/*++
Routine Description:
Initialize the Network tab
Arguments:
NONE
Return Value:
HRESULT
Revision History:
1-6-2000 Created by omiller
--*/
HRESULT CNetPage::Initialize(HWND hwndParent)
{
CreatePens();
// Our pseudo-parent is the tab contrl, and is what we base our
// sizing on. However, in order to keep tab order right among
// the controls, we actually create ourselves with the main
// window as the parent
m_hwndTabs = hwndParent;
//
// Create the dialog which represents the body of this page
//
m_hPage = CreateDialogParam(
g_hInstance, // handle to application instance
MAKEINTRESOURCE(IDD_NETPAGE), // identifies dialog box template name
g_hMainWnd, // handle to owner window
NetPageProc, // pointer to dialog box procedure
(LPARAM) this ); // User data (our this pointer)
if (NULL == m_hPage)
{
return GetLastHRESULT();
}
// no fail if GetDlgItem
m_hNoAdapterText = GetDlgItem(m_hPage, IDC_NOADAPTERS);
if( !m_hNoAdapterText )
{
return E_FAIL;
}
m_hScrollBar = GetDlgItem(m_hPage, IDC_GRAPHSCROLLVERT);
if( !m_hScrollBar )
{
return E_FAIL;
}
m_hListView = GetDlgItem(m_hPage, IDC_NICTOTALS);
if( !m_hListView )
{
return E_FAIL;
}
// Add the columns to the list view
//
SetupColumns();
// Order the columns for the user
//
RestoreColumnOrder(m_hListView);
return S_OK;
}
/*++
Routine Description:
Creates the memory bitmaps for the graphs
Arguments:
NONE
Return Value:
HRESULT
Revision History:
1-6-2000 Created by omiller
--*/
HRESULT CNetPage::CreateMemoryBitmaps(int x, int y)
{
//
// Create the inmemory bitmaps and DCs that we will use
//
HDC hdcPage = GetDC(m_hPage);
m_hdcGraph = CreateCompatibleDC(hdcPage);
if (NULL == m_hdcGraph)
{
ReleaseDC(m_hPage, hdcPage);
return GetLastHRESULT();
}
m_rcGraph.left = 0;
m_rcGraph.top = 0;
m_rcGraph.right = x;
m_rcGraph.bottom = y;
m_hbmpGraph = CreateCompatibleBitmap(hdcPage, x, y);
ReleaseDC(m_hPage, hdcPage);
if (NULL == m_hbmpGraph)
{
HRESULT hr = GetLastHRESULT();
DeleteDC(m_hdcGraph);
m_hdcGraph = NULL;
return hr;
}
// Select the bitmap into the DC
hOld2 = SelectObject(m_hdcGraph, m_hbmpGraph);
return S_OK;
}
/*++
Routine Description:
Destroy the bitmaps for the graphs
Arguments:
NONE
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
void CNetPage::FreeMemoryBitmaps()
{
if (m_hdcGraph)
{
if (hOld2)
SelectObject(m_hdcGraph, m_hbmpGraph);
DeleteDC(m_hdcGraph);
}
if (m_hbmpGraph)
{
DeleteObject(m_hbmpGraph);
}
}
/*++
Routine Description:
This function is called when the Network tab is activated.
Arguments:
NONE
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
HRESULT CNetPage::Activate()
{
// Adjust the size and position of our dialog relative
// to the tab control which "owns" us
RECT rcParent;
GetClientRect(m_hwndTabs, &rcParent);
MapWindowPoints(m_hwndTabs, g_hMainWnd, (LPPOINT) &rcParent, 2);
TabCtrl_AdjustRect(m_hwndTabs, FALSE, &rcParent);
// The user has switched to the tab. The Networking tab is now active
// The tab will stay active for the whole life time of taskmgr
//
m_bPageActive = TRUE;
SetWindowPos(m_hPage,
HWND_TOP,
rcParent.left, rcParent.top,
rcParent.right - rcParent.left, rcParent.bottom - rcParent.top,
0);
// Make this page visible
ShowWindow(m_hPage, SW_SHOW);
// Newly created dialogs seem to steal the focus, so give it back to the
// tab control (which must have had it if we got here in the first place)
SetFocus(m_hwndTabs);
TimerEvent();
// Change the menu bar to be the menu for this page
HMENU hMenuOld = GetMenu(g_hMainWnd);
HMENU hMenuNew = LoadMenu(g_hInstance, MAKEINTRESOURCE(IDR_MAINMENU_NET));
AdjustMenuBar(hMenuNew);
CheckMenuItem(hMenuNew,IDM_BYTESSENT,g_Options.m_bAutoSize ? MF_CHECKED:MF_UNCHECKED);
CheckMenuItem(hMenuNew,IDM_BYTESSENT,g_Options.m_bGraphBytesSent ? MF_CHECKED:MF_UNCHECKED);
CheckMenuItem(hMenuNew,IDM_BYTESRECEIVED,g_Options.m_bGraphBytesReceived ? MF_CHECKED:MF_UNCHECKED);
CheckMenuItem(hMenuNew,IDM_BYTESTOTAL,g_Options.m_bGraphBytesTotal ? MF_CHECKED:MF_UNCHECKED);
g_hMenu = hMenuNew;
if (g_Options.m_fNoTitle == FALSE)
{
SetMenu(g_hMainWnd, hMenuNew);
}
if (hMenuOld)
{
DestroyMenu(hMenuOld);
}
SizeNetPage();
return S_OK;
}
/*++
Routine Description:
This function is called when the Network tab is deactivated.
Arguments:
NONE
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
void CNetPage::Deactivate()
{
SaveColumnWidths();
if (m_hPage)
{
ShowWindow(m_hPage, SW_HIDE);
}
if (m_hbmpGraph)
{
DeleteObject(m_hbmpGraph);
m_hbmpGraph = NULL;
}
if (m_hdcGraph)
{
DeleteDC(m_hdcGraph);
m_hdcGraph = NULL;
}
}
HRESULT CNetPage::Destroy()
{
//
// When we are being destroyed, kill off our dialog
//
if (m_hPage)
{
DestroyWindow(m_hPage);
m_hPage = NULL;
}
if (m_hbmpGraph)
{
DeleteObject(m_hbmpGraph);
m_hbmpGraph = NULL;
}
if (m_hdcGraph)
{
DeleteDC(m_hdcGraph);
m_hdcGraph = NULL;
}
return S_OK;
}
/*++
Routine Description:
Get the title of the networking tab i.e. "Networking"
Arguments:
NONE
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
void CNetPage::GetTitle(LPTSTR pszText, size_t bufsize)
{
LoadString(g_hInstance, IDS_NETPAGETITLE, pszText, static_cast<int>(bufsize));
}
/*++
Routine Description:
Size the History graph
Arguments:
hdwp -- Defered Window Handle
pGraph -- History graph to size
pRect -- The corrdinates of the graph
pDimRect -- The dimentions of the actual history graph
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
void CNetPage::SizeGraph(HDWP hdwp, GRAPH *pGraph, RECT *pRect, RECT *pDimRect)
{
RECT rc;
DWORD dwGraphWidth = pRect->right - g_DefSpacing * 2;
DWORD dwGraphHeight = pRect->bottom - g_TopSpacing - g_DefSpacing;
// Size the frame
//
rc.left = pRect->left;
rc.top = pRect->top;
rc.right = pRect->left + pRect->right;
rc.bottom = pRect->top + pRect->bottom;
DeferWindowPos(hdwp,
pGraph->hwndFrame,
NULL,
rc.left,
rc.top,
rc.right - rc.left,
rc.bottom - rc.top,
SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
// Size the History graph
//
rc.left = rc.left + g_DefSpacing;
rc.top = rc.top + g_TopSpacing;
rc.right = rc.left + dwGraphWidth;
rc.bottom = rc.top + dwGraphHeight;
DeferWindowPos(hdwp,
pGraph->hwndGraph,
NULL,
rc.left,
rc.top,
rc.right - rc.left,
rc.bottom - rc.top,
SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
if( pDimRect )
{
// Return the size of the history graph
//
memcpy(pDimRect,&rc,sizeof(RECT));
}
}
/*++
Routine Description:
Hide the history graph
Arguments:
hdwp -- Defered Window Handle
pGraph -- History graph to hide
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
void CNetPage::HideGraph(HDWP hdwp, GRAPH *pGraph)
{
// Hide the frame
//
DeferWindowPos(hdwp,
pGraph->hwndFrame,
NULL,
0,0,0,0,
SWP_NOZORDER | SWP_NOACTIVATE | SWP_HIDEWINDOW);
// Hide the graph
//
DeferWindowPos(hdwp,
pGraph->hwndGraph,
NULL,
0,0,0,0,
SWP_NOZORDER | SWP_NOACTIVATE | SWP_HIDEWINDOW);
}
/*++
Routine Description:
Compute the number of graphs we can squeeze on a page
Arguments:
dwHeight -- Height of the graphing area
dwAdapterCount -- Total number of adapters
Return Value:
Number of adapters that can be squeeze on to the tab
Revision History:
1-6-2000 Created by omiller
--*/
DWORD CNetPage::GraphsPerPage(DWORD dwHeight, DWORD dwAdapterCount)
{
DWORD dwGraphsPerPage = 0;
if( dwAdapterCount )
{
DWORD dwGraphHeight;
// Compute the average height of an adapter if all adapters were put on the page
// If they all fit then squueze all of them on the page, if the height is smaller then the min
// height compute the number of adapters we can squeeze on the page.
//
dwGraphHeight = dwHeight / dwAdapterCount;
dwGraphHeight = dwGraphHeight < MIN_GRAPH_HEIGHT ? MIN_GRAPH_HEIGHT : dwGraphHeight;
dwGraphsPerPage = dwHeight > dwGraphHeight ? dwHeight / dwGraphHeight : 1;
}
return dwGraphsPerPage;
}
/*++
Routine Description:
Get the first adapter that the user sees graphed.
Arguments:
void
Return Value:
The first adapter the user sees graphed
Revision History:
1-6-2000 Created by omiller
--*/
DWORD CNetPage::GetFirstVisibleAdapter()
{
DWORD dwAdapter = m_dwFirstVisibleAdapter;
DWORD dwAdapterCount = m_Adapter.GetNumberOfAdapters();
if( dwAdapter + m_dwGraphsPerPage > dwAdapterCount )
{
dwAdapter = dwAdapterCount - m_dwGraphsPerPage;
}
if( dwAdapter >= dwAdapterCount )
{
dwAdapter = 0;
}
return dwAdapter;
}
/*++
Routine Description:
Assigns a name to each graph.
Arguments:
void
Return Value:
void
Revision History:
1-6-2000 Created by omiller
--*/
void CNetPage::LabelGraphs()
{
DWORD dwAdapter;
dwAdapter = GetFirstVisibleAdapter();
for(DWORD dwGraph=0; dwGraph < m_dwGraphsPerPage; dwGraph++)
{
SetWindowText(m_pGraph[dwGraph].hwndFrame,m_Adapter.GetAdapterText(dwAdapter + dwGraph,COL_ADAPTERNAME));
}
UpdateGraphs();
}
/*++
Routine Description:
Size the history graphs.
Arguments:
void
Return Value:
void
Revision History:
1-6-2000 Created by omiller
--*/
void CNetPage::SizeNetPage()
{
HRESULT hr;
HDWP hdwp;
RECT rcParent;
RECT rcGraph = {0};
RECT rcGraphDim = {0};
DWORD dwAdapterCount;
DWORD dwGraphHistoryHeight = 0;
BOOLEAN bNeedScrollBar = FALSE;
m_dwGraphsPerPage = 0;
if (g_Options.m_fNoTitle)
{
// Just display the graphs, not the list view or the tabs
//
GetClientRect(g_hMainWnd, &rcParent);
dwGraphHistoryHeight = rcParent.bottom - rcParent.top - g_DefSpacing;
}
else
{
// Display the graphs, list view and tabs
//
GetClientRect(m_hwndTabs, &rcParent);
MapWindowPoints(m_hwndTabs, m_hPage, (LPPOINT) &rcParent, 2);
TabCtrl_AdjustRect(m_hwndTabs, FALSE, &rcParent);
dwGraphHistoryHeight = (rcParent.bottom - rcParent.top - g_DefSpacing) * 3 / 4;
}
// Determine the number of adapters so we can compute the number of graphs to display perpage.
//
dwAdapterCount = m_Adapter.GetNumberOfAdapters();
if( dwAdapterCount )
{
// Compute the number of graphs we can squeeze onto the page. One graph always fits onto the tab.
//
m_dwGraphsPerPage = GraphsPerPage(dwGraphHistoryHeight,dwAdapterCount);
hr = CreateGraphs(m_dwGraphsPerPage);
if( FAILED(hr) )
{
// Unable to create the graphs, abort
//
return;
}
// Determine if we need to display the scroll bar
//
bNeedScrollBar = (dwAdapterCount > m_dwGraphsPerPage);
// Determine the rect for the first graph
//
rcGraph.left = rcParent.left + g_DefSpacing;
rcGraph.right = (rcParent.right - rcParent.left) - g_DefSpacing*2 - (bNeedScrollBar ? SCROLLBAR_WIDTH + g_DefSpacing : 0);
rcGraph.top = rcParent.top + g_DefSpacing;
rcGraph.bottom = dwGraphHistoryHeight / m_dwGraphsPerPage;
}
hdwp = BeginDeferWindowPos(10);
if( hdwp )
{
// Position the scroll bar window
//
DeferWindowPos(hdwp,
m_hScrollBar,
NULL,
rcParent.right - g_DefSpacing - SCROLLBAR_WIDTH,
rcParent.top + g_DefSpacing,
SCROLLBAR_WIDTH,
rcGraph.bottom * m_dwGraphsPerPage,
(bNeedScrollBar ? SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW : SWP_HIDEWINDOW));
// Position the induvidual graphs. We might have created more graphs then we needed, hide the extra graphs
//
for(DWORD dwGraph=0; dwGraph < m_dwGraphCount; dwGraph++ )
{
if( dwGraph < m_dwGraphsPerPage )
{
SizeGraph(hdwp,&m_pGraph[dwGraph], &rcGraph, &rcGraphDim);
rcGraph.top += rcGraph.bottom;
}
else
{
// Do not display these graphs
//
HideGraph(hdwp,&m_pGraph[dwGraph]);
}
}
// Postion the list view that displays the stats
DeferWindowPos(hdwp,
m_hListView,
NULL,
rcGraph.left,
rcGraph.top + g_DefSpacing,
rcParent.right - rcParent.left - rcGraph.left - g_DefSpacing,
rcParent.bottom - rcGraph.top - g_DefSpacing,
dwAdapterCount ? SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW : SWP_HIDEWINDOW);
// Position the "No Active Adapters found" text
//
DeferWindowPos(hdwp,
m_hNoAdapterText,
NULL,
rcParent.left ,
rcParent.top + (rcParent.bottom - rcParent.top) / 2 - 40,
rcParent.right - rcParent.left,
rcParent.bottom - rcParent.top,
dwAdapterCount ? SWP_HIDEWINDOW : SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
EndDeferWindowPos(hdwp);
FreeMemoryBitmaps(); // Free any old ones
CreateMemoryBitmaps(rcGraphDim.right - rcGraphDim.left, rcGraphDim.bottom - rcGraphDim.top - 4);
LabelGraphs();
if( bNeedScrollBar )
{
SCROLLINFO si;
// Set up the scroll bar
//
si.cbSize = sizeof(SCROLLINFO);
si.fMask = SIF_PAGE | SIF_RANGE;
si.nPage = 1;
si.nMin = 0;
si.nMax = dwAdapterCount - m_dwGraphsPerPage;
SetScrollInfo(m_hScrollBar,SB_CTL,&si,TRUE);
}
}
}
/*++
Routine Description:
Update all of the Networking graphs. i.e. redraw the graphs
Arguments:
NONE
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
void CNetPage::UpdateGraphs()
{
for (DWORD dwGraph = 0; dwGraph < m_dwGraphsPerPage; dwGraph++)
{
InvalidateRect(m_pGraph[dwGraph].hwndGraph,NULL,FALSE);
UpdateWindow(m_pGraph[dwGraph].hwndGraph);
}
}
/*++
Routine Description:
Draw a Networking graph
Arguments:
prc -- the coordinates of the graph
hPen -- The color of the graph line
dwZoom -- the zoom level of the graph
pHistory -- The history to plot
pHistory2 -- The other history to draw in cobonation with the first history i.e. pHistory + pHistory2
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
DWORD CNetPage::DrawGraph(LPRECT prc, HPEN hPen, DWORD dwZoom, ULONG *pHistory, ULONG *pHistory2)
{
HGDIOBJ hOldA;
ULONGLONG nValue;
DWORD nMax=0;
int Width = prc->right - prc->left;
int Scale = (Width - 1) / HIST_SIZE;
if (0 == Scale)
{
Scale = 2;
}
hOldA = SelectObject(m_hdcGraph, hPen );
// Compute the height of the graph
//
int GraphHeight = m_rcGraph.bottom - m_rcGraph.top;
// Get the first value to plot
//
if( pHistory2 )
{
if( pHistory[0] == INVALID_VALUE || pHistory2[0] == INVALID_VALUE )
{
return nMax;
}
nValue = (DWORD) (pHistory[0]+pHistory2[0]);
}
else
{
if( pHistory[0] == INVALID_VALUE )
{
return nMax;
}
nValue = (DWORD) (pHistory[0]);
}
// Memorize the max value that is plotted (effects the zoom level)
//
nMax = (DWORD)(nValue/PERCENT_SHIFT > nMax ? nValue/PERCENT_SHIFT : nMax);
nValue = (nValue * GraphHeight * dwZoom/ 100)/PERCENT_SHIFT;
nValue = nValue == 0 ? 1 : nValue;
MoveToEx(m_hdcGraph,
m_rcGraph.right,
m_rcGraph.bottom - (ULONG)nValue,
(LPPOINT) NULL);
// Plot the points
//
for (INT nPoint = 1; nPoint < HIST_SIZE && nPoint * Scale < Width; nPoint++)
{
if( pHistory2 )
{
if( pHistory[nPoint] == INVALID_VALUE || pHistory2[nPoint] == INVALID_VALUE )
{
return nMax;
}
// Get both points
//
nValue = (DWORD) (pHistory[nPoint]+pHistory2[nPoint]);
}
else
{
if( pHistory[nPoint] == INVALID_VALUE )
{
return nMax;
}
// Just get the first point
//
nValue = (DWORD) (pHistory[nPoint]);
}
//nValue /= PERCENT_SHIFT;
// Memorize the max value that is plotted (effects the zoom level)
//
nMax = (DWORD)(nValue/PERCENT_SHIFT > nMax ? nValue/PERCENT_SHIFT : nMax);
nValue = (nValue * GraphHeight * dwZoom / 100) / PERCENT_SHIFT;
nValue = nValue == 0 ? 1 : nValue;
LineTo(m_hdcGraph,
m_rcGraph.right - (Scale * nPoint),
m_rcGraph.bottom - (ULONG)nValue);
}
if (hOldA)
{
SelectObject(m_hdcGraph, hOldA);
}
// Return the maximum value plotted
//
return nMax;
}
/*++
Routine Description:
Draw a Networking graph
Arguments:
lpdi -- the coordinates of the graph
iPane -- The id of the graph to draw
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
void CNetPage::DrawAdapterGraph(LPDRAWITEMSTRUCT lpdi, UINT iPane)
{
DWORD dwZoom = 1;
DWORD dwScale = 100;
DWORD dwAdapter;
if( iPane > m_dwGraphCount )
{
return;
}
// Get the adapter index.
//
dwAdapter = iPane + GetFirstVisibleAdapter();
if( dwAdapter >= m_Adapter.GetNumberOfAdapters() )
{
// Invalid adapter, abort.
//
return;
}
// Get the scale for the adapter
//
dwScale = m_Adapter.GetScale(dwAdapter);
// Determine the zoom level
//
if( g_Options.m_bAutoSize )
{
if( dwScale < 1 )
{
dwZoom = 100;
}
else if( dwScale < 5)
{
dwZoom = 20;
}
else if( dwScale < 25)
{
dwZoom = 4;
}
else if( dwScale < 50)
{
dwZoom = 2;
}
else
{
dwZoom = 1;
}
}
if (NULL == m_hdcGraph)
{
return;
}
// Draw a black background into the graph
//
FillRect(m_hdcGraph, &m_rcGraph, (HBRUSH) GetStockObject(BLACK_BRUSH));
int Width = lpdi->rcItem.right - lpdi->rcItem.left;
int Scale = (Width - 1) / HIST_SIZE;
if (0 == Scale)
{
Scale = 2;
}
// Draw the graph paper. The zoom effects the horzontal lines
//
ULONG ulWidth = DrawAdapterGraphPaper(m_hdcGraph, &m_rcGraph, Width, dwZoom);
DWORD nValue;
dwScale = 0;
lpdi->rcItem.left += ulWidth;
if( g_Options.m_bGraphBytesSent )
{
// Draw the bytes sent graph. Check the max value plotted
//
nValue = DrawGraph(&lpdi->rcItem, m_hPens[0], dwZoom, m_Adapter.GetAdapterHistory(dwAdapter,BYTES_SENT_UTIL));
dwScale = nValue > dwScale ? nValue : dwScale;
}
if( g_Options.m_bGraphBytesReceived )
{
// Draw the bytes received graph. Check the max value plotted
//
nValue = DrawGraph(&lpdi->rcItem,m_hPens[1], dwZoom, m_Adapter.GetAdapterHistory(dwAdapter,BYTES_RECEIVED_UTIL));
dwScale = nValue > dwScale ? nValue : dwScale;
}
if( g_Options.m_bGraphBytesTotal)
{
// Draw the bytes total graph. Check the max value plotted
//
nValue = DrawGraph(&lpdi->rcItem,m_hPens[2],dwZoom, m_Adapter.GetAdapterHistory(dwAdapter,BYTES_SENT_UTIL),m_Adapter.GetAdapterHistory(dwAdapter,BYTES_RECEIVED_UTIL));
dwScale = nValue > dwScale ? nValue : dwScale;
}
lpdi->rcItem.left -= ulWidth;
// Save the max value plotted
//
m_Adapter.SetScale(dwAdapter,dwScale);
// Shift and display the graph
//
INT xDiff = 0; //(m_rcGraph.right - m_rcGraph.left) - (lpdi->rcItem.right - lpdi->rcItem.left);
BitBlt( lpdi->hDC,
lpdi->rcItem.left,
lpdi->rcItem.top,
lpdi->rcItem.right - lpdi->rcItem.left,
lpdi->rcItem.bottom - lpdi->rcItem.top,
m_hdcGraph,
xDiff,
0,
SRCCOPY);
}
/*++
Routine Description:
Updates the Network tab's listview
Arguments:
NONE
Return Value:
HRESULT
Revision History:
1-6-2000 Created by omiller
--*/
HRESULT CNetPage::UpdatePage()
{
HRESULT hr = S_OK;
LVITEM lvitem;
INT iColumn = 0;
DWORD dwItemCount;
DWORD dwItem=0;
ULONGLONG ull;
DWORD dwAdapterCount = m_Adapter.GetNumberOfAdapters();
dwItemCount = ListView_GetItemCount(m_hListView);
// Add or update the list view items
//
for(DWORD dwAdapter = 0; dwAdapter < dwAdapterCount; dwAdapter++)
{
// Only show the requested stats
//
iColumn = 0;
while (g_Options.m_ActiveNetCol[iColumn] >= 0)
{
// This buffer needs to hold a 20 digit number with commas and G, M K and sometime bs so it is big enough
WCHAR szw[100];
lvitem.mask = LVIF_TEXT;
lvitem.iSubItem = iColumn;
lvitem.iItem = dwItem;
lvitem.pszText = L"";
lvitem.lParam = (LPARAM)NULL; //&m_Adapter.m_pAdapterInfo[dwAdapter]; //dwAdapter; //NULL; //(LPARAM)pna;
// Get the value
//
switch(g_Options.m_ActiveNetCol[iColumn])
{
case COL_ADAPTERNAME:
case COL_ADAPTERDESC:
case COL_STATE:
lvitem.pszText = m_Adapter.GetAdapterText(dwAdapter,g_Options.m_ActiveNetCol[iColumn]);
break;
case COL_NETWORKUTIL:
case COL_BYTESSENTTHRU:
case COL_BYTESRECTHRU:
case COL_BYTESTOTALTHRU:
// This buffer needs to hold a 20 digit number with commas and G, M K and sometime bs so it is big enough
ull = m_Adapter.GetAdapterStat(dwAdapter,g_Options.m_ActiveNetCol[iColumn],!g_Options.m_bNetShowAll);
FloatToString(ull,szw,FALSE);
lstrcat(szw,L" ");
lstrcat(szw,g_szPercent);
lvitem.pszText = szw;
break;
case COL_LINKSPEED:
ull = m_Adapter.GetAdapterStat(dwAdapter,g_Options.m_ActiveNetCol[iColumn],!g_Options.m_bNetShowAll);
SimplifyNumber(ull,szw);
lstrcat(szw,g_szBitsPerSec);
lvitem.pszText = szw;
break;
case COL_BYTESSENT:
case COL_BYTESREC:
case COL_BYTESTOTAL:
case COL_BYTESSENTPERINTER:
case COL_BYTESRECPERINTER:
case COL_BYTESTOTALPERINTER:
ull = m_Adapter.GetAdapterStat(dwAdapter,g_Options.m_ActiveNetCol[iColumn],!g_Options.m_bNetShowAll);
CommaNumber(ull,szw,100);
lvitem.pszText = szw;
break;
case COL_UNICASTSSSENT:
case COL_UNICASTSREC:
case COL_UNICASTSTOTAL:
case COL_UNICASTSSENTPERINTER:
case COL_UNICASTSRECPERINTER:
case COL_UNICASTSTOTALPERINTER:
case COL_NONUNICASTSSSENT:
case COL_NONUNICASTSREC:
case COL_NONUNICASTSTOTAL:
case COL_NONUNICASTSSENTPERINTER:
case COL_NONUNICASTSRECPERINTER:
case COL_NONUNICASTSTOTALPERINTER:
ull = m_Adapter.GetAdapterStat(dwAdapter,g_Options.m_ActiveNetCol[iColumn],!g_Options.m_bNetShowAll);
CommaNumber(ull,szw,100);
lvitem.pszText = szw;
break;
}
if( dwItem >= dwItemCount)
{
// The adapter is not in the listview, add it
//
lvitem.mask |= LVIF_PARAM;
if( -1 == ListView_InsertItem(m_hListView, &lvitem) )
{
return E_FAIL;
}
dwItemCount = ListView_GetItemCount(m_hListView);
}
else
{
// The adapter is already in the list view, update the value
//
ListView_SetItem(m_hListView, &lvitem);
}
iColumn++;
}
dwItem++;
}
return hr;
}
/*++
Routine Description:
Collect the Adapter information and update the tab
Arguments:
fUpdateHistory -- not used
Return Value:
HRESULT
Revision History:
1-6-2000 Created by omiller
--*/
void CNetPage::CalcNetTime(BOOL fUpdateHistory)
{
BOOLEAN bAdapterListChange = FALSE;
HRESULT hr;
// Update our adapter list with the new stats
//
hr = m_Adapter.Update(bAdapterListChange);
if( SUCCEEDED(hr) )
{
// Collect the adapter information
//
if( m_bReset )
{
// Reset the Adapter start values
//
m_Adapter.Reset();
m_bReset = FALSE;
}
if( bAdapterListChange )
{
// Some adapters changed, update the graphs (create and delete graphs)
//
Refresh();
}
// Update the listview
//
UpdatePage();
}
}
void CNetPage::Refresh()
{
m_Adapter.RefreshConnectionNames();
SizeNetPage();
ListView_DeleteAllItems(m_hListView);
}
/*++
Routine Description:
Handle the timer event
Arguments:
NONE
Return Value:
NONE
Revision History:
1-6-2000 Created by omiller
--*/
void CNetPage::TimerEvent()
{
// If the Network tab is not selected and the user does not want to waste cpu usage for the networking adapter history
// do not do any of the Networking calculations.
//
if( m_bPageActive || g_Options.m_bTabAlwaysActive)
{
// This will make the graph scrolll
//
g_NetScrollamount+=2;
g_NetScrollamount %= GRAPHPAPERSIZE;
// Collect the Adapter information
//
CalcNetTime(TRUE);
// Check if window minimized
//
if (FALSE == IsIconic(g_hMainWnd))
{
UpdateGraphs();
}
}
}
DWORD CNetPage::GetNumberOfGraphs()
{
return m_dwGraphCount;
}
void CNetPage::ScrollGraphs(WPARAM wParam, LPARAM lParam)
{
SCROLLINFO si;
si.cbSize = sizeof(SCROLLINFO);
si.fMask = SIF_ALL;
if( GetScrollInfo(m_hScrollBar,SB_CTL,&si) )
{
switch(LOWORD(wParam))
{
case SB_BOTTOM:
si.nPos = si.nMax;
break;
case SB_TOP:
si.nPos = si.nMin;
break;
case SB_LINEDOWN:
si.nPos++;
break;
case SB_LINEUP:
si.nPos--;
break;
case SB_PAGEUP:
si.nPos -= m_dwGraphsPerPage;
break;
case SB_PAGEDOWN:
si.nPos += m_dwGraphsPerPage;
break;
case SB_THUMBTRACK:
case SB_THUMBPOSITION:
si.nPos = HIWORD(wParam);
break;
}
if( si.nPos < si.nMin )
{
si.nPos = si.nMin;
}
else if( si.nPos > si.nMax )
{
si.nPos = si.nMax;
}
m_dwFirstVisibleAdapter = si.nPos;
SetScrollPos(m_hScrollBar,SB_CTL,si.nPos,TRUE);
LabelGraphs();
}
}
/*++
Routine Description:
Window Proc for the Networking tab
Arguments:
hwnd -- handle to dialog box
uMsg -- message
wParam -- first message parameter
lParam -- second message parameter
Return Value:
NO IDEA
Revision History:
1-6-2000 Created by omiller
--*/
INT_PTR CALLBACK NetPageProc(
HWND hwnd, // handle to dialog box
UINT uMsg, // message
WPARAM wParam, // first message parameter
LPARAM lParam // second message parameter
)
{
CNetPage * thispage = (CNetPage *) GetWindowLongPtr(hwnd, GWLP_USERDATA);
// See if the parent wants this message
//
if (TRUE == CheckParentDeferrals(uMsg, wParam, lParam))
{
return TRUE;
}
switch(uMsg)
{
// Size our kids
//
case WM_SHOWWINDOW:
case WM_SIZE:
thispage->SizeNetPage();
return TRUE;
case WM_INITDIALOG:
{
SetWindowLongPtr(hwnd, GWLP_USERDATA, lParam);
DWORD dwStyle = GetWindowLong(hwnd, GWL_STYLE);
dwStyle |= WS_CLIPCHILDREN;
SetWindowLong(hwnd, GWL_STYLE, dwStyle);
return TRUE;
}
// We need to fake client mouse clicks in this child to appear as nonclient
// (caption) clicks in the parent so that the user can drag the entire app
// when the title bar is hidden by dragging the client area of this child
case WM_LBUTTONUP:
case WM_LBUTTONDOWN:
{
if (g_Options.m_fNoTitle)
{
SendMessage(g_hMainWnd,
uMsg == WM_LBUTTONUP ? WM_NCLBUTTONUP : WM_NCLBUTTONDOWN,
HTCAPTION,
lParam);
}
break;
}
case WM_COMMAND :
{
if( LOWORD(wParam) == IDM_NETRESET)
{
thispage->Reset();
}
break;
}
case WM_NCLBUTTONDBLCLK:
case WM_LBUTTONDBLCLK:
{
return 0;
}
// Draw one of our owner draw controls
//
case WM_DRAWITEM:
{
if (wParam >= IDC_NICGRAPH && wParam <= (WPARAM)(IDC_NICGRAPH + thispage->GetNumberOfGraphs()) )
{
thispage->DrawAdapterGraph( (LPDRAWITEMSTRUCT) lParam, (UINT)wParam - IDC_NICGRAPH);
return TRUE;
}
}
case WM_DESTROY:
thispage->RememberColumnOrder(GetDlgItem(hwnd, IDC_NICTOTALS));
break;
case WM_VSCROLL:
thispage->ScrollGraphs(wParam,lParam);
return 0;
default:
return FALSE;
}
return FALSE;
}