NT4/private/sdktools/winmeter/winmeter.c

/***************************************************************************\
* winmeter.c
*
* Microsoft Confidential
* Copyright (c) 1991 Microsoft Corporation
*
* main module for WINMETER application - sets up windows, etc.
*
* History:
*           Written by Hadi Partovi (t-hadip) summer 1991
*
*           Re-written and adapted for NT by Fran Borda (v-franb) Nov.1991
*           for Newman Consulting
*           Took out all WIN-specific and bargraph code. Added 3 new
*           linegraphs (Mem/Paging, Process/Threads/Handles, IO), and
*           tailored info to that available under NT.
\***************************************************************************/

#include "winmeter.h"

// Main global information structures
GLOBAL g;

// local function declarations
int PASCAL WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    LPSTR lpszCmdLine, int nCmdShow); // main function
long FAR PASCAL WndProc (HWND, WORD, WPTYPE, LONG);
                                                // window procedure
extern SYSTEM_PERFORMANCE_INFORMATION PerfInfo,PreviousPerfInfo;
extern int win_on_top;
extern void   FreeDatabaseMemory(void) ;
extern void   QueryThreadData(void);

                                                // dialog procedures
void EnableIntervalField(HWND hdlg, BOOL fEnable);
                                        // enables Sampling Interval field
BOOL fRefreshDlgOK(HWND hdlg);                  // handles OK - refresh dlg
BOOL HandleCMD(WPTYPE wParam, DWORD lParam);    // handles WM_COMMAND msg
void HandleKey(WPTYPE wParam, DWORD lParam);    // handles keyboard input
void HandleKeyUp(WPTYPE wParam, DWORD lParam);  // handles keyboard input
void HandleSwitchToNewLG(PLGRAPH plg);          // handle switch to LG
void HandleTimer(WPTYPE wParam, DWORD lParam);  // handles WM_TIMER messages
void InitializeMenu(void);                      // initializes main menu
void InitializeRefreshDlgInfo(HWND hdlg, BOOL fManual, int  nInterval);
                                                // initialize refresh dialog
void KillWinmeterTimer(void);                   // destroys timer

BOOL FAR PASCAL OKDlgProc(HWND, WORD, WPTYPE, LONG);
BOOL FAR PASCAL RefreshDlgProc(HWND, WORD, WPTYPE, LONG);
BOOL FAR PASCAL AboutDlgProc(HWND, WORD, WPTYPE, LONG);

void ResetWinmeterTimer(void);                  // resets timer
void SetWindowTitle(void);                      // to reflect current display
void SetWinmeterTimer(void);                    // sets up timer
void UnCheckDisplayMenuItems(void);             // removes menu checkmarks

/***************************************************************************\
* main()
\***************************************************************************/
int _CRTAPI1 main(
    int argc,
    char *argv[])
{
    HANDLE hInstance;
    hInstance=GetModuleHandle("WINMETER");
    WinMain(hInstance, 0, NULL, SW_SHOWNORMAL);
    return 1;
    argc, argv; // just to avoid compiler warning that param not used
}

