В прошлый раз мы использовали готовые иконки. Так вот их можно смело удалять. Также нужно удалить их из .rc файла

IDR_CPUICON1 ICON "cpu4.ico"
 IDR_CPUICON2 ICON "cpu6.ico"
 IDR_CPUICON3 ICON "cpu5.ico"
 IDR_RAMICON0 ICON "ram0.ico"

И из Recourse.h

#define IDR_CPUICON1					131
 #define IDR_CPUICON2					132
 #define IDR_CPUICON3					133
 #define IDR_RAMICON0					134

Так как готовые иконки больше не используются, то наш список иконок больше не нужен. В методе инициализации убираем следующие строки

cpu_icons[0] = (HICON)LoadImage(hInstance, MAKEINTRESOURCE(IDR_CPUICON1), IMAGE_ICON, 64, 64, 0);
cpu_icons[1] = (HICON)LoadImage(hInstance, MAKEINTRESOURCE(IDR_CPUICON2), IMAGE_ICON, 64, 64, 0);
cpu_icons[2] = (HICON)LoadImage(hInstance, MAKEINTRESOURCE(IDR_CPUICON3), IMAGE_ICON, 64, 64, 0);

#include <windows.h>
#include <iostream>
#include <string>

class Checkbox
{
private:
	HWND parentWindow;
	HMENU hMenu;
	bool checked;
	HWND hwnd;
public:

	Checkbox(HWND hwnd_, HINSTANCE hInstance, UINT id_, LPCWCHAR text_, UINT x, UINT y, UINT width, UINT height) 
		: parentWindow(hwnd_), hMenu((HMENU)id_)
	{
		hwnd = CreateWindowEx(NULL, 
			L"BUTTON", 
			text_, 
			WS_VISIBLE | WS_CHILD | BS_CHECKBOX, 
			x, 
			y, 
			width, 
			height, 
			parentWindow, 
			hMenu, 
			hInstance, 
			nullptr);
		UnCheck();
	}

	void Check()
	{
		checked = true;
		SendMessage(hwnd, BM_SETCHECK, checked, 0);
	}

	void UnCheck()
	{
		checked = false;
		SendMessage(hwnd, BM_SETCHECK, checked, 0);
	}

	void Block()
	{
		EnableWindow(hwnd, FALSE);
	}

	void UnBlock()
	{
		EnableWindow(hwnd, TRUE);
	}

	bool Status()
	{
		return checked;
	}

	void Revers()
	{
		checked = !checked;
		SendMessage(hwnd, BM_SETCHECK, checked, 0);
	}
};

HINSTANCE hInst;
WCHAR szTitle[MAX_LOADSTRING];
WCHAR szWindowClass[MAX_LOADSTRING];
HANDLE htimer_ram = NULL;
HANDLE htimer_cpu = NULL;
NOTIFYICONDATA cpu_status_icon;
NOTIFYICONDATA ram_status_icon;
MEMORYSTATUSEX mem_info;
//новые
ULONG_PTR g_gdiplusToken = 0; //токен для использования GDI+
std::map<uint16_t, HICON> hash_cpu_icons; //хэш-таблица для хранения иконок CPU
std::map<uint16_t, HICON> hash_ram_icons; //аналогично для ОЗУ

byte show_window_flag; //флаг состояния окна 0x0 - скрыто; 0x5 - открыто
byte settings_param = 0b0111; //переменная настроек всей программы
//Последние 3 бита отвечают за все показ иконок и запуск окна при запуске
byte cpu_show = 0x2; // состояние иконки cpu. 0x2 - показано, 0x0 -  скрыто
byte ram_show = 0x2; // аналогично для озу

//указатели на 3 чекбокса настроек
Checkbox *cpu_checkbox;
Checkbox *ram_checkbox;
Checkbox *open_start_checkbox;

void InitGDIPlus()
{
    Gdiplus::GdiplusStartupInput gdiplusStartupInput;
    Gdiplus::GdiplusStartup(&g_gdiplusToken, &gdiplusStartupInput, nullptr);
}

