windows-xp/Source/XPSP1/NT/shell/osshell/cpls/powercfg/alarm.c

/*******************************************************************************
*
*  (C) COPYRIGHT MICROSOFT CORP., 1996
*
*  TITLE:       ALARM.C
*
*  VERSION:     2.0
*
*  AUTHOR:      ReedB
*
*  DATE:        17 Oct, 1996
*
*  DESCRIPTION:
*   Alarm dialog support.
*
*******************************************************************************/

#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>

#include <windows.h>
#include <mmsystem.h>
#include <commctrl.h>
#include <shlobj.h>
#include <shellapi.h>
#include <shlobjp.h>
#include <help.h>
#include <powercfp.h>
#include <mstask.h>
#include <shfusion.h>
#include <ntpoapi.h>

#include "powercfg.h"
#include "pwrresid.h"
#include "PwrMn_cs.h"

// Private functions implemented in ALARM.C
void     EditWorkItem(HWND, LPTSTR);
BOOLEAN  SetSliderStatusText(HWND, UINT, UINT);
BOOLEAN  SetAlarmStatusText(HWND);
#ifdef WINNT
void     HideShowRunProgram(HWND hWnd);
#endif

// Alarm dialog property sheet init data structure:
typedef struct _ALARM_POL_DLG_DATA
{
    LPTSTR  lpszTitleExt;
    WPARAM  wParam;
} ALARM_POL_DLG_DATA, *PALARM_POL_DLG_DATA;

/*******************************************************************************
*
*                     G L O B A L    D A T A
*
*******************************************************************************/

extern HINSTANCE g_hInstance;           // Global instance handle of this DLL.

// This structure is filled in by the Power Policy Manager at CPL_INIT time.
extern SYSTEM_POWER_CAPABILITIES g_SysPwrCapabilities;
extern DWORD g_dwNumSleepStates;
extern DWORD g_dwSleepStatesMaxMin;
extern DWORD g_dwBattryLevelMaxMin;

SYSTEM_POWER_STATE g_spsMaxSleepState = PowerSystemHibernate;

extern UINT g_uiDisableWakesFlag;           // Flag mask value.
extern UINT g_uiOverrideAppsFlag;           // Flag mask value.

// A systary change requires PowerSchemeDlgProc re-init.
extern BOOL g_bSystrayChange;

// Machine is currently capable of hibernate, managed by code in hibernat.c.
extern UINT g_uiPwrActIDs[];

// Persistant storage of this data is managed by POWRPROF.DLL API's.
extern GLOBAL_POWER_POLICY  g_gpp;

// Indices into g_uiPwrActIDs
#define ID_STANDBY  0
#define ID_SHUTDOWN 1

// Local visable/enabled control state variables.
UINT g_uiSoundState;
UINT g_uiTextState;
UINT g_uiProgState;
UINT g_uiLoChangeEnable;
UINT g_uiLoChangeState;
UINT g_uiAlwaysHide = CONTROL_HIDE;

UINT g_uiNotifySoundFlag   = POWER_LEVEL_USER_NOTIFY_SOUND;
UINT g_uiNotifyTextFlag    = POWER_LEVEL_USER_NOTIFY_TEXT;

#ifdef WINNT
UINT g_uiNotifyProgFlag    = POWER_LEVEL_USER_NOTIFY_EXEC;

CONST LPTSTR g_szAlarmTaskName [NUM_DISCHARGE_POLICIES] = {
    TEXT("Critical Battery Alarm Program"),
    TEXT("Low Battery Alarm Program"),
    NULL,
    NULL
};
#endif

// Advanced alarm policies dialog controls descriptions:
#ifdef WINNT
#define NUM_ALARM_ACTIONS_CONTROLS 7
#else
#define NUM_ALARM_ACTIONS_CONTROLS 5
#endif

// Handy indicies into our AlarmActions control arrays
#define ID_NOTIFYWITHSOUND      0
#define ID_NOTIFYWITHTEXT       1
#define ID_ENABLELOWSTATE       2
#define ID_ALARMACTIONPOLICY    3
#define ID_ALARMIGNORENONRESP   4
#ifdef WINNT
#define ID_RUNPROGCHECKBOX      5
#define ID_RUNPROGWORKITEM      6
#endif

POWER_CONTROLS g_pcAlarmActions[NUM_ALARM_ACTIONS_CONTROLS] =
{// Control ID              Control Type        Data Address        Data Size                       Parameter Pointer               EnableVisible State Pointer
    IDC_NOTIFYWITHSOUND,    CHECK_BOX_ENABLE,   NULL,               sizeof(DWORD),                  &g_uiNotifySoundFlag,           &g_uiSoundState,
    IDC_NOTIFYWITHTEXT,     CHECK_BOX,          NULL,               sizeof(DWORD),                  &g_uiNotifyTextFlag,            &g_uiTextState,
    IDC_ENABLELOWSTATE,     CHECK_BOX_ENABLE,   &g_uiLoChangeEnable,sizeof(DWORD),                  NULL,                           &g_uiLoChangeState,
    IDC_ALARMACTIONPOLICY,  COMBO_BOX,          NULL,               sizeof(DWORD),                  NULL,                           &g_uiLoChangeState,
    IDC_ALARMIGNORENONRESP, CHECK_BOX,          NULL,               sizeof(DWORD),                  &g_uiOverrideAppsFlag,          &g_uiLoChangeState,
#ifdef WINNT
    IDC_RUNPROGCHECKBOX,    CHECK_BOX_ENABLE,   NULL,               sizeof(DWORD),                  &g_uiNotifyProgFlag,            &g_uiProgState,
    IDC_RUNPROGWORKITEM,    PUSHBUTTON,         NULL,               0,                              NULL,                           &g_uiProgState,
#endif
};

