Изменение цвета фона приложения при нажатии на пункт меню

@Hyrax · Регистрация: 20.05.2015

Author24 — интернет-сервис помощи студентам

Здравствуйте. Впервые столкнулся с Win Api 32. Суть проблемы: был создан простой калькулятор.
Далее, по заданию необходимо с помощью меню Цвет и диалогового окна задавать цвет диалогового окна.
Я подключил rc файл, создал меню, создал пункт - меню "Изменить цвет", и на этом этапе у меня ступор. Гугл помог только текстом, примеров не нашел. Буду благодарен любой помощи.

Calculate.cpp

C++

#include "stdafx.h"
#include <windows.h>
#include <stdlib.h>
#include <string.h>
#include <tchar.h>
#include <Shlwapi.h>
#include <iostream>
#include "Calculate.h"
#include "resource.h"
 
static TCHAR szWindowClass[] = _T("Калькулятор");
static TCHAR szTitle[] = _T("Калькулятор");
TCHAR buf[256];
 
HINSTANCE hInst;
 
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
 
// Главная часть программы-------------------------------------------------------------------------------------
int WINAPI WinMain(HINSTANCE hInstance,
    HINSTANCE hPrevInstance,
    LPSTR lpCmdLine,
    int nCmdShow)
{
    // ------------------------------------------------------------------------------------------------------------
 
    // Структура класса окна---------------------------------------------------------------------------------------
    WNDCLASSEX 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, IDI_APPLICATION);
    wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 11);
    wcex.lpszMenuName = MAKEINTRESOURCE (IDC_CALCULATE);
    wcex.lpszClassName = szWindowClass;
    wcex.hIconSm = LoadIcon(wcex.hInstance, IDI_APPLICATION);
    // ------------------------------------------------------------------------------------------------------------
 
    // Регистрируем класс окна------------------------------------------------------------------------------------
    if (!RegisterClassEx(&wcex))
    {
        MessageBox(NULL,
            _T("Call to RegisterClassEx failed!"),
            _T("Win32 Guided Tour"),
            0);
        return 1;
    }
    // ------------------------------------------------------------------------------------------------------------
 
    // Создаём окно---------------------------------------------------------------------------------------
    hInst = hInstance;
 
    HWND hWnd = CreateWindow(
        szWindowClass,
        szTitle,
        WS_SYSMENU,
        CW_USEDEFAULT, CW_USEDEFAULT,
        260, 260,
        NULL,
        NULL,
        hInstance,
        NULL
    );
 
    if (!hWnd)
    {
        MessageBox(NULL,
            _T("Call to CreateWindow failed!"),
            _T("Win32 Guided Tour"),
            0);
        return 1;
    }
    // ------------------------------------------------------------------------------------------------------------
 
    // Отображаем окно---------------------------------------------------------------------------------------------
    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);
    // ------------------------------------------------------------------------------------------------------------
 
    // Цикл обработки сообщений для прослушивания отправляемых ОС сообщений----------------------------------------
    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
 
    return (int)msg.wParam;
}
// ------------------------------------------------------------------------------------------------------------
 