void ShutdownGDIPlus()
{
    if (g_gdiplusToken != 0)
        Gdiplus::GdiplusShutdown(g_gdiplusToken);
}

ICON CreateIconWithNumber(int number, int size, int fontSize, Gdiplus::Color textColor)
{
    std::wstring text = std::to_wstring(number);

    //создаем битмапу с константой PixelFormat32bppARGB - 32 бита на пиксель:
    //по 8 бит на каждые 4 канала ARGB
    Gdiplus::Bitmap bitmap(size, size, PixelFormat32bppARGB);

    //объявляем класс, которые предоставляет инструменты для рисования на устройстве вывода
    Gdiplus::Graphics graphics(&bitmap);
    graphics.Clear(Gdiplus::Color(0, 0, 0, 0)); // Прозрачный фон

    //инициализируем шрифт
    Gdiplus::FontFamily fontFamily(L"Segoe UI");
    Gdiplus::Font font(&fontFamily, static_cast<Gdiplus::REAL>(fontSize), Gdiplus::FontStyleBold, Gdiplus::UnitPixel);
    Gdiplus::SolidBrush brush(textColor);

    // Для вертикального центрирования измеряем высоту одной цифры
    Gdiplus::RectF charRect;
    graphics.MeasureString(L"0", 1, &font, Gdiplus::PointF(0, 0), &charRect);
    float y = (size - charRect.Height) / 2.0f;

    float x = 0.0f;
    float spacingFactor = 0.65f; // Коэффициент уменьшения межбуквенного интервала (больше => плотнее)

    for (wchar_t ch : text)
    {
        wchar_t str[2] = { ch, 0 };

        // Измеряем ширину символа
        graphics.MeasureString(str, 1, &font, Gdiplus::PointF(0, 0), &charRect);

        // Рисуем символ по координатам (x, y), вертикально выровнено по центру
        graphics.DrawString(str, 1, &font, Gdiplus::PointF(x, y), &brush);

        // Смещаем x с учётом коэффициента уменьшения межсимвольного интервала
        x += charRect.Width * spacingFactor;
    }

    HICON hIcon = nullptr;
    bitmap.GetHICON(&hIcon);
    return hIcon;
}

Решил ввести коэффициент уменьшения межбуквенного интервала, так как из-за стандартного интервала часть второй цифр обрезалась. А так можно регулировать и размер шрифта и межсимвольный интервал. По-моему, довольно гибкая настройка

void CALLBACK TimerRAM(PVOID pVoid, BOOLEAN TimerOrWaitFired)
{
    static wchar_t ram_info[64];
    ZeroMemory(ram_info, 64);
    if (GlobalMemoryStatusEx(&mem_info)) {
        static uint16_t totalPhys = (uint16_t)ceil((float)mem_info.ullTotalPhys / 1024 / 1024 / 1024);
        float physUsed = (float)(mem_info.ullTotalPhys - mem_info.ullAvailPhys) / 1024 / 1024 / 1024;
        uint16_t usagePercent = mem_info.dwMemoryLoad;
        HICON icon;
        if (hash_ram_icons.find((uint16_t)usagePercent) == hash_ram_icons.end())
        {
            icon = CreateIconWithNumber(usagePercent, ICON_SIZE, 50, RAM_COLOR);
            hash_ram_icons.insert({ (uint16_t)usagePercent, icon});
        }
        ram_status_icon.hIcon = hash_ram_icons[(uint16_t)usagePercent];
        swprintf(ram_info, 64, L"%.2f\\%u Gb   %u%%", physUsed, totalPhys, usagePercent);
        lstrcpy(ram_status_icon.szTip, ram_info);
        Shell_NotifyIcon(NIM_MODIFY, &ram_status_icon);
    }
}

