/******************************************************************************* * * 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 #include #include #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, MAX_PATH); 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, size_t aBufferLength){ 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); _tcsncpy(aBuffer,lpszTaskApplicationName, (aBufferLength - 1)); CoTaskMemFree(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, MAX_PATH)){ 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, MAX_PATH)) { 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; }