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

/*******************************************************************************
*
*  Copyright 1999 American Power Conversion, All Rights Reserved
*
*  TITLE:       UPSCONFIG.C
*
*  VERSION:     1.0
*
*  AUTHOR:      TedC
*
*  DATE:        07 June, 1999
*
*  DESCRIPTION:  Dialog for configuring UPS service behavior:
*                                       - display popup messages on power failure
*                                       - wait X seconds before displaying warnings
*                                       - repeat warning messages every  X  seconds
*                                       - shutdown X minutes after power fails
*                                       - ALWAYS shutdown when low battery
*                                       - execute a task before shutdown
*                                       - turn off the UPS after shutdown
******************************************************************************/
/*********************  Header Files  ************************/
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>

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

#define VALIDDIGITS             3       // number of digits allowed in each edit box

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

// local copy of UPS Configuration settings
static DWORD   g_ulWaitSeconds = 0;
static DWORD   g_ulRepeatSeconds = 0;
static DWORD   g_ulOnBatteryMinutes = 0;
static DWORD   g_ulNotifyEnable = 0;
static DWORD   g_ulShutdownOnBattery = 0;
static DWORD   g_ulCriticalPowerAction = 0;
static DWORD   g_ulRunTaskEnable = 0;
static DWORD   g_ulTurnOffUPS = 0;
static TCHAR   g_szTaskName[MAX_PATH] = _T("");
static DWORD   g_ulOptions = 0;
static BOOL    g_bPowerFailSignal = FALSE;
static BOOL    g_bLowBatterySignal = FALSE;
static BOOL    g_bShutOffSignal = FALSE;


// context-sensitive help table
const DWORD g_UPSConfigHelpIDs[]=
{
        IDC_NOTIFYCHECKBOX,idh_enable_notification,
        IDC_WAITTEXT,idh_first_warning_delay,
        IDC_WAITEDITBOX,idh_first_warning_delay,
        IDC_WAITSPIN,idh_first_warning_delay,
        IDC_REPEATTEXT,idh_warning_message_interval,
        IDC_REPEATEDITBOX,idh_warning_message_interval,
        IDC_REPEATSPIN,idh_warning_message_interval,
        IDC_SHUTDOWNTIMERCHECKBOX,idh_time_before_critical_action,
        IDC_SHUTDOWNTIMEREDITBOX,idh_time_before_critical_action,
        IDC_TIMERSPIN,idh_time_before_critical_action,
        IDC_SHUTDOWNTEXT,idh_time_before_critical_action,
        IDC_LOWBATTERYSHUTDOWNTEXT,idh_low_battery,
        IDC_POWERACTIONTEXT,idh_shutdown_or_hibernate,
        IDC_POWERACTIONCOMBO,idh_shutdown_or_hibernate,
        IDC_RUNTASKCHECKBOX,idh_run_program,
        IDC_TASKNAMETEXT,idh_run_program,
        IDC_CONFIGURETASKBUTTON,idh_configure_program,
        IDC_TURNOFFCHECKBOX,idh_ups_turn_off,
        IDC_STATIC, NO_HELP,
        IDC_SHUTDOWNGROUPBOX, NO_HELP,
        0, 0
};



/*******************************************************************************
*
*   GetRegistryValues
*
*   DESCRIPTION:  Initialize UPS configuration settings from the registry
*
*   PARAMETERS:
*
*******************************************************************************/
void GetRegistryValues()
{
        GetUPSConfigFirstMessageDelay(&g_ulWaitSeconds);
        GetUPSConfigNotifyEnable(&g_ulNotifyEnable);
        GetUPSConfigMessageInterval(&g_ulRepeatSeconds);
        GetUPSConfigShutdownOnBatteryEnable(&g_ulShutdownOnBattery);
        GetUPSConfigShutdownOnBatteryWait(&g_ulOnBatteryMinutes);
        GetUPSConfigCriticalPowerAction(&g_ulCriticalPowerAction);
        GetUPSConfigRunTaskEnable(&g_ulRunTaskEnable);
        GetUPSConfigTaskName(g_szTaskName);

        if (!_tcsclen(g_szTaskName)) {
                // The taskname in the registry is NULL so
                // get the default taskname from the resource file.
            LoadString(GetUPSModuleHandle(),
                                   IDS_SHUTDOWN_TASKNAME,
                                   (LPTSTR) g_szTaskName,
                                   sizeof(g_szTaskName)/sizeof(TCHAR));
        }
        GetUPSConfigTurnOffEnable(&g_ulTurnOffUPS);
        GetUPSConfigOptions(&g_ulOptions);
}

/*******************************************************************************
*
*   SetRegistryValues
*
*   DESCRIPTION:  Flush UPS configuration settings to the registry
*
*   PARAMETERS:
*
*******************************************************************************/
void SetRegistryValues()
{
        SetUPSConfigFirstMessageDelay(g_ulWaitSeconds);
        SetUPSConfigNotifyEnable(g_ulNotifyEnable);
        SetUPSConfigMessageInterval(g_ulRepeatSeconds);
        SetUPSConfigShutdownOnBatteryEnable(g_ulShutdownOnBattery);
        SetUPSConfigShutdownOnBatteryWait(g_ulOnBatteryMinutes);
        SetUPSConfigCriticalPowerAction(g_ulCriticalPowerAction);
        SetUPSConfigRunTaskEnable(g_ulRunTaskEnable);
        SetUPSConfigTaskName(g_szTaskName);
        SetUPSConfigTurnOffEnable(g_ulTurnOffUPS);
}