// Alarm policies dialog controls descriptions:
#define NUM_ALARM_CONTROLS 6

// Local visable/enabled control state variables.
UINT g_uiLoState;
UINT g_uiCritState;
UINT g_uiBatteryLevelScale;

POWER_CONTROLS g_pcAlarm[NUM_ALARM_CONTROLS] =
{// Control ID                Control Type        Data Address                                                            Data Size                       Parameter Pointer       Enable/Visible State Pointer
    IDC_LOBATALARMENABLE,     CHECK_BOX_ENABLE,   &(g_gpp.user.DischargePolicy[DISCHARGE_POLICY_LOW].Enable),             sizeof(ULONG),                  NULL,                   &g_uiLoState,
    IDC_LOWACTION,            PUSHBUTTON,         NULL,                                                                   0,                              NULL,                   &g_uiLoState,
    IDC_LOALARMSLIDER,        SLIDER,             &(g_gpp.user.DischargePolicy[DISCHARGE_POLICY_LOW].BatteryLevel),       sizeof(ULONG),                  &g_dwBattryLevelMaxMin, &g_uiLoState,
    IDC_CRITBATALARMENABLE,   CHECK_BOX_ENABLE,   &(g_gpp.user.DischargePolicy[DISCHARGE_POLICY_CRITICAL].Enable),        sizeof(ULONG),                  NULL,                   &g_uiCritState,
    IDC_CRITACTION,           PUSHBUTTON,         NULL,                                                                   0,                              NULL,                   &g_uiCritState,
    IDC_CRITALARMSLIDER,      SLIDER,             &(g_gpp.user.DischargePolicy[DISCHARGE_POLICY_CRITICAL].BatteryLevel),  sizeof(ULONG),                  &g_dwBattryLevelMaxMin, &g_uiCritState,
};

// "Alarms" Dialog Box (IDD_ALARMPOLICY == 103) help array:

const DWORD g_AlarmHelpIDs[]=
{
    IDC_POWERCFGGROUPBOX3,    IDH_103_1110,   // Alarms: "Low battery alarm groupbox" (Button)
    IDC_LOBATALARMENABLE,     IDH_103_1106,   // Alarms: "Set off &low battery alarm when power level reaches:" (Button)
    IDC_LOWALARMLEVEL,        IDH_103_1104,   // Alarms: "Low alarm level" (Static)
    IDC_LOALARMSLIDER,        IDH_103_1102,   // Alarms: "Low alarm slider" (msctls_trackbar32)
    IDC_LOWACTION,            IDH_103_1101,   // Alarms: "Alar&m Action..." (Button)
    IDC_LOALARMNOTIFICATION,  IDH_103_1108,   // Alarms: "Low alarm status text" (Static)
    IDC_LOALARMPOWERMODE,     IDH_103_1108,   // Alarms: "Low alarm status text" (Static)
#ifdef WINNT
    IDC_LOALARMPROGRAM,       IDH_103_1108,   // Alarms: "Low alarm status text" (Static)
#endif
    IDC_POWERCFGGROUPBOX4,    IDH_103_1111,   // Alarms: "Critical battery alarm groupbox" (Button)
    IDC_CRITBATALARMENABLE,   IDH_103_1107,   // Alarms: "Set off &critical battery alarm when power level reaches:" (Button)
    IDC_CRITALARMLEVEL,       IDH_103_1105,   // Alarms: "Critical alarm level" (Static)
    IDC_CRITALARMSLIDER,      IDH_103_1103,   // Alarms: "Critical alarm slider" (msctls_trackbar32)
    IDC_CRITACTION,           IDH_103_1100,   // Alarms: "Ala&rm Action..." (Button)
    IDC_CRITALARMNOTIFICATION,IDH_103_1109,   // Alarms: "Critical alarm status text" (Static)
    IDC_CRITALARMPOWERMODE,   IDH_103_1109,   // Alarms: "Critical alarm status text" (Static)
#ifdef WINNT
    IDC_CRITALARMPROGRAM,     IDH_103_1109,   // Alarms: "Critical alarm status text" (Static)
#endif
    IDC_NO_HELP_1,            NO_HELP,
    IDC_NO_HELP_2,            NO_HELP,
    IDC_NO_HELP_3,            NO_HELP,
    IDC_NO_HELP_4,            NO_HELP,
    0, 0
};

// "Alarm Actions" Dialog Box (IDD_ALARMACTIONS == 106) help array:

const DWORD g_AlarmActHelpIDs[]=
{
    IDC_POWERCFGGROUPBOX5,  IDH_106_1608,   // Alarm Actions: "Notification groupbox" (Button)
    IDC_NOTIFYWITHSOUND,    IDH_106_1603,   // Alarm Actions: "&Sound alarm" (Button)
    IDC_NOTIFYWITHTEXT,     IDH_106_1605,   // Alarm Actions: "&Display message" (Button)
    IDC_POWERCFGGROUPBOX6,  IDH_106_1609,   // Alarm Actions: "Power level groupbox" (Button)
    IDC_POWERCFGGROUPBOX7,  IDH_106_1609,   // Alarm Actions: "Run program groupbox"
    IDC_ENABLELOWSTATE,     IDH_106_1600,   // Alarm Actions: "When the &alarm goes off, the computer will:" (Button)
    IDC_ALARMACTIONPOLICY,  IDH_106_1601,   // Alarm Actions: "Alarm action dropdown" (ComboBox)
    IDC_ALARMIGNORENONRESP, IDH_106_1602,   // Alarm Actions: "&Force standby or shutdown even if a program stops responding." (Button)
#ifdef WINNT
    IDC_RUNPROGCHECKBOX,    IDH_106_1620,   // Alarm Actions: "Specifies that you want a program to run..."
    IDC_RUNPROGWORKITEM,    IDH_106_1621,   // Alarm Actions: "Displays a dialog box wher the work item is configured..."
#endif
    0, 0
};

/*******************************************************************************
*
*               P U B L I C   E N T R Y   P O I N T S
*
*******************************************************************************/

/*******************************************************************************
*
*   AlarmActionsDlgProc
*
*   DESCRIPTION:
*
*   PARAMETERS:
*
*******************************************************************************/

