windows-server-2003/net/config/shell/statmon/smgenpsp.cpp

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1998.
//
//  File:       S M G E N P S P . C P P
//
//  Contents:   The rendering of the UI for the network status monitor.
//
//  Notes:
//
//  Author:     CWill   6 Oct 1997
//
//----------------------------------------------------------------------------

#include "pch.h"
#pragma hdrstop

#include "foldinc.h"

#include "ncatlui.h"
#include "ncnetcon.h"
#include "ncperms.h"
#include "ncui.h"
#include "ncreg.h"
#include "nsres.h"
#include "sminc.h"
#include "smpsh.h"
#include "windutil.h"

#include "conprops.h"
#include "oncommand.h"

#include "pidlutil.h"

#include "openfold.h"
#include "..\folder\confold.h"
#include "cfpidl.h"

DWORD  MapRSSIToWirelessSignalStrength(int iRSSI);
PCWSTR PszGetRSSIString(int iRSSI);

//
//  Function Prototypes
//

VOID CompressionToSz(UINT uiCompression, WCHAR* pchbuffer);

//
//  Common Strings
//
extern const WCHAR c_szNetShellDll[];

//
//  Constants
//

const UINT  c_unLocalRefreshTimerID = 817;
const INT  c_iSignalStrengthIconXOffset = 24;
const INT  c_iSignalStrengthIconYOffset = -32;

//
//  ShowLanErrors
//
static const WCHAR  c_szRegKeyStatmonRoot[] = L"System\\CurrentControlSet\\Control\\Network\\Connections\\StatMon";
static const WCHAR  c_szShowLanErrors[]     = L"ShowLanErrors";

// forward declaration
DWORD PropertyThread(CNetStatisticsEngine * pnse);


//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::CPspStatusMonitorGen
//
//  Purpose:    Creator
//
//  Arguments:  None
//
//  Returns:    Nil
//
CPspStatusMonitorGen::CPspStatusMonitorGen() :
    m_psmEngineData(NULL),
    m_pnseStat(NULL),
    m_dwConPointCookie(0),
    m_fStats(FALSE),
    m_ncmType(NCM_LAN),
    m_ncsmType(NCSM_LAN),
    m_dwCharacter(0),
    m_dwLastUpdateStatusDisplayTick(0),
    m_fProcessingTimerEvent(FALSE),
    m_fIsFirstPage(FALSE),
    m_iLastSignalStrength(-100)
{
    TraceFileFunc(ttidStatMon);
}


