/media/development/cpp/BatteryMonitor/main.cpp

#include "main.h"

using namespace BatteryMonitor;

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
        LPSTR lpCmdLine, int nCmdShow) {

    // Do some initialization.
    strcpy(classname, "BatMonOverlay");
    instance=hInstance;
    red = CreateSolidBrush(RGB(0xFF, 0, 0));
    green = CreateSolidBrush(RGB(0, 0xFF, 0));
    yellow = CreateSolidBrush(RGB(0xFF, 0xFF, 0));
    blue = CreateSolidBrush(RGB(0, 0, 0xDF));

    // Register window class.
    if (!setupWindowClass()) {
        errOut();
        return 0;
    }

    // Show window.
    HWND hwnd=setupWindow(nCmdShow);
    if (hwnd == NULL) {

        errOut();
        return 0;
    }

    /* Battery initialization.
     *
     * - Sets up battery device path name
     * - Commits initial update to window
     * - Starts timer for periodic updates (500 ms)
     */
    initDevice();
    SetTimer(hwnd, UPDATE_BATTERY, 500, NULL);
    SendMessage(hwnd, WM_TIMER, UPDATE_BATTERY, 0);

    // Taskbar icon
    addNotifyIcon(hwnd);
    WM_TASKBARCREATED = RegisterWindowMessage(TEXT("TaskbarCreated"));

    // Message loop
    MSG Msg;
    while (GetMessage(&Msg, NULL, 0, 0) > 0) {
        TranslateMessage(&Msg);
        DispatchMessage(&Msg);
    }

    // Finish
    cleanUp(hwnd);
    return Msg.wParam;
}

namespace BatteryMonitor {
    HWND setupWindow(int nCmdShow){
        RECT desktop;
        GetWindowRect(GetDesktopWindow(), &desktop);
        HWND hwnd;
        /* Window creation.
         *
         * - Position: upper right
         * - No titlebar, no taskbar button
         * - Transparent (Opacity 120/255)
         * - Stay on top
         * - Click through (WS_EX_TRANSPARENT!)
         */
        hwnd = CreateWindowEx(
                WS_EX_TOOLWINDOW | WS_EX_LAYERED | WS_EX_TOPMOST | WS_EX_TRANSPARENT,
                classname,
                "Battery Monitor",
                WS_POPUP | WS_BORDER,
                desktop.right - 90, 20, 70, 30,
                NULL, NULL, instance, NULL);
        if(!hwnd)return 0;
        SetLayeredWindowAttributes(hwnd, 0, 120, LWA_ALPHA);
        ShowWindow(hwnd, nCmdShow);
        UpdateWindow(hwnd);
        return hwnd;
    }

    void cleanUp(HWND hwnd) {
        // Delete icon and brushes.
        NOTIFYICONDATA nfi;
        nfi.cbSize = sizeof (nfi);
        nfi.hWnd = hwnd;
        nfi.uID = 0;
        Shell_NotifyIcon(NIM_DELETE, &nfi);
        DeleteObject(red);
        DeleteObject(yellow);
        DeleteObject(blue);
        DeleteObject(green);
    }

    long setupWindowClass() {
        WNDCLASSEX wc;
        wc.cbSize = sizeof (WNDCLASSEX);
        wc.style = 0;
        wc.lpfnWndProc = wndProc;
        wc.cbClsExtra = 0;
        wc.cbWndExtra = 0;
        wc.hInstance = instance;
        wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
        wc.hCursor = LoadCursor(NULL, IDC_ARROW);
        wc.hbrBackground = CreateSolidBrush(RGB(255, 255, 255));
        wc.lpszMenuName = NULL;
        wc.lpszClassName = classname;
        wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

        return RegisterClassEx(&wc);
    }