/*******************************************************************************
*
*   ErrorBox
*
*   DESCRIPTION:  used to display error messagebox when data is out of range
*
*   PARAMETERS:   hWnd
*                                 wText
*                                 wCaption
*                                 wType
*
*******************************************************************************/
void ErrorBox (HWND hWnd, DWORD wText, DWORD wCaption, DWORD wType)
{
        TCHAR szText[256+MAX_PATH], szCaption[256];
        HANDLE hModule;

        hModule = GetUPSModuleHandle ();

        LoadString(hModule, wCaption, szCaption, sizeof (szCaption)/sizeof(TCHAR));
        LoadString(hModule, wText, szText, sizeof (szText)/sizeof(TCHAR));
        MessageBox(hWnd, szText, szCaption, MB_OK|MB_ICONSTOP);
}

/*******************************************************************************
*
*   ValidWaitSeconds
*
*   DESCRIPTION:  check if user's data is in range
*
*   PARAMETERS:   hDlg
*
*******************************************************************************/
BOOL ValidWaitSeconds(HWND hDlg)
{
        // Popup warning if g_ulWaitSeconds is not in the valid range:
        if ( g_ulWaitSeconds > (DWORD)WAITSECONDSLASTVAL )
        {
                ErrorBox(hDlg, IDS_OUTOFWAITRANGE, IDS_NOTIFYCAPTION, MB_OK|MB_ICONSTOP);
                SetFocus (GetDlgItem (hDlg, IDC_WAITEDITBOX));
                SendMessage(GetDlgItem (hDlg, IDC_WAITEDITBOX),EM_SETSEL, 0, -1L);
                return FALSE;
        }

        return TRUE;
}

/*******************************************************************************
*
*   ValidRepeatSeconds
*
*   DESCRIPTION:  check if user's data is in range
*
*   PARAMETERS:   hDlg
*
*******************************************************************************/
BOOL ValidRepeatSeconds(HWND hDlg)
{
        // Popup warning if g_ulWaitSeconds is not in the valid range:
        if ((g_ulRepeatSeconds < (DWORD)REPEATSECONDSFIRSTVAL) ||
                (g_ulRepeatSeconds > (DWORD)REPEATSECONDSLASTVAL ))
        {
                ErrorBox(hDlg, IDS_OUTOFREPEATRANGE, IDS_NOTIFYCAPTION, MB_OK|MB_ICONSTOP);
                SetFocus (GetDlgItem (hDlg, IDC_REPEATEDITBOX));
                SendMessage(GetDlgItem (hDlg, IDC_REPEATEDITBOX),EM_SETSEL, 0, -1L);
                return FALSE;
        }

        return TRUE;
}

/*******************************************************************************
*
*   ValidShutdownDelay
*
*   DESCRIPTION:  check if user's data is in range
*
*   PARAMETERS:   hDlg
*
*******************************************************************************/
BOOL ValidShutdownDelay(HWND hDlg)
{
        // Popup warning if shutdown delay is not in the valid range:
        if ((g_ulOnBatteryMinutes< (DWORD)SHUTDOWNTIMERMINUTESFIRSTVAL) ||
                (g_ulOnBatteryMinutes > (DWORD)SHUTDOWNTIMERMINUTESLASTVAL ))
        {
                ErrorBox(hDlg, IDS_OUTOFSHUTDELAYRANGE, IDS_SHUTDOWNCAPTION, MB_OK|MB_ICONSTOP);
                SetFocus (GetDlgItem (hDlg,IDC_SHUTDOWNTIMEREDITBOX));
                SendMessage(GetDlgItem (hDlg,IDC_SHUTDOWNTIMEREDITBOX),EM_SETSEL, 0, -1L);
                return FALSE;
        }

        return TRUE;
}

/*******************************************************************************
*
*   ValidateFields
*
*   DESCRIPTION:  Validate all the user's data before we save the values
*
*   PARAMETERS:   hDlg
*
*******************************************************************************/
BOOL ValidateFields(HWND hDlg)
{
        BOOL    bOK;

        // get the Notification configuration
        if (g_ulNotifyEnable = IsDlgButtonChecked (hDlg, IDC_NOTIFYCHECKBOX))
        {
                //g_ulNotifyEnable = 1;
                g_ulWaitSeconds = (DWORD) GetDlgItemInt (hDlg,IDC_WAITEDITBOX, &bOK, FALSE);
                g_ulRepeatSeconds = (DWORD) GetDlgItemInt (hDlg,IDC_REPEATEDITBOX, &bOK, FALSE);
                // check that the delay & interval are in valid range
                if ((!ValidWaitSeconds(hDlg)) || (!ValidRepeatSeconds(hDlg)))
                          return FALSE;
        }

        // get the Shutdown configuration
        if (g_ulShutdownOnBattery = IsDlgButtonChecked (hDlg, IDC_SHUTDOWNTIMERCHECKBOX))
        {
                //g_ulShutdownOnBattery = 1;
                g_ulOnBatteryMinutes = (DWORD) GetDlgItemInt (hDlg,IDC_SHUTDOWNTIMEREDITBOX, &bOK, FALSE);
                // check that the shutdown delay is in valid range
                if (!ValidShutdownDelay(hDlg))
                          return FALSE;
        }

        // get the Shutdown Actions configuration
        g_ulRunTaskEnable = IsDlgButtonChecked (hDlg, IDC_RUNTASKCHECKBOX);


        g_ulTurnOffUPS = IsDlgButtonChecked (hDlg, IDC_TURNOFFCHECKBOX);

        // all configuration data is captured & validated
        return TRUE;
}