INT_PTR CALLBACK AlarmActionsDlgProc(
    HWND hWnd,
    UINT uMsg,
    WPARAM wParam,
    LPARAM lParam
    )
{
    static  GLOBAL_POWER_POLICY   gpp;
    static  PALARM_POL_DLG_DATA   papdd;

    static  UINT    uiIndex;
    static  UINT    uiEventId;
#ifdef WINNT
    static  LPTSTR  lpszTaskName;
    HWND    hTaskWnd;
#endif
    LPTSTR  lpszCaption;
    UINT    ii;

    switch (uMsg) {

        case WM_INITDIALOG:

            // Save a copy of the global policies to restore on cancel.
            memcpy(&gpp, &g_gpp, sizeof(gpp));

            // Set the pointers to the data of interest.
            papdd  = (PALARM_POL_DLG_DATA) lParam;
            if (papdd->wParam == IDC_LOWACTION) {
                uiIndex = DISCHARGE_POLICY_LOW;
                uiEventId = IDS_LOWSOUNDEVENT;
            }
            else {
                uiIndex = DISCHARGE_POLICY_CRITICAL;
                uiEventId = IDS_CRITSOUNDEVENT;
            }
#ifdef WINNT
            lpszTaskName = g_szAlarmTaskName [uiIndex];
#endif
            // Set up the data pointers in g_pcAlarmActions.
            g_pcAlarmActions[ID_NOTIFYWITHSOUND].lpvData =
                &(g_gpp.user.DischargePolicy[uiIndex].PowerPolicy.EventCode);
            g_pcAlarmActions[ID_NOTIFYWITHTEXT].lpvData =
                &(g_gpp.user.DischargePolicy[uiIndex].PowerPolicy.EventCode);
#ifdef WINNT
            g_pcAlarmActions[ID_RUNPROGCHECKBOX].lpvData =
                &(g_gpp.user.DischargePolicy[uiIndex].PowerPolicy.EventCode);
#endif
            g_pcAlarmActions[ID_ALARMACTIONPOLICY].lpdwParam =
                (LPDWORD)&(g_gpp.user.DischargePolicy[uiIndex].PowerPolicy.Action);
            g_pcAlarmActions[ID_ALARMIGNORENONRESP].lpvData =
                &(g_gpp.user.DischargePolicy[uiIndex].PowerPolicy.Flags);

            //
            // Set the appropriate choices for the Alarms
            //
            ii=0;

            if (g_SysPwrCapabilities.SystemS1 ||
                    g_SysPwrCapabilities.SystemS2 || g_SysPwrCapabilities.SystemS3) {
                g_uiPwrActIDs[ii++] = IDS_STANDBY;
                g_uiPwrActIDs[ii++] = PowerActionSleep;
            }

            if (g_SysPwrCapabilities.HiberFilePresent) {
                g_uiPwrActIDs[ii++] = IDS_HIBERNATE;
                g_uiPwrActIDs[ii++] = PowerActionHibernate;
            }

            g_uiPwrActIDs[ii++] = IDS_POWEROFF;
            g_uiPwrActIDs[ii++] = PowerActionShutdownOff;
            g_uiPwrActIDs[ii++] = 0;
            g_uiPwrActIDs[ii++] = 0;

            g_pcAlarmActions[ID_ALARMACTIONPOLICY].lpvData = g_uiPwrActIDs;

            if (g_gpp.user.DischargePolicy[uiIndex].PowerPolicy.Action == PowerActionNone) {
                g_uiLoChangeEnable = FALSE;
            }
            else {
                g_uiLoChangeEnable = TRUE;
            }
            MapPwrAct(&(g_gpp.user.DischargePolicy[uiIndex].PowerPolicy.Action), FALSE);

            // Set the dialog caption.
            lpszCaption = LoadDynamicString(IDS_ALARMACTIONS,
                                            papdd->lpszTitleExt);
            if (lpszCaption) {
                SetWindowText(hWnd, lpszCaption);
                LocalFree(lpszCaption);
            }

            // Initialize the controls.
            SetControls(hWnd, NUM_ALARM_ACTIONS_CONTROLS, g_pcAlarmActions);

#ifdef WINNT
            HideShowRunProgram(hWnd);
#endif
            return (INT_PTR) TRUE;

        case WM_COMMAND:
            switch (wParam) {
#ifdef WINNT
                case IDC_RUNPROGWORKITEM:
                    hTaskWnd =  FindWindow( NULL, lpszTaskName);
                    if (hTaskWnd) {
                        BringWindowToTop(hTaskWnd);
                    } else {
                        EditWorkItem(hWnd, lpszTaskName);
                    }
                    break;

                case IDC_RUNPROGCHECKBOX:
                    hTaskWnd =  FindWindow( NULL, lpszTaskName);
                    if (hTaskWnd)
                    {
                        DestroyWindow(hTaskWnd);
                    }
                    // No break: Fall through to update grayed status of controls.
#endif
                case IDC_ENABLELOWSTATE:
                    GetControls(hWnd, NUM_ALARM_ACTIONS_CONTROLS, g_pcAlarmActions);
                    SetControls(hWnd, NUM_ALARM_ACTIONS_CONTROLS, g_pcAlarmActions);
#ifdef WINNT
                    HideShowRunProgram(hWnd);
#endif
                    break;

                case IDOK:
#ifdef WINNT
                    hTaskWnd =  FindWindow( NULL, lpszTaskName);
                    if (hTaskWnd) {
                        BringWindowToTop(hTaskWnd);
                    } else {
#endif
                        GetControls(hWnd, NUM_ALARM_ACTIONS_CONTROLS, g_pcAlarmActions);
                        if (!g_uiLoChangeEnable) {
                            g_gpp.user.DischargePolicy[uiIndex].PowerPolicy.Action =
                                PowerActionNone;
                        }
                        g_gpp.user.DischargePolicy[uiIndex].MinSystemState = g_spsMaxSleepState;
                        EndDialog(hWnd, wParam);
#ifdef WINNT
                    }
#endif
                    break;

                case IDCANCEL:
#ifdef WINNT
                    hTaskWnd =  FindWindow( NULL, lpszTaskName);
                    if (hTaskWnd)
                    {
                        DestroyWindow(hTaskWnd);
                    }
#endif
                    // Restore the original global policies.
                    memcpy(&g_gpp, &gpp, sizeof(gpp));
                    EndDialog(hWnd, wParam);
                    break;
            }
            break;

        case PCWM_NOTIFYPOWER:
           // Notification from systray, user has changed a PM UI setting.
           g_bSystrayChange = TRUE;
           break;

        case WM_HELP:             // F1
            WinHelp(((LPHELPINFO)lParam)->hItemHandle, PWRMANHLP, HELP_WM_HELP, (ULONG_PTR)(LPTSTR)g_AlarmActHelpIDs);
            return TRUE;

        case WM_CONTEXTMENU:      // right mouse click
            WinHelp((HWND)wParam, PWRMANHLP, HELP_CONTEXTMENU, (ULONG_PTR)(LPTSTR)g_AlarmActHelpIDs);
            return TRUE;
    }
    return FALSE;
}

/*******************************************************************************
*
*   AlarmDlgProc
*
*   DESCRIPTION:
*
*   PARAMETERS:
*
*******************************************************************************/