void CALLBACK TimerCPU(PVOID pVoid, BOOLEAN TimerOrWaitFired)
{
    static wchar_t cpu_inf[8];
    ZeroMemory(cpu_inf, 8);
    double cpu_total = GetCPULoad();
    HICON icon;
    if (hash_cpu_icons.find((uint16_t)cpu_total) == hash_cpu_icons.end())
    {
        icon = CreateIconWithNumber((uint16_t)cpu_total, ICON_SIZE, 50, GetGradColor(cpu_total));
        hash_cpu_icons.insert({ (uint16_t)cpu_total,  icon });
    }
    cpu_status_icon.hIcon = hash_cpu_icons[(uint16_t)cpu_total];
    swprintf(cpu_inf, 8, L"%.2f %%", cpu_total);
    lstrcpy(cpu_status_icon.szTip, cpu_inf);
    Shell_NotifyIcon(NIM_MODIFY, &cpu_status_icon);
}

void CALLBACK TimerRAM(PVOID pVoid, BOOLEAN TimerOrWaitFired)
{
    static wchar_t ram_info[128];
    if (GlobalMemoryStatusEx(&mem_info)) {
        static uint16_t totalPhys = (uint16_t)ceil((float)mem_info.ullTotalPhys / 1024 / 1024 / 1024);
        float physUsed = (float)(mem_info.ullTotalPhys - mem_info.ullAvailPhys) / 1024 / 1024 / 1024;
        uint16_t usagePercent = mem_info.dwMemoryLoad;

        swprintf(ram_info, 128, L"%.2f\\%u Gb   %u%%", physUsed, totalPhys, usagePercent);
        lstrcpy(ram_status_icon.szTip, ram_info);
        Shell_NotifyIcon(NIM_MODIFY, &ram_status_icon);
    }

}

void CALLBACK TimerCPU(PVOID pVoid, BOOLEAN TimerOrWaitFired)
{
    static wchar_t cpu_inf[8];
    double cpu_total = GetCPULoad();
    if (cpu_total < 25)
        cpu_status_icon.hIcon = cpu_icons[0];
    else if (cpu_total < 50)
        cpu_status_icon.hIcon = cpu_icons[1];
    else if (cpu_total >= 50)
        cpu_status_icon.hIcon = cpu_icons[2];
    swprintf(cpu_inf, 8, L"%.2f %%", cpu_total);
    lstrcpy(cpu_status_icon.szTip, cpu_inf);
    Shell_NotifyIcon(NIM_MODIFY, &cpu_status_icon);
}

Gdiplus::Color GetGradColor(double x) {
    double u = x / 50.0;
    Gdiplus::Color c(
        255, //alfa
        int(255 * min(u, 1.0)), //r
        int(255 - 90 * min(u, 1.0) - 165 * max(u - 1.0, 0)), //g
        0);  //b
    return c;
}

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance;

   HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU,
      300, 300, 300, 300, nullptr, nullptr, hInstance, nullptr);

   if (!hWnd)
   {
      return FALSE;
   }
//этот блок разберем в следующей главе
   try
   {
        settings_param = ReadSettings();
   }
   catch (std::runtime_error &msg)
   {
       settings_param = 0b0111;
       WriteSettings();
   }

  //инициализируем чекбоксы, задаем им координаты на нашем окне и текст
   cpu_checkbox = new Checkbox(hWnd, hInstance, CPU_CLICK, L"CPU", 100, 50, 100, 30);
   ram_checkbox = new Checkbox(hWnd, hInstance, RAM_CLICK, L"RAM", 100, 100, 100, 30);
   open_start_checkbox = new Checkbox(hWnd, hInstance, OPEN_AT_START, L"Open at start", 100, 150, 110, 30);