//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::FinalRelease
//
//  Purpose:    Called after last Release.
//
//  Arguments:  None
//
//  Returns:    Nil
//
VOID
CPspStatusMonitorGen::FinalRelease(VOID)
{
    TraceFileFunc(ttidStatMon);
    
    (VOID) HrCleanupGenPage();
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::HrInitGenPage
//
//  Purpose:    Before the property page is populated, we have to make sure
//              that we have some of the required data.  This method
//              initializes the page so that it is ready to be shown.
//
//  Arguments:  pnseNew - The statistics engine associated with this page
//              pncNew  - The connection the page is being created for
//
//  Returns:    Error code
//
HRESULT
CPspStatusMonitorGen::HrInitGenPage (
    CNetStatisticsEngine*   pnseNew,
    INetConnection*         pncNew,
    const DWORD *           adwHelpIDs)
{
    TraceFileFunc(ttidStatMon);

    HRESULT                     hr              = S_OK;
    INetStatisticsEngine*       pnseInter       = pnseNew;
              
    AssertSz(pnseNew, "We don't have a pnseNew");

    // Set context help ID
    m_adwHelpIDs = adwHelpIDs;

    // Initialize the engine data
    //
    AssertSz(!m_psmEngineData, "We should't have a m_psmEngineData");

    DWORD dwBytes = sizeof(STATMON_ENGINEDATA);
    PVOID pbBuf;
    hr = HrCoTaskMemAlloc(dwBytes, &pbBuf);
    if (SUCCEEDED(hr))
    {
        m_psmEngineData = reinterpret_cast<STATMON_ENGINEDATA *>(pbBuf);
        ZeroMemory(m_psmEngineData, sizeof(STATMON_ENGINEDATA));
    }

    // Advise the interface
    //
    if (SUCCEEDED(hr))
    {
        IConnectionPoint*   pcpStat = NULL;

        hr = ::HrGetPcpFromPnse(pnseInter, &pcpStat);
        if (SUCCEEDED(hr))
        {
            INetConnectionStatisticsNotifySink* pncsThis = this;

            hr = pcpStat->Advise(pncsThis, &m_dwConPointCookie);

            ::ReleaseObj(pcpStat);
        }
    }

    // Keep track of our owner
    //
    if (SUCCEEDED(hr))
    {
        AssertSz(!m_pnseStat, "We should't have a m_pnseStat");
        m_pnseStat = pnseNew;
        ::AddRefObj(pnseInter);
    }

    TraceError("CPspStatusMonitorGen::HrInitGenPage", hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::OnInitDialog
//
//  Purpose:    When the page comes up, initialize the fields
//
//  Arguments:  Standard command parameters
//
//  Returns:    Standard return
//
LRESULT
CPspStatusMonitorGen::OnInitDialog (
    UINT    uMsg,
    WPARAM  wParam,
    LPARAM  lParam,
    BOOL&   bHandled)
{
    TraceFileFunc(ttidStatMon);
    
    // initialize data member
    m_iStatTrans = Stat_Unknown;

    // Initialize the icon in the dialog by forcing it to change
    //
    UpdatePageIcon(SMDCF_TRANSMITTING | SMDCF_RECEIVING);
    UpdatePageIcon(SMDCF_NULL);

    UpdateSignalStrengthIcon(0);

    // Tell the CNetStatisticsEngine about our parent property sheet
    // so if someone attempts to bring up a statistics monitor we
    // can utilize the existing one
    //
    Assert(m_pnseStat);
    m_pnseStat->SetPropsheetWindow(GetParent());

    // Start our local refresh timer with a 1 second period.
    //
    SetTimer (c_unLocalRefreshTimerID, 1000, NULL);

    // leaving creating mode
    m_pnseStat->UnSetCreatingDialog();

    BOOL fEnableDisconnect = TRUE;  // Should we disable the Disconnect button
    BOOL fEnableProperties = TRUE;  // Should we disable the Properties button
    BOOL fShowErrorCount = TRUE;
    
    switch(m_ncmType)
    {
    case NCM_LAN:
    case NCM_BRIDGE:
        fEnableDisconnect = FHasPermission(NCPERM_LanConnect);
        fEnableProperties = FHasPermission(NCPERM_LanProperties);
        if(!FIsShowLanErrorRegKeySet())
        {
            fShowErrorCount = FALSE;
        }
        ::ShowWindow(GetDlgItem(IDC_TXT_ERROR), fShowErrorCount);
        ::ShowWindow(GetDlgItem(IDC_TXT_SM_ERROR_TRANS), fShowErrorCount);
        ::ShowWindow(GetDlgItem(IDC_TXT_SM_ERROR_RECV), fShowErrorCount);
        ::ShowWindow(GetDlgItem(IDC_FRM_LONG), fShowErrorCount);
        ::ShowWindow(GetDlgItem(IDC_FRM_SHORT), !fShowErrorCount); // reversed...
        break;
    
    case NCM_SHAREDACCESSHOST_RAS:
        ::SetWindowText(GetDlgItem(IDC_PSB_DISCONNECT), ::SzLoadIds(IDS_SM_PSH_DISCONNECT)); // If RAS connection, change the "Disable" button to "Disconnect"
        //fallthru
    case NCM_SHAREDACCESSHOST_LAN:
        {
            // TODO fEnableDisconnect
            // TODO fEnableProperties
            HRESULT hr;

            fShowErrorCount = FALSE; // no error stuff in spec
        }
        break;
    
    case NCM_TUNNEL:
        ::ShowWindow(GetDlgItem(IDC_TXT_SM_SPEED_LABEL), FALSE);
        ::ShowWindow(GetDlgItem(IDC_TXT_SM_SPEED), FALSE);
        //fallthru
    
    case NCM_DIRECT: // REVIEW correct?
    case NCM_ISDN:
    case NCM_PHONE:
    case NCM_PPPOE:
        fEnableDisconnect = FHasPermission(NCPERM_RasConnect);
        if (
            (m_dwCharacter & NCCF_INCOMING_ONLY) ||
            ((m_dwCharacter & NCCF_ALL_USERS) && !FHasPermission(NCPERM_RasAllUserProperties)) ||
            (!(m_dwCharacter & NCCF_ALL_USERS) && !FHasPermission(NCPERM_RasMyProperties)) 
           )
        {
            fEnableProperties = FALSE;
        }
        ::SetWindowText(GetDlgItem(IDC_PSB_DISCONNECT), ::SzLoadIds(IDS_SM_PSH_DISCONNECT)); // If RAS connection, change the "Disable" button to "Disconnect"

        ::ShowWindow(GetDlgItem(IDC_TXT_ERROR), fShowErrorCount);
        ::ShowWindow(GetDlgItem(IDC_TXT_SM_ERROR_TRANS), fShowErrorCount);
        ::ShowWindow(GetDlgItem(IDC_TXT_SM_ERROR_RECV), fShowErrorCount);
        ::ShowWindow(GetDlgItem(IDC_FRM_LONG), fShowErrorCount);
        ::ShowWindow(GetDlgItem(IDC_FRM_SHORT), !fShowErrorCount); // reversed...
        break;
    
    default:
        AssertSz(FALSE, "Unknown media type");
        break;
    }
    
    ::EnableWindow(::GetDlgItem(m_hWnd, IDC_PSB_DISCONNECT), fEnableDisconnect);
    ::EnableWindow(::GetDlgItem(m_hWnd, IDC_PSB_PROPERTIES), fEnableProperties);

    if (m_fIsFirstPage)
    {
        // get window handle to propertysheet
        HWND hwndParent=GetParent();
        Assert(hwndParent);

        // center the property sheet on desktop
        FCenterWindow (hwndParent, NULL);
        
        // hide the "ok" button
        //
        ::ShowWindow(::GetDlgItem(hwndParent, IDOK), FALSE);
    }
	

    return TRUE;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::OnSetActive
//
//  Purpose:    Enable statistics when the page has focus
//
//  Arguments:  Standard notification parameters
//
//  Returns:    Standard return
//
LRESULT
CPspStatusMonitorGen::OnSetActive (
    INT     idCtrl,
    LPNMHDR pnmh,
    BOOL&   bHandled)
{
    TraceFileFunc(ttidStatMon);

    HRESULT     hr  = S_OK;

    // Only turn them on if they are not running
    //
    if (!m_fStats)
    {
        hr = m_pnseStat->StartStatistics();
        m_fStats = TRUE;
    }

    // User's intent is to view statistics, so give them an immediate
    // refreshed view of them.
    //
    ::PostMessage (m_hWnd, PWM_UPDATE_STATUS_DISPLAY, 0, SMDCF_NULL);

    TraceError("CPspStatusMonitorGen::OnSetActive", hr);
    return LresFromHr(hr);
}


//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::OnKillActive
//
//  Purpose:    Disable statistics when the page is changed
//
//  Arguments:  Standard notification parameters
//
//  Returns:    Standard return
//
LRESULT
CPspStatusMonitorGen::OnKillActive (
    INT     idCtrl,
    LPNMHDR pnmh,
    BOOL&   bHandled)
{
    TraceFileFunc(ttidStatMon);

    HRESULT     hr  = S_OK;

    // Only turn them off if they are running
    //
    if (m_fStats)
    {
        hr = m_pnseStat->StopStatistics();
        m_fStats = FALSE;
    }

    TraceError("CPspStatusMonitorGen::OnKillActive", hr);
    return LresFromHr(hr);
}


//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::OnClose
//
//  Purpose:    Cleans up the items in the page when the dialog is being
//              closed
//
//  Arguments:  Standard command parameters
//
//  Returns:    Standard return
//
LRESULT
CPspStatusMonitorGen::OnClose (
    UINT    uMsg,
    WPARAM  wParam,
    LPARAM  lParam,
    BOOL&   bHandled)
{
    return DestroyWindow();
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::OnDestroy
//
//  Purpose:    Cleans up the items in the page when the dialog is being
//              destroyed
//
//  Arguments:  Standard command parameters
//
//  Returns:    Standard return
//
LRESULT
CPspStatusMonitorGen::OnDestroy (
    UINT    uMsg,
    WPARAM  wParam,
    LPARAM  lParam,
    BOOL&   bHandled)
{
    TraceFileFunc(ttidStatMon);

    HWND  hwndIcon = ::GetDlgItem(m_hWnd, IDI_SM_STATUS_ICON);
    HICON hOldIcon = reinterpret_cast<HICON>(::SendMessage(
            hwndIcon,
            STM_GETICON,
            0,
            0));

    if (hOldIcon)
    {
        DestroyIcon(hOldIcon);
    }


    HRESULT                 hr          = S_OK;

    AssertSz(m_pnseStat, "We should have a m_pnseStat");

    // Make sure we don't get released during our destroy
    //
    ::AddRefObj(this);

    // Stop our local refresh timer
    //
    KillTimer (c_unLocalRefreshTimerID);

    // Make sure stats are in a happy state
    //
    if (m_fStats)
    {
        (VOID) m_pnseStat->StopStatistics();
        m_fStats = FALSE;
    }

    //
    //  *** Do this last ***
    //
    //  It is very likely this will result in the this page being destroyed
    //  if it is the window closing
    //

    m_pnseStat->SetPropsheetWindow(NULL);

    // Clean up all the interfaces
    //
    hr = HrCleanupGenPage();

    m_iLastSignalStrength       = -100;

    ::ReleaseObj(this);

    TraceError("CPspStatusMonitorGen::OnDestroy", hr);
    return 0;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::HrCleanupGenPage
//
//  Purpose:    Cleans out all the interfaces that are used by the open page
//
//  Arguments:  None
//
//  Returns:    Error code
//
HRESULT
CPspStatusMonitorGen::HrCleanupGenPage (
    VOID)
{
    TraceFileFunc(ttidStatMon);

    HRESULT                 hr          = S_OK;
    INetStatisticsEngine*   pnseStat    = m_pnseStat;

    // Only disconnect if we haven't already.
    //
    if (pnseStat)
    {
        // Unadvise the interface
        //
        IConnectionPoint*       pcpStat     = NULL;

        if (m_dwConPointCookie
            && (SUCCEEDED(::HrGetPcpFromPnse(pnseStat, &pcpStat))))
        {
            (VOID) pcpStat->Unadvise(m_dwConPointCookie);

            ::ReleaseObj(pcpStat);

            // Very important to zero the cookie.  This tells
            // OnStatisticsChanged that we're no longer interested in updates.
            //
            m_dwConPointCookie = 0;
        }

        if (m_psmEngineData)
        {
            CoTaskMemFree(m_psmEngineData);
            m_psmEngineData = NULL;
        }

        //
        //  *** Do this last ***
        //
        //  It is very likely this will result in the this page being destroyed
        //  if it is the window closing
        //

        m_pnseStat = NULL;
        ::ReleaseObj(pnseStat);
    }

    TraceError("CPspStatusMonitorGen::HrCleanupGenPage", hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::OnContextMenu
//
//  Purpose:    When right click a control, bring up help
//
//  Arguments:  Standard command parameters
//
//  Returns:    Standard return
//
LRESULT
CPspStatusMonitorGen::OnContextMenu(UINT uMsg,
                                    WPARAM wParam,
                                    LPARAM lParam,
                                    BOOL& fHandled)
{
    TraceFileFunc(ttidStatMon);

    if (m_adwHelpIDs != NULL)
    {
        ::WinHelp(m_hWnd,
                  c_szNetCfgHelpFile,
                  HELP_CONTEXTMENU,
                  (ULONG_PTR)m_adwHelpIDs);
    }
    return 0;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::OnHelp
//
//  Purpose:    When drag context help icon over a control, bring up help
//
//  Arguments:  Standard command parameters
//
//  Returns:    Standard return
//
LRESULT
CPspStatusMonitorGen::OnHelp(UINT uMsg,
                             WPARAM wParam,
                             LPARAM lParam,
                             BOOL& fHandled)
{
    TraceFileFunc(ttidStatMon);

    LPHELPINFO lphi = reinterpret_cast<LPHELPINFO>(lParam);
    Assert(lphi);

    if ((m_adwHelpIDs != NULL) && (HELPINFO_WINDOW == lphi->iContextType))
    {
        ::WinHelp(static_cast<HWND>(lphi->hItemHandle),
                  c_szNetCfgHelpFile,
                  HELP_WM_HELP,
                  (ULONG_PTR)m_adwHelpIDs);
    }

    return 0;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::OnDisconnect
//
//  Purpose:    When the disconnect button is hit, disconnect the connection
//              and closes the dialog
//
//  Arguments:  Standard notification parameters
//
//  Returns:    Standard return
//
LRESULT CPspStatusMonitorGen::OnDisconnect(WORD wNotifyCode, WORD wID,
                                           HWND hWndCtl, BOOL& fHandled)
{
    TraceFileFunc(ttidStatMon);

    HRESULT hr  = S_OK;

    switch (wNotifyCode)
    {
    case BN_CLICKED:
    case BN_DOUBLECLICKED:
        {
            hr = HrDisconnectConnection();
        }
    }

    TraceError("CPspStatusMonitorGen::OnDisconnect", hr);
    return 0;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::OnRaiseproperties
//
//  Purpose:    Bring up the property of this connection
//
//  Arguments:  Standard notification parameters
//
//  Returns:    Standard return
//
LRESULT CPspStatusMonitorGen::OnRaiseProperties(WORD wNotifyCode, WORD wID,
                                                HWND hWndCtl, BOOL& fHandled)
{
    TraceFileFunc(ttidStatMon);

    HRESULT hr  = S_OK;

    switch (wNotifyCode)
    {
    case BN_CLICKED:
    case BN_DOUBLECLICKED:
        {

            // Addref m_pnseStat object
            //
            AddRefObj(static_cast<INetStatisticsEngine *>(m_pnseStat));

            // Make sure the netshell.dll is not unloaded
            //
            HINSTANCE hInst = LoadLibrary(c_szNetShellDll);
            HANDLE hthrd = NULL;

            // Create the property sheet on a different thread
            //
            if (hInst)
            {
                DWORD  dwThreadId;
                hthrd = CreateThread(NULL, STACK_SIZE_TINY,
                                     (LPTHREAD_START_ROUTINE)PropertyThread,
                                     (LPVOID)m_pnseStat, 0, &dwThreadId);
            }

            if (NULL != hthrd)
            {
                CloseHandle(hthrd);
            }
            else
            {
                /// Release m_pnseStat object on failure
                //
                ReleaseObj(static_cast<INetStatisticsEngine *>(m_pnseStat));

                // release the dll 
                //
                if (hInst)
                    FreeLibrary(hInst);

                hr = HrFromLastWin32Error();
            }
        }
    }

    TraceError("CPspStatusMonitorGen::OnRaiseproperties", hr);
    return 0;
}

DWORD PropertyThread(CNetStatisticsEngine * pnse)
{
    HRESULT hr = S_OK;
    
    // Create a new scope since FreeLibraryAndExitThread will not call destructors on global scope
    {
        TraceFileFunc(ttidStatMon);

        BOOL    fUninitCom = TRUE;

        // Initialize COM on this thread
        //
        hr = CoInitializeEx(NULL, COINIT_DISABLE_OLE1DDE | COINIT_APARTMENTTHREADED);
        if (RPC_E_CHANGED_MODE == hr)
        {
            hr = S_OK;
            fUninitCom = FALSE;
        }

        if (SUCCEEDED(hr))
        {
            INetConnection* pncMonitor  = NULL;

            // Get the INetConnection
            //
            Assert (pnse);
            hr = pnse->HrGetConnectionFromBlob(&pncMonitor);

            if (SUCCEEDED(hr))
            {
                hr = HrRaiseConnectionProperties(NULL, pncMonitor);
            }
            ReleaseObj(pncMonitor);
        }

        if (fUninitCom)
        {
            CoUninitialize();
        }

        // release input interface
        ReleaseObj(static_cast<INetStatisticsEngine *>(pnse));

        TraceError("PropertyThread", hr);
    }

    // release the library we loaded
    FreeLibraryAndExitThread(GetModuleHandle(c_szNetShellDll), hr);

    return 1;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::HrDisconnectConnection
//
//  Purpose:    disconnect the connection and closes the dialog if succeeded
//
//  Arguments:  fConfirmed  TRUE if the user has confirmed to disconnect the connection
//
//  Returns:    Standard return
//
HRESULT CPspStatusMonitorGen::HrDisconnectConnection(BOOL   fConfirmed)
{
    TraceFileFunc(ttidStatMon);

    HRESULT hr;

    Assert (m_pnseStat);

    // Get the INetConnection
    //
    INetConnection* pncMonitor;

    hr = m_pnseStat->HrGetConnectionFromBlob(&pncMonitor);
    if (SUCCEEDED(hr))
    {
        PCONFOLDPIDL pidlConnection;

        hr = HrCreateConFoldPidl(WIZARD_NOT_WIZARD, pncMonitor, pidlConnection);
        if (SUCCEEDED(hr))
        {
            CONFOLDENTRY ccfe;

            hr = pidlConnection.ConvertToConFoldEntry(ccfe);
            if (SUCCEEDED(hr))
            {
                // Get the pidl for the Connections Folder
                //
                PCONFOLDPIDLFOLDER pidlFolder;
                hr = HrGetConnectionsFolderPidl(pidlFolder);
                if (SUCCEEDED(hr))
                {
                    // Get the Connections Folder object
                    //
                    LPSHELLFOLDER psfConnections;

                    hr = HrGetConnectionsIShellFolder(pidlFolder, &psfConnections);
                    if (SUCCEEDED(hr))
                    {
                        hr = HrOnCommandDisconnectInternal(ccfe,
                                                           m_hWnd,
                                                           psfConnections);
                        ReleaseObj(psfConnections);
                    }
                }
            }
        }

        // release INetConnection interface
        ReleaseObj(pncMonitor);
    }

    // If anything above failed.
    //
    if (SUCCEEDED(hr))
    {
        if (S_OK == hr)
        {
            // close the property sheet
            HWND hwndPS = ::GetParent(m_hWnd);

            // Push the Close ("Cancel") button to close dialog
            //
            ::PostMessage(hwndPS, WM_COMMAND, MAKEWPARAM(IDCANCEL, 0),
                          (LPARAM)::GetDlgItem(hwndPS, IDCANCEL));
        }
        else
        {
            // Disconnect confirmation canceled. Do nothing (don't close
            // statmon, anyway).
            //
            AssertSz(S_FALSE == hr, "Disconnect != S_OK or S_FALSE, but succeeded? What is it then?");
        }
    }
    else
    {
        TraceError("pncMonitor->Disconnect", hr);

        // Warn the user and don't close if we couldn't disconnect
        //
        ::NcMsgBox( m_hWnd,
                    IDS_SM_ERROR_CAPTION,
                    IDS_SM_ERROR_CANNOT_DISCONNECT,
                    MB_ICONWARNING);
    }

    TraceError("CPspStatusMonitorGen::HrDisconnectConnection", hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::OnSetCursor
//
//  Purpose:    Ensure the mouse cursor over the Property Sheet is an Arrow.
//
//  Arguments:  Standard command parameters
//
//  Returns:    Standard return
//

LRESULT
CPspStatusMonitorGen::OnSetCursor (
    UINT    uMsg,
    WPARAM  wParam,
    LPARAM  lParam,
    BOOL&   bHandled)
{
    TraceFileFunc(ttidStatMon);

    if (LOWORD(lParam) == HTCLIENT)
    {
        SetCursor(LoadCursor(NULL, IDC_ARROW));
    }

    return FALSE;
}

LRESULT
CPspStatusMonitorGen::OnTimer (
    UINT    uMsg,
    WPARAM  wParam,
    LPARAM  lParam,
    BOOL&   bHandled)
{
    TraceFileFunc(ttidStatMon);

    // Prevent same-thread re-entrancy.  Any Win32 call made while
    // processing this event that return control to the message
    // loop may cause this timer to fire again.
    //
    if (!m_fProcessingTimerEvent)
    {
        m_fProcessingTimerEvent = TRUE;

        // If we're within 200 milliseconds of the last time we updated the
        // status display, don't bother doing it again.  This covers the case
        // where our timer coincides with the timer in smcent which would
        // would cause us to update the status display twice in rapid
        // succession each time the timers fire.
        //
        DWORD dwTick = GetTickCount ();
        if (dwTick > m_dwLastUpdateStatusDisplayTick + 200)
        {
            OnUpdateStatusDisplay (uMsg, 0, m_dwChangeFlags, bHandled);
        }

        m_fProcessingTimerEvent = FALSE;
    }
    return 0;
}

LRESULT
CPspStatusMonitorGen::OnUpdateStatusDisplay(
    UINT    uMsg,
    WPARAM  wParam,
    LPARAM  lParam,
    BOOL&   bHandled)
{
    TraceFileFunc(ttidStatMon);

    HRESULT hr = S_OK;
    DWORD dwChangeFlags = (DWORD)lParam;

    // We may be in the process of disconnecting the statistics page in
    // which case m_dwConPointCookie will be zero.
    //
    if (m_dwConPointCookie)
    {
        Assert (m_psmEngineData);

        STATMON_ENGINEDATA*  psmNewData = NULL;
        hr = m_pnseStat->GetStatistics(&psmNewData);

        if (SUCCEEDED(hr) && psmNewData)
        {
            if (m_psmEngineData)
            {
                //
                // Display the new stats
                //
                UpdatePage(m_psmEngineData, psmNewData);

                // Update the icon image
                //
                UpdatePageIcon(dwChangeFlags);

                UpdateSignalStrengthIcon(psmNewData->SMED_802_11_SIGNAL_STRENGTH);

                // Note the clock tick of when we last updated
                // the status display.
                //
                m_dwLastUpdateStatusDisplayTick = GetTickCount();

                // Replace the old data with the new
                //
                CoTaskMemFree(m_psmEngineData);
            }

            m_psmEngineData = psmNewData;
        }
    }
    else
    {
        TraceTag (ttidStatMon,
            "CPspStatusMonitorGen::OnStatisticsChanged called but we've "
            "been closed.  Ignoring.");
    }
    TraceError("CPspStatusMonitorGen::OnUpdateStatusDisplay", hr);
    return 0;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::OnStatisticsChanged
//
//  Purpose:    This is the callback that tell the property page that the
//              data on the page has changed
//
//  Arguments:  dwCookie -      The cookie of the connection that has changed
//              dwChangeFlags - What has changed
//
//  Returns:    Error code
//
STDMETHODIMP
CPspStatusMonitorGen::OnStatisticsChanged(
    DWORD dwChangeFlags)
{
    TraceFileFunc(ttidStatMon);

    ::PostMessage (m_hWnd, PWM_UPDATE_STATUS_DISPLAY, 0, dwChangeFlags);
    return S_OK;
}


//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::UpdatePage
//
//  Purpose:    Fill the fields on the page with new data
//
//  Arguments:  pseOldData -    The old stats being displayed on the page
//              pseNewData -    The new stats being displayed on the page
//
//  Returns:    Nothing
//
VOID
CPspStatusMonitorGen::UpdatePage (
    STATMON_ENGINEDATA* pseOldData,
    const STATMON_ENGINEDATA* pseNewData)
{
    TraceFileFunc(ttidStatMon);

    AssertSz(pseOldData, "We don't have a puiOld");
    AssertSz(pseNewData, "We don't have a puiNew");

    //
    // Update the dialog fields
    //
    UpdatePageConnectionStatus(pseOldData, pseNewData);

    UpdatePageDuration(pseOldData, pseNewData);

    UpdatePageSpeed(pseOldData, pseNewData);

    // If the StatMon is not getting any bytes (a common problem with net
    // cards), display packets instead
    //
    if (ShouldShowPackets(pseNewData))
    {
        // Only change the label if we have to
        //
        if (Stat_Packets != m_iStatTrans)
        {
            SetDlgItemText(IDC_TXT_SM_BYTES_LABEL, ::SzLoadIds(IDS_SM_PACKETS));
            m_iStatTrans = Stat_Packets;

            // Force a refresh
            //
            pseOldData->SMED_PACKETSTRANSMITTING = 0;
            pseOldData->SMED_PACKETSRECEIVING = 0;
        }

        UpdatePageBytesTransmitting(pseOldData, pseNewData, Stat_Packets);
        UpdatePageBytesReceiving(pseOldData, pseNewData, Stat_Packets);
    }
    else
    {
        // Only change the label if we have to
        //
        if (Stat_Bytes != m_iStatTrans)
        {
            SetDlgItemText(IDC_TXT_SM_BYTES_LABEL, ::SzLoadIds(IDS_SM_BYTES));
            m_iStatTrans = Stat_Bytes;

            // Force a refresh
            //
            pseOldData->SMED_BYTESTRANSMITTING = 0;
            pseOldData->SMED_BYTESRECEIVING = 0;
        }

        UpdatePageBytesTransmitting(pseOldData, pseNewData, Stat_Bytes);
        UpdatePageBytesReceiving(pseOldData, pseNewData, Stat_Bytes);
    }

    UpdatePageCompTransmitting(pseOldData, pseNewData);
    UpdatePageCompReceiving(pseOldData, pseNewData);

    UpdatePageErrorsTransmitting(pseOldData, pseNewData);
    UpdatePageErrorsReceiving(pseOldData, pseNewData);
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::ShouldShowPackets
//
//  Purpose:    Decided whether to show bytes or packets
//
//  Arguments:  pseNewData -    The new stats being displayed on the page
//
//  Returns:    Nothing
//

BOOL CPspStatusMonitorGen::ShouldShowPackets(const STATMON_ENGINEDATA* pseNewData)
{
    TraceFileFunc(ttidStatMon);

    return (0 == pseNewData->SMED_BYTESTRANSMITTING) && (0 == pseNewData->SMED_BYTESRECEIVING);
}


//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::UpdatePageSpeed
//
//  Purpose:    Updates the speed display on the general page
//
//  Arguments:  pseOldData -    The old stats being displayed on the page
//              pseNewData -    The new stats being displayed on the page
//
//  Returns:    Nothing
//
VOID
CPspStatusMonitorGen::UpdatePageSpeed(
    const STATMON_ENGINEDATA* pseOldData,
    const STATMON_ENGINEDATA* pseNewData)
{
    TraceFileFunc(ttidStatMon);

    AssertSz(pseOldData, "We don't have a pseOldData");
    AssertSz(pseNewData, "We don't have a pseNewData");

    // Get the data and see if either is different
    //
    if ((pseOldData->SMED_SPEEDTRANSMITTING != pseNewData->SMED_SPEEDTRANSMITTING)
        || (pseOldData->SMED_SPEEDRECEIVING != pseNewData->SMED_SPEEDRECEIVING))
    {
        WCHAR achBuffer[MAX_PATH];

        FormatTransmittingReceivingSpeed (
            pseNewData->SMED_SPEEDTRANSMITTING,
            pseNewData->SMED_SPEEDRECEIVING,
            achBuffer);

        // Set the control text.
        //
        SetDlgItemText(IDC_TXT_SM_SPEED, achBuffer);
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::UpdatePageConnectionStatus
//
//  Purpose:    Update the connections field on the property page
//
//  Arguments:  puiOldData -    The old stats being displayed on the page
//              puiNewData -    The new stats being displayed on the page
//
//  Returns:    Nothing
//
VOID
CPspStatusMonitorGen::UpdatePageConnectionStatus(
    const STATMON_ENGINEDATA* pseOldData,
    const STATMON_ENGINEDATA* pseNewData)
{
    TraceFileFunc(ttidStatMon);

    AssertSz(pseOldData, "We don't have a pseOldData");
    AssertSz(pseNewData, "We don't have a pseNewdata");

    // Update the Connection Status
    //
    if ((pseNewData->SMED_CONNECTIONSTATUS == NCS_DISCONNECTED) ||
        (pseOldData->SMED_CONNECTIONSTATUS != pseNewData->SMED_CONNECTIONSTATUS))
    {
        INT idsConnection   = IDS_SM_CS_DISCONNECTED;

        // Make sure our strings are still intact
        AssertSz((((IDS_SM_CS_DISCONNECTED + 1) == IDS_SM_CS_CONNECTING)
            && ((IDS_SM_CS_DISCONNECTED + 2) == IDS_SM_CS_CONNECTED)
            && ((IDS_SM_CS_DISCONNECTED + 3) == IDS_SM_CS_DISCONNECTING)
            && ((IDS_SM_CS_DISCONNECTED + 4) == IDS_SM_CS_HARDWARE_NOT_PRESENT)
            && ((IDS_SM_CS_DISCONNECTED + 5) == IDS_SM_CS_HARDWARE_DISABLED)
            && ((IDS_SM_CS_DISCONNECTED + 6) == IDS_SM_CS_HARDWARE_MALFUNCTION)),
                "Some one has been messing with connection status strings");

        idsConnection = (IDS_SM_CS_DISCONNECTED
                        + pseNewData->SMED_CONNECTIONSTATUS);

        if (idsConnection == IDS_SM_CS_DISCONNECTED)
        {
            // close the property sheet
            HWND hwndPS = ::GetParent(m_hWnd);

            TraceTag(ttidStatMon, "Closing Status Monitor page because status was: DISCONNECTED");
            // Push the Close ("Cancel") button to close dialog
            //
            ::PostMessage(hwndPS, WM_COMMAND, MAKEWPARAM(IDCANCEL, 0),
                          (LPARAM)::GetDlgItem(hwndPS, IDCANCEL));
        }
        else
        {
            SetDlgItemText(IDC_TXT_SM_STATUS, ::SzLoadIds(idsConnection));
        }
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::UpdatePageIcon
//
//  Purpose:    Update the icon on the property page
//
//  Arguments:  dwChangeFlags -  The new changed state
//
//  Returns:    Nothing
//
VOID
CPspStatusMonitorGen::UpdatePageIcon (
    DWORD dwChangeFlags)
{
    TraceFileFunc(ttidStatMon);

    // If either of these have changed, change the icon
    // so we'll know to update the icon
    //
    if (((SMDCF_TRANSMITTING | SMDCF_RECEIVING) & m_dwChangeFlags)
        != ((SMDCF_TRANSMITTING | SMDCF_RECEIVING) & dwChangeFlags))
    {
        HICON   hStatusIcon    = 0;
        HWND    hwndIcon       = NULL;

        //  Get the new icon
        //
        hStatusIcon = GetCurrentConnectionStatusIconId(m_ncmType, m_ncsmType, m_dwCharacter, dwChangeFlags);
        if (hStatusIcon)
        {
            hwndIcon = ::GetDlgItem(m_hWnd, IDI_SM_STATUS_ICON);

            // Set the icon to the new one
            //
            HICON hOldIcon = reinterpret_cast<HICON>(::SendMessage(
                    hwndIcon,
                    STM_SETICON,
                    (WPARAM)hStatusIcon,
                    0));

            DestroyIcon(hOldIcon);
        }
    }

    // Keep the flags for the next update
    //
    m_dwChangeFlags = dwChangeFlags;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::UpdateSignalStrengthIcon
//
//  Purpose:    Update the icon on the property page
//
//  Arguments:  iRSSI -  The new signal strenghth
//
//  Returns:    Nothing
//
inline
VOID
CPspStatusMonitorGen::UpdateSignalStrengthIcon (
    INT iRSSI)
{
    TraceFileFunc(ttidStatMon);

    if (0 == iRSSI)
    {
        if (0 != m_iLastSignalStrength)
        {
            ::ShowWindow(::GetDlgItem(m_hWnd, IDC_TXT_SM_SIGNAL_STRENGTH),  SW_HIDE);
            ::ShowWindow(::GetDlgItem(m_hWnd, IDI_SM_SIGNAL_STRENGTH_ICON), SW_HIDE);
        }

        m_iLastSignalStrength = iRSSI;

        return;
    }
    else
    {
        if (0 == m_iLastSignalStrength)
        {
            ::ShowWindow(::GetDlgItem(m_hWnd, IDC_TXT_SM_SIGNAL_STRENGTH),  SW_SHOW);
            ::ShowWindow(::GetDlgItem(m_hWnd, IDI_SM_SIGNAL_STRENGTH_ICON), SW_SHOW);
        }
    }
    
    INT     idStatusIcon    = 0;
    m_iLastSignalStrength   = iRSSI;

    //  Get the new icon
    //
    idStatusIcon = IDI_802_11_LEVEL0 + MapRSSIToWirelessSignalStrength(iRSSI);

    HWND hwndSignalStrength = ::GetDlgItem(m_hWnd, IDI_SM_SIGNAL_STRENGTH_ICON);
    Assert(hwndSignalStrength);
    if (hwndSignalStrength) 
    {
        HDC hdcSignalStrength = ::GetDC(hwndSignalStrength);
        Assert(hdcSignalStrength);
        if (hdcSignalStrength)
        {

            HICON hIconSignalStrength = LoadIconTile(_Module.GetResourceInstance(), MAKEINTRESOURCE(idStatusIcon));
            Assert(hIconSignalStrength);
            if (hIconSignalStrength)
            {
                ::DrawIconEx(hdcSignalStrength, 
                             c_iSignalStrengthIconXOffset,
                             c_iSignalStrengthIconYOffset,
                             hIconSignalStrength, 
                             48, 48, 0, NULL, DI_IMAGE | DI_MASK);
                DestroyIcon(hIconSignalStrength);
            }

            ::ReleaseDC(hwndSignalStrength, hdcSignalStrength);
        }
    }
}


//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::UpdateSignalStrengthIcon
//
//  Purpose:    Update the icon on the property page
//
//  Arguments:  iRSSI -  The new signal strenghth
//
//  Returns:    Nothing
//
LRESULT CPspStatusMonitorGen::OnPaint (
    UINT    uMsg,
    WPARAM  wParam,
    LPARAM  lParam,
    BOOL&   bHandled)
{
    TraceFileFunc(ttidStatMon);

    PAINTSTRUCT ps;
    BeginPaint(&ps);
    
    UpdateSignalStrengthIcon(m_iLastSignalStrength);
    
    EndPaint(&ps);

    bHandled = TRUE;
    return 0;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::UpdatePageDuration
//
//  Purpose:    Updates the duration display on the general page
//
//  Arguments:  pseOldData -    The old stats being displayed on the page
//              pseNewData -    The new stats being displayed on the page
//
//  Returns:    Nothing
//
VOID
CPspStatusMonitorGen::UpdatePageDuration(
    const STATMON_ENGINEDATA* pseOldData,
    const STATMON_ENGINEDATA* pseNewData)
{
    TraceFileFunc(ttidStatMon);

    AssertSz(pseOldData, "We don't have a pseOldData");
    AssertSz(pseNewData, "We don't have a pseNewData");

    // Get the see if either is different
    //
    if (pseOldData->SMED_DURATION != pseNewData->SMED_DURATION)
    {
        tstring strDuration;

        // Format the time duration as a string
        //
        FormatTimeDuration(pseNewData->SMED_DURATION, &strDuration);

        // Set the control
        //
        SetDlgItemText(IDC_TXT_SM_DURATION, strDuration.c_str());
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::UpdatePageBytesTransmitting
//
//  Purpose:    Updates the bytes Transmitting display on the general page
//
//  Arguments:  pseOldData -    The old stats being displayed on the page
//              pseNewData -    The new stats being displayed on the page
//              iStat      -    The which stats to display
//
//  Returns:    Nothing
//
VOID
CPspStatusMonitorGen::UpdatePageBytesTransmitting(
    const STATMON_ENGINEDATA* pseOldData,
    const STATMON_ENGINEDATA* pseNewData,
    StatTrans    iStat)
{
    TraceFileFunc(ttidStatMon);

    AssertSz(pseOldData, "We don't have a pseOldData");
    AssertSz(pseNewData, "We don't have a pseNewData");

    AssertSz(((Stat_Packets == iStat) || (Stat_Bytes == iStat)), "We have an invalid iStat");

    UINT64 ui64Old;
    UINT64 ui64New;

    if (Stat_Bytes == iStat)
    {
        ui64Old = pseOldData->SMED_BYTESTRANSMITTING;
        ui64New = pseNewData->SMED_BYTESTRANSMITTING;
    }
    else
    {
        ui64Old = pseOldData->SMED_PACKETSTRANSMITTING;
        ui64New = pseNewData->SMED_PACKETSTRANSMITTING;
    }

    // See if either is different
    //
    if (ui64Old != ui64New)
    {
        SetDlgItemFormatted64bitInteger(
            m_hWnd,
            IDC_TXT_SM_BYTES_TRANS,
            ui64New, FALSE);
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::UpdatePageBytesReceiving
//
//  Purpose:    Updates the bytes receiving display on the general page
//
//  Arguments:  puiOld -    The old stats being displayed on the page
//              puiNew -    The new stats being displayed on the page
//              iStat -     The which stats to display
//
//  Returns:    Nothing
//
VOID
CPspStatusMonitorGen::UpdatePageBytesReceiving(
    const STATMON_ENGINEDATA* pseOldData,
    const STATMON_ENGINEDATA* pseNewData,
    StatTrans    iStat)
{
    TraceFileFunc(ttidStatMon);

    AssertSz(pseOldData, "We don't have a puiOld");
    AssertSz(pseNewData, "We don't have a puiNew");
    AssertSz(((Stat_Packets == iStat) || (Stat_Bytes == iStat)), "We have an invalid iStat");

    UINT64 ui64Old;
    UINT64 ui64New;

    if (Stat_Bytes == iStat)
    {
        ui64Old = pseOldData->SMED_BYTESRECEIVING;
        ui64New = pseNewData->SMED_BYTESRECEIVING;
    }
    else
    {
        ui64Old = pseOldData->SMED_PACKETSRECEIVING;
        ui64New = pseNewData->SMED_PACKETSRECEIVING;
    }

    // See if either is different
    //
    if (ui64Old != ui64New)
    {
        SetDlgItemFormatted64bitInteger(
            m_hWnd,
            IDC_TXT_SM_BYTES_RCVD,
            ui64New, FALSE);
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::UpdatePageCompTransmitting
//
//  Purpose:    Updates the compression transmitting display on the general
//              page
//
//  Arguments:  pseOldData -    The old stats being displayed on the page
//              pseNewData -    The new stats being displayed on the page
//
//  Returns:    Nothing
//
VOID
CPspStatusMonitorGen::UpdatePageCompTransmitting(
    const STATMON_ENGINEDATA* pseOldData,
    const STATMON_ENGINEDATA* pseNewData)
{
    TraceFileFunc(ttidStatMon);

    AssertSz(pseOldData, "We don't have a pseOldData");
    AssertSz(pseNewData, "We don't have a pseNewData");

    // See if either is different
    //
    if (pseOldData->SMED_COMPRESSIONTRANSMITTING
            != pseNewData->SMED_COMPRESSIONTRANSMITTING)
    {
        WCHAR   achBuf[20];

        CompressionToSz(pseNewData->SMED_COMPRESSIONTRANSMITTING, achBuf);

        SetDlgItemText(IDC_TXT_SM_COMP_TRANS, achBuf);
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::UpdatePageCompReceiving
//
//  Purpose:    Updates the compression receiving display on the general page
//
//  Arguments:  pseOldData -    The old stats being displayed on the page
//              pseNewData -    The new stats being displayed on the page
//
//  Returns:    Nothing
//
VOID
CPspStatusMonitorGen::UpdatePageCompReceiving(
    const STATMON_ENGINEDATA* pseOldData,
    const STATMON_ENGINEDATA* pseNewData)
{
    TraceFileFunc(ttidStatMon);

    AssertSz(pseOldData, "We don't have a puiOld");
    AssertSz(pseNewData, "We don't have a puiNew");

    // see if either is different
    //
    if (pseOldData->SMED_COMPRESSIONRECEIVING != pseNewData->SMED_COMPRESSIONRECEIVING)
    {
        WCHAR   achBuf[20];

        CompressionToSz(pseNewData->SMED_COMPRESSIONRECEIVING, achBuf);

        SetDlgItemText(IDC_TXT_SM_COMP_RCVD, achBuf);
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::UpdatePageErrorsTransmitting
//
//  Purpose:    Updates the compression transmitting display on the general
//              page
//
//  Arguments:  pseOldData -    The old stats being displayed on the page
//              pseNewData -    The new stats being displayed on the page
//
//  Returns:    Nothing
//
VOID
CPspStatusMonitorGen::UpdatePageErrorsTransmitting(
    const STATMON_ENGINEDATA* pseOldData,
    const STATMON_ENGINEDATA* pseNewData)
{
    TraceFileFunc(ttidStatMon);

    AssertSz(pseOldData, "We don't have a pseOldData");
    AssertSz(pseNewData, "We don't have a pseNewData");

    // See if either is different
    //
    if (pseOldData->SMED_ERRORSTRANSMITTING
            != pseNewData->SMED_ERRORSTRANSMITTING)
    {
        SetDlgItemFormatted32bitInteger (
                m_hWnd,
                IDC_TXT_SM_ERROR_TRANS,
                pseNewData->SMED_ERRORSTRANSMITTING,
                FALSE);
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CPspStatusMonitorGen::UpdatePageErrorsReceiving
//
//  Purpose:    Updates the compression receiving display on the general page
//
//  Arguments:  pseOldData -    The old stats being displayed on the page
//              pseNewData -    The new stats being displayed on the page
//
//  Returns:    Nothing
//
VOID
CPspStatusMonitorGen::UpdatePageErrorsReceiving(
    const STATMON_ENGINEDATA* pseOldData,
    const STATMON_ENGINEDATA* pseNewData)
{
    TraceFileFunc(ttidStatMon);

    AssertSz(pseOldData, "We don't have a pseOldData");
    AssertSz(pseNewData, "We don't have a pseNewData");

    // see if either is different
    //
    if (pseOldData->SMED_ERRORSRECEIVING != pseNewData->SMED_ERRORSRECEIVING)
    {
        SetDlgItemFormatted32bitInteger (
                m_hWnd,
                IDC_TXT_SM_ERROR_RECV,
                pseNewData->SMED_ERRORSRECEIVING,
                FALSE);
    }
}

//+---------------------------------------------------------------------------
//
//  Function:   CompressionToSz
//
//  Purpose:    To format nicely BPS into a readable string
//
//  Arguments:  uiCompression   - The amount of compression
//              pchBuffer       - The Buffer to receive the string
//
//  Returns:    Nothing
//
VOID
CompressionToSz (
    UINT    uiCompression,
    WCHAR*  pchBuffer)
{
    TraceFileFunc(ttidStatMon);

    AssertSz((((INT)uiCompression >= 0) && ((INT)uiCompression <= 100)),
        "Invalid compression");

    wsprintfW(pchBuffer, L"%lu %%", uiCompression);
}

//+---------------------------------------------------------------------------
//
//  Function:   FIsShowLanErrorRegKeySet
//
//  Purpose:    Check if the registry key is set:
//              System\CurrentControlSet\Control\Network\Connections\StatMon\ShowLanErrors
//
//  Arguments:
//
//  Returns:    Nothing
//
BOOL CPspStatusMonitorGen::FIsShowLanErrorRegKeySet()
{
    TraceFileFunc(ttidStatMon);

    BOOL fRet = FALSE;

    HKEY hkeyStatmonRoot = NULL;
    HRESULT hr = S_OK;

    // "System\\CurrentControlSet\\Control\\Network\\Connections\\StatMon\\ShowLanErrors"
    hr = ::HrRegOpenKeyEx(
            HKEY_LOCAL_MACHINE,
            c_szRegKeyStatmonRoot,
            KEY_READ,
            &hkeyStatmonRoot);

    if (SUCCEEDED(hr))
    {
        Assert(hkeyStatmonRoot);

        DWORD dwValue =0;
        hr = HrRegQueryDword(hkeyStatmonRoot, c_szShowLanErrors, &dwValue);

        if SUCCEEDED(hr)
        {
            fRet = !!dwValue;
        }
        RegCloseKey(hkeyStatmonRoot);
    }

    return fRet;
}