INT_PTR CALLBACK AlarmDlgProc(
    HWND hWnd,
    UINT uMsg,
    WPARAM wParam,
    LPARAM lParam
    )
{
    NMHDR FAR *lpnm;
    ALARM_POL_DLG_DATA apdd;
    PUINT puiPos, puiPosVar, puiOtherPosVar, puiOtherPos, puiEnableState;
    UINT  uiEnable, uiSliderStatusId, uiID;
    SYSTEM_BATTERY_STATE sbsBatteryState;
    BOOL  bAdjust;

    static HWND hWndLoSlider, hWndCritSlider;
    static UINT uiDefaultAlert1, uiLoPos, uiCritPos, uiLoPosSave, uiCritPosSave;
    static BOOL bDirty = FALSE;

    switch (uMsg) {

        case WM_INITDIALOG:
            // If we can't read the global power policies hide
            // the controls on this page.
            if (!GetGlobalPwrPolicy(&g_gpp)) {
                HideControls(hWnd, NUM_ALARM_CONTROLS, g_pcAlarm);
                return TRUE;
            }

            g_uiTextState = g_uiSoundState = CONTROL_ENABLE;

            // Set the scale value.
            if (!HIWORD(g_dwBattryLevelMaxMin)) {
                g_uiBatteryLevelScale = 1;
            }
            else {
                g_uiBatteryLevelScale = 100 / HIWORD(g_dwBattryLevelMaxMin);
            }

            g_gpp.user.DischargePolicy[DISCHARGE_POLICY_LOW].BatteryLevel /=
                g_uiBatteryLevelScale;
            g_gpp.user.DischargePolicy[DISCHARGE_POLICY_CRITICAL].BatteryLevel /=
                g_uiBatteryLevelScale;

            // Read DefaultAlert1 from composite battery 
            NtPowerInformation (SystemBatteryState, NULL, 0, &sbsBatteryState, sizeof(sbsBatteryState));
            if (sbsBatteryState.MaxCapacity == 0) {
                uiDefaultAlert1 = 0;
            } else {
                uiDefaultAlert1 = (100 * sbsBatteryState.DefaultAlert1)/sbsBatteryState.MaxCapacity;
            }

            // Cache the low alarm slider window handle.
            hWndLoSlider   = GetDlgItem(hWnd, IDC_LOALARMSLIDER);
            hWndCritSlider = GetDlgItem(hWnd, IDC_CRITALARMSLIDER);

            // Initialize the local enable and position variables.
            uiLoPosSave   = uiLoPos   =
                g_gpp.user.DischargePolicy[DISCHARGE_POLICY_LOW].BatteryLevel;
            uiCritPosSave = uiCritPos =
                g_gpp.user.DischargePolicy[DISCHARGE_POLICY_CRITICAL].BatteryLevel;

            // Initialize the dialog controls
            SendDlgItemMessage(hWnd, IDC_LOALARMSLIDER, TBM_SETTICFREQ, 25, 0);
            SendDlgItemMessage(hWnd, IDC_CRITALARMSLIDER, TBM_SETTICFREQ, 25, 0);
            SetControls(hWnd, NUM_ALARM_CONTROLS, g_pcAlarm);
            SetSliderStatusText(hWnd, IDC_LOWALARMLEVEL,  uiLoPos);
            SetSliderStatusText(hWnd, IDC_CRITALARMLEVEL, uiCritPos);
            SetAlarmStatusText(hWnd);

            // If we can't write the global policies disable the controls.
            if (!WriteGlobalPwrPolicyReport(hWnd, &g_gpp, FALSE)) {
                DisableControls(hWnd, NUM_ALARM_CONTROLS, g_pcAlarm);
            }
            return TRUE;

        case WM_NOTIFY:
            lpnm = (NMHDR FAR *)lParam;
            switch(lpnm->code)
            {
                case PSN_APPLY:
                    if (bDirty)
                    {
                        GetControls(hWnd, NUM_ALARM_CONTROLS, g_pcAlarm);
                        g_gpp.user.DischargePolicy[DISCHARGE_POLICY_LOW].BatteryLevel *=
                             g_uiBatteryLevelScale;
                        g_gpp.user.DischargePolicy[DISCHARGE_POLICY_CRITICAL].BatteryLevel *=
                             g_uiBatteryLevelScale;
                        WriteGlobalPwrPolicyReport(hWnd, &g_gpp, TRUE);
                        GetActivePwrScheme(&uiID);
                        SetActivePwrSchemeReport(hWnd, uiID, &g_gpp, NULL);
                        bDirty = FALSE;
                    }
                    break;
            }
            break;

        case WM_COMMAND:
            switch (wParam) {
                case IDC_CRITACTION:
                    apdd.lpszTitleExt = LoadDynamicString(IDS_CRITBAT);
                    goto do_config_alarm_act;

                case IDC_LOWACTION:
                    apdd.lpszTitleExt = LoadDynamicString(IDS_LOWBAT);

do_config_alarm_act:
                    apdd.wParam = wParam;
                    if (IDOK == DialogBoxParam(g_hInstance,
                                               MAKEINTRESOURCE(IDD_ALARMACTIONS),
                                               hWnd,
                                               AlarmActionsDlgProc,
                                               (LPARAM)&apdd)) {
                        // Enable the parent dialog Apply button on change.
                        MarkSheetDirty(hWnd, &bDirty);
                    }

                    if (apdd.lpszTitleExt) {
                        LocalFree(apdd.lpszTitleExt);
                    }
                    SetAlarmStatusText(hWnd);
                    break;

                case IDC_LOBATALARMENABLE:
                    puiPosVar = &(g_gpp.user.DischargePolicy[DISCHARGE_POLICY_LOW].BatteryLevel);
                    puiOtherPosVar = &(g_gpp.user.DischargePolicy[DISCHARGE_POLICY_CRITICAL].BatteryLevel);
                    uiSliderStatusId = IDC_LOWALARMLEVEL;
                    goto do_sheet_dirty;

                case IDC_CRITBATALARMENABLE:
                    puiPosVar = &(g_gpp.user.DischargePolicy[DISCHARGE_POLICY_CRITICAL].BatteryLevel);
                    puiOtherPosVar = &(g_gpp.user.DischargePolicy[DISCHARGE_POLICY_LOW].BatteryLevel);
                    uiSliderStatusId = IDC_CRITALARMLEVEL;

do_sheet_dirty:
                    GetControls(hWnd, NUM_ALARM_CONTROLS, g_pcAlarm);
                    if ((uiEnable = IsDlgButtonChecked(hWnd, (int) wParam)) ==
                        BST_CHECKED) {
                        if (uiLoPos < uiCritPos) {
                            uiLoPos = uiCritPos = *puiPosVar = *puiOtherPosVar;
                            SetSliderStatusText(hWnd, uiSliderStatusId, uiCritPos);
                        }
                    }
                    SetControls(hWnd, NUM_ALARM_CONTROLS, g_pcAlarm);
                    SetAlarmStatusText(hWnd);
                    MarkSheetDirty(hWnd, &bDirty);
                    break;
            }
            break;

        case WM_HSCROLL:
            // Only handle slider controls.
            if (((HWND)lParam != hWndLoSlider) &&
                ((HWND)lParam != hWndCritSlider)) {
                break;
            }

            // Don't allow the low slider to be set lower than the critical
            // slider. Reset position on TB_ENDTRACK for this case.
            if (hWndLoSlider == (HWND)lParam) {
                puiPos           = &uiLoPos;
                puiOtherPos      = &uiCritPos;
                puiEnableState   = &g_uiCritState;
                uiSliderStatusId = IDC_LOWALARMLEVEL;
            }
            else {
                puiPos           = &uiCritPos;
                puiOtherPos      = &uiLoPos;
                puiEnableState   = &g_uiLoState;
                uiSliderStatusId = IDC_CRITALARMLEVEL;
            }

            switch (LOWORD(wParam)) {
                case TB_ENDTRACK:
                    
                    bAdjust = FALSE;

                    if (*puiEnableState & CONTROL_ENABLE) {
                        if (uiLoPos < uiCritPos) {
                            *puiPos = *puiOtherPos;
                            bAdjust = TRUE;
                        }
                    }

                    if (*puiPos < uiDefaultAlert1) {
                        *puiPos = uiDefaultAlert1;
                        bAdjust = TRUE;
                    }

                    if (bAdjust) {
                        SendMessage((HWND)lParam, TBM_SETPOS, TRUE,
                                    (LPARAM)*puiPos);
                    }

                    break;

                case TB_THUMBPOSITION:
                case TB_THUMBTRACK:
                    // New position comes with these messages.
                    *puiPos = HIWORD(wParam);
                    break;

                default:
                    // New position must be fetched for the rest.
                    *puiPos = (UINT) SendMessage((HWND)lParam, TBM_GETPOS, 0, 0);
            }

            // Update the current slider position text.
            SetSliderStatusText(hWnd, uiSliderStatusId, *puiPos);

            // Enable the parent dialog Apply button on any  change.
            MarkSheetDirty(hWnd, &bDirty);
            break;

        case WM_HELP:             // F1
            WinHelp(((LPHELPINFO)lParam)->hItemHandle, PWRMANHLP, HELP_WM_HELP, (ULONG_PTR)(LPTSTR)g_AlarmHelpIDs);
            return TRUE;

        case WM_CONTEXTMENU:      // right mouse click
            WinHelp((HWND)wParam, PWRMANHLP, HELP_CONTEXTMENU, (ULONG_PTR)(LPTSTR)g_AlarmHelpIDs);
            return TRUE;
    }
    return FALSE;
}