/***************************************************************************\
* WinMain()
\***************************************************************************/
int PASCAL WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    LPSTR lpszCmdLine, int nCmdShow)
{
    MSG         msg;
    WNDCLASS    wndclass;

    // open file for debugging (#ifdef DEBUGDUMP)
    OPENDUMPFILE;

    g.hInstance = hInstance;

    // set up menu
    g.hMenu = LoadMenu(g.hInstance, MAKEINTRESOURCE(IDM_MAINMENU));
    if (!g.hMenu)
        return 0;


    // set up application name
    MyLoadString(IDS_APPNAME);
    g.lpszAppName = MemAlloc(lstrlen(g.szBuf)+1);
    if (!g.lpszAppName)
        return 0;

    lstrcpy(g.lpszAppName, g.szBuf);

    // load initial settings
    LoadRefreshSettings();
    LoadWindowSettings();
    LoadLGDispSettings();
    g.fDisplayMenu=TRUE;

    if (!hPrevInstance)
    {
        wndclass.style         = CS_DBLCLKS | CS_BYTEALIGNCLIENT;
        wndclass.lpfnWndProc   = (WNDPROC) WndProc;
        wndclass.hInstance     = g.hInstance;
        wndclass.cbClsExtra    = 0;
        wndclass.cbWndExtra    = 0;
        wndclass.hIcon         = LoadIcon (g.hInstance, g.lpszAppName);
        wndclass.hCursor       = LoadCursor (NULL, IDI_APPLICATION);
        wndclass.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
        wndclass.lpszMenuName  = NULL;
        wndclass.lpszClassName = g.lpszAppName;

        if (!RegisterClass (&wndclass))
            return 0;

    }

    NtQuerySystemInformation(SystemPerformanceInformation,
            &PerfInfo,
            sizeof(PerfInfo),
            NULL
            );
    PreviousPerfInfo = PerfInfo;

    g.hwnd = CreateWindow (g.lpszAppName, g.lpszAppName,
                         WS_OVERLAPPEDWINDOW | WS_VSCROLL,
                         g.xWindowLeft, g.yWindowTop, g.cxClient, g.cyClient,
                         NULL, NULL, g.hInstance, NULL);
    if (!g.hwnd)
        return 0;


    SetMenu(g.hwnd, g.hMenu);
    SetWindowTitle();

    // set up sampling timer with default value
    if (!g.fManualSampling)
        SetWinmeterTimer();


    ShowWindow (g.hwnd, nCmdShow);
    SetFocus(g.hwnd);
    UpdateWindow (g.hwnd);

    while (GetMessage (&msg, NULL, 0, 0))
    {
        TranslateMessage (&msg);
        DispatchMessage (&msg);
    }
    return msg.wParam;
    lpszCmdLine;
}

/***************************************************************************\
 * WndProc()
 *
 * Entry: Regular WndProc parameters
 * Exit:  Handles all top level User Interface, main WindowProcedure
\***************************************************************************/
long FAR PASCAL WndProc (HWND hwnd, WORD message, WPTYPE wParam, LONG lParam)
{
    HDC          hdc;
    PAINTSTRUCT  ps;

    switch (message) {
    case WM_TIMER:
        HandleTimer(wParam, lParam);
        return 0;

    case WM_SIZE:
        if (win_on_top)
            SetWindowPos(g.hwnd, (HWND) -1,0,0,0,0,SWP_NOMOVE | SWP_NOSIZE);
        HandleSize(wParam, lParam);
        return 0;


    case WM_PAINT:
        hdc = BeginPaint (hwnd, &ps);
        SetupDC(hdc);
        if (g.LineGraph)
            DoLineGraphics(hdc, &(ps.rcPaint));

        ResetDC(hdc);
        EndPaint (hwnd, &ps);
        return 0;

    case WM_KEYDOWN:
        HandleKey(wParam, lParam);
        return 0;

    case WM_KEYUP:
        HandleKeyUp(wParam, lParam);
        return 0;

    case WM_COMMAND:
        if (HandleCMD(wParam, lParam)) {
            return 0;
        }
        break;

    case WM_NCLBUTTONDBLCLK:
        // user double clicked on a non-client area of the window
        // in case the menu is hidden, this might be an attempt to
        // bring it back (clicking on the client area when menu is hidden
        // is translated to clicking on the caption bar (see WM_NCHHITTEST)
        if ((g.fMenuFits) && (g.fDisplayMenu)) {
            // pass to DefWndProc()
            break;
        }
        // otherwise, fall through...

    case WM_LBUTTONDBLCLK:
        DoMouseDblClk(lParam);
        return 0;

    case WM_NCHITTEST:
        /* if we have no title/menu bar, clicking and dragging the client
         * area moves the window. To do this, return HTCAPTION.
         * Note dragging not allowed if window maximized, or if caption
         * bar is present.
         */
        lParam = DefWindowProc(hwnd, message, wParam, lParam);
        if((!g.fMenuFits || !g.fDisplayMenu) && (lParam == HTCLIENT)
                    && !IsZoomed(hwnd) ) {
            return HTCAPTION;
        }
        else {
            return lParam;
        }

    case WM_CREATE:

        // NewCon: 10/25/91,
        // g.hwnd is undefined until we return from the CreateWindow call.
        // so during the processing of this WM_CREATE message we need to
        // assign the window handle passed into this WinProc so things
        // will work.

        g.hwnd = hwnd ;

        GetFont(hwnd);
        GetBrushesAndPens();
        InitializeDatabase();
        LoadDisplayState();
        InitializeMenu();

        // force initial display, but without scrollbar
        SetScrollRange(hwnd, SB_VERT, 0, 0, TRUE);

        ClearLineGraph() ;

        PostMessage(hwnd, WM_TIMER, TIMER_ID, 0L);
        return 0;

    case WM_GETMINMAXINFO:
        SetMinMaxInfo(wParam, lParam);
        return 0;

    case WM_DESTROY:
#ifdef DEBUGDUMP
        doCloseDumpFile();
#endif
        KillWinmeterTimer();
        SaveDisplayState();
        TossBrushesAndPens();
        FreeDatabaseMemory();
        SaveWindowSettings();
        PostQuitMessage (0);
        return 0;

    case WM_SYSCOLORCHANGE:
        if (g.BlankBrush) {
            DeleteObject(g.BlankBrush);
        }
        g.BlankBrush = CreateSolidBrush(BLANK_COLOR);
        break;
    }

    return DefWindowProc (hwnd, message, wParam, lParam);
}