//инициализируем GDI+
   InitGDIPlus();
  
   mem_info.dwLength = sizeof(mem_info);

  //Все как в первой части. Но теперь мы заранее не выставляем готовые иконки,
  //ведь нам нужно было отказаться от них

  //в поле uCallbackMessage указываем наше значение, которое будем обрабатывать
  //при нажатии на иконку
   cpu_status_icon.cbSize = sizeof(NOTIFYICONDATA);
   cpu_status_icon.hWnd = hWnd;
   cpu_status_icon.uID = 1;
   cpu_status_icon.uCallbackMessage = ICON_CLICK;
   cpu_status_icon.uFlags = NIF_ICON | NIF_TIP | NIF_MESSAGE;

   ram_status_icon.cbSize = sizeof(NOTIFYICONDATA);
   ram_status_icon.hWnd = hWnd;
   ram_status_icon.uID = 2;
   ram_status_icon.uCallbackMessage = ICON_CLICK;
   ram_status_icon.uFlags = NIF_ICON | NIF_TIP | NIF_MESSAGE;

//проверяем настройки каждого бита и выставляем необходимые настройки для
//чекбокса и флагов
   if (settings_param & 0b0100)
   {
       show_window_flag = 5;
       open_start_checkbox->Check();
   }
   if (settings_param & 0b0010)
   {
       ram_show = 0;
       ram_checkbox->Check();
   }
   if (settings_param & 0b0001)
   {
       cpu_show = 0;
       cpu_checkbox->Check();
   }
//ну а теперь в соответсвии с флагами у нас будут отображаеться необходимые элементы
   ShowWindow(hWnd, show_window_flag);
   Shell_NotifyIcon(cpu_show, &cpu_status_icon);
   Shell_NotifyIcon(ram_show, &ram_status_icon);
//Без изменений. Запускаем параллельные таймеры
   if (!CreateTimerQueueTimer(&htimer_cpu, NULL, TimerCPU, NULL, 1000, 1500, WT_EXECUTEDEFAULT))
   {
       std::cerr << "Error cpu timer\n";
       return -1;
   }

   if (!CreateTimerQueueTimer(&htimer_ram, NULL, TimerRAM, NULL, 1000, 1500, WT_EXECUTEDEFAULT))
   {
       std::cerr << "Error ram timer\n";
       return -2;
   }
   return TRUE;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case ICON_CLICK:
        if (lParam == WM_LBUTTONDOWN)
        {
            show_window_flag ^= 5;
            ShowWindow(hWnd, show_window_flag);
        }
        break;
    case WM_CLOSE:
        show_window_flag = 0;
        ShowWindow(hWnd, show_window_flag);
        break;
    case WM_COMMAND:
        if (HIWORD(wParam) == BN_CLICKED)
        {
            switch (LOWORD(wParam))
            {
                case CPU_CLICK:
                    cpu_checkbox->Revers();
                    cpu_show ^= 0x2;
                    settings_param ^= 0b001;
                    Shell_NotifyIcon(cpu_show, &cpu_status_icon);
                    open_start_checkbox->UnBlock();
                    WriteSettings();
                    break;
                case RAM_CLICK:
                    ram_checkbox->Revers();
                    ram_show ^= 0x2;
                    settings_param ^= 0b010;
                    Shell_NotifyIcon(ram_show, &ram_status_icon);
                    open_start_checkbox->UnBlock();
                    WriteSettings();
                    break;
                case OPEN_AT_START:
                    open_start_checkbox->Revers();
                    settings_param ^= 0b100;
                    WriteSettings();
                    break;
                }
                if (!(settings_param & 1) && !(settings_param & 2))
                {
                    settings_param = 0b100;
                    open_start_checkbox->Check();
                    open_start_checkbox->Block();
                    WriteSettings();
                }
        }
        break;
    case WM_DESTROY:
        ShutdownGDIPlus();
        Shell_NotifyIcon(NIM_DELETE, &cpu_status_icon);
        Shell_NotifyIcon(NIM_DELETE, &ram_status_icon);
        DeleteTimerQueueTimer(NULL, htimer_cpu, NULL);
        DeleteTimerQueueTimer(NULL, htimer_ram, NULL);
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

