mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1341 lines
41 KiB
1341 lines
41 KiB
/*******************************************************************************
|
|
*
|
|
* (C) COPYRIGHT MICROSOFT CORP., 1997
|
|
*
|
|
* TITLE: BATMETER.C
|
|
*
|
|
* VERSION: 2.0
|
|
*
|
|
* AUTHOR: ReedB
|
|
*
|
|
* DATE: 17 Oct, 1996
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* Implements the battery meter of the PowerCfg or SysTray battery
|
|
* meter windows. The battery meter has two display modes, single and
|
|
* multi-battery. In single mode, a representation of the total of all battery
|
|
* capacity in a system is displayed. In multi-battery mode, battery
|
|
* information is displayed for each individual battery as well as the total.
|
|
*
|
|
* The battery meter parent window receives notification from USER when
|
|
* any battery status has changed through the WM_POWERBROADCAST,
|
|
* PBT_APMPOWERSTATUSCHANGE message.
|
|
*
|
|
* ??? We need to add perfmon support: Create and maintain keys/values
|
|
* under HKEY_PERFORMANCE_DATA.
|
|
*
|
|
*******************************************************************************/
|
|
|
|
#include <nt.h>
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
|
|
#include <windows.h>
|
|
#include <commctrl.h>
|
|
|
|
#include <dbt.h>
|
|
#include <objbase.h>
|
|
#include <initguid.h>
|
|
#include <ntpoapi.h>
|
|
#include <poclass.h>
|
|
|
|
#include <setupapi.h>
|
|
#include <syssetup.h>
|
|
#include <setupbat.h>
|
|
#include <ccstock.h>
|
|
|
|
#include <help.h>
|
|
|
|
#include "powrprofp.h"
|
|
#include "batmeter.h"
|
|
#include "bmresid.h"
|
|
#include "..\powercfg\PwrMn_cs.h"
|
|
#include "shfusion.h"
|
|
|
|
#define ARRAYSIZE(x) (sizeof(x)/sizeof(x[0]))
|
|
|
|
// Simulated battery only for debug build.
|
|
#ifndef DEBUG
|
|
#undef SIM_BATTERY
|
|
#endif
|
|
|
|
|
|
// Define some things for debug.h. Required when you include ccstock.h in
|
|
// one and only one file.
|
|
#define SZ_DEBUGINI "ccshell.ini"
|
|
#define SZ_DEBUGSECTION "BATMETER"
|
|
#define SZ_MODULE "BATMETER"
|
|
#define DECLARE_DEBUG
|
|
|
|
#include <debug.h>
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* G L O B A L D A T A
|
|
*
|
|
*******************************************************************************/
|
|
|
|
HINSTANCE g_hInstance; // Global instance handle of this DLL.
|
|
HWND g_hwndParent; // Parent of the battery meter.
|
|
HWND g_hwndBatMeter; // Battery meter.
|
|
|
|
// The following constant global array is used to walk through the
|
|
// control ID's in the battery metter dialog box. It makes getting
|
|
// a control ID from a battery number easy.
|
|
|
|
#define BAT_ICON 0
|
|
#define BAT_STATUS 1
|
|
#define BAT_REMAINING 2
|
|
#define BAT_NUM 3
|
|
#define BAT_LAST BAT_NUM+1
|
|
|
|
UINT g_iMapBatNumToID [NUM_BAT+1][4]={
|
|
{IDC_POWERSTATUSICON, IDC_POWERSTATUSBAR, IDC_REMAINING, IDC_BATNUM0},
|
|
{IDC_POWERSTATUSICON1, IDC_STATUS1, IDC_REMAINING1, IDC_BATNUM1},
|
|
{IDC_POWERSTATUSICON2, IDC_STATUS2, IDC_REMAINING2, IDC_BATNUM2},
|
|
{IDC_POWERSTATUSICON3, IDC_STATUS3, IDC_REMAINING3, IDC_BATNUM3},
|
|
{IDC_POWERSTATUSICON4, IDC_STATUS4, IDC_REMAINING4, IDC_BATNUM4},
|
|
{IDC_POWERSTATUSICON5, IDC_STATUS5, IDC_REMAINING5, IDC_BATNUM5},
|
|
{IDC_POWERSTATUSICON6, IDC_STATUS6, IDC_REMAINING6, IDC_BATNUM6},
|
|
{IDC_POWERSTATUSICON7, IDC_STATUS7, IDC_REMAINING7, IDC_BATNUM7},
|
|
{IDC_POWERSTATUSICON8, IDC_STATUS8, IDC_REMAINING8, IDC_BATNUM8}
|
|
};
|
|
|
|
// Global battery state list. This list has the composite system battery state
|
|
// as it's always present head. individual battery devices are linked to this
|
|
// head. Use WalkBatteryState(ALL, ... to walk the entire list, including the
|
|
// head. Use WalkBatteryState(DEVICES, ... to walk just the device list. If a
|
|
// battery is in this list, it's displayable. g_uiBatCount is the count of
|
|
// battery devices in this list. The composite battery is not counted. The
|
|
// g_pbs array provides a handy UI battery number to pbs conversion. The
|
|
// following three variables are only changed during DeviceChanged.
|
|
|
|
BATTERY_STATE g_bs;
|
|
UINT g_uiBatCount;
|
|
PBATTERY_STATE g_pbs[NUM_BAT+1];
|
|
LPTSTR g_lpszDriverNames[NUM_BAT];
|
|
UINT g_uiDriverCount;
|
|
BOOL g_bShowingMulti;
|
|
|
|
// The following array provides context sensitive help associations between
|
|
// resource control identifiers and help resource string identifiers.
|
|
|
|
const DWORD g_ContextMenuHelpIDs[] =
|
|
{
|
|
IDC_BATMETERGROUPBOX, IDH_COMM_GROUPBOX,
|
|
IDC_BATMETERGROUPBOX1, IDH_COMM_GROUPBOX,
|
|
IDC_POWERSTATUSICON, NO_HELP,
|
|
IDC_POWERSTATUSICON1, IDH_BATMETER_CHARGING_ICON,
|
|
IDC_POWERSTATUSICON2, IDH_BATMETER_CHARGING_ICON,
|
|
IDC_POWERSTATUSICON3, IDH_BATMETER_CHARGING_ICON,
|
|
IDC_POWERSTATUSICON4, IDH_BATMETER_CHARGING_ICON,
|
|
IDC_POWERSTATUSICON5, IDH_BATMETER_CHARGING_ICON,
|
|
IDC_POWERSTATUSICON6, IDH_BATMETER_CHARGING_ICON,
|
|
IDC_POWERSTATUSICON7, IDH_BATMETER_CHARGING_ICON,
|
|
IDC_POWERSTATUSICON8, IDH_BATMETER_CHARGING_ICON,
|
|
IDC_BATNUM1, NO_HELP,
|
|
IDC_BATNUM2, NO_HELP,
|
|
IDC_BATNUM3, NO_HELP,
|
|
IDC_BATNUM4, NO_HELP,
|
|
IDC_BATNUM5, NO_HELP,
|
|
IDC_BATNUM6, NO_HELP,
|
|
IDC_BATNUM7, NO_HELP,
|
|
IDC_BATNUM8, NO_HELP,
|
|
IDC_STATUS1, NO_HELP,
|
|
IDC_STATUS2, NO_HELP,
|
|
IDC_STATUS3, NO_HELP,
|
|
IDC_STATUS4, NO_HELP,
|
|
IDC_STATUS5, NO_HELP,
|
|
IDC_STATUS6, NO_HELP,
|
|
IDC_STATUS7, NO_HELP,
|
|
IDC_STATUS8, NO_HELP,
|
|
IDC_MOREINFO, NO_HELP,
|
|
IDC_CURRENTPOWERSOURCE, IDH_BATMETER_CURPOWERSOURCE,
|
|
IDC_BATTERYLEVEL, IDH_BATMETER_CURPOWERSOURCE,
|
|
IDC_TOTALBATPWRREMAINING, IDH_BATMETER_TOTALBATPOWER,
|
|
IDC_REMAINING, IDH_BATMETER_TOTALBATPOWER,
|
|
IDC_POWERSTATUSBAR, IDH_BATMETER_TOTALBATPOWER,
|
|
IDC_BARPERCENT, IDH_BATMETER_TOTALBATPOWER,
|
|
IDC_TOTALTIME, IDH_BATMETER_TOTALTIME,
|
|
IDC_TIMEREMAINING, IDH_BATMETER_TOTALTIME,
|
|
IDC_BATTERYNAME, IDH_DETAILED_BATINFO_LABELS,
|
|
IDC_DEVNAME, IDH_DETAILED_BATINFO_LABELS,
|
|
IDC_UNIQUEID, IDH_DETAILED_BATINFO_LABELS,
|
|
IDC_BATID, IDH_DETAILED_BATINFO_LABELS,
|
|
IDC_MANUFACTURE, IDH_DETAILED_BATINFO_LABELS,
|
|
IDC_BATMANNAME, IDH_DETAILED_BATINFO_LABELS,
|
|
IDC_DATEMANUFACTURED, IDH_DETAILED_BATINFO_LABELS,
|
|
IDC_BATMANDATE, IDH_DETAILED_BATINFO_LABELS,
|
|
IDC_CHEMISTRY, IDH_DETAILED_BATINFO_LABELS,
|
|
IDC_CHEM, IDH_DETAILED_BATINFO_LABELS,
|
|
IDC_POWERSTATE, IDH_DETAILED_BATINFO_LABELS,
|
|
IDC_STATE, IDH_DETAILED_BATINFO_LABELS,
|
|
IDC_REFRESH, IDH_DETAILED_BATINFO_REFRESH,
|
|
0, 0
|
|
};
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* P U B L I C E N T R Y P O I N T S
|
|
*
|
|
*******************************************************************************/
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* DllInitialize
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
BOOL DllInitialize(IN PVOID hmod, IN ULONG ulReason, IN PCONTEXT pctx OPTIONAL)
|
|
{
|
|
UNREFERENCED_PARAMETER(pctx);
|
|
|
|
switch (ulReason) {
|
|
|
|
case DLL_PROCESS_ATTACH:
|
|
g_hInstance = hmod;
|
|
DisableThreadLibraryCalls(g_hInstance);
|
|
SHFusionInitializeFromModuleID(hmod, 124);
|
|
break;
|
|
|
|
case DLL_PROCESS_DETACH:
|
|
SHFusionUninitialize();
|
|
break;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* PowerCapabilities
|
|
*
|
|
* DESCRIPTION:
|
|
* This public function is used to determine if the system has any power
|
|
* management capabilities which require UI support. Return TRUE if power
|
|
* management UI should be displayed.
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
BOOL PowerCapabilities()
|
|
{
|
|
SYSTEM_POWER_CAPABILITIES spc;
|
|
int dummy;
|
|
|
|
#ifndef SIM_BATTERY
|
|
if (GetPwrCapabilities(&spc)) {
|
|
if ((spc.PowerButtonPresent) ||
|
|
(spc.SleepButtonPresent) ||
|
|
(spc.LidPresent) ||
|
|
(spc.SystemS1) ||
|
|
(spc.SystemS2) ||
|
|
(spc.SystemS3) ||
|
|
(spc.SystemS4) ||
|
|
(spc.SystemS5) ||
|
|
(spc.DiskSpinDown) ||
|
|
(spc.SystemBatteriesPresent)) {
|
|
return TRUE;
|
|
}
|
|
else {
|
|
if (SystemParametersInfo(SPI_GETLOWPOWERACTIVE, 0, &dummy, 0)) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
#else
|
|
return TRUE;
|
|
#endif
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* BatMeterCapabilities
|
|
*
|
|
* DESCRIPTION:
|
|
* This public function is used to determine if the battery meter library
|
|
* can run on the host machine. Return TRUE on success (battery meter can run).
|
|
*
|
|
* PARAMETERS:
|
|
* ppuiBatCount - Points to a pointer which will be filled in with a pointer
|
|
* to the global battery count.
|
|
*
|
|
*******************************************************************************/
|
|
|
|
BOOL BatMeterCapabilities(
|
|
PUINT *ppuiBatCount
|
|
)
|
|
{
|
|
#ifndef SIM_BATTERY
|
|
SYSTEM_POWER_CAPABILITIES spc;
|
|
#endif // SIM_BATTERY
|
|
|
|
if (ppuiBatCount) {
|
|
*ppuiBatCount = &g_uiBatCount;
|
|
}
|
|
g_uiBatCount = 0;
|
|
|
|
#ifndef SIM_BATTERY
|
|
// Make sure we have batteries to query.
|
|
if (GetPwrCapabilities(&spc)) {
|
|
if (spc.SystemBatteriesPresent) {
|
|
g_uiDriverCount = GetBatteryDriverNames(g_lpszDriverNames);
|
|
if (g_uiDriverCount != 0) {
|
|
g_uiBatCount = g_uiDriverCount;
|
|
|
|
return TRUE;
|
|
}
|
|
else {
|
|
DebugPrint( "BatMeterCapabilities, no battery drivers found.");
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
|
|
#else // SIM_BATTERY
|
|
g_uiBatCount = g_uiDriverCount = GetBatteryDriverNames(g_lpszDriverNames);
|
|
return UpdateDriverList(g_lpszDriverNames, g_uiDriverCount);
|
|
#endif // SIM_BATTERY
|
|
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* CreateBatMeter
|
|
*
|
|
* DESCRIPTION:
|
|
* Create, fetch data for and draw the battery meter window. Returns a handle
|
|
* to the newly created battery meter window on success, NULL on failure.
|
|
*
|
|
* PARAMETERS:
|
|
* hwndParent - Parent of the battery meter dialog.
|
|
* wndFrame - Frame to locate the battery meter dialog.
|
|
* bShowMulti - Specifies the display mode (TRUE -> multiple battery).
|
|
* pbsComposite - Optional pointer to composite battery state.
|
|
*
|
|
*******************************************************************************/
|
|
|
|
HWND CreateBatMeter(
|
|
HWND hwndParent,
|
|
HWND hwndFrame,
|
|
BOOL bShowMulti,
|
|
PBATTERY_STATE pbsComposite
|
|
)
|
|
{
|
|
INT iWidth, iHeight;
|
|
RECT rFrame = {0};
|
|
|
|
// Build the battery devices name list if hasn't already been built.
|
|
if (!g_uiBatCount)
|
|
{
|
|
BatMeterCapabilities(NULL);
|
|
}
|
|
|
|
// Remember if we are showing details for each battery
|
|
g_bShowingMulti = bShowMulti;
|
|
|
|
// Make sure we have at least one battery.
|
|
if (g_uiBatCount)
|
|
{
|
|
// Create the battery meter control.
|
|
g_hwndParent = hwndParent;
|
|
g_hwndBatMeter = CreateDialog(g_hInstance,
|
|
MAKEINTRESOURCE(IDD_BATMETER),
|
|
hwndParent,
|
|
BatMeterDlgProc);
|
|
|
|
// Place the battery meter in the passed frame window.
|
|
if ((g_hwndBatMeter) && (hwndFrame))
|
|
{
|
|
// Position the BatMeter dialog in the frame.
|
|
if (!GetWindowRect(hwndFrame, &rFrame))
|
|
{
|
|
DebugPrint( "CreateBatMeter, GetWindowRect failed, hwndFrame: %08X", hwndFrame);
|
|
}
|
|
|
|
iWidth = rFrame.right - rFrame.left;
|
|
iHeight = rFrame.bottom - rFrame.top;
|
|
|
|
if (IsBiDiLocalizedSystemEx(NULL))
|
|
{
|
|
// Whistler #209400: On BIDI systems, ScreenToClient() wants the right
|
|
// coord in the left location because everything is flipped.
|
|
rFrame.left = rFrame.right;
|
|
}
|
|
|
|
if (!ScreenToClient(hwndParent, (LPPOINT)&rFrame))
|
|
{
|
|
DebugPrint( "CreateBatMeter, ScreenToClient failed");
|
|
}
|
|
|
|
if (!MoveWindow(g_hwndBatMeter,
|
|
rFrame.left,
|
|
rFrame.top,
|
|
iWidth,
|
|
iHeight,
|
|
FALSE))
|
|
{
|
|
DebugPrint( "CreateBatMeter, MoveWindow failed, %d, %d", rFrame.left, rFrame.top);
|
|
}
|
|
|
|
// Build the battery driver data list.
|
|
if (!UpdateDriverList(g_lpszDriverNames, g_uiDriverCount))
|
|
{
|
|
return DestroyBatMeter(g_hwndBatMeter);
|
|
}
|
|
|
|
// Do the first update.
|
|
UpdateBatMeter(g_hwndBatMeter, bShowMulti, TRUE, pbsComposite);
|
|
ShowWindow(g_hwndBatMeter, SW_SHOWNOACTIVATE);
|
|
}
|
|
}
|
|
|
|
return g_hwndBatMeter;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* DestroyBatMeter
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
HWND DestroyBatMeter(HWND hWnd)
|
|
{
|
|
SendMessage(hWnd, WM_DESTROYBATMETER, 0, 0);
|
|
g_hwndBatMeter = NULL;
|
|
return g_hwndBatMeter;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* UpdateBatMeter
|
|
*
|
|
* DESCRIPTION:
|
|
* This function should be called when the battery meter parent window
|
|
* receives a WM_POWERBROADCAST, PBT_APMPOWERSTATUSCHANGE message, it will
|
|
* update the data in the global battery state list. If needed the display
|
|
* will also be updated.
|
|
*
|
|
* PARAMETERS:
|
|
* HWND hwndBatMeter, hWnd of the battery meter dialog
|
|
* BOOL bShowMulti, Specifies the display mode
|
|
* BOOL bForceUpdate, Forces a UI update
|
|
* PBATTERY_STATE pbsComposite Optional pointer to composite battery state.
|
|
*
|
|
*******************************************************************************/
|
|
|
|
BOOL UpdateBatMeter(
|
|
HWND hWnd,
|
|
BOOL bShowMulti,
|
|
BOOL bForceUpdate,
|
|
PBATTERY_STATE pbsComposite
|
|
)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
SYSTEM_POWER_STATUS sps;
|
|
UINT uIconID;
|
|
|
|
// Update the composite battery state.
|
|
if (GetSystemPowerStatus(&sps) && hWnd) {
|
|
if (sps.BatteryLifePercent > 100) {
|
|
DebugPrint( "GetSystemPowerStatuse, set BatteryLifePercent: %d", sps.BatteryLifePercent);
|
|
}
|
|
|
|
// Fill in the composite battery state.
|
|
SystemPowerStatusToBatteryState(&sps, &g_bs);
|
|
|
|
// Update the information in the battery state list if we have a battery.
|
|
if (g_hwndBatMeter) {
|
|
|
|
#ifndef SIM_BATTERY
|
|
WalkBatteryState(DEVICES,
|
|
(WALKENUMPROC)UpdateBatInfoProc,
|
|
NULL,
|
|
(LPARAM)NULL,
|
|
(LPARAM)NULL);
|
|
#else
|
|
WalkBatteryState(DEVICES,
|
|
(WALKENUMPROC)SimUpdateBatInfoProc,
|
|
NULL,
|
|
(LPARAM)NULL,
|
|
(LPARAM)NULL);
|
|
#endif
|
|
|
|
// See if the current display mode matches the requested mode.
|
|
if ((g_bShowingMulti != bShowMulti) || (bForceUpdate)) {
|
|
g_bShowingMulti = SwitchDisplayMode(hWnd, bShowMulti);
|
|
bForceUpdate = TRUE;
|
|
}
|
|
|
|
if (g_bShowingMulti) {
|
|
// Walk the bs list, and update all battery displays.
|
|
WalkBatteryState(ALL,
|
|
(WALKENUMPROC)UpdateBatMeterProc,
|
|
hWnd,
|
|
(LPARAM)g_bShowingMulti,
|
|
(LPARAM)bForceUpdate);
|
|
}
|
|
else {
|
|
// Display only the comosite battery information.
|
|
UpdateBatMeterProc(&g_bs,
|
|
hWnd,
|
|
(LPARAM)g_bShowingMulti,
|
|
(LPARAM)bForceUpdate);
|
|
}
|
|
bRet = TRUE;
|
|
}
|
|
}
|
|
else {
|
|
// Fill in default composite info.
|
|
g_bs.ulPowerState = BATTERY_POWER_ON_LINE;
|
|
g_bs.ulBatLifePercent = (UINT) -1;
|
|
g_bs.ulBatLifeTime = (UINT) -1;
|
|
|
|
uIconID = MapBatInfoToIconID(&g_bs);
|
|
g_bs.hIconCache = GetBattIcon(hWnd, uIconID, g_bs.hIconCache, FALSE, 32);
|
|
g_bs.hIconCache16 = GetBattIcon(hWnd, uIconID, g_bs.hIconCache16, FALSE, 16);
|
|
}
|
|
|
|
// If a pointer is provided, copy the composite battery state data.
|
|
if (pbsComposite) {
|
|
if (pbsComposite->ulSize == sizeof(BATTERY_STATE)) {
|
|
memcpy(pbsComposite, &g_bs, sizeof(BATTERY_STATE));
|
|
}
|
|
else {
|
|
DebugPrint( "UpdateBatMeter, passed BATTERY_STATE size is invalid");
|
|
}
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* P R I V A T E F U N C T I O N S
|
|
*
|
|
*******************************************************************************/
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* LoadDynamicString
|
|
*
|
|
* DESCRIPTION:
|
|
* Wrapper for the FormatMessage function that loads a string from our
|
|
* resource table into a dynamically allocated buffer, optionally filling
|
|
* it with the variable arguments passed.
|
|
*
|
|
* PARAMETERS:
|
|
* uiStringID - resource identifier of the string to use.
|
|
* ... - Optional parameters to use to format the string message.
|
|
*
|
|
*******************************************************************************/
|
|
|
|
LPTSTR CDECL LoadDynamicString(UINT uiStringID, ... )
|
|
{
|
|
va_list Marker;
|
|
TCHAR szBuf[256];
|
|
LPTSTR lpsz;
|
|
int iLen;
|
|
|
|
// va_start is a macro...it breaks when you use it as an assign...on ALPHA.
|
|
va_start(Marker, uiStringID);
|
|
|
|
iLen = LoadString(g_hInstance, uiStringID, szBuf, ARRAYSIZE(szBuf));
|
|
|
|
if (iLen == 0) {
|
|
DebugPrint( "LoadDynamicString: LoadString on: 0x%X failed", uiStringID);
|
|
return NULL;
|
|
}
|
|
|
|
FormatMessage(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
|
|
(LPVOID) szBuf, 0, 0, (LPTSTR)&lpsz, 0, &Marker);
|
|
|
|
return lpsz;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* DisplayFreeStr
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
LPTSTR DisplayFreeStr(HWND hWnd, UINT uID, LPTSTR lpsz, BOOL bFree)
|
|
{
|
|
if (lpsz) {
|
|
SetDlgItemText(hWnd, uID, lpsz);
|
|
ShowWindow(GetDlgItem(hWnd, uID), SW_SHOWNOACTIVATE);
|
|
if (bFree) {
|
|
LocalFree(lpsz);
|
|
return NULL;
|
|
}
|
|
}
|
|
else {
|
|
ShowWindow(GetDlgItem(hWnd, uID), SW_HIDE);
|
|
}
|
|
return lpsz;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ShowHideItem
|
|
* ShowItem
|
|
* HideItem
|
|
*
|
|
* DESCRIPTION:
|
|
* Handy helpers to show or hide dialog items in the battery meter dialog.
|
|
*
|
|
* PARAMETERS:
|
|
* hWnd - Battery meter dialog handle.
|
|
* uID - Control ID of control to be shown or hidden.
|
|
*
|
|
*******************************************************************************/
|
|
|
|
BOOL ShowHideItem(HWND hWnd, UINT uID, BOOL bShow)
|
|
{
|
|
ShowWindow(GetDlgItem(hWnd, uID), (bShow) ? SW_SHOWNOACTIVATE : SW_HIDE);
|
|
return bShow;
|
|
}
|
|
|
|
void ShowItem(HWND hWnd, UINT uID)
|
|
{
|
|
ShowWindow(GetDlgItem(hWnd, uID), SW_SHOWNOACTIVATE);
|
|
}
|
|
|
|
void HideItem(HWND hWnd, UINT uID)
|
|
{
|
|
ShowWindow(GetDlgItem(hWnd, uID), SW_HIDE);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* SwitchDisplayMode
|
|
*
|
|
* DESCRIPTION:
|
|
* Return TRUE if display is switched to multi battery mode.
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
BOOL SwitchDisplayMode(HWND hWnd, BOOL bShowMulti)
|
|
{
|
|
ULONG i, j;
|
|
|
|
// Override request if multi-battery display is not possible.
|
|
if ((bShowMulti) && (!g_uiBatCount)) {
|
|
bShowMulti = FALSE;
|
|
}
|
|
|
|
if (!g_uiBatCount) {
|
|
|
|
//
|
|
// Hide all info if no batteries are installed
|
|
//
|
|
HideItem(hWnd, IDC_POWERSTATUSBAR);
|
|
HideItem(hWnd, IDC_BARPERCENT);
|
|
HideItem(hWnd, IDC_MOREINFO);
|
|
|
|
} else if (bShowMulti) {
|
|
HideItem(hWnd, IDC_POWERSTATUSBAR);
|
|
HideItem(hWnd, IDC_BARPERCENT);
|
|
ShowItem(hWnd, IDC_MOREINFO);
|
|
|
|
for (i = 1; i <= g_uiBatCount; i++) {
|
|
for (j = 0; j < BAT_LAST; j++) {
|
|
ShowItem(hWnd, g_iMapBatNumToID[i][0]);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for (i = 1; i <= g_uiBatCount; i++) {
|
|
for (j = 0; j < BAT_LAST; j++) {
|
|
HideItem(hWnd, g_iMapBatNumToID[i][j]);
|
|
}
|
|
}
|
|
|
|
ShowItem(hWnd, IDC_POWERSTATUSBAR);
|
|
ShowItem(hWnd, IDC_BARPERCENT);
|
|
HideItem(hWnd, IDC_MOREINFO);
|
|
}
|
|
return bShowMulti;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* CleanupBatteryData
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
void CleanupBatteryData(void)
|
|
{
|
|
g_hwndBatMeter = NULL;
|
|
|
|
// Mark all batteries as missing.
|
|
memset(&g_pbs, 0, sizeof(g_pbs));
|
|
|
|
// Walk the bs list, remove all devices and cleanup.
|
|
WalkBatteryState(DEVICES,
|
|
(WALKENUMPROC)RemoveMissingProc,
|
|
NULL,
|
|
(LPARAM)NULL,
|
|
(LPARAM)REMOVE_ALL);
|
|
|
|
// Free any old driver names.
|
|
FreeBatteryDriverNames(g_lpszDriverNames);
|
|
g_uiBatCount = 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* BatMeterDlgProc
|
|
*
|
|
* DESCRIPTION:
|
|
* DialogProc for the Battery Meter control. Provide support for more battery
|
|
* info.
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
LRESULT CALLBACK BatMeterDlgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
#ifdef WINNT
|
|
UINT i, j;
|
|
PBATTERY_STATE pbsTemp;
|
|
#endif // WINNT
|
|
|
|
UINT uiBatNum;
|
|
|
|
switch (uMsg) {
|
|
case WM_COMMAND:
|
|
if ((HIWORD(wParam) == STN_CLICKED) ||
|
|
(HIWORD(wParam) == BN_CLICKED)) {
|
|
switch (LOWORD(wParam)) {
|
|
case IDC_POWERSTATUSICON1:
|
|
case IDC_POWERSTATUSICON2:
|
|
case IDC_POWERSTATUSICON3:
|
|
case IDC_POWERSTATUSICON4:
|
|
case IDC_POWERSTATUSICON5:
|
|
case IDC_POWERSTATUSICON6:
|
|
case IDC_POWERSTATUSICON7:
|
|
case IDC_POWERSTATUSICON8:
|
|
uiBatNum = LOWORD(wParam) - IDC_POWERSTATUSICON1 + 1;
|
|
// Allow battery details only for present batteries.
|
|
if ((g_pbs[uiBatNum]) &&
|
|
(g_pbs[uiBatNum]->ulTag != BATTERY_TAG_INVALID)) {
|
|
DialogBoxParam(g_hInstance,
|
|
MAKEINTRESOURCE(IDD_BATDETAIL),
|
|
hWnd,
|
|
BatDetailDlgProc,
|
|
(LPARAM)g_pbs[uiBatNum]);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_DESTROYBATMETER:
|
|
CleanupBatteryData();
|
|
EndDialog(hWnd, wParam);
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
CleanupBatteryData();
|
|
break;
|
|
|
|
case WM_DEVICECHANGE:
|
|
#ifdef WINNT
|
|
if ((wParam == DBT_DEVICEQUERYREMOVE) || (wParam == DBT_DEVICEREMOVECOMPLETE)) {
|
|
if ( ((PDEV_BROADCAST_HANDLE)lParam)->dbch_devicetype == DBT_DEVTYP_HANDLE) {
|
|
|
|
//
|
|
// Find Device that got removed
|
|
//
|
|
pbsTemp = DEVICES;
|
|
while (pbsTemp) {
|
|
if (pbsTemp->hDevNotify == ((PDEV_BROADCAST_HANDLE)lParam)->dbch_hdevnotify) {
|
|
break;
|
|
}
|
|
pbsTemp = pbsTemp->bsNext;
|
|
}
|
|
if (!pbsTemp) {
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Close the handle to this device and release cached data.
|
|
//
|
|
RemoveBatteryStateDevice (pbsTemp);
|
|
g_uiDriverCount--;
|
|
g_uiBatCount = g_uiDriverCount;
|
|
|
|
// Clear and rebuild g_pbs, the handy batttery number to pbs array.
|
|
memset(&g_pbs, 0, sizeof(g_pbs));
|
|
pbsTemp = &g_bs;
|
|
for (i = 0; i <= g_uiBatCount; i++) {
|
|
if (pbsTemp) {
|
|
g_pbs[i] = pbsTemp;
|
|
pbsTemp->ulBatNum = i;
|
|
pbsTemp = pbsTemp->bsNext;
|
|
}
|
|
}
|
|
|
|
// Refresh display
|
|
for (i = 1; i <= NUM_BAT; i++) {
|
|
for (j = 0; j < BAT_LAST; j++) {
|
|
HideItem(g_hwndBatMeter, g_iMapBatNumToID[i][j]);
|
|
}
|
|
}
|
|
|
|
g_bShowingMulti = SwitchDisplayMode (g_hwndBatMeter, g_bShowingMulti);
|
|
if (g_bShowingMulti) {
|
|
// Walk the bs list, and update all battery displays.
|
|
WalkBatteryState(DEVICES,
|
|
(WALKENUMPROC)UpdateBatMeterProc,
|
|
g_hwndBatMeter,
|
|
(LPARAM)g_bShowingMulti,
|
|
(LPARAM)TRUE);
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
if (wParam == DBT_DEVICEQUERYREMOVE) {
|
|
if (g_hwndBatMeter) {
|
|
// Close all of the batteries.
|
|
CleanupBatteryData();
|
|
}
|
|
}
|
|
#endif
|
|
return TRUE;
|
|
|
|
case WM_HELP: // F1
|
|
WinHelp(((LPHELPINFO)lParam)->hItemHandle, PWRMANHLP, HELP_WM_HELP, (ULONG_PTR)(LPTSTR)g_ContextMenuHelpIDs);
|
|
return TRUE;
|
|
|
|
case WM_CONTEXTMENU: // right mouse click
|
|
WinHelp((HWND)wParam, PWRMANHLP, HELP_CONTEXTMENU, (ULONG_PTR)(LPTSTR)g_ContextMenuHelpIDs);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* GetBattIcon
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
HICON PASCAL GetBattIcon(
|
|
HWND hWnd,
|
|
UINT uIconID,
|
|
HICON hIconCache,
|
|
BOOL bWantBolt,
|
|
UINT uiRes)
|
|
{
|
|
static HIMAGELIST hImgLst32, hImgLst16;
|
|
HIMAGELIST hImgLst;
|
|
int ImageIndex;
|
|
|
|
// Destroy the old cached icon.
|
|
if (hIconCache) {
|
|
DestroyIcon(hIconCache);
|
|
}
|
|
|
|
// Don't put the charging bolt over the top of IDI_BATGONE.
|
|
if (uIconID == IDI_BATGONE) {
|
|
bWantBolt = FALSE;
|
|
}
|
|
|
|
// Use the transparency color must match that in the bit maps.
|
|
if (!hImgLst32 || !hImgLst16) {
|
|
hImgLst32 = ImageList_LoadImage(g_hInstance,
|
|
MAKEINTRESOURCE(IDB_BATTS),
|
|
32, 0, RGB(255, 0, 255), IMAGE_BITMAP, 0);
|
|
hImgLst16 = ImageList_LoadImage(g_hInstance,
|
|
MAKEINTRESOURCE(IDB_BATTS16),
|
|
16, 0, RGB(255, 0, 255), IMAGE_BITMAP, 0);
|
|
ImageList_SetOverlayImage(hImgLst32, IDI_CHARGE-FIRST_ICON_IMAGE, 1);
|
|
ImageList_SetOverlayImage(hImgLst16, IDI_CHARGE-FIRST_ICON_IMAGE, 1);
|
|
}
|
|
|
|
if (uiRes == 32) {
|
|
hImgLst = hImgLst32;
|
|
}
|
|
else {
|
|
hImgLst = hImgLst16;
|
|
}
|
|
|
|
ImageIndex = uIconID - FIRST_ICON_IMAGE;
|
|
|
|
if (bWantBolt) {
|
|
return ImageList_GetIcon(hImgLst, ImageIndex, INDEXTOOVERLAYMASK(1));
|
|
}
|
|
else {
|
|
return ImageList_GetIcon(hImgLst, ImageIndex, ILD_NORMAL);
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* CheckUpdateBatteryState
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
#define UPDATESTATUS_NOUPDATE 0
|
|
#define UPDATESTATUS_UPDATE 1
|
|
#define UPDATESTATUS_UPDATE_CHARGE 2
|
|
|
|
UINT CheckUpdateBatteryState(
|
|
PBATTERY_STATE pbs,
|
|
BOOL bForceUpdate
|
|
)
|
|
{
|
|
UINT uiRetVal = UPDATESTATUS_NOUPDATE;
|
|
|
|
// Check to see if anything in the battery status has changed
|
|
// since last time. If not then we have no work to do!
|
|
|
|
if ((bForceUpdate) ||
|
|
!((pbs->ulTag == pbs->ulLastTag) &&
|
|
(pbs->ulBatLifePercent == pbs->ulLastBatLifePercent) &&
|
|
(pbs->ulBatLifeTime == pbs->ulLastBatLifeTime) &&
|
|
(pbs->ulPowerState == pbs->ulLastPowerState))) {
|
|
|
|
uiRetVal = UPDATESTATUS_UPDATE;
|
|
|
|
// Check for the special case where the charging state has changed.
|
|
if ((pbs->ulPowerState & BATTERY_CHARGING) !=
|
|
(pbs->ulLastPowerState & BATTERY_CHARGING)) {
|
|
uiRetVal |= UPDATESTATUS_UPDATE_CHARGE;
|
|
}
|
|
|
|
// Copy current battery state to last.
|
|
pbs->ulLastTag = pbs->ulTag;
|
|
pbs->ulLastBatLifePercent = pbs->ulBatLifePercent;
|
|
pbs->ulLastBatLifeTime = pbs->ulBatLifeTime;
|
|
pbs->ulLastPowerState = pbs->ulPowerState;
|
|
}
|
|
return uiRetVal;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* MapBatInfoToIconID
|
|
*
|
|
* DESCRIPTION:
|
|
* Map battery info to an Icon ID.
|
|
*
|
|
* PARAMETERS:
|
|
* ulBatNum - Zero implies composite system state
|
|
*
|
|
*******************************************************************************/
|
|
|
|
UINT MapBatInfoToIconID(PBATTERY_STATE pbs)
|
|
{
|
|
UINT uIconID = IDI_BATDEAD;
|
|
|
|
if (!pbs->ulBatNum) {
|
|
if (pbs->ulPowerState & BATTERY_POWER_ON_LINE) {
|
|
return IDI_PLUG;
|
|
}
|
|
}
|
|
else {
|
|
if (pbs->ulTag == BATTERY_TAG_INVALID) {
|
|
return IDI_BATGONE;
|
|
}
|
|
}
|
|
|
|
if (pbs->ulPowerState & BATTERY_CRITICAL) {
|
|
return IDI_BATDEAD;
|
|
}
|
|
|
|
if (pbs->ulBatLifePercent > 66) {
|
|
uIconID = IDI_BATFULL;
|
|
}
|
|
else {
|
|
if (pbs->ulBatLifePercent > 33) {
|
|
uIconID = IDI_BATHALF;
|
|
}
|
|
else {
|
|
if (pbs->ulBatLifePercent > 9) {
|
|
uIconID = IDI_BATLOW;
|
|
}
|
|
}
|
|
}
|
|
|
|
return uIconID;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* DisplayIcon
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
void DisplayIcon(
|
|
HWND hWnd,
|
|
UINT uIconID,
|
|
PBATTERY_STATE pbs,
|
|
ULONG ulUpdateStatus
|
|
)
|
|
{
|
|
BOOL bBolt;
|
|
UINT uiMsg;
|
|
|
|
// Only redraw the icon if it has changed OR
|
|
// if it has gone from charging to not charging.
|
|
if ((uIconID != pbs->uiIconIDcache) ||
|
|
(ulUpdateStatus != UPDATESTATUS_NOUPDATE)) {
|
|
|
|
pbs->uiIconIDcache = uIconID;
|
|
bBolt = (pbs->ulPowerState & BATTERY_CHARGING);
|
|
|
|
pbs->hIconCache = GetBattIcon(hWnd, uIconID, pbs->hIconCache, bBolt, 32);
|
|
pbs->hIconCache16 = GetBattIcon(hWnd, uIconID, pbs->hIconCache16, bBolt, 16);
|
|
|
|
if (pbs->ulBatNum) {
|
|
uiMsg = BM_SETIMAGE;
|
|
}
|
|
else {
|
|
uiMsg = STM_SETIMAGE;
|
|
}
|
|
SendDlgItemMessage(hWnd, g_iMapBatNumToID[pbs->ulBatNum][BAT_ICON],
|
|
uiMsg, IMAGE_ICON, (LPARAM) pbs->hIconCache);
|
|
ShowItem(hWnd, g_iMapBatNumToID[pbs->ulBatNum][BAT_ICON]);
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* UpdateBatMeterProc
|
|
*
|
|
* DESCRIPTION:
|
|
* Updates the System and per battery UI elements if needed.
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
BOOL UpdateBatMeterProc(
|
|
PBATTERY_STATE pbs,
|
|
HWND hWnd,
|
|
LPARAM bShowMulti,
|
|
LPARAM bForceUpdate
|
|
)
|
|
{
|
|
UINT uIconID, uiHour, uiMin;
|
|
LPTSTR lpsz, lpszRemaining;
|
|
ULONG ulUpdateStatus;
|
|
|
|
ulUpdateStatus = CheckUpdateBatteryState(pbs, (BOOL) bForceUpdate);
|
|
|
|
// Make sure there is work to do.
|
|
if (ulUpdateStatus == UPDATESTATUS_NOUPDATE) {
|
|
return TRUE;
|
|
}
|
|
|
|
// Determine which icon to display.
|
|
uIconID = MapBatInfoToIconID(pbs);
|
|
DisplayIcon(hWnd, uIconID, pbs, ulUpdateStatus);
|
|
|
|
// Are we looking for system power status ?
|
|
if (!pbs->ulBatNum) {
|
|
|
|
// Display the Current Power Source text
|
|
lpsz = LoadDynamicString(((pbs->ulPowerState & BATTERY_POWER_ON_LINE) ?
|
|
IDS_ACLINEONLINE : IDS_BATTERIES));
|
|
DisplayFreeStr(hWnd, IDC_BATTERYLEVEL, lpsz, FREE_STR);
|
|
|
|
if (pbs->ulBatLifePercent <= 100) {
|
|
lpsz = LoadDynamicString(IDS_PERCENTREMAININGFORMAT,
|
|
pbs->ulBatLifePercent);
|
|
}
|
|
else {
|
|
lpsz = LoadDynamicString(IDS_UNKNOWN);
|
|
}
|
|
DisplayFreeStr(hWnd, IDC_REMAINING, lpsz, NO_FREE_STR);
|
|
|
|
ShowHideItem(hWnd, IDC_CHARGING, pbs->ulPowerState & BATTERY_CHARGING);
|
|
|
|
// Show and Update the PowerStatusBar only if in single battery mode and
|
|
// there is al least one battery installed.
|
|
if (!bShowMulti && g_uiBatCount) {
|
|
SendDlgItemMessage(hWnd, IDC_POWERSTATUSBAR, PBM_SETPOS,
|
|
(WPARAM) pbs->ulBatLifePercent, 0);
|
|
lpsz = DisplayFreeStr(hWnd, IDC_BARPERCENT, lpsz, FREE_STR);
|
|
}
|
|
|
|
if (lpsz) {
|
|
LocalFree(lpsz);
|
|
}
|
|
|
|
if (pbs->ulBatLifeTime != (UINT) -1) {
|
|
uiHour = pbs->ulBatLifeTime / 3600;
|
|
uiMin = (pbs->ulBatLifeTime % 3600) / 60;
|
|
if (uiHour) {
|
|
lpsz = LoadDynamicString(IDS_TIMEREMFORMATHOUR, uiHour, uiMin);
|
|
}
|
|
else {
|
|
lpsz = LoadDynamicString(IDS_TIMEREMFORMATMIN, uiMin);
|
|
}
|
|
DisplayFreeStr(hWnd, IDC_TIMEREMAINING, lpsz, FREE_STR);
|
|
ShowHideItem(hWnd, IDC_TOTALTIME, TRUE);
|
|
}
|
|
else {
|
|
ShowHideItem(hWnd, IDC_TOTALTIME, FALSE);
|
|
ShowHideItem(hWnd, IDC_TIMEREMAINING, FALSE);
|
|
}
|
|
}
|
|
else {
|
|
|
|
// Here when getting the power status of each individual battery
|
|
// when in multi-battery display mode.
|
|
lpsz = LoadDynamicString(IDS_BATNUM, pbs->ulBatNum);
|
|
DisplayFreeStr(hWnd, g_iMapBatNumToID[pbs->ulBatNum][BAT_NUM],
|
|
lpsz, FREE_STR);
|
|
|
|
if (pbs->ulTag != BATTERY_TAG_INVALID) {
|
|
if (pbs->ulPowerState & BATTERY_CHARGING) {
|
|
lpsz = LoadDynamicString(IDS_BATTCHARGING);
|
|
}
|
|
else {
|
|
lpsz = NULL;
|
|
}
|
|
lpszRemaining = LoadDynamicString(IDS_PERCENTREMAININGFORMAT,
|
|
pbs->ulBatLifePercent);
|
|
}
|
|
else {
|
|
lpsz = LoadDynamicString(IDS_NOT_PRESENT);
|
|
lpszRemaining = NULL;
|
|
}
|
|
DisplayFreeStr(hWnd, g_iMapBatNumToID[pbs->ulBatNum][BAT_STATUS],
|
|
lpsz, FREE_STR);
|
|
|
|
DisplayFreeStr(hWnd, g_iMapBatNumToID[pbs->ulBatNum][BAT_REMAINING],
|
|
lpszRemaining, FREE_STR);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FreeBatteryDriverNames
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
VOID FreeBatteryDriverNames(LPTSTR *lpszDriverNames)
|
|
{
|
|
UINT i;
|
|
|
|
// Free any old driver names.
|
|
for (i = 0; i < NUM_BAT; i++) {
|
|
if (lpszDriverNames[i]) {
|
|
LocalFree(lpszDriverNames[i]);
|
|
lpszDriverNames[i] = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* GetBatteryDriverNames
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
UINT GetBatteryDriverNames(LPTSTR *lpszDriverNames)
|
|
{
|
|
UINT uiDriverCount, uiIndex;
|
|
DWORD dwReqSize;
|
|
HDEVINFO hDevInfo;
|
|
SP_INTERFACE_DEVICE_DATA InterfaceDevData;
|
|
PSP_INTERFACE_DEVICE_DETAIL_DATA pFuncClassDevData;
|
|
|
|
// Free any old driver names.
|
|
FreeBatteryDriverNames(lpszDriverNames);
|
|
uiDriverCount = 0;
|
|
|
|
#ifndef SIM_BATTERY
|
|
// Use the SETUPAPI.DLL interface to get the
|
|
// possible battery driver names.
|
|
hDevInfo = SetupDiGetClassDevs((LPGUID)&GUID_DEVICE_BATTERY, NULL, NULL,
|
|
DIGCF_PRESENT | DIGCF_INTERFACEDEVICE);
|
|
|
|
if (hDevInfo != INVALID_HANDLE_VALUE) {
|
|
InterfaceDevData.cbSize = sizeof(SP_DEVINFO_DATA);
|
|
|
|
uiIndex = 0;
|
|
while (uiDriverCount < NUM_BAT) {
|
|
if (SetupDiEnumInterfaceDevice(hDevInfo,
|
|
0,
|
|
(LPGUID)&GUID_DEVICE_BATTERY,
|
|
uiIndex,
|
|
&InterfaceDevData)) {
|
|
|
|
// Get the required size of the function class device data.
|
|
SetupDiGetInterfaceDeviceDetail(hDevInfo,
|
|
&InterfaceDevData,
|
|
NULL,
|
|
0,
|
|
&dwReqSize,
|
|
NULL);
|
|
|
|
pFuncClassDevData = LocalAlloc(0, dwReqSize);
|
|
if (pFuncClassDevData != NULL) {
|
|
pFuncClassDevData->cbSize =
|
|
sizeof(SP_INTERFACE_DEVICE_DETAIL_DATA);
|
|
|
|
if (SetupDiGetInterfaceDeviceDetail(hDevInfo,
|
|
&InterfaceDevData,
|
|
pFuncClassDevData,
|
|
dwReqSize,
|
|
&dwReqSize,
|
|
NULL)) {
|
|
|
|
dwReqSize = (lstrlen(pFuncClassDevData->DevicePath) + 1) * sizeof(TCHAR);
|
|
lpszDriverNames[uiDriverCount] = LocalAlloc(0, dwReqSize);
|
|
|
|
if (lpszDriverNames[uiDriverCount]) {
|
|
lstrcpy(lpszDriverNames[uiDriverCount],
|
|
pFuncClassDevData->DevicePath);
|
|
uiDriverCount++;
|
|
}
|
|
}
|
|
else {
|
|
DebugPrint("SetupDiGetInterfaceDeviceDetail, failed: %d", GetLastError());
|
|
}
|
|
|
|
LocalFree(pFuncClassDevData);
|
|
}
|
|
} else {
|
|
if (ERROR_NO_MORE_ITEMS == GetLastError()) {
|
|
break;
|
|
}
|
|
else {
|
|
DebugPrint("SetupDiEnumInterfaceDevice, failed: %d", GetLastError());
|
|
}
|
|
}
|
|
uiIndex++;
|
|
}
|
|
SetupDiDestroyDeviceInfoList(hDevInfo);
|
|
}
|
|
else {
|
|
DebugPrint("SetupDiGetClassDevs on GUID_DEVICE_BATTERY, failed: %d", GetLastError());
|
|
}
|
|
#else
|
|
// Simulate batteries.
|
|
{
|
|
UINT i;
|
|
static UINT uiState = 1;
|
|
|
|
for (i = 0; i <= uiState; i++) {
|
|
lpszDriverNames[i] = LocalAlloc(0, STRSIZE(TEXT("SIMULATED_BATTERY_0")));
|
|
wsprintf(lpszDriverNames[i], TEXT("SIMULATED_BATTERY_%d"), i);
|
|
}
|
|
uiState++;
|
|
uiDriverCount = uiState;
|
|
if (uiState >= NUM_BAT) {
|
|
uiState = 0;
|
|
}
|
|
}
|
|
#endif
|
|
return uiDriverCount;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* UpdateDriverList
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
BOOL UpdateDriverList(
|
|
LPTSTR *lpszDriverNames,
|
|
UINT uiDriverCount
|
|
)
|
|
{
|
|
UINT i;
|
|
PBATTERY_STATE pbs;
|
|
|
|
// Walk the bs list, and remove any devices which aren't in pszDeviceNames.
|
|
WalkBatteryState(DEVICES,
|
|
(WALKENUMPROC)RemoveMissingProc,
|
|
NULL,
|
|
(LPARAM)g_lpszDriverNames,
|
|
(LPARAM)REMOVE_MISSING);
|
|
|
|
// Scan the pszDeviceNames list and add any devices which aren't in bs.
|
|
for (i = 0; i < uiDriverCount; i++) {
|
|
|
|
if (WalkBatteryState(DEVICES,
|
|
(WALKENUMPROC)FindNameProc,
|
|
NULL,
|
|
(LPARAM)g_lpszDriverNames[i],
|
|
(LPARAM)NULL)) {
|
|
|
|
#ifndef SIM_BATTERY
|
|
if (!AddBatteryStateDevice(g_lpszDriverNames[i], i + 1)) {
|
|
// We weren't able get minimal info from driver, dec the
|
|
// battery counts. g_uiBatCount should always be > 0.
|
|
if (--g_uiDriverCount) {;
|
|
g_uiBatCount--;
|
|
}
|
|
}
|
|
#else
|
|
SimAddBatteryStateDevice(g_lpszDriverNames[i], i + 1);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
// Clear and rebuild g_pbs, the handy batttery number to pbs array.
|
|
memset(&g_pbs, 0, sizeof(g_pbs));
|
|
pbs = &g_bs;
|
|
for (i = 0; i <= g_uiBatCount; i++) {
|
|
if (pbs) {
|
|
g_pbs[i] = pbs;
|
|
pbs = pbs->bsNext;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|