/***************************************************************************\
 * EnableIntervalField()
 *
 * Entry: Handle to dialog box, and a enable flag
 * Exit:  If fEnable is TRUE, enables field. Else disables it
 *        This is so that the user can't change the sampling rate if he
 *        has selected manual sampling
\***************************************************************************/
void EnableIntervalField(
    HWND hdlg,                      // handle to dialog box
    BOOL fEnable)                   // flag specifying what to do
{
    EnableWindow(GetDlgItem(hdlg,IDD_INTERVAL),fEnable);
    EnableWindow(GetDlgItem(hdlg,IDD_INTERVALTEXT1),fEnable);
    EnableWindow(GetDlgItem(hdlg,IDD_INTERVALTEXT2),fEnable);

    return;
}

/***************************************************************************\
 * ErrorExit()
 *
 * Entry: A string to display
 * Exit:  Displays the string in a message box, then destroys window
 *        NOTE: THIS DOES NOT WORK RIGHT IN WIN32. IT WILL CRASH THE
 *        PROGRAM. A METHOD OF EXITING SHOULD BE USED (like _exit(0))
\***************************************************************************/
void ErrorExit(
    PSTR pszError)          // string to display
{
    g.fStopQuerying=TRUE;
    if (g.hwnd)
    {
        MessageBox(NULL, pszError, g.lpszAppName, WINMETER_MB_FLAGS);
        DestroyWindow(g.hwnd);
    }
    return;
}

/***************************************************************************\
 * fRefreshDlgOK()
 *
 * Entry: Handle to dialog box
 * Exit:  Processes pressing the OK button
 *        RETURNS TRUE IF DATA WAS OK, FALSE OTHERWISE
\***************************************************************************/
BOOL fRefreshDlgOK(
    HWND hdlg)                   // handle to dialog box
{
    int  wInterval;         // interval requested
    BOOL fOK;               // flag, if numeric entry OK
    BOOL fOldfManual=FALSE; // flag -> old g.fManualSampling value
    char szBuf[TEMP_BUF_LEN];// used for message if number out of range

    if (g.fManualSampling)
        fOldfManual=TRUE;


    // check radio buttons, etc. check that values are OK, ...
    g.fManualSampling = IsDlgButtonChecked(hdlg, IDD_MANUAL);
    wInterval=GetDlgItemInt(hdlg,IDD_INTERVAL,&fOK, FALSE);
    if (!fOK)
    {
        // bad numeric entry in edit box
        wsprintf(szBuf, MyLoadString(IDS_NONNUMERIC),0,UINT_MAX);
        MessageBox(NULL, szBuf, g.lpszAppName,
                MB_TASKMODAL|MB_ICONEXCLAMATION|MB_OK);
        SetFocus(GetDlgItem(hdlg,IDD_INTERVAL));
        return FALSE;
    }

    // implement requested changes
    g.nTimerInterval=wInterval;
    if (g.fManualSampling)
    {
        // kill old timer
        if (!fOldfManual)
            KillWinmeterTimer();

        EnableMenuItem(g.hMenu, IDM_REFRESH_NOW, MF_ENABLED);
    }
    else
    {
        // set new timer interval
        if (fOldfManual)
            SetWinmeterTimer();
        else
            ResetWinmeterTimer();

        NtQuerySystemInformation(SystemPerformanceInformation,
            &PerfInfo,
            sizeof(PerfInfo),
            NULL
            );
        PreviousPerfInfo = PerfInfo;
        EnableMenuItem(g.hMenu, IDM_REFRESH_NOW, MF_GRAYED);
    }

    return TRUE;
}