bool WriteSettings(int n)
{
    std::wstring valueStr = std::to_wstring(n);
    HKEY hKey;
//открываем раздел в реестре 
    if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Environment", 0, KEY_SET_VALUE, &hKey) != ERROR_SUCCESS)
        return false;
//RegSetValueEx Устанавливает данные и тип указанного значения в ключе реестра. Если значение с таким именем ещё не присутствует в ключе, функция добавляет его. 
    LONG result = RegSetValueEx(
        hKey,
        SETTINGS_MONITOR_NAME,
        0,
        REG_SZ,
        reinterpret_cast<const BYTE *>(valueStr.c_str()),
        static_cast<DWORD>((valueStr.size() + 1) * sizeof(wchar_t)));
  //закрываем ключ
    RegCloseKey(hKey);

    if (result != ERROR_SUCCESS)
        return false;
//отправляем сообщение в броадкаст, чтобы все приложения увидели изменение в реестре
    SendMessageTimeoutW(HWND_BROADCAST, WM_SETTINGCHANGE, 0,
        (LPARAM)L"Environment",
        SMTO_ABORTIFHUNG, 5000, nullptr);

    return true;
}

byte ReadSettings()
{
    HKEY hKey;
    if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Environment", 0, KEY_QUERY_VALUE, &hKey) != ERROR_SUCCESS)
        throw std::runtime_error("Couldnt open the key registry Environment");

    wchar_t buffer[4];
    DWORD bufferSize = sizeof(buffer);
    DWORD type = 0;

    LONG result = RegQueryValueExW(
        hKey,
        SETTINGS_MONITOR_NAME,
        nullptr,
        &type,
        reinterpret_cast<LPBYTE>(buffer),
        &bufferSize
    );

    RegCloseKey(hKey);

    if (result != ERROR_SUCCESS)
        throw std::runtime_error(std::string("variable was not found"));

    if (type != REG_SZ)
        throw std::runtime_error(std::string("variable has in incorrect format"));

    try {
        return (byte)std::stoi(buffer);
    }
    catch (...) {
        throw std::runtime_error(std::string("Couldnt convert the value to a number"));
    }
}

#include "framework.h"
#include "CPU_status_icon.h"
#include "checkbox.h"
#include <objidl.h>
#include <gdiplus.h>
#include <windows.h>
#include <shellapi.h>
#include <iostream>
#include <string>
#include <map>

#pragma comment(lib, "gdiplus.lib")

#pragma comment(lib, "Ole32.lib")

#define MAX_LOADSTRING 100
#define ICON_SIZE 64
#define ICON_CLICK (WM_APP + 1)
#define CPU_CLICK (WM_APP + 2)
#define RAM_CLICK (WM_APP + 3)
#define OPEN_AT_START (WM_APP + 4)
#define SETTINGS_MONITOR_NAME L"SETTINGS_MONITOR"
#define RAM_COLOR Gdiplus::Color(255, 200, 90, 240)

// Глобальные переменные:
HINSTANCE hInst;
WCHAR szTitle[MAX_LOADSTRING];
WCHAR szWindowClass[MAX_LOADSTRING];
HANDLE htimer_ram = NULL;
HANDLE htimer_cpu = NULL;
NOTIFYICONDATA cpu_status_icon;
NOTIFYICONDATA ram_status_icon;
MEMORYSTATUSEX mem_info;
ULONG_PTR g_gdiplusToken = 0;
std::map<uint16_t, HICON> hash_cpu_icons;
std::map<uint16_t, HICON> hash_ram_icons;

byte show_window_flag;
byte settings_param = 0b0111;
byte cpu_show = 0x2;
byte ram_show = 0x2;

Checkbox *cpu_checkbox;
Checkbox *ram_checkbox;
Checkbox *open_start_checkbox;


ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);

Gdiplus::Color GetGradColor(double x) {
    double u = x / 50.0;
    Gdiplus::Color c(
        255, //alfa
        int(255 * min(u, 1.0)), //r
        int(255 - 90 * min(u, 1.0) - 165 * max(u - 1.0, 0.0)), //g
        0);  //b
    return c;
}