// Функция------------------------------------------------------------------------------------------------------------
#define ID_EDIT  99
#define ID_BUTTON    100
#define ID_BUTTON_1  101
#define ID_BUTTON_2  102
#define ID_BUTTON_3  103
#define ID_BUTTON_4  104
#define ID_BUTTON_5  105
#define ID_BUTTON_6  106
#define ID_BUTTON_7  107
#define ID_BUTTON_8  108
#define ID_BUTTON_9  109
#define ID_BUTTON_ADD    110
#define ID_BUTTON_SUB    111
#define ID_BUTTON_MUL    112
#define ID_BUTTON_DIV    113
#define ID_BUTTON_RES   114
#define ID_BUTTON_C    115
 
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    // Структура класса кнопки-------------------------------------------------------------------------------------
    static HWND hButton[17], hEdit, hListBox;
    PAINTSTRUCT ps;
    HDC hdc;
    int i = 0;
    int count = 0, a = 0, b = 0;
    // ------------------------------------------------------------------------------------------------------------
    switch (message)
    {
    case WM_CREATE:
        hEdit = CreateWindow(_T("edit"), _T("0"), WS_CHILD | WS_VISIBLE | WS_BORDER | ES_RIGHT, 10, 5, 230, 35, hWnd, (HMENU)ID_EDIT, hInst, 0);
        hButton[0] = CreateWindow(_T("Button"), _T("0"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 10, 150, 130, 30, hWnd, (HMENU)ID_BUTTON, hInst, 0);
        hButton[1] = CreateWindow(_T("Button"), _T("1"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 10, 115, 40, 30, hWnd, (HMENU)ID_BUTTON_1, hInst, 0);
        hButton[2] = CreateWindow(_T("Button"), _T("2"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 55, 115, 40, 30, hWnd, (HMENU)ID_BUTTON_2, hInst, 0);
        hButton[3] = CreateWindow(_T("Button"), _T("3"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 100, 115, 40, 30, hWnd, (HMENU)ID_BUTTON_3, hInst, 0);
        hButton[4] = CreateWindow(_T("Button"), _T("4"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 10, 80, 40, 30, hWnd, (HMENU)ID_BUTTON_4, hInst, 0);
        hButton[5] = CreateWindow(_T("Button"), _T("5"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 55, 80, 40, 30, hWnd, (HMENU)ID_BUTTON_5, hInst, 0);
        hButton[6] = CreateWindow(_T("Button"), _T("6"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 100, 80, 40, 30, hWnd, (HMENU)ID_BUTTON_6, hInst, 0);
        hButton[7] = CreateWindow(_T("Button"), _T("7"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 10, 45, 40, 30, hWnd, (HMENU)ID_BUTTON_7, hInst, 0);
        hButton[8] = CreateWindow(_T("Button"), _T("8"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 55, 45, 40, 30, hWnd, (HMENU)ID_BUTTON_8, hInst, 0);
        hButton[9] = CreateWindow(_T("Button"), _T("9"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 100, 45, 40, 30, hWnd, (HMENU)ID_BUTTON_9, hInst, 0);
        hButton[10] = CreateWindow(_T("Button"), _T("+"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 150, 80, 43, 30, hWnd, (HMENU)ID_BUTTON_ADD, hInst, 0);
        hButton[11] = CreateWindow(_T("Button"), _T("-"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 196, 80, 43, 30, hWnd, (HMENU)ID_BUTTON_SUB, hInst, 0);
        hButton[12] = CreateWindow(_T("Button"), _T("*"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 150, 115, 43, 30, hWnd, (HMENU)ID_BUTTON_MUL, hInst, 0);
        hButton[13] = CreateWindow(_T("Button"), _T("/"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 196, 115, 43, 30, hWnd, (HMENU)ID_BUTTON_DIV, hInst, 0);
        hButton[14] = CreateWindow(_T("Button"), _T("="), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 150, 150, 90, 30, hWnd, (HMENU)ID_BUTTON_RES, hInst, 0);
        hButton[15] = CreateWindow(_T("Button"), _T("C"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 150, 45, 90, 30, hWnd, (HMENU)ID_BUTTON_C, hInst, 0);
        
        break;
    case WM_COMMAND:
        if ((LOWORD(wParam) == ID_BUTTON) && (HIWORD(wParam) == BN_CLICKED))
        {
            GetWindowText(hEdit, buf, sizeof(buf));
            if (*buf == TEXT('0') && 0 == buf[1]) *buf = 0;
            StrCat(buf, TEXT("0"));
            SetWindowText(hEdit, buf);
        }
 
        if ((LOWORD(wParam) == ID_BUTTON_1) && (HIWORD(wParam) == BN_CLICKED))
        {
            GetWindowText(hEdit, buf, sizeof(buf));
            if (*buf == TEXT('0') && 0 == buf[1]) *buf = 0;
            StrCat(buf, TEXT("1"));
            SetWindowText(hEdit, buf);
        }
 
        if ((LOWORD(wParam) == ID_BUTTON_2) && (HIWORD(wParam) == BN_CLICKED))
        {
            GetWindowText(hEdit, buf, sizeof(buf));
            if (*buf == '0' && 0 == buf[1]) *buf = 0;
            StrCat(buf, TEXT("2"));
            SetWindowText(hEdit, buf);
        }
 
        if ((LOWORD(wParam) == ID_BUTTON_3) && (HIWORD(wParam) == BN_CLICKED))
        {
            GetWindowText(hEdit, buf, sizeof(buf));
            if (*buf == '0' && 0 == buf[1]) *buf = 0;
            StrCat(buf, TEXT("3"));
            SetWindowText(hEdit, buf);
        }
 
        if ((LOWORD(wParam) == ID_BUTTON_4) && (HIWORD(wParam) == BN_CLICKED))
        {
            GetWindowText(hEdit, buf, sizeof(buf));
            if (*buf == '0' && 0 == buf[1]) *buf = 0;
            StrCat(buf, TEXT("4"));
            SetWindowText(hEdit, buf);
        }
 
        if ((LOWORD(wParam) == ID_BUTTON_5) && (HIWORD(wParam) == BN_CLICKED))
        {
            GetWindowText(hEdit, buf, sizeof(buf));
            if (*buf == '0' && 0 == buf[1]) *buf = 0;
            StrCat(buf, TEXT("5"));
            SetWindowText(hEdit, buf);
        }
 
        if ((LOWORD(wParam) == ID_BUTTON_6) && (HIWORD(wParam) == BN_CLICKED))
        {
            GetWindowText(hEdit, buf, sizeof(buf));
            if (*buf == '0' && 0 == buf[1]) *buf = 0;
            StrCat(buf, TEXT("6"));
            SetWindowText(hEdit, buf);
        }
 
        if ((LOWORD(wParam) == ID_BUTTON_7) && (HIWORD(wParam) == BN_CLICKED))
        {
            GetWindowText(hEdit, buf, sizeof(buf));
            if (*buf == '0' && 0 == buf[1]) *buf = 0;
            StrCat(buf, TEXT("7"));
            SetWindowText(hEdit, buf);
        }
 
        if ((LOWORD(wParam) == ID_BUTTON_8) && (HIWORD(wParam) == BN_CLICKED))
        {
            GetWindowText(hEdit, buf, sizeof(buf));
            if (*buf == '0' && 0 == buf[1]) *buf = 0;
            StrCat(buf, TEXT("8"));
            SetWindowText(hEdit, buf);
        }
 
        if ((LOWORD(wParam) == ID_BUTTON_9) && (HIWORD(wParam) == BN_CLICKED))
        {
            GetWindowText(hEdit, buf, sizeof(buf));
            if (*buf == '0' && 0 == buf[1]) *buf = 0;
            StrCat(buf, TEXT("9"));
            SetWindowText(hEdit, buf);
        }
 
        if ((LOWORD(wParam) == ID_BUTTON_ADD) && (HIWORD(wParam) == BN_CLICKED))
        {
            GetWindowText(hEdit, buf, sizeof(buf));
            StrCat(buf, TEXT("+"));
            SetWindowText(hEdit, buf);
        }
 
        if ((LOWORD(wParam) == ID_BUTTON_SUB) && (HIWORD(wParam) == BN_CLICKED))
        {
            GetWindowText(hEdit, buf, sizeof(buf));
            StrCat(buf, TEXT("-"));
            SetWindowText(hEdit, buf);
        }
 
        if ((LOWORD(wParam) == ID_BUTTON_MUL) && (HIWORD(wParam) == BN_CLICKED))
        {
            GetWindowText(hEdit, buf, sizeof(buf));
            StrCat(buf, TEXT("*"));
            SetWindowText(hEdit, buf);
        }
 
        if ((LOWORD(wParam) == ID_BUTTON_DIV) && (HIWORD(wParam) == BN_CLICKED))
        {
            GetWindowText(hEdit, buf, sizeof(buf));
            StrCat(buf, TEXT("/"));
            SetWindowText(hEdit, buf);
        }
 
        if ((LOWORD(wParam) == ID_BUTTON_RES) && (HIWORD(wParam) == BN_CLICKED))
        {
            GetWindowText(hEdit, buf, sizeof(buf));
            SetWindowText(hEdit, Calculate(buf));
        }
 
        if ((LOWORD(wParam) == ID_BUTTON_C) && (HIWORD(wParam) == BN_CLICKED))
        {
            SetWindowText(hEdit, TEXT("0"));
            buf[0] = 0;
        }
 
        break;
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps);
        EndPaint(hWnd, &ps);
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
        break;
    }
    return 0;
}

Calculate.h

C++

#include <stack>
#include <cctype>
#include <map>
#include <string>
#include <cstdio>
#include <sstream>
#include <windows.h>
 
TCHAR* Calculate(TCHAR* buf)
{
    std::basic_string<TCHAR> s(buf), srpn, sres;
    std::basic_string<TCHAR>::size_type ind;
    while ((ind = s.find(TEXT(' '))) != std::basic_string<TCHAR>::npos) // удаление пробелов из входной строки
    {
        s.erase(ind, 1);
    }
    std::map<TCHAR, size_t> map; // карата весов символов
    map.insert(std::make_pair(TEXT('*'), 3));
    map.insert(std::make_pair(TEXT('/'), 3));
    map.insert(std::make_pair(TEXT('+'), 2));
    map.insert(std::make_pair(TEXT('-'), 2));
    map.insert(std::make_pair(TEXT('('), 1));
    std::stack<TCHAR> stack;
    for (std::basic_string<TCHAR>::iterator ib = s.begin(); ib != s.end(); ++ib) // формировка результирующей строки в ОПЗ
    {
        if (!isdigit(*ib) && (TEXT('.') != *ib) && !(s.begin() == ib && '-' == *ib))
        {
            srpn += TEXT(' ');
            if (TEXT(')') == *ib)
            {
                while (stack.top() != TEXT('('))
                {
                    srpn += stack.top();
                    stack.pop();
                    srpn += TEXT(' ');
                }
                stack.pop();
            }
            else if (TEXT('(') == *ib)
            {
                stack.push(*ib);
            }
            else if (stack.empty() || (map[stack.top()] < map[*ib]))
            {
                stack.push(*ib);
            }
            else
            {
                do
                {
                    srpn += stack.top();
                    srpn += TEXT(' ');
                    stack.pop();
                } while (!(stack.empty() || (map[stack.top()] < map[*ib])));
                stack.push(*ib);
            }
        }
        else
        {
            srpn += *ib;
        }
    }
    while (!stack.empty())// остаток из стека добавляется в результ. строку
    {
        srpn += stack.top();
        srpn += TEXT(' ');
        stack.pop();
    }
    std::stack<double> dstack;
    std::basic_stringstream<TCHAR> ss(srpn);
    double d, d1;
    TCHAR c;
    while (ss.get(c)) // вычисление результата
    {
        if (isdigit(c) || TEXT('.') == c || (1 == ss.tellg() && TEXT('-') == c))
        {
            ss.unget();
            ss >> d;
            dstack.push(d);
        }
        else if (!isspace(c))
        {
            d1 = dstack.top();
            dstack.pop();
            d = dstack.top();
            dstack.pop();
            switch (c)
            {
            case TEXT('+'):
                dstack.push(d + d1);
                break;
            case TEXT('-'):
                dstack.push(d - d1);
                break;
            case TEXT('*'):
                dstack.push(d * d1);
                break;
            case TEXT('/'):
                dstack.push(d / d1);
                break;
            }
        }
    }
    if (1 == dstack.size())
    {
        _stprintf(buf, TEXT("%lf"), dstack.top());
        dstack.pop();
    }
    else
    {
        _stprintf(buf, TEXT("error"));
    }
    return buf;
}

@~~stamp~~ · 16.06.2017, 02:26

C++

// Hyrax.cpp : Defines the entry point for the application.
//
 
#include "stdafx.h"
#include <commdlg.h>
#include "resource.h"
 
#define MAX_LOADSTRING 100
 
// Global Variables:
HINSTANCE hInst;                                // current instance
TCHAR szTitle[MAX_LOADSTRING];                              // The title bar text
TCHAR szWindowClass[MAX_LOADSTRING];                                // The title bar text
 
// Foward declarations of functions included in this code module:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
 
int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
    // TODO: Place code here.
    MSG msg;
    HACCEL hAccelTable;
 
    // Initialize global strings
    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadString(hInstance, IDC_HYRAX, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);
 
    // Perform application initialization:
    if (!InitInstance (hInstance, nCmdShow)) 
    {
        return FALSE;
    }
 
    hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_HYRAX);
 
    // Main message loop:
    while (GetMessage(&msg, NULL, 0, 0)) 
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) 
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
 
    return msg.wParam;
}
 
 
 
//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
//  COMMENTS:
//
//    This function and its usage is only necessary if you want this code
//    to be compatible with Win32 systems prior to the 'RegisterClassEx'
//    function that was added to Windows 95. It is important to call this function
//    so that the application will get 'well formed' small icons associated
//    with it.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEX wcex;
 
    wcex.cbSize = sizeof(WNDCLASSEX); 
 
    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = (WNDPROC)WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, (LPCTSTR)IDI_HYRAX);
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = (LPCSTR)IDC_HYRAX;
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);
 
    return RegisterClassEx(&wcex);
}
 
//
//   FUNCTION: InitInstance(HANDLE, int)
//
//   PURPOSE: Saves instance handle and creates main window
//
//   COMMENTS:
//
//        In this function, we save the instance handle in a global variable and
//        create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;
 
   hInst = hInstance; // Store instance handle in our global variable
 
   hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
 
   if (!hWnd)
   {
      return FALSE;
   }
 
   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);
 
   return TRUE;
}
 
//
// appChooseColor
//
COLORREF appChooseColor(HWND hwndParent, COLORREF crColor)
{
    static COLORREF crCust[16];
    static COLORREF crResult=crColor;
    CHOOSECOLOR cc;
    ZeroMemory(&cc, sizeof(CHOOSECOLOR));
    cc.lStructSize  = sizeof(CHOOSECOLOR);
    cc.hwndOwner    = hwndParent;
    cc.lpCustColors = (LPDWORD)crCust;
    cc.rgbResult    = crColor;
    cc.Flags        = CC_FULLOPEN | CC_RGBINIT;
    if( TRUE==ChooseColor(&cc) )
        crResult = cc.rgbResult;
    if( hwndParent )
        InvalidateRect(hwndParent, NULL, TRUE);
    return crResult;
}
 
//
//  FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND  - process the application menu
//  WM_PAINT    - Paint the main window
//  WM_DESTROY  - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    static HBRUSH Brush;
    static COLORREF crBgnd;
 
    int wmId, wmEvent;
    PAINTSTRUCT ps;
    HDC hdc;
    TCHAR szHello[MAX_LOADSTRING];
    LoadString(hInst, IDS_HELLO, szHello, MAX_LOADSTRING);
 
    switch (message) 
    {
 
    case WM_CREATE:
    Brush = reinterpret_cast<HBRUSH>(COLOR_WINDOW+1);
    return 1;
 
        case WM_COMMAND:
            wmId    = LOWORD(wParam); 
            wmEvent = HIWORD(wParam); 
            // Parse the menu selections:
            switch (wmId)
            {
 
    case IDM_COLOR:
    {
 
    if( crBgnd )
        crBgnd = appChooseColor(hWnd, crBgnd);
    else
        crBgnd = appChooseColor(hWnd, GetSysColor(COLOR_WINDOW));
 
    LOGBRUSH lplb;
    lplb.lbStyle = BS_SOLID;
    lplb.lbColor = crBgnd;
    lplb.lbHatch = HS_BDIAGONAL;
    Brush=CreateBrushIndirect(&lplb);
    if( NULL==Brush )
        Brush=reinterpret_cast<HBRUSH>(COLOR_WINDOW+1);
 
    }
    break;
 
                case IDM_ABOUT:
                   DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
                   break;
                case IDM_EXIT:
                   DestroyWindow(hWnd);
                   break;
                default:
                   return DefWindowProc(hWnd, message, wParam, lParam);
            }
            break;
            
    case WM_ERASEBKGND:
    {
        RECT rc;
        GetClientRect(hWnd, &rc);
        FillRect((HDC)wParam, &rc, Brush);
    }
    return 1;
 
        case WM_PAINT:
            hdc = BeginPaint(hWnd, &ps);
            // TODO: Add any drawing code here...
            RECT rt;
            GetClientRect(hWnd, &rt);
 
        SetBkMode(hdc, TRANSPARENT);
        lstrcpy(szHello, _T("Color window\r\nPress Key "C""));
        DrawText(hdc, szHello, lstrlen(szHello), &rt, DT_CENTER);
            //DrawText(hdc, szHello, strlen(szHello), &rt, DT_CENTER);
            EndPaint(hWnd, &ps);
            break;
 
        case WM_DESTROY:
        {
    DeleteObject(Brush);
            PostQuitMessage(0);
        }
        break;
 
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
   }
   return 0;
}

Hyrax.zip

@Hyrax · 16.06.2017, 19:06 **[ТС]**

С цветом разобрался, пример помог, спасибо stamp!

Заключительная проблема, которую также не могу избежать: как убрать нули после запятой при получении итогового значения?
Скрин проблемы прикреплю, код выше.

@Hyrax 0 / 0 / 0 Регистрация: 20.05.2015 Сообщений: 35
	16.06.2017, 19:06 [ТС]	3
	С цветом разобрался, пример помог, спасибо stamp! Заключительная проблема, которую также не могу избежать: как убрать нули после запятой при получении итогового значения? Скрин проблемы прикреплю, код выше. Изображения 0

Изменение цвета фона приложения при нажатии на пункт меню

Решение