/***************************************************************************\
 * HandleCMD()
 *
 * Entry: the wParam and lParam from the WM_COMMAND message
 * Exit:  checks what menuitem was selected, and acts accordingly
 *          Returns true if actually processed the message, false otherwise
\***************************************************************************/
BOOL HandleCMD(
    WPTYPE wParam,        // wParam from WndProc WM_COMMAND message
    DWORD  lParam)        // lParam from WndProc WM_COMMAND message
{
    switch(wParam)
    {
    case IDM_CPU_USAGE:


        if ((g.LineGraph == DO_CPU) && (g.plg == g.plgCPU))
            return FALSE;  // no switch necessary, do default processing

        g.LineGraph = DO_CPU;

        // check the correct menu item
        UnCheckDisplayMenuItems();
        CheckMenuItem(g.hMenu, IDM_CPU_USAGE, MF_CHECKED);

        HandleSwitchToNewLG(g.plgCPU);

        return TRUE;

    case IDM_MEM_USAGE:

        if ((g.LineGraph == DO_MEM) && (g.plg == g.plgMemory))
            return FALSE;   // pass to DefaultWndProc

        g.LineGraph = DO_MEM;

        // check correct menu item
        UnCheckDisplayMenuItems();
        CheckMenuItem(g.hMenu, IDM_MEM_USAGE, MF_CHECKED);

        HandleSwitchToNewLG(g.plgMemory);

        return TRUE;

    case IDM_IO_USAGE:

        if ((g.LineGraph == DO_IO) && (g.plg == g.plgIO))
            return FALSE;   // pass to DefaultWndProc

        g.LineGraph = DO_IO;

        // check correct menu item
        UnCheckDisplayMenuItems();
        CheckMenuItem(g.hMenu, IDM_IO_USAGE, MF_CHECKED);

        HandleSwitchToNewLG(g.plgIO);

        return TRUE;

    case IDM_PROCS:

        if ((g.LineGraph == DO_PROCS) && (g.plg == g.plgProcs))
            return FALSE;   // pass to DefaultWndProc

        g.LineGraph = DO_PROCS;

        // check correct menu item
        UnCheckDisplayMenuItems();
        CheckMenuItem(g.hMenu, IDM_PROCS, MF_CHECKED);

        HandleSwitchToNewLG(g.plgProcs);

        return TRUE;


    case IDM_CLEAR_GRAPH:

        ClearLineGraph();
        RedrawLineGraph();
        return TRUE;

    case IDM_DISPLAY_LEGEND:

        CheckMenuItem(g.hMenu, IDM_DISPLAY_LEGEND,
            ((g.fDisplayLegend^=1) ? MF_CHECKED : MF_UNCHECKED));
        // fake a window resize to do recalculations, etc.
        HandleSize(SIZENORMAL, MAKELONG((WORD) g.cxClient, (WORD) g.cyClient));
        SaveLGDispSettings();
        return TRUE;

    case IDM_DISPLAY_CALIBRATION:

        CheckMenuItem(g.hMenu, IDM_DISPLAY_CALIBRATION,
            ((g.fDisplayCalibration^=1) ? MF_CHECKED : MF_UNCHECKED));
        // fake a window resize to do recalculations, etc.
        HandleSize(SIZENORMAL, MAKELONG((WORD) g.cxClient, (WORD) g.cyClient));
        SaveLGDispSettings();
        return TRUE;

    case IDM_HIDE_MENU:

        // act as if user double clicked (in LG mode)
        Assert(g.LineGraph);
        SendMessage(g.hwnd, WM_LBUTTONDBLCLK, 0, 0L);
        return TRUE;

    case IDM_EXIT:

        PostMessage(g.hwnd, WM_DESTROY, 0, 0L);
        return TRUE;

    /******************************************\
    ***              OPTIONS MENU            ***
    \******************************************/
    case IDM_SETTINGS:

        SetWindowPos(g.hwnd, (HWND)(win_on_top ? 1 : -1) ,0,0,0,0,SWP_NOMOVE | SWP_NOSIZE);
        win_on_top = !win_on_top;
        CheckMenuItem(g.hMenu, IDM_SETTINGS, win_on_top ? MF_CHECKED : MF_UNCHECKED);
        return TRUE;

    case IDM_REFRESH:
        DialogBox(g.hInstance, MAKEINTRESOURCE(IDD_REFRESH),
            g.hwnd, (WNDPROC) RefreshDlgProc);
        return TRUE;

    case IDM_REFRESH_NOW:
        // force timer tick
        PostMessage(g.hwnd, WM_TIMER, TIMER_ID, 0L);
        return TRUE;

    /******************************************\
    ***              HELP    MENU            ***
    \******************************************/
    case IDM_HELP_ABOUT:

        DialogBox(g.hInstance,MAKEINTRESOURCE(IDD_ABOUT),
            g.hwnd, (WNDPROC) AboutDlgProc);
        return TRUE;

/*
NO HELP EVEN IN MENU
    case IDM_HELP_CONT:
    case IDM_HELP_SEARCH:
        DialogBox(g.hInstance, MAKEINTRESOURCE(IDD_HELP),
            g.hwnd, (WNDPROC) OKDlgProc);
        return TRUE;
*/

    default:
        return FALSE;
    }
    lParam; // just to avoid compiler warning that param not used
}