void InitGDIPlus()
{
    Gdiplus::GdiplusStartupInput gdiplusStartupInput;
    Gdiplus::GdiplusStartup(&g_gdiplusToken, &gdiplusStartupInput, nullptr);
}

void ShutdownGDIPlus()
{
    if (g_gdiplusToken != 0)
        Gdiplus::GdiplusShutdown(g_gdiplusToken);
}

HICON CreateIconWithNumber(int number, int size, int fontSize, Gdiplus::Color textColor)
{
    std::wstring text = std::to_wstring(number);

    Gdiplus::Bitmap bitmap(size, size, PixelFormat32bppARGB);
    Gdiplus::Graphics graphics(&bitmap);
    graphics.Clear(Gdiplus::Color(0, 0, 0, 0));

    Gdiplus::FontFamily fontFamily(L"Segoe UI");
    Gdiplus::Font font(&fontFamily, static_cast<Gdiplus::REAL>(fontSize), Gdiplus::FontStyleBold, Gdiplus::UnitPixel);
    Gdiplus::SolidBrush brush(textColor);

    Gdiplus::RectF charRect;
    graphics.MeasureString(L"0", 1, &font, Gdiplus::PointF(0, 0), &charRect);
    float y = (size - charRect.Height) / 2.0f;

    float x = 0.0f;
    float spacingFactor = 0.65f;
    for (wchar_t ch : text)
    {
        wchar_t str[2] = { ch, 0 };
        graphics.MeasureString(str, 1, &font, Gdiplus::PointF(0, 0), &charRect);
        graphics.DrawString(str, 1, &font, Gdiplus::PointF(x, y), &brush);
        x += charRect.Width * spacingFactor;
    }

    HICON hIcon = nullptr;
    bitmap.GetHICON(&hIcon);
    return hIcon;
}

float GetCPULoad() {
    static FILETIME idleTimePrev = {}, kernelTimePrev = {}, userTimePrev = {};

    FILETIME idleTime, kernelTime, userTime;
    if (!GetSystemTimes(&idleTime, &kernelTime, &userTime)) return 0.0;

    auto toUInt64 = [](FILETIME ft) {
        return ((uint64_t)ft.dwHighDateTime << 32) | ft.dwLowDateTime;
        };

    uint64_t idleDiff = toUInt64(idleTime) - toUInt64(idleTimePrev);
    uint64_t kernelDiff = toUInt64(kernelTime) - toUInt64(kernelTimePrev);
    uint64_t userDiff = toUInt64(userTime) - toUInt64(userTimePrev);

    idleTimePrev = idleTime;
    kernelTimePrev = kernelTime;
    userTimePrev = userTime;

    uint64_t total = kernelDiff + userDiff;
    return total ? (1.0 - (float)idleDiff / total) * 100.0 : 0.0;
}

void CALLBACK TimerRAM(PVOID pVoid, BOOLEAN TimerOrWaitFired)
{
    static wchar_t ram_info[64];
    ZeroMemory(ram_info, 64);
    if (GlobalMemoryStatusEx(&mem_info)) {
        static uint16_t totalPhys = (uint16_t)ceil((float)mem_info.ullTotalPhys / 1024 / 1024 / 1024);
        float physUsed = (float)(mem_info.ullTotalPhys - mem_info.ullAvailPhys) / 1024 / 1024 / 1024;
        uint16_t usagePercent = mem_info.dwMemoryLoad;
        HICON icon;
        if (hash_ram_icons.find((uint16_t)usagePercent) == hash_ram_icons.end())
        {
            icon = CreateIconWithNumber(usagePercent, ICON_SIZE, 50, RAM_COLOR);
            hash_ram_icons.insert({ (uint16_t)usagePercent, icon});
        }
        ram_status_icon.hIcon = hash_ram_icons[(uint16_t)usagePercent];
        swprintf(ram_info, 64, L"%.2f\\%u Gb   %u%%", physUsed, totalPhys, usagePercent);
        lstrcpy(ram_status_icon.szTip, ram_info);
        Shell_NotifyIcon(NIM_MODIFY, &ram_status_icon);
    }
}