/*******************************************************************************
*
*  APCFileNameOnly
*
*  DESCRIPTION: Returns a pointer to the first character after the last
*               backslash in a string
*
*  PARAMETERS:  sz: string from which to strip the path
*
*******************************************************************************/
LPTSTR APCFileNameOnly(LPTSTR sz)
{
 LPTSTR next = sz;
 LPTSTR prev;
 LPTSTR begin = next;

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

  while ( *next ) {
        prev = next;
        next++;

        if ( (*prev == TEXT('\\')) || (*prev == TEXT(':')) ) {
            begin = next;
        }
  }
 return begin;
}


/*******************************************************************************
*
*  GetTaskApplicationInfo
*
*  DESCRIPTION: if the UPS System Shutdown task exists get the application name
*
*  PARAMETERS:  aBuffer:
*
*******************************************************************************/
BOOL GetTaskApplicationInfo(LPTSTR aBuffer){
    HRESULT hr;
    ITaskScheduler *task_sched = NULL;
    ITask *shutdown_task = NULL;
        BOOL taskExists = FALSE;

        //
        // if there is no task name, don't bother
        //
        if (_tcsclen(g_szTaskName)) {
          //
      // Get a handle to the ITaskScheduler COM Object
          //
      hr = CoCreateInstance( &CLSID_CSchedulingAgent,
                                                        NULL,
                                                        CLSCTX_INPROC_SERVER,
                            &IID_ISchedulingAgent,
                                                        (LPVOID *)&task_sched);
      if (SUCCEEDED(hr)) {
                //
        // Get an instance of the Task if it already exists
                //
        hr = task_sched->lpVtbl->Activate( task_sched,
                                                                                        g_szTaskName,
                                                                                        &IID_ITask,
                                                                                        (IUnknown**)&shutdown_task);
                if (SUCCEEDED(hr)) {
                        LPTSTR lpszTaskApplicationName;

                        if (aBuffer != NULL) {
                                //
                                // get the app name
                                //
                                shutdown_task->lpVtbl->GetApplicationName( shutdown_task,
                                                                                                                        &lpszTaskApplicationName);
                                _tcscpy(aBuffer,lpszTaskApplicationName);
                        }
                        //
                        // release the task
                        //
                        shutdown_task->lpVtbl->Release(shutdown_task);
                        shutdown_task = NULL;
                        taskExists = TRUE;
        }
                //
        // Release the instance of the Task Scheduler
                //
        task_sched->lpVtbl->Release(task_sched);
                task_sched = NULL;
          }
        }

        return taskExists;
}