/***************************************************************************\
 * HandleKey()
 *
 * Entry: the wParam and lParam from the WM_KEYDOWN message
 * Exit:  sends WM_SCROLL message back to the window to mimic scroll bar
 *        (if in manual sampling mode, sends WndProc a WM_TIMER message)
\***************************************************************************/
void HandleKey(
    WPTYPE wParam,       // wParam from WndProc WM_KEYDOWN message
    DWORD  lParam)       // lParam from WndProc WM_KEYDOWN message
{
    if (g.LineGraph)
    {
        // (if not manual sampling, pressing a key should do nothing)
        if (g.fManualSampling)
            // if in linegraph mode, no scrolling (YET)
            SendMessage(g.hwnd, WM_TIMER, TIMER_ID, 0L);

        return;
    }

    switch (wParam)
    {

    case VK_HOME:
        SendMessage(g.hwnd, WM_VSCROLL, SB_TOP, 0L);
        break;

    case VK_END:
        SendMessage(g.hwnd, WM_VSCROLL, SB_BOTTOM, 0L);
        break;

    case VK_PRIOR:
        SendMessage(g.hwnd, WM_VSCROLL, SB_PAGEUP, 0L);
        break;

    case VK_NEXT:
        SendMessage(g.hwnd, WM_VSCROLL, SB_PAGEDOWN, 0L);
        break;

    case VK_UP:
        SendMessage(g.hwnd, WM_VSCROLL, SB_LINEUP, 0L);
        break;

    case VK_DOWN:
        SendMessage(g.hwnd, WM_VSCROLL, SB_LINEDOWN, 0L);
        break;

    default:
        if (g.fManualSampling)
            SendMessage(g.hwnd, WM_TIMER, TIMER_ID, 0L);

        break;
    }

    return;
    lParam; // just to avoid compiler warning that param not used
}

/***************************************************************************\
 * HandleKeyUp()
 *
 * Entry: the wParam and lParam from the WM_KEYUP message
 * Exit:  sends an WM_SCROLL message with SB_ENDSCROLL to end scrolling
\***************************************************************************/
void HandleKeyUp(
    WPTYPE wParam,        // wParam from WndProc WM_KEYUP message
    DWORD  lParam)        // lParam from WndProc WM_KEYUP message
{
    if (g.LineGraph)
        // do nothing if in linegraph mode (YET)
        return;


    switch (wParam)
    {
    case VK_HOME:
    case VK_END:
    case VK_PRIOR:
    case VK_NEXT:
    case VK_UP:
    case VK_DOWN:
        // assume user ended scrolling by releasing a cursor
        // key -> enable querying once more
        SendMessage(g.hwnd, WM_VSCROLL, SB_ENDSCROLL, 0L);
        break;

    default:
        break;
    }

    return;
    lParam; // just to avoid compiler warning that param not used
}