/*******************************************************************************
*
*                 P R I V A T E   F U N C T I O N S
*
*******************************************************************************/

/*******************************************************************************
*
*  PathOnly
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

BOOL PathOnly(LPTSTR sz)
{
   LPTSTR p = sz;
   LPTSTR s = NULL;

   while ( *p ) {
      if ( *p == TEXT('\\') ) {
         s = p;
      } else if ( *p == TEXT(':') ) {
         s = p + 1;
      }
#if defined(DBCS) || (defined(FE_SB) && !defined(UNICODE))
      p = AnsiNext(p);
#else
      p++;
#endif
   }

   if ( s ) {
      if ( s == sz )
         s++;

      *s = TEXT('\0');
      return TRUE;
   }

   return FALSE;
}

#ifdef WINNT
/*******************************************************************************
*
*  FileNameOnly
*
*  DESCRIPTION: Returns a pointer to the first character after the last
*               backslash in a string
*
*  PARAMETERS:
*
*******************************************************************************/

LPTSTR FileNameOnly(LPTSTR sz)
{
    LPTSTR next = sz;
    LPTSTR prev;
    LPTSTR begin = next;

    if (next == NULL) {
        return NULL;
    }

    while ( *next ) {
        prev = next;

#if defined(DBCS) || (defined(FE_SB) && !defined(UNICODE))
      next = AnsiNext(next);
#else
      next++;
#endif
        if ( (*prev == TEXT('\\')) || (*prev == TEXT(':')) ) {
            begin = next;
        }
    }

    return begin;
}