void CALLBACK TimerCPU(PVOID pVoid, BOOLEAN TimerOrWaitFired)
{
    static wchar_t cpu_inf[8];
    ZeroMemory(cpu_inf, 8);
    double cpu_total = GetCPULoad();
    HICON icon;
    if (hash_cpu_icons.find((uint16_t)cpu_total) == hash_cpu_icons.end())
    {
        icon = CreateIconWithNumber((uint16_t)cpu_total, ICON_SIZE, 50, GetGradColor(cpu_total));
        hash_cpu_icons.insert({ (uint16_t)cpu_total,  icon });
    }
    cpu_status_icon.hIcon = hash_cpu_icons[(uint16_t)cpu_total];
    swprintf(cpu_inf, 8, L"%.2f %%", cpu_total);
    lstrcpy(cpu_status_icon.szTip, cpu_inf);
    Shell_NotifyIcon(NIM_MODIFY, &cpu_status_icon);
}

bool WriteSettings(int n)
{
    std::wstring valueStr = std::to_wstring(n);
    HKEY hKey;

    if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Environment", 0, KEY_SET_VALUE, &hKey) != ERROR_SUCCESS)
        return false;

    LONG result = RegSetValueEx(
        hKey,
        SETTINGS_MONITOR_NAME,
        0,
        REG_SZ,
        reinterpret_cast<const BYTE *>(valueStr.c_str()),
        static_cast<DWORD>((valueStr.size() + 1) * sizeof(wchar_t)));
    RegCloseKey(hKey);

    if (result != ERROR_SUCCESS)
        return false;

    SendMessageTimeoutW(HWND_BROADCAST, WM_SETTINGCHANGE, 0,
        (LPARAM)L"Environment",
        SMTO_ABORTIFHUNG, 5000, nullptr);

    return true;
}