/***************************************************************************\
 * HandleSwitchToNewLG()
 *
 * Entry: Linegraph to switch to
 * Exit:
\***************************************************************************/
void HandleSwitchToNewLG(
    PLGRAPH plg)          // linegraph to switch to
{
    int nMinPos=0;        // to be used to check if scroll bar is up
    int nMaxPos=0;

    if (g.LineGraph)
       // deallocate old linegraph data
       FreeLGValues(FALSE);

    // set up new linegraph
    g.plg = plg;
    AllocLGValues();

    if (g.LineGraph == DO_PROCS)
    {
        g.plg->dvalAxisHeight = T_DEFAULT_DVAL_AXISHEIGHT;
        g.plg->nMaxValues = T_DEFAULT_MAX_VALUES;

    }
    else
    if (g.LineGraph == DO_MEM)
    {
        g.plg->dvalAxisHeight = M_DEFAULT_DVAL_AXISHEIGHT;
        g.plg->nMaxValues = M_DEFAULT_MAX_VALUES;

    }
    else
    if (g.LineGraph == DO_IO)
    {
        g.plg->dvalAxisHeight = I_DEFAULT_DVAL_AXISHEIGHT;
        g.plg->nMaxValues = I_DEFAULT_MAX_VALUES;

    }


    EnableMenuItem(g.hMenu, IDM_CLEAR_GRAPH, MF_ENABLED);
    EnableMenuItem(g.hMenu, IDM_DISPLAY_LEGEND, MF_ENABLED);
    EnableMenuItem(g.hMenu, IDM_DISPLAY_CALIBRATION, MF_ENABLED);
    EnableMenuItem(g.hMenu, IDM_HIDE_MENU, MF_ENABLED);
    CheckMenuItem(g.hMenu, IDM_DISPLAY_LEGEND,
            ((g.fDisplayLegend) ? MF_CHECKED : MF_UNCHECKED));
    CheckMenuItem(g.hMenu, IDM_DISPLAY_CALIBRATION,
            ((g.fDisplayCalibration) ? MF_CHECKED : MF_UNCHECKED));
    GetScrollRange(g.hwnd, SB_VERT, &nMinPos, &nMaxPos);
    if ((nMinPos)||(nMaxPos))
            // scroll bar existed, remove it, this will cause a WM_SIZE
        SetScrollRange(g.hwnd, SB_VERT, 0, 0, TRUE);

    SetWindowTitle();

    if ((!nMinPos) && (!nMaxPos))
        // fake the WM_SIZE message to process the switch
        HandleSize(SIZENORMAL, MAKELONG((WORD) g.cxClient, (WORD) g.cyClient));


    PostMessage(g.hwnd, WM_TIMER, TIMER_ID, 0L);


    return;
}

/***************************************************************************\
 * HandleTimer
 *
 * Entry: the wParam and lParam from the WM_TIMER message
 * Exit:  queries system info, and displays graphics - either linegraph or
 *        bargraph
\***************************************************************************/
void HandleTimer(
    WPTYPE wParam,        // wParam from WndProc WM_TIMER message
    DWORD  lParam)        // lParam from WndProc WM_TIMER message
{
    HDC hdc;

    if (g.fStopQuerying)
        return;


    switch (wParam)
    {
        case TIMER_ID:
            hdc = GetDC(g.hwnd);
            SetupDC(hdc);

            // only do query if not busy scrolling
            if(g.LineGraph == DO_PROCS)
            {
                QueryThreadData();
                UpdateLGS();
                DoLineGraphics(hdc, NULL);

            }
            else
            {
                PreviousPerfInfo = PerfInfo;
                QueryGlobalData();
                UpdateLGS();
                DoLineGraphics(hdc, NULL);
            }


            ResetDC(hdc);
            ReleaseDC(g.hwnd, hdc);
            break;
        default:
            ErrorExit(MyLoadString(IDS_BADTIMERMSG));
    }

    return;
    lParam; // just to avoid compiler warning that param not used
}