/*******************************************************************************
*
*  EditWorkItem
*
*  DESCRIPTION: Opens the specified task.
*
*  PARAMETERS:
*
*******************************************************************************/
void EditWorkItem(HWND hWnd, LPTSTR pszTaskName)
{
    ITaskScheduler  *pISchedAgent = NULL;
    ITask           *pITask;
    IPersistFile    *pIPersistFile;
    HRESULT     hr;

    hr = CoInitialize(NULL);

    if (FAILED(hr)) {
        DebugPrint( "EditWorkItem: CoInitialize returned hr = %08x\n", hr);
        return;
    }

    hr = CoCreateInstance( &CLSID_CSchedulingAgent,
                           NULL,
                           CLSCTX_INPROC_SERVER,
                           &IID_ISchedulingAgent,
                           (LPVOID*)&pISchedAgent);

    if (SUCCEEDED(hr)) {

        hr = pISchedAgent->lpVtbl->Activate(pISchedAgent,
                                       pszTaskName,
                                       &IID_ITask,
                                       &(IUnknown *)pITask);

        if (SUCCEEDED(hr)) {
            pITask->lpVtbl->EditWorkItem(pITask, hWnd, 0);
            pITask->lpVtbl->Release(pITask);
        }
        else if (HRESULT_CODE (hr) == ERROR_FILE_NOT_FOUND){
            hr = pISchedAgent->lpVtbl->NewWorkItem(
                    pISchedAgent,
                    pszTaskName,
                    &CLSID_CTask,
                    &IID_ITask,
                    &(IUnknown *)pITask);

            if (SUCCEEDED(hr)) {
                hr = pITask->lpVtbl->QueryInterface(pITask, &IID_IPersistFile,
                                (void **)&pIPersistFile);

                if (SUCCEEDED(hr)) {
                    hr = pIPersistFile->lpVtbl->Save(pIPersistFile, NULL, TRUE);

                    if (SUCCEEDED(hr)) {
                        pITask->lpVtbl->EditWorkItem(pITask, hWnd, 0);
                    }
                    else {
                        DebugPrint( "EditWorkItem: Save filed hr = %08x\n", hr);
                    }
                    pIPersistFile->lpVtbl->Release(pIPersistFile);
                }
                else {
                    DebugPrint( "EditWorkItem: QueryInterface for IPersistFile hr = %08x\n", hr);
                }
                pITask->lpVtbl->Release(pITask);

            }
            else {
                DebugPrint( "EditWorkItem: Activate returned hr = %08x\n", hr);
            }
        }
        else {
            DebugPrint( "EditWorkItem: NewWorkItem returned hr = %08x\n", hr);
        }

        pISchedAgent->lpVtbl->Release(pISchedAgent);
    }
    else {
        DebugPrint( "EditWorkItem: CoCreateInstance returned hr = %08x\n", hr);
    }

    CoUninitialize();

}
#endif
/*******************************************************************************
*
*  SetSliderStatusText
*
*  DESCRIPTION:
*   Update the current slider position text.
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN SetSliderStatusText(HWND hWnd, UINT uiStatusId, UINT uiLevel)
{
    LPTSTR  pString;

    pString = LoadDynamicString(IDS_ALARMLEVELFORMAT,
                                uiLevel * g_uiBatteryLevelScale);
    DisplayFreeStr(hWnd, uiStatusId, pString, FREE_STR);
    return TRUE;
}

/*******************************************************************************
*
*  SetAlarmStatusText
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN SetAlarmStatusText(HWND hWnd)
{
   TCHAR   szStatus[MAX_UI_STR_LEN];
   LPTSTR  lpsz;
   UINT    uiActionId, uiStatusId, uiIndex, uiAction;
   PUINT   puiState;
#ifdef WINNT

   LPTSTR  lpszRunProg;

#endif

   puiState    = &g_uiCritState;
   uiStatusId  = IDC_CRITALARMNOTIFICATION;
   for (uiIndex = DISCHARGE_POLICY_CRITICAL; uiIndex <= DISCHARGE_POLICY_LOW; uiIndex++) {

      // Format the alarm action notification status string.
      szStatus[0] = '\0';
      if (g_gpp.user.DischargePolicy[uiIndex].PowerPolicy.EventCode &
          POWER_LEVEL_USER_NOTIFY_SOUND) {
         if ((lpsz = LoadDynamicString(IDS_ALARMSTATUSSOUND)) != NULL) {
            lstrcat(szStatus, lpsz);
            LocalFree(lpsz);
         }
      }

      if (g_gpp.user.DischargePolicy[uiIndex].PowerPolicy.EventCode &
          POWER_LEVEL_USER_NOTIFY_TEXT) {
         if (szStatus[0] != '\0') {
            lstrcat(szStatus, TEXT(", "));
         }
         if ((lpsz = LoadDynamicString(IDS_ALARMSTATUSTEXT)) != NULL) {
            lstrcat(szStatus, lpsz);
            LocalFree(lpsz);
         }
      }

      if (szStatus[0] == '\0') {
         if ((lpsz = LoadDynamicString(IDS_NOACTION)) != NULL) {
            lstrcat(szStatus, lpsz);
            LocalFree(lpsz);
         }
      }
      DisplayFreeStr(hWnd, uiStatusId, szStatus, NO_FREE_STR);
      ShowWindow(GetDlgItem(hWnd, uiStatusId),
                 (*puiState & CONTROL_ENABLE) ?  SW_SHOW:SW_HIDE);
      uiStatusId++;

      // Format the alarm action power mode status string.
      uiAction = g_gpp.user.DischargePolicy[uiIndex].PowerPolicy.Action;
      switch (uiAction) {
         case PowerActionNone:
            uiActionId = IDS_NOACTION;
            break;

         case PowerActionSleep:
            uiActionId = IDS_STANDBY;
            break;

         case PowerActionHibernate:
            uiActionId = IDS_HIBERNATE;
            break;

         case PowerActionShutdown:
         case PowerActionShutdownReset:
         case PowerActionShutdownOff:
            uiActionId = IDS_POWEROFF;
            break;

         case PowerActionReserved:
         default:
            DebugPrint( "SetAlarmStatusText, unable to map power action: %X", uiAction);
            uiActionId = IDS_NOACTION;
      }
      lpsz = LoadDynamicString(uiActionId);
      DisplayFreeStr(hWnd, uiStatusId, lpsz, FREE_STR);
      ShowWindow(GetDlgItem(hWnd, uiStatusId),
                 (*puiState & CONTROL_ENABLE) ?  SW_SHOW:SW_HIDE);
      uiStatusId++;

      // Format the alarm action run program status string.
#ifdef WINNT
      lpszRunProg = NULL;

      if (g_gpp.user.DischargePolicy[uiIndex].PowerPolicy.EventCode &
         POWER_LEVEL_USER_NOTIFY_EXEC) {
         {
            //
            // Open up the alarm action task and read the program name.
            //

            ITaskScheduler   *pISchedAgent = NULL;
            ITask            *pITask;

            HRESULT     hr;

            hr = CoInitialize(NULL);

            if (SUCCEEDED(hr)) {

               hr = CoCreateInstance( &CLSID_CSchedulingAgent,
                                      NULL,
                                      CLSCTX_INPROC_SERVER,
                                      &IID_ISchedulingAgent,
                                      (LPVOID*)&pISchedAgent);

               if (SUCCEEDED(hr)) {

                  hr = pISchedAgent->lpVtbl->Activate(pISchedAgent,
                                                      g_szAlarmTaskName [uiIndex],
                                                      &IID_ITask,
                                                      &(IUnknown *)pITask);

                  if (SUCCEEDED(hr)) {
                     pITask->lpVtbl->GetApplicationName(pITask, &lpszRunProg);
                     pITask->lpVtbl->Release(pITask);
                  }

                  pISchedAgent->lpVtbl->Release(pISchedAgent);
               }
               else {
                  DebugPrint( "SetAlarmStatusText: CoCreateInstance returned hr = %08x\n", hr);
               }

               CoUninitialize();
            }
         }

      }
      if (lpszRunProg != NULL) {

          DisplayFreeStr(hWnd, uiStatusId, FileNameOnly(lpszRunProg), NO_FREE_STR);
          CoTaskMemFree (lpszRunProg);
          lpszRunProg = NULL;
      }
      else {
         lpsz = LoadDynamicString(IDS_NONE);
         DisplayFreeStr(hWnd, uiStatusId, lpsz, FREE_STR);
      }
      ShowWindow(GetDlgItem(hWnd, uiStatusId),
                 (*puiState & CONTROL_ENABLE) ?  SW_SHOW:SW_HIDE);
#endif
      uiStatusId++;

      puiState    = &g_uiLoState;
      uiStatusId  = IDC_LOALARMNOTIFICATION;
   }
   return TRUE;
}

#ifdef WINNT
/*******************************************************************************
*
*  HideShowRunProgram
*
*  DESCRIPTION:
*
*  PARAMETERS:
*   On WINNT, only power users may set the run program.
*   The run program is stored under HKLM.
*
*******************************************************************************/

void HideShowRunProgram(HWND hWnd)
{
    if (CanUserWritePwrScheme()) {
        ShowWindow(GetDlgItem(hWnd, IDC_POWERCFGGROUPBOX7), SW_SHOW);
        ShowWindow(GetDlgItem(hWnd, IDC_RUNPROGCHECKBOX), SW_SHOW);
        ShowWindow(GetDlgItem(hWnd, IDC_RUNPROGWORKITEM), SW_SHOW);
    }
    else {
        ShowWindow(GetDlgItem(hWnd, IDC_POWERCFGGROUPBOX7), SW_HIDE);
        ShowWindow(GetDlgItem(hWnd, IDC_RUNPROGCHECKBOX), SW_HIDE);
        ShowWindow(GetDlgItem(hWnd, IDC_RUNPROGWORKITEM), SW_HIDE);
    }
}
#endif