/*******************************************************************************
*
*  EditWorkItem
*
*  DESCRIPTION: Opens the specified task or creates a new one if the specified
*               name is not found in the task list.
*
*  PARAMETERS:  hWnd            : handle to the parent window
*                               pszTaskName : task to edit (create or open existing)
*
*******************************************************************************/
void EditWorkItem_UPS(HWND hWnd)
{       
  HRESULT     hr;
  ITask *pITask = NULL; 
  ITaskScheduler   *pISchedAgent = NULL;
  IPersistFile     *pIPersistFile = NULL;
  TCHAR szTaskApplicationName[MAX_PATH] = _T("");
  unsigned long ulSchedAgentHandle = 0;

  //
  // if there is no task name, don't even bother
  //
  if (_tcsclen(g_szTaskName)) {
          //
          // get an instance of the scheduler
          //
    hr = CoCreateInstance( &CLSID_CSchedulingAgent,
                           NULL,
                           CLSCTX_INPROC_SERVER,
                           &IID_ISchedulingAgent,
                           (LPVOID*)&pISchedAgent);

    if (SUCCEEDED(hr)) {
                //
                // get an instance of the task if it exists...
                //
        hr = pISchedAgent->lpVtbl->Activate(pISchedAgent,
                                       g_szTaskName,
                                       &IID_ITask,
                                       &(IUnknown *)pITask);
        
            if (HRESULT_CODE (hr) == ERROR_FILE_NOT_FOUND){
                        //
                        // otherwise create a new task instance
                        //
            hr = pISchedAgent->lpVtbl->NewWorkItem(
                    pISchedAgent,
                    g_szTaskName,
                    &CLSID_CTask,
                    &IID_ITask,
                    &(IUnknown *)pITask);

            if (SUCCEEDED(hr)) {
                //
                // Commit new work item to disk before editing.
                //
                hr = pITask->lpVtbl->QueryInterface(pITask, &IID_IPersistFile,
                                                    (void **)&pIPersistFile);

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

                //
                // register the task scheduler agent in the ROT table
                //
        if (SUCCEEDED(hr)) {
                    hr = RegisterActiveObject(
                                 (IUnknown *) pITask,
                                 &CLSID_CTask,
                                 ACTIVEOBJECT_WEAK,
                                 &ulSchedAgentHandle);

                        //
                        // allow the user to edit the task
                        //
                        if(SUCCEEDED(hr)) {
                pITask->lpVtbl->EditWorkItem(pITask, hWnd, 0);
                                //
                                // user is finished; remove the task scheduler agent from the ROT
                                //
                                if(ulSchedAgentHandle != 0){
                                  RevokeActiveObject(ulSchedAgentHandle, NULL);
                                }
                        }

                        //
                        // release the task
                        //
            pITask->lpVtbl->Release(pITask);
                        pITask = NULL;
        }

                //
                // release the agent
                //
        pISchedAgent->lpVtbl->Release(pISchedAgent);
                pISchedAgent = NULL;

        }

        //
    // if a task was successfully created, display the task's program name;
        //
    if (GetTaskApplicationInfo(szTaskApplicationName)){
                SetDlgItemText (hWnd, IDC_TASKNAMETEXT, APCFileNameOnly(szTaskApplicationName));
        }
  }
}

/*******************************************************************************
*
*  OnNotifyWaitSpin
*
*  DESCRIPTION: handles all notification messages for the Notification spin control
*
*  PARAMETERS:  lParam:
*
*******************************************************************************/
BOOL OnNotifyWaitSpin( LPARAM lParam )
{
        LPNMUPDOWN lpNMUpDown = (LPNMUPDOWN)lParam;
    UINT uNotify = lpNMUpDown->hdr.code;

        switch( uNotify )
        {
        case UDN_DELTAPOS:
#if WAITSECONDSFIRSTVAL // Code is dead if WAITSECONDSFIRSTVAL == 0 since unsigneds cannot go < 0
                if ((g_ulWaitSeconds < (DWORD)WAITSECONDSFIRSTVAL) && (lpNMUpDown->iDelta > 0))
                {
                        /*
                         * user has spec'd a value less than min and wants
                         * to scroll up, so first value should be min
                         */
                        g_ulWaitSeconds = WAITSECONDSFIRSTVAL;
                        lpNMUpDown->iDelta=0; // to disallow request
                }
                else
#endif
        if ((g_ulWaitSeconds > (DWORD)WAITSECONDSLASTVAL ) && (lpNMUpDown->iDelta < 0))
                {
                        /*
                         * user had spec'd a value greater than max and wants
                         * to scroll down, so first value should be max
                         */
                        g_ulWaitSeconds = WAITSECONDSLASTVAL;
                        lpNMUpDown->iDelta=0; // to disallow request
                }
                break;
        default:
                break;
        }

        return FALSE;
}

/*******************************************************************************
*
*  OnNotifyRepeatSpin
*
*  DESCRIPTION: handles all notification messages for the Repeat spin control
*
*  PARAMETERS:  lParam:
*
*******************************************************************************/
BOOL OnNotifyRepeatSpin( LPARAM lParam )
{
        LPNMUPDOWN lpNMUpDown = (LPNMUPDOWN)lParam;
    UINT uNotify = lpNMUpDown->hdr.code;

        switch( uNotify )
        {
        case UDN_DELTAPOS:
                if ((g_ulRepeatSeconds < (DWORD)REPEATSECONDSFIRSTVAL) && (lpNMUpDown->iDelta > 0))
                {
                        /*
                         * user has spec'd a value less than min and wants
                         * to scroll up, so first value should be min
                         */
                        g_ulRepeatSeconds = REPEATSECONDSFIRSTVAL;
                        lpNMUpDown->iDelta=0; // to disallow request
                }
                else if ((g_ulRepeatSeconds > (DWORD)REPEATSECONDSLASTVAL ) && (lpNMUpDown->iDelta < 0))
                {
                        /*
                         * user had spec'd a value greater than max and wants
                         * to scroll down, so first value should be max
                         */
                        g_ulRepeatSeconds = REPEATSECONDSLASTVAL;
                        lpNMUpDown->iDelta=0; // to disallow request
                }
                break;
        default:
                break;
        }

        return FALSE;
}

/*******************************************************************************
*
*  OnNotifyTimerSpin
*
*  DESCRIPTION: handles all notification messages for the Timer spin control
*
*  PARAMETERS:  lParam:
*
*******************************************************************************/
BOOL OnNotifyTimerSpin( LPARAM lParam )
{
        LPNMUPDOWN lpNMUpDown = (LPNMUPDOWN)lParam;
    UINT uNotify = lpNMUpDown->hdr.code;

        switch( uNotify )
        {
        case UDN_DELTAPOS:
                if ((g_ulOnBatteryMinutes < (DWORD)SHUTDOWNTIMERMINUTESFIRSTVAL) && (lpNMUpDown->iDelta > 0))
                {
                        /*
                         * user has spec'd a value less than min and wants
                         * to scroll up, so first value should be min
                         */
                        g_ulOnBatteryMinutes = SHUTDOWNTIMERMINUTESFIRSTVAL;
                        lpNMUpDown->iDelta=0; // to disallow request
                }
                else if ((g_ulOnBatteryMinutes > (DWORD)SHUTDOWNTIMERMINUTESLASTVAL ) && (lpNMUpDown->iDelta < 0))
                {
                        /*
                         * user had spec'd a value greater than max and wants
                         * to scroll down, so first value should be max
                         */
                        g_ulOnBatteryMinutes = SHUTDOWNTIMERMINUTESLASTVAL;
                        lpNMUpDown->iDelta=0; // to disallow request
                }
                break;
        default:
                break;
        }

        return FALSE;
}

/********************************************************************
*
* FUNCTION: handleSpinners
*
* DESCRIPTION:  this function insures that if the user enters out-of-
*                               bounds spinner values, then click on a spinner, the
*                               next value shown is the min or max valid value.
*
* PARAMETERS:   HWND hWnd - a handle to the main dialog window
*                               WPARAM wParam - the WPARAM parameter to the Window's
*                                                               CALLBACK function.
*                               LPARAM lParam - the LPARAM parameter to the Window's
*                                                               CALLBACK function
*
* RETURNS: TRUE to deny request, FALSE to allow it
*                       (NOTE: testing suggests that this has no affect)
*
*********************************************************************/


/*******************************************************************************
*
*  OnNotificationCheckBox
*
*  DESCRIPTION: Command handler for the notification check box
*
*  PARAMETERS:  hWnd:
*
*******************************************************************************/
BOOL OnNotificationCheckBox( HWND hWnd )
{
        g_ulNotifyEnable = IsDlgButtonChecked( hWnd, IDC_NOTIFYCHECKBOX );
    EnableWindow( GetDlgItem( hWnd, IDC_WAITEDITBOX ), g_ulNotifyEnable );
    EnableWindow( GetDlgItem( hWnd, IDC_WAITTEXT ), g_ulNotifyEnable );
        EnableWindow( GetDlgItem( hWnd, IDC_REPEATEDITBOX ), g_ulNotifyEnable );
    EnableWindow( GetDlgItem( hWnd, IDC_REPEATTEXT ), g_ulNotifyEnable );
    EnableWindow( GetDlgItem( hWnd, IDC_REPEATSPIN ), g_ulNotifyEnable );
    EnableWindow( GetDlgItem( hWnd, IDC_WAITSPIN ), g_ulNotifyEnable );
        return TRUE;
}

/*******************************************************************************
*
*  OnShutdownTimerCheckBox
*
*  DESCRIPTION: Command handler for the Timer check box
*
*  PARAMETERS:  hWnd:
*
*******************************************************************************/
BOOL OnShutdownTimerCheckBox( HWND hWnd )
{
        g_ulShutdownOnBattery = IsDlgButtonChecked( hWnd, IDC_SHUTDOWNTIMERCHECKBOX );
        EnableWindow( GetDlgItem( hWnd, IDC_SHUTDOWNTIMEREDITBOX ), g_ulShutdownOnBattery );
        EnableWindow( GetDlgItem( hWnd, IDC_TIMERSPIN ), g_ulShutdownOnBattery );
        return TRUE;
}

/*******************************************************************************
*
*  OnRunTaskCheckBox
*
*  DESCRIPTION: Command handler for the run task check box
*
*  PARAMETERS:  hWnd:
*
*******************************************************************************/
BOOL OnRunTaskCheckBox( HWND hWnd )
{
        g_ulRunTaskEnable = IsDlgButtonChecked( hWnd, IDC_RUNTASKCHECKBOX );
        EnableWindow( GetDlgItem( hWnd, IDC_RUNTASKCHECKBOX ), TRUE );
        EnableWindow( GetDlgItem( hWnd, IDC_TASKNAMETEXT ), g_ulRunTaskEnable );
        EnableWindow( GetDlgItem( hWnd, IDC_CONFIGURETASKBUTTON ), g_ulRunTaskEnable );
        return TRUE;
}

/*******************************************************************************
*
*  OnTurnOffCheckBox
*
*  DESCRIPTION: Command handler for the turn off UPS check box
*
*  PARAMETERS:  hWnd:
*
*******************************************************************************/
BOOL OnTurnOffCheckBox( HWND hWnd )
{
        g_ulTurnOffUPS = IsDlgButtonChecked( hWnd, IDC_TURNOFFCHECKBOX );
        return TRUE;
}

/*******************************************************************************
*
*  OnConfigureTaskButton
*
*  DESCRIPTION: Command handler for the configure task button
*
*  PARAMETERS:  hWnd:
*
*******************************************************************************/
BOOL OnConfigureTaskButton( HWND hWnd )
{
        HWND    hTaskWnd;
        ITask *pITask = NULL;   

        // if task scheduler window is not already active, start it
        if (GetActiveObject(&CLSID_CTask, NULL,&(IUnknown*)pITask) != S_OK)
        {
                EditWorkItem_UPS(hWnd);
        }
        else
        {
           // task scheduler window already active, pop to foreground
           hTaskWnd =  FindWindow( NULL, g_szTaskName);
           BringWindowToTop(hTaskWnd);
        }

        return TRUE;
}

/*******************************************************************************
*
*  OnPowerActionCombo
*
*  DESCRIPTION: Command handler for the power action combobox
*
*  PARAMETERS:  hWnd:
*                               wParam:
*                               lParam
*
*******************************************************************************/
BOOL OnPowerActionCombo(
    IN HWND hWnd,
    IN WPARAM wParam,
    IN LPARAM lParam)
{
        BOOL bRetVal = FALSE;

        switch(HIWORD(wParam))
        {
                case CBN_SELCHANGE:
                {
                        g_ulCriticalPowerAction = (DWORD) SendDlgItemMessage( hWnd,
                                                                IDC_POWERACTIONCOMBO,
                                                                CB_GETCURSEL,
                                                                0,0);

                        // if Hibernate selected, uncheck the run task
                        // and disable all associated controls
                        if( UPS_SHUTDOWN_HIBERNATE == g_ulCriticalPowerAction )
                        {
                                g_ulRunTaskEnable = BST_UNCHECKED;
                                CheckDlgButton( hWnd, IDC_RUNTASKCHECKBOX, (BOOL) BST_UNCHECKED );
                                EnableWindow( GetDlgItem( hWnd, IDC_RUNTASKCHECKBOX ), FALSE );
                                EnableWindow( GetDlgItem( hWnd, IDC_TASKNAMETEXT ), FALSE );
                                EnableWindow( GetDlgItem( hWnd, IDC_CONFIGURETASKBUTTON ), FALSE );
                        }
                        else
                        {
                                EnableWindow( GetDlgItem( hWnd, IDC_RUNTASKCHECKBOX ), TRUE );
                        }

                }

                bRetVal = TRUE;
                break;
        default:
                break;
        }

        return bRetVal;
}


/*******************************************************************************
*
*   OnInitDialog
*
*   DESCRIPTION:  Handles WM_INITDIALOG message sent to UPSConfigDlgProc
*
*   PARAMETERS:
*
*******************************************************************************/
BOOL
OnInitDialog(
    IN HWND hWnd,
    IN WPARAM wParam,
    IN LPARAM lParam)
{
        #define SHORTBZ 16
        TCHAR   szNum[SHORTBZ];
        UDACCEL accel;
        TCHAR szTaskApplicationName[MAX_PATH] = _T("");
        TCHAR szShutdown[SHORTBZ], szHibernate[SHORTBZ];
        HANDLE g_hInstance;
    BOOL   fCallCoUninitialize;

        g_hInstance = GetUPSModuleHandle ();


        // Initialize COM
        fCallCoUninitialize = (S_OK == CoInitialize(NULL));

    SetWindowLong(hWnd, DWLP_USER, fCallCoUninitialize);

        // Get data from the registry
    GetRegistryValues();

        g_bPowerFailSignal = g_ulOptions & UPS_POWERFAILSIGNAL;
        g_bLowBatterySignal = g_ulOptions & UPS_LOWBATTERYSIGNAL;
        g_bShutOffSignal = g_ulOptions & UPS_SHUTOFFSIGNAL;

        // Set the number of valid digits in each editbox
        SendDlgItemMessage( hWnd,
                                                IDC_WAITEDITBOX,
                                                EM_LIMITTEXT,
                                                VALIDDIGITS, 0L );
        SendDlgItemMessage( hWnd,
                                                IDC_REPEATEDITBOX,
                                                EM_LIMITTEXT,
                                                VALIDDIGITS, 0L );
        SendDlgItemMessage( hWnd,
                                                IDC_SHUTDOWNTIMEREDITBOX,
                                                EM_LIMITTEXT,
                                                VALIDDIGITS,0L );

        // (reverse default behavior)
    // set up spinners so that uparrow increases value & downarrow decreases
        accel.nSec = 0;
        accel.nInc = -1;

        SendDlgItemMessage( hWnd, IDC_WAITSPIN, UDM_SETACCEL, 1, (LPARAM)&accel );
        SendDlgItemMessage( hWnd, IDC_REPEATSPIN, UDM_SETACCEL, 1, (LPARAM)&accel );
        SendDlgItemMessage( hWnd, IDC_TIMERSPIN, UDM_SETACCEL, 1, (LPARAM)&accel );

    // Set the range of valid integers for each spinner
    SendDlgItemMessage( hWnd,
                                                IDC_WAITSPIN,
                                                UDM_SETRANGE,
                                                0L,
                                                MAKELONG(WAITSECONDSFIRSTVAL, WAITSECONDSLASTVAL) );
    SendDlgItemMessage( hWnd,
                                                IDC_REPEATSPIN,
                                                UDM_SETRANGE,
                                                0L,
                                                MAKELONG(REPEATSECONDSFIRSTVAL,REPEATSECONDSLASTVAL) );
    SendDlgItemMessage( hWnd,
                                                IDC_TIMERSPIN,
                                                UDM_SETRANGE,
                                                0L,
                                                MAKELONG(SHUTDOWNTIMERMINUTESFIRSTVAL,SHUTDOWNTIMERMINUTESLASTVAL) );

        // Set the initial editbox values
        _itow (g_ulWaitSeconds, szNum, 10);
        SetDlgItemText (hWnd, IDC_WAITEDITBOX, (LPTSTR)szNum);
        _itow (g_ulRepeatSeconds, szNum, 10);
        SetDlgItemText (hWnd, IDC_REPEATEDITBOX, (LPTSTR)szNum);
        _itow (g_ulOnBatteryMinutes, szNum, 10);
        SetDlgItemText (hWnd, IDC_SHUTDOWNTIMEREDITBOX, (LPTSTR)szNum);

        // Set the initial state of the notification checkbox
        // and enable/disable associated controls
        CheckDlgButton (hWnd, IDC_NOTIFYCHECKBOX, (BOOL) g_ulNotifyEnable);
        OnNotificationCheckBox(hWnd);

        // Set the initial state of the shutdown timer checkbox
        // and enable/disable associated controls
        CheckDlgButton (hWnd, IDC_SHUTDOWNTIMERCHECKBOX, (BOOL) g_ulShutdownOnBattery);
        OnShutdownTimerCheckBox(hWnd);

        // Set the initial state of the run task checkbox
        // and enable/disable associated controls
        CheckDlgButton (hWnd, IDC_RUNTASKCHECKBOX, (BOOL) g_ulRunTaskEnable);
        OnRunTaskCheckBox(hWnd);

        // Display the task's program name
        if (GetTaskApplicationInfo(szTaskApplicationName))
        {
                SetDlgItemText (hWnd, IDC_TASKNAMETEXT, APCFileNameOnly(szTaskApplicationName));
        }

	// Initialize the power action combo box
    LoadString(g_hInstance, IDS_POWEROFF, (LPTSTR) szShutdown, sizeof(szShutdown)/sizeof(TCHAR));
    LoadString(g_hInstance, IDS_HIBERNATE, (LPTSTR) szHibernate, sizeof(szHibernate)/sizeof(TCHAR));

        SendDlgItemMessage( hWnd,
                                            IDC_POWERACTIONCOMBO,
                                                CB_ADDSTRING,
                                                0,
                                                (LPARAM) szShutdown);

    //
        // Offer Hibernate as an option if the Hiberfile is present
    //
        if(g_SysPwrCapabilities.SystemS4 && g_SysPwrCapabilities.HiberFilePresent) {
            SendDlgItemMessage( hWnd,
                                                        IDC_POWERACTIONCOMBO,
                                                        CB_ADDSTRING,
                                                        0,
                                                        (LPARAM) szHibernate );
        }

        SendDlgItemMessage( hWnd,
                                                IDC_POWERACTIONCOMBO,
                                                CB_SETCURSEL,
                                                g_ulCriticalPowerAction,0);

        // if Hibernate selected, disable the run task
        if( UPS_SHUTDOWN_HIBERNATE == g_ulCriticalPowerAction )
        {
                g_ulRunTaskEnable = BST_UNCHECKED;
                CheckDlgButton (hWnd, IDC_RUNTASKCHECKBOX, (BOOL) g_ulRunTaskEnable);
                OnRunTaskCheckBox(hWnd);
                EnableWindow( GetDlgItem( hWnd, IDC_RUNTASKCHECKBOX ), g_ulRunTaskEnable );
        }

        // Set the initial state of the turn off UPS checkbox
        // and enable/disable associated controls
        CheckDlgButton (hWnd, IDC_TURNOFFCHECKBOX , (BOOL) g_ulTurnOffUPS);
        OnTurnOffCheckBox(hWnd);

        // Finally, hide controls that aren't supported based on options key
//      ShowWindow(GetDlgItem( hWnd, IDC_WAITEDITBOX ), g_bPowerFailSignal ?  SW_SHOW : SW_HIDE);
//      ShowWindow(GetDlgItem( hWnd, IDC_WAITSPIN ), g_bPowerFailSignal ?  SW_SHOW : SW_HIDE);
//      ShowWindow(GetDlgItem( hWnd, IDC_WAITTEXT ), g_bPowerFailSignal ?  SW_SHOW : SW_HIDE);
//      ShowWindow(GetDlgItem( hWnd, IDC_REPEATEDITBOX ), g_bPowerFailSignal ?  SW_SHOW : SW_HIDE);
//      ShowWindow(GetDlgItem( hWnd, IDC_REPEATSPIN ), g_bPowerFailSignal ?  SW_SHOW : SW_HIDE);
//      ShowWindow(GetDlgItem( hWnd, IDC_REPEATTEXT ), g_bPowerFailSignal ?  SW_SHOW : SW_HIDE);

        ShowWindow(GetDlgItem(hWnd,IDC_LOWBATTERYSHUTDOWNTEXT), g_bLowBatterySignal ?  SW_SHOW : SW_HIDE);

        ShowWindow(GetDlgItem(hWnd,IDC_TURNOFFCHECKBOX), g_bShutOffSignal ?  SW_SHOW : SW_HIDE);

        return  TRUE;
}


/*******************************************************************************
*
*   OnClose
*
*   DESCRIPTION:  Handles WM_CLOSE message sent to UPSConfigDlgProc
*
*   PARAMETERS:
*
*******************************************************************************/
BOOL
OnClose(
    IN HWND hWnd,
    IN WPARAM wParam,
    IN LPARAM lParam)
{
        HWND taskHwnd = NULL;

        // if task scheduler window is still up, kill it
        taskHwnd =  FindWindow( NULL, g_szTaskName);
        if (taskHwnd)
        {
                DestroyWindow(taskHwnd);
        }

    if (GetWindowLong(hWnd, DWLP_USER))
            CoUninitialize();
        EndDialog(hWnd, wParam);

        return TRUE;
}


/*******************************************************************************
*
*   OnOK
*
*   DESCRIPTION:  Handles WM_COMMAND message sent to IDOK
*
*   PARAMETERS:
*
*******************************************************************************/
BOOL OnOK(
    IN HWND hWnd,
    IN WPARAM wParam,
    IN LPARAM lParam)
{
        if (ValidateFields(hWnd))
        {
                 SetRegistryValues();

                 AddActiveDataState(CONFIG_DATA_CHANGE);

                 EnableApplyButton();

                 return OnClose(hWnd, wParam, lParam);
        }

        return FALSE;
}


/*******************************************************************************
*
*   OnCommand
*
*   DESCRIPTION:  Handles WM_COMMAND messages sent to UPSConfigDlgProc
*
*   PARAMETERS:
*
*******************************************************************************/
BOOL
OnCommand(
    IN HWND hWnd,
    IN WPARAM wParam,
    IN LPARAM lParam
    )
{
    BOOL    bRetVal;
    WORD    idCtl   = LOWORD(wParam);
    WORD    wNotify = HIWORD(wParam);

    //
    // Assume we handle the command, the default switch will catch exceptions.
    //
    bRetVal = TRUE;

    switch (idCtl)
        {
                case IDC_NOTIFYCHECKBOX:
                        bRetVal = OnNotificationCheckBox(hWnd);
                        break;

                case IDC_SHUTDOWNTIMERCHECKBOX:
                        bRetVal = OnShutdownTimerCheckBox(hWnd);
                        break;

                case IDC_POWERACTIONCOMBO:
                        bRetVal = OnPowerActionCombo(hWnd, wParam, lParam);
                        break;

                case IDC_RUNTASKCHECKBOX:
                        bRetVal = OnRunTaskCheckBox(hWnd);
                        break;

                case IDC_CONFIGURETASKBUTTON:
                        bRetVal = OnConfigureTaskButton(hWnd);
                        break;

                case IDOK:
                        bRetVal = OnOK(hWnd, wParam, lParam);
                        break;

                case IDCANCEL:                          // escape key,cancel buttion
                        bRetVal = OnClose(hWnd, wParam, lParam);
                        break;

                default:
                        bRetVal = FALSE;                // unhandled command, return FALSE
        }
        
        return bRetVal;
}



/*******************************************************************************
*
*   OnNotify
*
*   DESCRIPTION:  Handles WM_NOTIFY messages sent to UPSConfigDlgProc
*
*   PARAMETERS:
*
*******************************************************************************/
BOOL
OnNotify(
    IN HWND hWnd,
    IN WPARAM wParam,
    IN LPARAM lParam
    )
{
    int idCtl = (int) wParam;

        switch (idCtl) {
                case IDC_WAITSPIN:
                        OnNotifyWaitSpin( lParam );
                        break;
                case IDC_REPEATSPIN:
                        OnNotifyRepeatSpin( lParam );
                        break;
                case IDC_TIMERSPIN:
                        OnNotifyTimerSpin( lParam );
                        break;
                default:
                        break;
        }

        return FALSE;
}


/*******************************************************************************
*
*   UPSConfigDlgProc
*
*   DESCRIPTION:
*
*   PARAMETERS:
*
*******************************************************************************/
INT_PTR CALLBACK UPSConfigDlgProc(
    HWND hWnd,
    UINT uMsg,
    WPARAM wParam,
    LPARAM lParam
    )
{
        BOOL bRet = TRUE;

    switch (uMsg) {
    case WM_INITDIALOG:
                OnInitDialog(hWnd,wParam,lParam);
                break;

    case WM_COMMAND:
                OnCommand(hWnd,wParam,lParam);
                break;

    case WM_HELP:             // F1
        WinHelp(((LPHELPINFO)lParam)->hItemHandle,
                                PWRMANHLP,
                                HELP_WM_HELP,
                                (ULONG_PTR)(LPTSTR)g_UPSConfigHelpIDs);
                break;

    case WM_CONTEXTMENU:      // right mouse click
                WinHelp((HWND)wParam,
                                PWRMANHLP,
                                HELP_CONTEXTMENU,
                                (ULONG_PTR)(LPTSTR)g_UPSConfigHelpIDs);
                break;

        case WM_CLOSE:
                OnClose(hWnd,wParam,lParam);
                break;

        case WM_NOTIFY:
                OnNotify(hWnd,wParam,lParam);
                break;

        default:
                bRet = FALSE;
                break;
    } // switch (uMsg)

    return bRet;
}