byte ReadSettings()
{
    HKEY hKey;
    if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Environment", 0, KEY_QUERY_VALUE, &hKey) != ERROR_SUCCESS)
        throw std::runtime_error("Couldnt open the key registry Environment");

    wchar_t buffer[4];
    DWORD bufferSize = sizeof(buffer);
    DWORD type = 0;

    LONG result = RegQueryValueExW(
        hKey,
        SETTINGS_MONITOR_NAME,
        nullptr,
        &type,
        reinterpret_cast<LPBYTE>(buffer),
        &bufferSize
    );

    RegCloseKey(hKey);

    if (result != ERROR_SUCCESS)
        throw std::runtime_error(std::string("variable was not found"));

    if (type != REG_SZ)
        throw std::runtime_error(std::string("variable has in incorrect format"));

    try {
        return (byte)std::stoi(buffer);
    }
    catch (...) {
        throw std::runtime_error(std::string("Couldnt convert the value to a number"));
    }
}

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

    // TODO: Разместите код здесь.

    // Инициализация глобальных строк
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_CPUSTATUSICON, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);

    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_CPUSTATUSICON));

    MSG msg;

    // Цикл осовного сообщения:
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    return (int) msg.wParam;
}

ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEXW wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);

    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(1));
    wcex.hCursor        = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCEW(IDC_CPUSTATUSICON);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

    return RegisterClassExW(&wcex);
}

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance;

   HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU,
      300, 300, 300, 300, nullptr, nullptr, hInstance, nullptr);

   if (!hWnd)
   {
      return FALSE;
   }

   try
   {
        settings_param = ReadSettings();
   }
   catch (std::runtime_error &msg)
   {
       settings_param = 0b0111;
       WriteSettings(settings_param);
   }

   cpu_checkbox = new Checkbox(hWnd, hInstance, CPU_CLICK, L"CPU", 100, 50, 100, 30);
   ram_checkbox = new Checkbox(hWnd, hInstance, RAM_CLICK, L"RAM", 100, 100, 100, 30);
   open_start_checkbox = new Checkbox(hWnd, hInstance, OPEN_AT_START, L"Open at start", 100, 150, 110, 30);

   InitGDIPlus();
   mem_info.dwLength = sizeof(mem_info);

   cpu_status_icon.cbSize = sizeof(NOTIFYICONDATA);
   cpu_status_icon.hWnd = hWnd;
   cpu_status_icon.uID = 1;
   cpu_status_icon.uCallbackMessage = ICON_CLICK;
   cpu_status_icon.uFlags = NIF_ICON | NIF_TIP | NIF_MESSAGE;

   ram_status_icon.cbSize = sizeof(NOTIFYICONDATA);
   ram_status_icon.hWnd = hWnd;
   ram_status_icon.uID = 2;
   ram_status_icon.uCallbackMessage = ICON_CLICK;
   ram_status_icon.uFlags = NIF_ICON | NIF_TIP | NIF_MESSAGE;


   if (settings_param & 0b0100)
   {
       show_window_flag = 5;
       open_start_checkbox->Check();
   }
   if (settings_param & 0b0010)
   {
       ram_show = 0;
       ram_checkbox->Check();
   }
   if (settings_param & 0b0001)
   {
       cpu_show = 0;
       cpu_checkbox->Check();
   }

   ShowWindow(hWnd, show_window_flag);
   Shell_NotifyIcon(cpu_show, &cpu_status_icon);
   Shell_NotifyIcon(ram_show, &ram_status_icon);

   if (!CreateTimerQueueTimer(&htimer_cpu, NULL, TimerCPU, NULL, 1000, 1500, WT_EXECUTEDEFAULT))
   {
       std::cerr << "Error cpu timer\n";
       return -1;
   }

   if (!CreateTimerQueueTimer(&htimer_ram, NULL, TimerRAM, NULL, 1000, 1500, WT_EXECUTEDEFAULT))
   {
       std::cerr << "Error ram timer\n";
       return -2;
   }
   return TRUE;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case ICON_CLICK:
        if (lParam == WM_LBUTTONDOWN)
        {
            show_window_flag ^= 5;
            ShowWindow(hWnd, show_window_flag);
        }
        break;
    case WM_CLOSE:
        show_window_flag = 0;
        ShowWindow(hWnd, show_window_flag);
        break;
    case WM_COMMAND:
        if (HIWORD(wParam) == BN_CLICKED)
        {
            switch (LOWORD(wParam))
            {
                case CPU_CLICK:
                    cpu_checkbox->Revers();
                    cpu_show ^= 0x2;
                    settings_param ^= 0b001;
                    Shell_NotifyIcon(cpu_show, &cpu_status_icon);
                    open_start_checkbox->UnBlock();
                    WriteSettings(settings_param);
                    break;
                case RAM_CLICK:
                    ram_checkbox->Revers();
                    ram_show ^= 0x2;
                    settings_param ^= 0b010;
                    Shell_NotifyIcon(ram_show, &ram_status_icon);
                    open_start_checkbox->UnBlock();
                    WriteSettings(settings_param);
                    break;
                case OPEN_AT_START:
                    open_start_checkbox->Revers();
                    settings_param ^= 0b100;
                    WriteSettings(settings_param);
                    break;
                }
                if (!(settings_param & 1) && !(settings_param & 2))
                {
                    settings_param = 0b100;
                    open_start_checkbox->Check();
                    open_start_checkbox->Block();
                    WriteSettings(settings_param);
                }
        }
        break;
    case WM_DESTROY:
        ShutdownGDIPlus();
        Shell_NotifyIcon(NIM_DELETE, &cpu_status_icon);
        Shell_NotifyIcon(NIM_DELETE, &ram_status_icon);
        DeleteTimerQueueTimer(NULL, htimer_cpu, NULL);
        DeleteTimerQueueTimer(NULL, htimer_ram, NULL);
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}