    void errOut() {
        char* buf = new char[255];
        FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, 0, GetLastError(), 0, buf, 255, NULL);
#ifdef DEBUG
        MessageBox(NULL, buf, "Error",
                MB_ICONEXCLAMATION | MB_OK);
#endif
        delete[] buf;
    }

    LRESULT CALLBACK wndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
        switch (msg) {
            case WM_CLOSE:
                DestroyWindow(hwnd);
                break;
            case WM_DESTROY:
                PostQuitMessage(0);
                break;
            case WM_TIMER:  // This message is received periodically to update the battery
                if (wParam == UPDATE_BATTERY) {
                    SYSTEM_POWER_STATUS pwr;
                    GetSystemPowerStatus(&pwr);
                    if (pwr.BatteryFlag == 128 || pwr.BatteryFlag == 255) { // Unknown state or Error
                                                battery = 2;
                    } else if (pwr.ACLineStatus) {
                        battery = -(double) pwr.BatteryLifePercent / 100.0;
                        if(shutdown_enabled) {
                            AbortSystemShutdown(NULL);
                            shutdown_enabled=false;
                        }
                    }
                    else {
                        battery = (double) pwr.BatteryLifePercent / 100.0;
                        batterylifetime = pwr.BatteryLifeTime;
                        if (batterylifetime > 0 && batterylifetime < 300)shutdown(); // Shutdown if battery low
                    }
                }
                InvalidateRect(hwnd, NULL, true);   // Force repaint
                break;
            case WM_PAINT:  // Paint window
            {
                PAINTSTRUCT p;
                HDC hdc = BeginPaint(hwnd, &p);
                if (hdc) {
                    RECT r1,rtext;
                    HBRUSH load;
                    if (battery > 1.5) {    // Yellow if no information available
                        load = yellow;
                        r1.top = 0;
                        r1.left = 0;
                        r1.right = 70;
                        r1.bottom = 30;
                    } else {    // Green if dischargin, blue if charging
                        load = battery > 0 ? green : blue;

                        r1.top = 0;
                        r1.left = 0;
                        r1.right = 70 * battery * (battery > 0 ? 1 : -1);
                        r1.bottom = 30;

                        RECT r2;
                        r2.top = 0;
                        r2.left = r1.right;
                        r2.right = 70;
                        r2.bottom = 30;
                        FillRect(hdc, &r2, red);

                    }
                    FillRect(hdc, &r1, load);
                    SetBkMode(hdc, TRANSPARENT); // Text background transparent
                    SetTextColor(hdc, 0);
                    // Used to center text
                    rtext.bottom = 30;
                    rtext.top = 0;
                    rtext.left = 0;
                    rtext.right = 70;
                    char time[6];
                    batterylifetime /= 60;
                                        sprintf(time, "%02ld:%02ld", batterylifetime / 60, batterylifetime % 60);
                    if (batterylifetime >= 0)
                        DrawText(hdc, time, 5, &rtext, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
                    else
                        DrawText(hdc, "N/A", 3, &rtext, DT_CENTER | DT_VCENTER | DT_SINGLELINE);

                }
                EndPaint(hwnd, &p);
            }
                break;
            case WM_USER + 1:   // Taskbar icon event. Now lParam contains the important window message.
                if (wParam != 0)break;
                switch (lParam) {
                    case WM_RBUTTONDBLCLK:
                        PostMessage(hwnd, WM_CLOSE, 0, 0);
                        break;
                    case WM_LBUTTONUP:
                        showBatteryInfo(hwnd);
                        break;
                    default:
                        break;
                }
                break;
            default:    // Refresh icon if taskbar was newly created. This can't be handled in a case as WM_TASKBARCREATED is not constant.
                if (msg == WM_TASKBARCREATED) {
                    addNotifyIcon(hwnd);
                    break;
                }
                return DefWindowProc(hwnd, msg, wParam, lParam); // Do default message handling
        }
        return 0;
    }

    void addNotifyIcon(HWND hwnd) {
        NOTIFYICONDATA nfi;
        HICON icon;
        if (!(icon = LoadIcon(instance, MAKEINTRESOURCE(MAIN_ICON)))) {errOut(); PostMessage(hwnd, WM_CLOSE, 0, 0);} // If icon can't be found, close application.
        nfi.cbSize = sizeof (nfi);
        nfi.hWnd = hwnd;
        nfi.hIcon = icon;
        nfi.uID = 0;
        strcpy(nfi.szTip, "BatteryMonitor");
        nfi.uFlags = NIF_ICON | NIF_TIP | 0x80 | NIF_MESSAGE;
        nfi.uCallbackMessage = WM_USER + 1;

        Shell_NotifyIcon(NIM_ADD, &nfi);
    }

    void showBatteryInfo(HWND hwnd) {
        NOTIFYICONDATA nfi;
        nfi.cbSize = sizeof (nfi);
        nfi.hWnd = hwnd;
        nfi.uID = 0;
        nfi.uFlags = NIF_INFO;
        strcpy(nfi.szInfoTitle, "Battery Info");
        nfi.uTimeout = 30000;
        nfi.dwInfoFlags = NIIF_INFO;
        BATTERY_INFORMATION info = getBatteryInformation();
        SYSTEM_POWER_STATUS pwr;
        GetSystemPowerStatus(&pwr);
        if (info.DesignedCapacity) {
            char chem[5];
            memcpy(chem, info.Chemistry, 4);
            chem[4] = 0;
                        sprintf(nfi.szInfo, "Type: %s\nAC: %s\nCharge: %d%%\nWear Level: %lu%%", chem, pwr.ACLineStatus ? "Online" : "Offline", pwr.BatteryLifePercent, 100 - info.FullChargedCapacity * 100 / info.DesignedCapacity);
        } else {
            strcpy(nfi.szInfo, "No information available :(");
        }

        Shell_NotifyIcon(NIM_MODIFY, &nfi);
    }

    void shutdown() {
        HANDLE hToken;
        TOKEN_PRIVILEGES tkp;

        // Get a token for this process.

        if (!OpenProcessToken(GetCurrentProcess(),
                TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
            MessageBox(0, "Low Battery! Shutdown failed.", "Error", MB_ICONERROR);

        // Get the LUID for the shutdown privilege.

        LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid);

        tkp.PrivilegeCount = 1;
        tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

        // Get the shutdown privilege.

        AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES) NULL, 0);

        if (GetLastError() != ERROR_SUCCESS)
            return;
        // Shutdown.
        InitiateSystemShutdown(NULL, "Low battery", 30, FALSE, FALSE);
        shutdown_enabled=true;
    }

    void initDevice() {
        devicepath = 0; // If something fails, devicepath will be NULL
        HDEVINFO devinfo = SetupDiGetClassDevs(&GUID_DEVICE_BATTERY, NULL, NULL, DIGCF_DEVICEINTERFACE);    // Get battery device information
        if (INVALID_HANDLE_VALUE != devinfo) {
            SP_DEVICE_INTERFACE_DATA deviceinfo;
            deviceinfo.cbSize = sizeof (deviceinfo);
            if (SetupDiEnumDeviceInterfaces(devinfo, 0, &GUID_DEVICE_BATTERY, 0, &deviceinfo)) { // Get device interface
                PSP_DEVICE_INTERFACE_DETAIL_DATA devdetails;
                DWORD reqSize = 0;
                SetupDiGetDeviceInterfaceDetail(devinfo, &deviceinfo, 0, 0, &reqSize, 0);   // Get required size for details
                if (ERROR_INSUFFICIENT_BUFFER == GetLastError()) {
                    devdetails = (PSP_DEVICE_INTERFACE_DETAIL_DATA) LocalAlloc(LPTR, reqSize); // Allocate
                    if (devdetails) {
                        devdetails->cbSize = sizeof (SP_DEVICE_INTERFACE_DETAIL_DATA);
                        if (SetupDiGetDeviceInterfaceDetail(devinfo, &deviceinfo, devdetails, reqSize, &reqSize, NULL)) { // Get some details on battery device
                            devicepath = new char[strlen(devdetails->DevicePath)]; // There it is, the device path!
                            strcpy(devicepath, devdetails->DevicePath);

                        }
                        LocalFree(devdetails);  // Free allocated memory
                    }
                }
            }
        }
        if (GetLastError() != ERROR_SUCCESS)errOut();
    }

    BATTERY_INFORMATION getBatteryInformation() {
        BATTERY_INFORMATION batteryinformation;
        if (devicepath) {
            HANDLE bat = CreateFile(devicepath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); // Open battery device file
            if (INVALID_HANDLE_VALUE != bat) {
                ULONG timeout = 100;
                ULONG tag;
                DWORD buf;
                if (DeviceIoControl(bat, IOCTL_BATTERY_QUERY_TAG, &timeout, sizeof (timeout), &tag, sizeof (tag), &buf, NULL)) { // Get the battery tag.
                    BATTERY_QUERY_INFORMATION infoqueryin;
                    infoqueryin.BatteryTag = tag;
                    infoqueryin.InformationLevel = BatteryInformation;
                    if (DeviceIoControl(bat, IOCTL_BATTERY_QUERY_INFORMATION, &infoqueryin, sizeof (infoqueryin), &batteryinformation, sizeof (batteryinformation), &buf, NULL)) { // Retrieve the wanted information.
                        CloseHandle(bat);   // Close battery file handle.
                        return batteryinformation;
                    }
                }
            }
            CloseHandle(bat); // If something fails close it, too.
        }
        errOut();
        batteryinformation.DesignedCapacity = 0; // Error occured
        return batteryinformation;
    }

}