/***************************************************************************\
 * InitializeMenu()
 *
 * Entry: None
 * Exit:  Initializes menu based on winmeter settings
\***************************************************************************/
void InitializeMenu(void)
{
    // start with clean slate (just in case)
    UnCheckDisplayMenuItems();


    EnableMenuItem(g.hMenu, IDM_CLEAR_GRAPH, MF_ENABLED);
    EnableMenuItem(g.hMenu, IDM_DISPLAY_LEGEND, MF_ENABLED);
    EnableMenuItem(g.hMenu, IDM_DISPLAY_CALIBRATION, MF_ENABLED);
    EnableMenuItem(g.hMenu, IDM_HIDE_MENU, MF_ENABLED);
    CheckMenuItem(g.hMenu, IDM_DISPLAY_LEGEND,
            ((g.fDisplayLegend) ? MF_CHECKED : MF_UNCHECKED));
    CheckMenuItem(g.hMenu, IDM_DISPLAY_CALIBRATION,
            ((g.fDisplayCalibration) ? MF_CHECKED : MF_UNCHECKED));

    if ((g.LineGraph == DO_CPU) && (g.plg == g.plgCPU))
        CheckMenuItem(g.hMenu, IDM_CPU_USAGE, MF_CHECKED);
    else
    if ((g.LineGraph == DO_PROCS) && (g.plg == g.plgProcs))
        CheckMenuItem(g.hMenu, IDM_PROCS, MF_CHECKED);
    else
    if ((g.LineGraph == DO_MEM) && (g.plg == g.plgMemory))
        CheckMenuItem(g.hMenu, IDM_MEM_USAGE, MF_CHECKED);
    else
    if ((g.LineGraph == DO_IO) && (g.plg == g.plgIO))
        CheckMenuItem(g.hMenu, IDM_IO_USAGE, MF_CHECKED);
    else
    {
        EnableMenuItem(g.hMenu, IDM_CLEAR_GRAPH, MF_GRAYED);
        EnableMenuItem(g.hMenu, IDM_DISPLAY_LEGEND, MF_GRAYED);
        EnableMenuItem(g.hMenu, IDM_DISPLAY_CALIBRATION, MF_GRAYED);
        EnableMenuItem(g.hMenu, IDM_HIDE_MENU, MF_GRAYED);
        CheckMenuItem(g.hMenu, IDM_DISPLAY_LEGEND, MF_UNCHECKED);
        CheckMenuItem(g.hMenu, IDM_DISPLAY_CALIBRATION, MF_UNCHECKED);
    }

    // settings irrespective of current display
    EnableMenuItem(g.hMenu, IDM_REFRESH_NOW,
        (g.fManualSampling) ? MF_ENABLED : MF_GRAYED);

    return;
}

/***************************************************************************\
 * InitializeRefreshDlgInfo()
 *
 * Entry: Handle to dialog box, info to display
 * Exit:  Initializes the refresh dialog box with given values
\***************************************************************************/
void InitializeRefreshDlgInfo(
    HWND hdlg,                   // handle to dialog box
    BOOL fManual,                // information to display
    int  nInterval)
{
    // SAMPLING INTERVAL
    if (fManual)
    {
        CheckRadioButton(hdlg, IDD_AUTOMATIC, IDD_MANUAL, IDD_MANUAL);
        EnableIntervalField(hdlg, FALSE);
    }
    else
    {
        CheckRadioButton(hdlg, IDD_AUTOMATIC, IDD_MANUAL, IDD_AUTOMATIC);
        EnableIntervalField(hdlg, TRUE);
    }
    wsprintf(g.szBuf, "%d", nInterval);
    SetDlgItemText(hdlg, IDD_INTERVAL, g.szBuf);

    return;
}

/***************************************************************************\
 * KillWinmeterTimer()
 *
 * Entry: None
 * Exit:  Destroys timer
\***************************************************************************/
void KillWinmeterTimer(void)
{
    KillTimer(g.hwnd, TIMER_ID);
    return;
}


/***************************************************************************\
 * MyLoadString()
 *
 * Entry: a string ID for the string table
 * Exit:  loads that string into g.szBuf, and returns a pointer to it
\***************************************************************************/
char *MyLoadString(
    WORD wID)           // string ID
{
    LoadString(g.hInstance, wID, g.szBuf, TEMP_BUF_LEN);
    return g.szBuf;
}

/***************************************************************************\
 * OKDlgProc()
 *
 * Entry: Standard dialog procedure stuff
 * Exit:  Closes window with click on OK button
\***************************************************************************/
BOOL FAR PASCAL OKDlgProc(
    HWND hdlg,              // handle to dialog box
    WORD message,           // message ID
    WPTYPE wParam,          // other info
    LONG lParam)
{
    switch (message)
    {
    case WM_INITDIALOG:
        return TRUE;

    case WM_COMMAND:
        switch (wParam)
        {
        case IDOK:
        case IDCANCEL:
            EndDialog(hdlg, 0);
            return TRUE;
        }
        break;
    }
    return FALSE;
    lParam; // just to avoid compiler warning that param not used
}


BOOL FAR PASCAL AboutDlgProc(
    HWND hdlg,
    WORD message,
    WPTYPE wParam,
    LONG lParam)
{
    switch (message)
    {
        case WM_INITDIALOG:
            return TRUE;

        case WM_COMMAND:
            switch (wParam)
            {
                case IDOK:
                case IDCANCEL:
                    EndDialog(hdlg, 0);
                return TRUE;
            }
            break;
    }
    return FALSE;
    lParam; // just to avoid compiler warning that param not used


}

/***************************************************************************\
 * RefreshDlgProc()
 *
 * Entry: Standard dialog procedure stuff
 * Exit:  Changes sampling rate, or uses manual sampling
 *        The global variables are not changed until the user presses ok,
 *        they are just changed on the screen, in case the user wants to
 *        choose cancel (even in the case of a "reset"
\***************************************************************************/
BOOL FAR PASCAL RefreshDlgProc(
    HWND hdlg,              // handle to dialog box
    WORD message,           // message ID
    WPTYPE wParam,          // other info
    LONG lParam)
{
    switch (message)
    {
    case WM_INITDIALOG:
        // initialize info in dialog box
        InitializeRefreshDlgInfo(hdlg, g.fManualSampling, g.nTimerInterval);
        return TRUE;

    case WM_COMMAND:
        switch (wParam)
    {

        // check pressing of radio buttons -> to enable/disable interval
        // edit field
        case IDD_MANUAL:
            CheckRadioButton(hdlg, IDD_AUTOMATIC, IDD_MANUAL, IDD_MANUAL);
            EnableIntervalField(hdlg, FALSE);
            return TRUE;

        case IDD_AUTOMATIC:
            CheckRadioButton(hdlg, IDD_AUTOMATIC, IDD_MANUAL, IDD_AUTOMATIC);
            EnableIntervalField(hdlg, TRUE);
            return TRUE;

        case IDOK:
            if (fRefreshDlgOK(hdlg))
            {
                EndDialog(hdlg, 0);
                SaveRefreshSettings();
            }
            return TRUE;

        case IDD_USEDEFAULT:
            InitializeRefreshDlgInfo(hdlg, DEFAULT_F_MANUAL,
                DEFAULT_TIMER_INTERVAL);
            return TRUE;

        case IDCANCEL:
            EndDialog(hdlg, 0);
            return TRUE;
        }
        break;
    }
    return FALSE;
    lParam; // just to avoid compiler warning that param not used
}

/***************************************************************************\
 * ResetWinmeterTimer()
 *
 * Entry: None
 * Exit:  Resets timer with global interval, if possible
\***************************************************************************/
void ResetWinmeterTimer()
{
    KillWinmeterTimer();
    SetWinmeterTimer();
    return;
}

/***************************************************************************\
 * SetWindowTitle()
 *
 * Entry: None
 * Exit:  Sets the window text to reflect current display
\***************************************************************************/
void SetWindowTitle(void)
{
    char szBuf[TEMP_BUF_LEN];   // to hold window title line

    lstrcpy(szBuf, g.lpszAppName);
    MyLoadString(IDS_TITLE_DIVIDER);
    lstrcat(szBuf, g.szBuf);
    lstrcat(szBuf, g.plg->lpszTitle);

    // display it
    SetWindowText(g.hwnd, szBuf);

    return;
}

/***************************************************************************\
 * SetWinmeterTimer()
 *
 * Entry: None
 * Exit:  Creates a timer with global interval, if possible
\***************************************************************************/
void SetWinmeterTimer()
{
    while (!SetTimer(g.hwnd, TIMER_ID,

                     max(g.nTimerInterval, MAX_TIMER_INTERVAL), NULL)) {
        if (IDCANCEL == MessageBox(NULL, MyLoadString(IDS_MANYCLOCKS),
                g.lpszAppName, MB_ICONHAND|MB_RETRYCANCEL|MB_TASKMODAL)) {
            ErrorExit(MyLoadString(IDS_CANTDOTIMER));
        }
    }

    return;
}

/***************************************************************************\
 * UnCheckDisplayMenuItems()
 *
 * Entry: None
 * Exit:  Unchecks the menu items in the "Display" menu
\***************************************************************************/
void UnCheckDisplayMenuItems(void)
{
    CheckMenuItem(g.hMenu, IDM_CPU_USAGE,       MF_UNCHECKED);
    CheckMenuItem(g.hMenu, IDM_PROCS,           MF_UNCHECKED);
    CheckMenuItem(g.hMenu, IDM_MEM_USAGE,       MF_UNCHECKED);
    CheckMenuItem(g.hMenu, IDM_IO_USAGE,        MF_UNCHECKED);

    return;
}