// WindowsProject1.cpp : Определяет точку входа для приложения.
//

// этот кусок можно пропустить (это добавил я)
// директива pragma once подразумевает
// исключение логического бага в программе,
// который может произойти из-за команды для
// подключения библиотек (файлов с заготовками кода)
// include, которая просто вставляет на свое место
// все содержимое файла, который был указан
// (включая и команды include внутри подключаемого
// файла) при вызове, из за чего могу возникать логические
// ошибки и множественные самоподключения (когда
// одна библиотека ссылается на вторую, а вторая на
// первую), в двух словах все исходники собираются
// в одни длинный исходный код (командами include),
// а команда pragma once удаляет все дубликаты,
// оставляя только самую первую include,
// лично я начинаю любой файл с pragma once,
// что бы не беспокоится о зависимостях, но это
// не обязательно (кароче пока не заморачивайтесь)
#pragma once 

// и начать отсюда
// подключаем вспомогательные библиотеки
// наборы готового кода как в этом файле, 
// где уже описанные какие-то функции (заготовки) для
// реализации и запуска нашей программы
#include "framework.h"
#include "WindowsProject2.h"

// определим вспомогательный термин 
// (читай создадим разновидность переменной)
// под названием MAX_LOADSTRING и ассоциируем
// с ней число 999, теперь везде в коде, где 
// будет встречается термин MAX_LOADSTRING
// он будет заменятся на 999
#define MAX_LOADSTRING 999

// Глобальные переменные:
// 
// hInst это глобальная переменная экземпляра нашей программы
// переменная создается следующим образом - сначала пишется ключевое слово,
// которое обозначает тип данных переменной, потом какое-нибудь имя (ключевое
// слово), с которым ассоциированных данные, то есть везде в коде, где будет
// встречается ключевое слово, оно будет автоматически заменятся на данные,
// которые были ассоциированы с этим ключевым словом
HINSTANCE hInst;                                // текущий экземпляр

// сразу создадим свою переменную, тип данных
// будет HWND, название Form1, будем хранить тут уникальный
// идентификатор на наше окно программы (формы)
HWND Form1;

// в общем то создаем пару переменных типа "буквенная многопеременная в одной",
// и сразу задаем его длину в параметре [MAX_LOADSTRING] (иначе говоря набор 
// символов, или текстовые переменные)
WCHAR szTitle[MAX_LOADSTRING];                  // Текст строки заголовка
WCHAR szWindowClass[MAX_LOADSTRING];            // имя класса главного окна

// Отправить объявления функций, включенных в этот модуль кода:
// 
// эти вспомогательные функции сейчас не важны, по сути, они просто "нормализуют"
// нашу программу для системы, создают новый экземпляр окна (из заготовок в системе) 
// и добавляют мониторинг действий (нет смысла вдаваться в подробности, и забивать голову)
// функции начинаются с заголовков, сначала идет тип данных, которые должна вернуть функция,
// потом ключевое слово, любое (название этой функции), и наконец в круглых () скобках
// "заготовки" переменных всех переменных, которые должы быть переданы функцие, в самой же
// (внутри), эти данные доступны под названиями "заготовк переменных"
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);

// создаем функцию wWinMain
// эта функция принимает в себя несколько параметров,
// это "точка входа", когда программа запускается, она 
// автоматически начинает выполнять эту функцию
//
// эта функция будет обеспечивать связь системы и нашей программы
// при помощи бесконечного цикла, который повторяется до тех пор, 
// пока программа запущена, и перехватывает сообщения от системы
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_WINDOWSPROJECT2, szWindowClass, MAX_LOADSTRING);

    // адаптируем нашу программу для системы при помощи функции
    // MyRegisterClass, в качестве параметра передаем идентификатор
    // нашего окна программы, который получаем из текущей функции 
    // (wWinMain) в параметре hInstance
    MyRegisterClass(hInstance);
    
    // создаем условие, если функция (InitInstance) вернула на место своего вызова
    // значение false, вызываем встроенное в идею функций ключевое слово
    // return, при встрече которого любая функция прекращает построчное выполнение
    // кода, и возвращаем ложь в функции wWinMain (в место вызова функции)
    // Выполнить инициализацию приложения:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

    // это вспомогательный код для отлова событий нажатия клавиш,
    // ассоциируем с переменной hAccelTable (типа HACCEL) результат
    // выполнения функции LoadAccelerators, сама функция извлекает из
    // ресурсов нашего файла готовые схемы сочетания клавиш и названия функций
    // для этих сочетаний (которые были сгенерированны автоматически)
    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_WINDOWSPROJECT2));

    // создадим переменную типа MSG (сложносоставной тип данных) под названием MSG
    // в эту переменную будут попадать команды, которые в цикле будут перехватываться 
    // универсальной функцией GetMessage
    MSG msg;

    // Цикл основного сообщения:

    // создаем цикл, до тех пор пока GetMessage, с пустыми параметрами 
    // (2,3,4, не нужно вдавятся сейчас в подробности почему)
    // возвращает какой-либо результат (в переменную msg) 
    // выполняем код в теле цикла
    //
    // важный момент, почему &msg (ассоциация значений), а не
    // просто msg (присвоение значений)? потому что если создать 
    // "условный" объект кнопка, задать ему какие-либо параметры, 
    // после чего создать еще один, и попробовать скопировать параметры 
    // простым присвоением, присвоены будут не параметры кнопки, 
    // а сама кнопка (объект), следовательно просто кнопка один 
    // будет также доступна под названием кнопка два
    while (GetMessage(&msg, nullptr, 0, 0))

    // это начало тела цикла
    {
        // нестандартная конструкция условия, она подразумевает
        // простую логику, если не "!" результат выполнения функции
        // TranslateAccelerator (функция для горячих клавиш)
        // то выполняем код в условии, иначе говоря, если 
        // нажатая клавиша не выполнила функцию, которая ей
        // назначена, то выполняем код условия, а именно обрабатываем 
        // горячую клавишу (не обязательно вдавятся в подробности 
        // нам сейчас это не нужно)
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            // код обработки нажатий горячих клавиш
            // которые были указаны в схеме, которая
            // была загружена из ресурсов ранее
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    // это конец тела цикла

    // возвращаем результат выполнения функции
    // в качестве подстановочного значение 
    // (которое встает в никуда) возвращаем параметры 
    // последней команды GetMessage
    return (int) msg.wParam;
}



//
//  ФУНКЦИЯ: MyRegisterClass()
//
//  ЦЕЛЬ: Регистрирует класс окна.
//

// выше уже была упомянута эта функция, она адаптирует
// в рамках системы нашу программу, вот, собственно, само 
// содержимое это функции, оно нам не интересно, двигаемся дальше
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(IDI_WINDOWSPROJECT2));
    wcex.hCursor        = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCEW(IDC_WINDOWSPROJECT2);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

    return RegisterClassExW(&wcex);
}

//
//   ФУНКЦИЯ: InitInstance(HINSTANCE, int)
//
//   ЦЕЛЬ: Сохраняет маркер экземпляра и создает главное окно
//
//   КОММЕНТАРИИ:
//
//        В этой функции маркер экземпляра сохраняется в глобальной переменной, а также
//        создается и выводится главное окно программы.
//

// я думаю из сгенерированных комментариев понятно, для чего эта функция
// так же выше было сказано об этой функции, ее тоже можно пропустить
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance; // Сохранить маркер экземпляра в глобальной переменной

   // разве что вот ключевая функция для создания окна, которая называется
   // CreateWindow (с модификатором W, то есть одна из вариаций этой функции)
   // и возвращает идентификатор на место своего вызова, который мы сразу
   // ассоциируем с переменной hWnd
   HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);

   // добавим условие, если "не hWnd" (то есть
   // нет ассоциированного объекта) возвращаем FALSE
   // и завершаем выполнение функции (ключевое слово
   // return помимо возврата данных в место вызова функции,
   // подразумивает завершение этой функции
   if (!hWnd)
   {
      return FALSE;
   }

   // после создания окна программы вызываем функции для отображения
   // окна программы и его перерисовки
   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);

   // если условие не сработа и дошли до этого
   // места возвращяем TRUE так как по логике
   // функция выполенилась без сбоев
   return TRUE;
}

//
//  ФУНКЦИЯ: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  ЦЕЛЬ: Обрабатывает сообщения в главном окне.
//
//  WM_COMMAND  - обработать меню приложения
//  WM_PAINT    - Отрисовка главного окна
//  WM_DESTROY  - отправить сообщение о выходе и вернуться
//
//

// еще одна сгенерированная функция, эта функция подвязывается
// к нашей форме (окну программы), и обрабатывает события нашей формы (к примеру
// изменение размера окна, тык мышкой, активность формы и тд)
// это основная функция нашей программы, которая отвечает за какие нибудь события
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    // добавим ассоциацию идентификатора окна программы
    // с нашей глобальной переменной, в которой храним
    // указатель на идентификатор
    Form1 = hWnd;

    // switch разновидность условия, не совсем понятно
    // целесообразность использования альтернативного
    // условного конструктора, поскольку то же самое 
    // можно было описать и конструкцией if (но предположу
    // что несмотря на то что switch не является "канонистической 
    // конструкцией, она обеспечивает одно единственное выполнение
    // условия, затем завершает, это может обеспечивает стабильность,
    // избегая множественных срабатываний на одну команду message)

    // в данном случае условие обрабатывает сообщения,
    // которые получает из GetMessage, в соответствии
    // с определенным содержимым message (который передается
    // в параметрах функции), и если значение message соответствует
    // какой либо конструкции case, выполняет этот фрагмент кода
    switch (message)
    {
        // не стоит забывать про зажатую Ctrl и левый тык мышкой
        // это перекинет в файл, где описано это ключевое слово
        

        // WM_COMMAND это универсальное событие обработки команд
        // (к примеру отправленных через SendMessage), сама конструкция
        // подразумевает условие, если содержимое message, соответствует
        // содержимому ключевого слова WM_COMMAND, выполняет блок кода внутри
        // скобочек (содержимое, читай какие-то данные, ассоциированные с 
        // этим ключевым словом)
        case WM_COMMAND:
        {
            // тут обработка элементов меню
            // сами элементы в ресурсах файла, 
            //сгенерированы автоматически
            int wmId = LOWORD(wParam);
            // Разобрать выбор в меню:
            switch (wmId)
            {
            case IDM_ABOUT:
                DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
                break;
            case IDM_EXIT:
                DestroyWindow(hWnd);
                break;
            default:
                return DefWindowProc(hWnd, message, wParam, lParam);
            }
        }
        break;

        // условие, если данные в message соответствуют WM_PAINT,
        // или событию отрисовки выполняем код внутри
    case WM_PAINT:
        {
            // создаем переменную типа параметры
            // области рисования
            PAINTSTRUCT ps;

            // создаем переменную типа область рисования
            // и ассоциируем с ней результат выполнения функции
            // BeginPaint (в параметрах которой передаем
            // идентификатор нашего окна, и ассоциируем данные
            // из переменной с параметрами
            HDC hdc = BeginPaint(hWnd, &ps);
            // TODO: Добавьте сюда любой код прорисовки, использующий HDC...

            // завершаем процесс рисования,
            // вызывая специальную функцию,
            // данным примером хитроумно затопарен
            // процесс рисования объектов на форме,
            // функцией BeginPaint, который продолжится,
            // после выполнения функции EndPaint
            EndPaint(hWnd, &ps);
        }
        break;

        // если переменная message 
        // содержит WM_DESTROY
        // выполняем код для завершения
        // работы приложения
    case WM_DESTROY:
        PostQuitMessage(0);
        break;

        // если message не содержит никаких сообщений
        // (или сообщения не соответствуют ни одному из условий)
        // выполняем другой код, функцию, которая гарантирует обработку
        // "неопределенного" message, она нас тоже пока не интересует
        // (но может понадобится, так как мы можем ее "переописать",
        // для каких-либо наших задач)
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }

    // вернем результат выполнения функции 0
    // можно изменить на 1 чтобы мониторить 
    // работоспособность программы, исходя
    // из возвращаемого значения этой функции
    // (то есть если функция WndProc выполнилась
    // и не вернула на место вызова 1, значит
    // какое то решение не работает, для этого
    // просто можно создать переменную (в начале
    // блока кода, с которой ассоциировать что
    // нибудь (к примеру 0), и если функция смогла
    // выполнить свой код до этой позиции, возвращяем 1
    return 0;
}

// Обработчик сообщений для окна "О программе".

// аналогично только не для основного окна программы,
// а для диалога "Об программе", его разбирать смысла нет
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}

// подключим вспомогательные библиотеки
#pragma once 
#include "stddef.h"
#include <string> 
#include <Windows.h>
#include <Strsafe.h>

// не будем заморачиватся, с++ очень старый язык
// это еще одна разновидность подключения библиотек
// (просто подключает не весь файл, а кусок из файла)
using namespace std;

// создадим наш собственный тип данных,
// что создавать переменные нашего типа данных
// (для удобства)
class MyVariableUniversalType {

	// опишем несколько переменных
	// разных типов данных, внутри нашего
	//
	// мы опишем их в "приватном" блоке кода
	// описывающего наш тип данных, чтобы они
	// были видны только нашему типу данных
	// и недоступны другим
private:

	bool BooleanType;
	int IntegerType;
	string TextType;

	//
	// единственное, это опишем еще одну функцию
	// что такое protected пока не нужно думать,
	// просто сделайте так же
	//
protected:
	// так как тип данных LPCWSTR Long Pointer to Constant Wide String
	// не совсем классический тип данных строка (не совсем "канонистический"), 
	// я использовал сводный тип данных строка из другой библиотеки, 
	// которую подключил сверху, поэтому опишем конвертор из str::string в LPCWSTR
	// вдаваться в подробности на этом этапе не нужно, дальше можно 
	// пропустить и просто скопировать
	LPWSTR TransformStringToWideString(string agrument1)
	{

		// создадим вспомогательную переменную
		// типа мультипеременная с кодами символов
		// (с которой мы ассоциируем результат создания 
		// нового массива типа WCHAR), длинной в 
		// количество символов из параметра, получаемого 
		// в функцию, при помощи встроенной функции 
		// length (встроенной в тип string)
		LPWSTR tmp_return = new WCHAR[agrument1.length()];

		// вызовем функцию, которая конвертирует набор символов строки
		// str::string в нужный нам набор символов, и сразу помещает его
		// в мультипеременную, функция принимает в себя указатель кодировки,
		// указатель способа конвертирования, текст, размер в байтах,
		// указатель переменной (в которую поместить результат), длину
		// в символах
		MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, agrument1.c_str(), agrument1.size(), tmp_return, agrument1.length());

		// из за особенностей типа LPWSTR
		// код последнего символа должен 
		// быть 0, это указатель того что
		// это конец текста
		tmp_return[agrument1.length()] = 0;

		// вернем результатом содержимое 
		return tmp_return;
	}

	// далее опишем общедоступные части нашего
	// типа данных (то есть доступные не только 
	// внутри нашего типа данных)
public:
	LPWSTR TransformStringToWideString2(string agrument1)
	{

		// создадим вспомогательную переменную
		// типа мультипеременная с кодами символов
		// (с которой мы ассоциируем результат создания 
		// нового массива типа WCHAR), длинной в 
		// количество символов из параметра, получаемого 
		// в функцию, при помощи встроенной функции 
		// length (встроенной в тип string)
		LPWSTR tmp_return = new WCHAR[agrument1.length()];

		// вызовем функцию, которая конвертирует набор символов строки
		// str::string в нужный нам набор символов, и сразу помещает его
		// в мультипеременную, функция принимает в себя указатель кодировки,
		// указатель способа конвертирования, текст, размер в байтах,
		// указатель переменной (в которую поместить результат), длину
		// в символах
		MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, agrument1.c_str(), agrument1.size(), tmp_return, agrument1.length());

		// из-за особенностей типа LPWSTR
		// код последнего символа должен 
		// быть 0, это указатель того, что
		// это конец текста
		tmp_return[agrument1.length()] = 0;

		// вернем результатом содержимое 
		return tmp_return;
	}

	// создадим общедоступную переменную
	// типа LPCWSTR, с которой ассоциируем
	// ничего (L вначале нужно, потому что
	// у компилятора и программы разные кодировки)
	// вникать в детали пока не нужно
	LPCWSTR LPCWSTRTextType = L"";

	// создадим функцию, одноименную с нашим типом данных,
	// такая функция будет вызывается при попытке создать новый
	// экземпляр переменной нашего типа данных (конструктор, или
	// инициирующий блок), в момент создания будем наполнять нашу переменную
	// базовыми данными (ложью для типа булевых данных, -1 для числовых,
	// ничем для строковых)
	MyVariableUniversalType() {
		BooleanType = false;
		IntegerType = -1;
		TextType = "";
	}

	// теперь для закрепления знаний опишем несколько вспомогательных
	// функций, которые будут сразу в нашем типе данных (то есть будут
	// доступны в каждой новой копии переменной), без необходимости
	// описания этих функций по новый

	// создадим функцию для конвертирования
	// булевой переменной в числовую
	int BooleanTypeToInteger(bool argument1)
	{

		// создадим условие, если значение
		// передаваемое в качестве параметра (аргумента)
		// соответствует истине, завершаем функцию
		// и возвращаем 1, иначе 0 (числовые аналоги)
		if (argument1 = true)
		{
			return 1;
		}
		else
		{
			return 0;
		}
	}

	// создадим обратную функцию
	bool IntegerTypeToBoolean(int argument1)
	{

		// создадим условие, если значение
		// передаваемое в качестве параметра (аргумента)
		// больше 0, завершаем функцию с
		// возвратом результата true, иначе false
		if (argument1 > 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	// создадим функцию для конвертирования 
	// булевой переменной в строковую
	string BooleanTypeToString(bool argument1)
	{

		// создадим условие, если значение
		// передаваемое в качестве параметра (аргумента)
		// соответствует истине, завершаем функцию
		// и возвращаем текст true, иначе false
		if (argument1 = true)
		{
			return "true";
		}
		else
		{
			return "false";
		}
	}

	// и обратную
	// тут немного сложнее, поскольку
	// вариантов написания может быть много,
	// и надо обработать их все
	bool StringTypeToBoolean(string argument1)
	{

		// создадим вспомогательную
		// переменную, сразу ассоциируем
		// с ней значение false, чтобы
		// в случае если ни одно из условий
		// не сработает, функция вернула результат
		// в место вызова
		bool tmp_return = "false";

		// создадим переменную (мультипеременную, много значений в одной)
		// в которую специальным образом сразу поместим
		// все возможные варианты текстового значения true
		string true_variants[]
		{
			"true",
			"True",
			"TRUE",
			"truE",
			"TRue"
			/* ... и тд */
		};

		// создадим переменную счетчик для цикла
		int a = 0;

		// создадим переменную с общим количеством записей в
		// мультипеременной при помощи встроенной функции size
		int b = true_variants->size();

		// и в цикле проверим каждое из значений массива true_variants
		// на соответствие 
		while (a < b) {

			// создадим условие, если значение
			// передаваемое в качестве параметра (аргумента)
			// соответствует нашему теоретическому значению
			// из мультипеременной (к конкретному значению мы
			// обращаемся по индексу записи [], который берем
			// из переменной счетчика), во вспомогательную переменную
			// tmp_return помещаем true, и завершаем цикл
			if (argument1 == true_variants[a])
			{
				tmp_return = true;
				a = b + 1;
			}

			// после каждого повтора увеличиваем счетчик на 1
			// чтобы таким образом перебрать все варианты
			a = a + 1;
		}

		// вернем значение из вспомогательной переменной
		return tmp_return;
	}

	//
	// 
	// нечто подобное можно сделать и для числовых данных
	// 
	//

	// чтобы не растягивать код еще больше опишем
	// обращения к данным в нашем типе данных
	// (в канонистических языках программирования есть
	// такое понятие как свойства, в этом подходе с++
	// нет (явно), поэтому мы опишем свойства "получить" и 
	// "изменить" в виде функций (сейчас непонятно что
	// это и как это полезно, и удобно, но со временем 
	// понимание придет)


	// опишем функцию для получения из нашего типа
	// содержимое в формате LPCWSTR, в качестве
	// параметра укажем тип данных, которые нужно
	// превратить в LPCWSTR и вернуть (параметром
	// будем передавать четко описанный текстовый
	// указатель
	LPCWSTR GetVariableValue(string call_back_type)
	{

		// создадим условие, если параметр,
		// передаваемый в функцию соответствует
		// слову boolean, выполняем возврат результата,
		// который получается в результате использования
		// функции BooleanTypeToString, в которой в качестве параметра
		// был передан параметр из скрытой переменной BooleanType, а результат
		// выполнения функции BooleanTypeToString был сразу передан
		// в качестве параметра в функцию TransformStringToWideString,
		// которая уже на свое место вернула результат (уже совей обработки 
		// результата) на место, где должны быть данные для выполнения возврата 
		// из этой функции, и в переменную LPCWSTRTextType
		if (call_back_type == "Boolean")
		{
			LPCWSTRTextType =
				TransformStringToWideString(
					BooleanTypeToString(BooleanType)
				);

			return
				TransformStringToWideString(
					BooleanTypeToString(BooleanType)
				);
		}

		// сделаем нечто подобное для строковой переменной
		if (call_back_type == "String")
		{
			LPCWSTRTextType =
				TransformStringToWideString(
					TextType
				);

			return
				TransformStringToWideString(
					TextType
				);
		}

		// вернем ничего, если
		// ни одно из условий не сработало
		LPCWSTRTextType = L"";
		return L"";
	}

	//
	//
	// далее должна быть аналогичная функция 
	// для определения из типа данных из LPCWSTRTextType,
	// конвертирования в соответствующий простой тип,
	// и перемещение в переменную, но так как тут уже 400
	// строчек кода (хотя я планировал уложиться в 100) 
	// рекомендую погуглить как ее реализовать
	//
	//

};

// классы (так называются наши типы данных), подразумевают
// такое явление как наследование решений, это позволяет 
// создать новый тип данных, но при этом использовать в качестве
// заготовки все содержимое типа данных, который является
// родителем этого, в данном примере я создаю MyChildrenUniversalType
// и через : (двоеточие) указываю в какую секцию этого класса
// поместить все решения из класса родителя (я выбрал private,
// чтобы все лишние функции не мешали при обращении к этому классу),
// далее идет название класса, который должен является родителем,
// таким подходом к программированию (это называется ООП) можно
// значительно упростить процесс для крупных программ, перенося
// уже готовые функции в другие классы, и использовать их когда нужно
class MyChildrenUniversalType : private MyVariableUniversalType {
public:

	// конструктор класса можно оставить пустым,
	// хотя можно было даже не описывать ни конструктор,
	// ни деструктор
	void MyVariableUniversalType() {

	}

	// еще одно полезное свойство класса
	// это создание множества функций под одним
	// ключевым словом (это называется перегрузка),
	// и позволяет в зависимости от ситуации (от набора 
	// параметров, которые были переданы в функцию) 
	// использовать разные решения, в данном случае я 
	// создаю несколько функций для конвертирования
	// текста (AnyTo), и задаю им разные аргументы,
	// чтобы во время вызова этой функции в коде не
	// возится с разными типами данных, пытаясь их
	// подвести под соответствие одного к другому
	LPCWSTR AnyTo(string Any_std_string) {

		// получить доступ к функции TransformStringToWideString
		// из другого типа данных мы можем благодаря секции protected,
		// она создана специально для того, чтобы все что находится внутри
		// секции не было видимо для всех, но было доступно для 
		// использования в дочерних классах
		return (LPCWSTR)TransformStringToWideString(Any_std_string);
	}

	LPCWSTR AnyTo(LPCSTR Any_LPCSTR) {
		return (LPCWSTR)Any_LPCSTR;
	}

	LPCWSTR AnyTo(char* Any_CHAR) {
		return (LPCWSTR)Any_CHAR;
	}
};

// новый уровень сложности, комментариев будет меньше

// эта строчка описана в первом этапе в самом начале
#pragma once 

// подключим библиотеки
#include "framework.h"
#include "windows.h"
#include "winuser.h"

// создадим наш тип данных, и опишем его сущность
// (на этот раз создадим кнопку)
class ObjectButton {
private:
	// поскольку целесообразность
	// "свойств класса" крайне условна
	// в с++ (и носит собой в основном
	// задачу избавить код от потенциальных
	// конфликтов с занятыми словами, под
	// какие-либо кунштюки, так как язык очень емкий, и
	// старый), опишем свойства в публичной секции
	// и сразу оттуда будем управлять объектом
public:

	// создадим простые числовые переменные
	// с которыми ассоциируем размеры и расположение
	// нашей кнопки на форме (ширину, высоту, отступ
	// из левого края окна программы, отступ
	// сверху окна программы)
	int Width = 100;
	int Height = 40;
	int Left = 10;
	int Top = 10;

	// код цвета для бордюра кнопки
	// и текста кнопки (аналогично для
	// ситуации, когда мышь над кнопкой)
	COLORREF BorderColor = RGB(0, 0, 0);
	COLORREF TextColor = RGB(0, 0, 0);
	COLORREF BorderActiveColor = RGB(120, 150, 120);
	COLORREF TextActiveColor = RGB(120, 150, 120);

	// переменную, где будет хранится текст
	// который мы будем отрисовывать на кнопке
	// (L перед текстом я использую, потому что
	// у компилятора и создаваемого приложения
	// разные кодировки), не заморачивайтесь,
	// просто делайте также
	LPCWSTR Caption = L"Button";

	// внутренние вспомогательные переменные
	// (вот их имеет смысл описать в приватной секции,
	// ну да ладно)
	int cfg_use_animation = 1;
	int cfg_enable_click_on_button = 1;
	int cfg_enable_border = 1;
	LPCSTR cfg_text_style = "Tahoma";
	int cfg_text_size = 18;
	int help_button_active_status = 0;
	int help_left_window_magrin_size = 8;
	int help_top_window_magrin_size = 51;
	int help_button_first_draw_status = 0;

	//
	//
	// далее опишем тело нашего типа данных (тело класса)
	//
	//


	// создадим "конструктор" для объекта
	// (эта функция будет вызывается, когда
	// мы будет создавать в переменную новый экземпляр
	// этого объекта)
	ObjectButton(int width, int height, int left, int top) {
		Width = width;
		Height = height;
		Left = left;
		Top = top;
	}

	// это "заголовок" функции, которая 
	// не определена, но должна быть у нашего
	// объекта кнопка (то есть эта заготовка,
	// на место которой мы поместим функцию,
	// которая будет выполнятся в момент нажатия
	// кнопки, а поскольку мы описываем тип данных
	// (шаблон), а не конкретную кнопку, мы не знаем
	// (пока) какой функционал будет у этой конкретной кнопки
	// (не обязательно вдавятся в подробности), но о назначении
	// звездочки я говорил в конце этапа 2)
	void(*ButtonClick)();

	// сразу же опишем функцию для проверки
	// координат, в которых происходит нажатие,
	// если координаты пересекаются с ожидаемым
	// расположением нашей кнопки, вызываем функцию
	// ButtonClick, о которой я говорил выше
	// (в качестве аргумента будет передавать уникальный
	// идентификатор окна программы, на которой будет находится
	// создаваемый нами объект кнопка)
	bool CheckMouseCoordinatesBeforeStartClickFunction(HWND form_link) {

		// создадим переменную, в которую
		// получим координаты мыши (текущие),
		// тип данных POINT, по сути, две числовых
		// переменных в одной (такой тип принимает
		// готовая функция для получения координат)
		POINT mouse_coordinates;

		// вызовем функцию (из библиотек),
		// которая позволяет получить в какую-либо переменную
		// текущие координаты мыши (в качестве параметра указываем
		// ранее созданную для этого переменную
		GetCursorPos(&mouse_coordinates);

		// создадим еще одну переменную (типа RECT,
		// он же квадрат, переменная состоит из 4 числовых
		// переменных в одной), именно такую переменную
		// принимает в себя готовая функция из библиотек
		// для получения размеров окна программы, и его
		// расположения на рабочем столе
		RECT program_size_and_position_on_screen;

		// вызовем функцию для получения размеров и позиции
		// окна программы (в качестве параметров указываем
		// идентификатор окна программы, и переменную, с 
		// которой можно ассоциировать результат выполнения функции)
		GetWindowRect(form_link, &program_size_and_position_on_screen);

		// создадим вспомогательную переменную,
		// в которой будем хранить состояние о статусе
		// кнопки (была ли вызвана функция по нажатию,
		// или нет)
		bool help_execute_status = false;

		// создадим "сложносоставное" условие (&& двойной амперсант это
		// логическое и, || а это логическое или),
		// если координаты мыши по оси Х (отступ слева)
		// меньше, чем отступ окна программы (отступ слева у окна), который был
		// приплюсован к отступу слева у кнопки (на форме, в переменной Left), 
		// и (&&) координаты мыши по оси Х меньше, чем отступ окна программы +
		// отступ конкретной кнопки на форме + ширина кнопки + 8 (пикселей бордюра
		// окна программы), тогда выполняем фрагмент кода внутри этого сложного условия
		if (
			mouse_coordinates.x > program_size_and_position_on_screen.left + Left
			&& mouse_coordinates.x < program_size_and_position_on_screen.left + Left + Width
			)
		{
			// выполняем еще одно условие (идентичное первому, но теперь для высоты,
			// то есть вместо Left -> Top, вместо Width -> Height), и таким образом
			// проверяем находится ли мышь в диапазоне от начала кнопки, до ее конца,
			// то есть в рамках размеров кнопки
			if (
				mouse_coordinates.y > program_size_and_position_on_screen.top + Top
				&& mouse_coordinates.y < program_size_and_position_on_screen.top + Top + Height)
			{
				// во вспомогательную переменную отправляем
				// (меняем) значение, которое будет сигнализировать что
				// функция CheckMouseCoordinatesBeforeStartClickFunction
				// вызвала функцию нажатия кнопки
				help_execute_status = true;

				// вызываем саму функцию (которую мы пока не знаем,
				// поэтому просто указываем заголовок этой теоретической
				// функции), но при условии, что в свойстве кнопки (переменной вверху)
				// с названием cfg_enable_click_on_button ассоциированно число 1
				if (cfg_enable_click_on_button == 1) {
					ButtonClick();
				}
			}
			else {
				help_execute_status = false;
			}
		}

		// возвращаем содержимое вспомогательной переменной со статусом нажатия
		return help_execute_status;
	}

	// опишем функцию, эта функция будет проверять находится ли мышь
	// над областью, где находится кнопка (по сути, дублирующийся функционал
	// с кнопкой нажатия, поэтому имеет смысл переписать ту функцию выше,
	// а в функции нажатия уже вызвать эту функцию для проверки координат)
	// отличие этой функции в том, что она может проверять по какой-либо одной 
	// оси, а не по обеим сразу
	bool CheckIsMouseOnThisButtonOrNo(HWND form_link, int axis_direction) {

		// дублируем код аналогично
		// представленному в функции нажатия
		POINT mouse_coordinates;
		RECT program_size_and_position_on_screen;
		//
		GetCursorPos(&mouse_coordinates);
		GetWindowRect(form_link, &program_size_and_position_on_screen);

		// но теперь создаем другую конструкцию условия,
		// если в параметре при вызове функции передано число 0
		// проверяем координаты только по оси Х, иначе по оси У
		if (axis_direction == 0) {

			// условие проверки координат по оси Х
			if (
				mouse_coordinates.x > program_size_and_position_on_screen.left + Left
				&& mouse_coordinates.x < program_size_and_position_on_screen.left + Left + Width
				) {

				// возвращаем истину, если проверка
				// пройдена
				return true;
			}
		}

		// конструкция else встречается впервые, это тот самый блочок кода, который выполняется
		// как альтернатива (если условие не выполнилось), для дополнения условия этим фрагментом,
		// надо просто удалить ; в конце основного условия, добавить слово else и развернуть тело
		// {} блока кода, но конструкция if может работать и без него
		else {

			// все то же самое только теперь по оси У
			if (
				mouse_coordinates.y > program_size_and_position_on_screen.top + Top
				&& mouse_coordinates.y < program_size_and_position_on_screen.top + Top + Height
				) {

				// возвращаем истину, если проверка
				// пройдена
				return true;
			}
		}

		// если проверки не завершили функцию,
		// соответственно координаты неправильные,
		// и завершаем функцию с false
		return false;
	}

	// опишем функцию, которая будет
	// отрисовывать текст (надпись на кнопке),
	// в качестве параметров передаем в функцию
	// указатель на область рисования, текст,
	// цвет отрисовки текста
	void DrawButtonText(HDC hdc, LPCWSTR text, COLORREF color)
	{

		// создаем вспомогательную переменную, с которой
		// ассоциируем результат создания стиля текста,
		// при помощи функции (из библиотек) CreateFontA,
		// функция принимает в себя очень много параметров
		HFONT hFont;

		// ассоциируем с нашей переменной результат
		// выполнения функции для создания нашего 
		// стиля шрифта, при этом в качестве параметров
		// имени шрифта и размера шрифта указываем наши
		// переменные со свойствами стиля текста, остальное
		// оставляем по умолчанию
		hFont = CreateFontA(
			cfg_text_size, // задаем высоту в em
			cfg_text_size / 3, // ширину (в em), делим на 3 от размера текста
			0, // градус наклона (вращение текста)
			0, // градус угла плоскости (наклон горизонта, от которого высчитывается градус наклона)
			FW_NORMAL, // толщина символов (тонкий, средний, толстый, очень толстый и тд)
			false, // рисовать курсивом (да или нет)
			false, // подчеркивать
			false, // зачеркивать
			OUT_DEFAULT_PRECIS, // указатель степени подгона шрифта под заданные параметры
			CLIP_DEFAULT_PRECIS, // указатель степени обрезки букв, которые вылезают за пределы своей области
			DEFAULT_CHARSET, // указатель кодировки для символов
			DEFAULT_QUALITY, // общее качество отрисовки (применения сглаживания, обводки, и тд)
			DEFAULT_PITCH | FF_DONTCARE, // отступ между символами (передаю сразу два 
			// параметра, через условную "запятую", второй
			// параметр указывает может ли расстояние между 
			// символами быть постоянным, или любым,
			// в параметре указано любое расстояние)
			cfg_text_style // имя шрифта
		);

		// вызываем функцию, которая привяжет
		// созданный нами шрифт с областью рисования,
		// в качестве параметров передаем идентификатор области
		// рисования, и наш стиль шрифта
		SelectObject(hdc, hFont);

		// создаем вспомогательную переменную типа SIZE
		// (две числовых переменных в одной), в которую будем
		// получать размер текста в пикселях, для конкретной
		// области рисования (формы программы), из библиотечной
		// (готовой функции)
		SIZE help_text_size;

		// получаю размеры текста в пикселях (в качестве параметров
		// область рисования, текст, размер строки (в байтах)),
		// в переменную, с которой нужно ассоциировать результат выполнения
		// этой функции (help_text_size)
		GetTextExtentPoint32(hdc, text, lstrlen(text), &help_text_size);

		// вызываем другую готовую функцию, эта функция
		// меняет цвет, которым будет напечатан текст,
		// в качестве параметра передаем указатель на область рисования
		// (нашу форму), и цвет текста (из аргумента color)
		SetTextColor(hdc, color);

		// вычисляем середину области кнопки, чтобы
		// отрисовать текст "по центру", для этого из ширины 
		// и высоты кнопки (разделенные на 2) вычитаем
		// ширину, и высоту текста (также разделенную на 2)
		// результат ассоциируем с переменными х и у
		int x = (Width / 2) - (help_text_size.cx / 2);
		int y = (Height / 2) - (help_text_size.cy / 2);

		// вызываем функцию для отрисовки текста на области рисования
		// в качестве параметров функция принимает область рисования,
		// отступ слева (от края формы), отступ сверху (от края формы),
		// текст для рисования, размер текста в байтах (текст берем из
		// второго параметра, получаемого при вызове функции)
		TextOut(hdc, Left + x, Top + y, text, lstrlen(text));
	}

	// теперь опишем функцию для отрисовки рамки у кнопки
	// для этого используем функцию SetPixel (позволяет
	// изменить цвет конкретного пикселя на области рисования),
	// используем циклы и размеры кнопки (из свойств объекта),
	// эта функция не возвращает никаких значений на место своего
	// вызова, поэтому тип данных у функции void (ничего), команда
	// return также не требуется, функция принимает параметры 
	// с указанием области рисования и цветом отрисовки
	void DrawButtonBorder(HDC hdc, COLORREF color) {

		// создадим условие, если значение свойства
		// cfg_enable_border равно 0, завершаем
		// выполнение функции еще до начала
		if (cfg_enable_border == 0)
		{
			return;
		}

		// создаем числовые переменные а и б, ассоциируя с ними
		// свойства объекта, но так чтобы можно было нарисовать
		// прямую линию в цикле, к примеру из верхней левой точки 
		// вправо, изменяя цвет каждого пикселя на пути, до тех пор
		// пока значение переменной старта (а, или левого верхнего края)
		// не станет равным (б, или левого верхнего края + ширина кнопки)
		int a = Left;
		int b = Left + Width;

		// вот пример
		// создаем цикл, до тех пор, пока, а меньше б повторяем код цикла
		while (a <= b) {

			// вызываем функцию изменения цвета пикселя, в качестве параметров
			// передаем указатель на область рисования, координаты оси х и у,
			// новый цвет пикселя (берем из color)
			SetPixel(hdc, a, Top, color);

			// эта упрощенная форма записи a = a + 1;
			// созданная специально для циклов
			a++;
		}

		// аналогичным образом протягиваем линию из правого
		// верхнего края вниз по размеру высоты кнопки
		a = Top;
		b = Top + Height;

		while (a <= b) {
			SetPixel(hdc, Left + Width, a, color);
			a++;
		}

		// еще одну из левого нижнего края, по ширине
		a = Left;
		b = Left + Width;

		while (a <= b) {
			SetPixel(hdc, a, Top + Height, color);
			a++;
		}

		// и последнюю из левого верхнего края по высоте
		a = Top;
		b = Top + Height;

		while (a <= b) {
			SetPixel(hdc, Left, a, color);
			a++;
		}
	}

	// теперь опишем функцию для отчистки области рисования
	void ClearButtonDraw(HWND hwnd) {

		// создадим вспомогательную переменную, с которой
		// ассоциируем координаты и размеры области нашей кнопки,
		// эта переменная нужна для готовой функции, которая очистит
		// область (переменная RECT это 4 числовых переменных в одной)
		RECT help_button_coordinates_and_size;

		// наполняем переменную из свойств нашей кнопки
		// (из значения Left мы вычитаем отступы меню
		// (которое было сгенерировано + бордюр окна, 19 и 32 пикселей),
		// слева вычитаем бордюр окна, 8 пикселей), для того чтобы
		// удалить всю рамку кнопки, вылезаем за 1 пиксель
		// для right и botton (конструкция help_left_window_magrin_size - 1)
		help_button_coordinates_and_size.left = Left - (help_left_window_magrin_size);
		help_button_coordinates_and_size.top = Top - (help_top_window_magrin_size);
		help_button_coordinates_and_size.right = (Left + Width) - (help_left_window_magrin_size - 1);
		help_button_coordinates_and_size.bottom = (Top + Height) - (help_top_window_magrin_size - 1);

		// вызываем функцию очистки
		// (ВАЖНО! даже если указать строго
		// область для стирания, функция
		// все равно сделает невалидной
		// всю область окна программы,
		// соответственно необходимо перерисовать
		// все объекты, но не всегда, типичная
		// наследованная функция с неполной
		// обратно совместимостью), в качестве 
		// параметров область для рисования,
		// координаты (прямоугольник) области
		// стирания, третий параметр ответ на вопрос о
		// стирании
		InvalidateRect(hwnd, &help_button_coordinates_and_size, TRUE);
	}

	// опишем функцию анимации при наведении курсора
	// в качестве параметров функция будет принимать идентификатор
	// окна программы, и указатель на область рисования
	void ActiveButtonAnimate(HWND hwnd, HDC hdc) {

		// создаем условие, которое вызывает нашу функцию для
		// проверки координат мыши, и ее пересечения области кнопки
		if (
			CheckIsMouseOnThisButtonOrNo(hwnd, 0) == true
			&& CheckIsMouseOnThisButtonOrNo(hwnd, 1) == true
			) {
			// добавим условие, завязанное на вспомогательном свойстве объекта
			// оно позволит отрисовывать кнопку один раз при наведении курсора,
			// и один раз при покидании курсором области кнопки (суть в 4 условиях,
			// то есть может быть 4 разных состояния (курсор над кнопкой, но 
			// help_button_active_status равно 0, курсор над кнопкой, но 
			// help_button_active_status равно 1 и тд)
			if (help_button_active_status < 1) {

				// рисуем рамку с цветом из свойств объекта
				DrawButtonBorder(hdc, BorderActiveColor);

				// рисуем текст с цветом из свойств нашего объекта
				DrawButtonText(hdc, Caption, TextActiveColor);

				// изменяем значение вспомогательной переменной на активный
				help_button_active_status = 1;
			}
		}
		// если курсор не над кнопкой проверяем установлено ли
		// help_button_active_status в 1, если да, перерисовываем
		// кнопку не активным, а простым (основным) цветом
		else {
			if (help_button_active_status > 0) {

				// рисуем рамку с цветом из свойств объекта
				DrawButtonBorder(hdc, BorderColor);
				// рисуем текст с цветом из свойств нашего объекта
				DrawButtonText(hdc, Caption, TextColor);
				// изменяем значение вспомогательной переменной на активный
				help_button_active_status = 0;
			}
		}
	}

	// напишем последнюю функцию, это будет функция конструктора
	// на самом деле у нас уже есть функция конструктора (одноименная
	// с названием типа данных, в самом начале), но так как у нас
	// последовательный для чтения код, опишем еще раз
	void Create(HWND hwnd, HDC hdc) {

		// создаем условие (с помощью вспомогательного свойства
		// нашего класса), благодаря которому выполняем функцию
		// Create только один раз после создания объекта, в любой
		// удобный момент
		if (help_button_first_draw_status == 0) {
			help_button_first_draw_status = 1;
		}
		else {
			// так как функция ничего не возвращает на свое место, команду return
			// используем для того, чтобы прервать выполнение функции, в случае
			// если значение вспомогательного свойства help_button_first_draw_status
			// не равно 0 (то есть функция уже была выполнена ранее)
			return;
		}
		// рисуем рамку с цветом из свойств объекта
		DrawButtonBorder(hdc, BorderColor);

		// рисуем текст с цветом из свойств нашего объекта
		DrawButtonText(hdc, Caption, TextColor);
	}

	// это упрощенная функция для отрисовки линий по "перемещению пера",
	// то есть мы сначала перемещаем в какие-то координаты условную точку
	// начала отрисовки, и из нее протягиваем линию в другу точку, потом 
	// снова перемещаем и тд, я просто оставлю это здесь
	void DrawLine(HDC hdc, COLORREF color, int x_from, int y_from, int x_to, int y_to) {

		MoveToEx(hdc, x_from, y_from, NULL);
		LineTo(hdc, x_to, y_to);

	}
};

// подключаем библиотеки
#pragma once 
#include <iostream>
#include <fstream>
#include "windows.h"
#include "winuser.h"
#include "winbase.h"
#include <string> 
#include "stddef.h"
#include <Strsafe.h>
#include <vector>
using namespace std;

// теперь заключительный этап создание кода,
// с минимумом комментариев, и максимумом 
// терминологии (для придания "каноничности"
// нашей программе)
class ObjectTextFileLoader {

    // для простоты понимания объясню один момент,
    // мало кто помнит, но точно также как function, 
    // if, while, switch, и тд, являются 
    // "заголовками конструкций", private секция
    // в классе является заголовком класса, а public его
    // телом (по аналогии с {телом конструкций}), и реализацией
private:

    // путь к файлу
    LPCWSTR HFilePath;

    // оригинальное содержимое файла
    string HText;

    // массив строк файла, так как в с++ нет такого понятия 
    // как "безразмерный массив", который можно было бы
    // дополнить, определим переменную типа vector (из 
    // библиотеки std), она подразумевает под собой аналог массива
    std::vector<std::string> HStringsList;

public:


    // конструктор класса (функция, которая выполняется
    // в момент создания нового экземпляра объекта)
    ObjectTextFileLoader(LPWSTR file_path)
    {
        // перенесем путь к файлу (из аргумента функции)
        // в свойство FilePath (переменную в классе, или
        // конкретном экземпляре объекта)
        HFilePath = file_path;
    }

    // загрузка и чтение файла, для этого мы используем
    // функцию CreateFileW, которая подготовит файл для чтения
    // 
    LPSTR LoadFromFile(LPCWSTR file_path)
    {
        HFilePath = file_path;

        // открываем файл универсальной командой для создания,
        // перезаписи файла
        HANDLE original_file = CreateFileW(HFilePath, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

        // создаем переменную file_size типа DWORD (разновидность
        // числовой переменной, для работы с двоичными числами),
        // с переменной ассоциируем результата выполнения функции
        // GetFileSize, чтобы получить размер загружаемого файла
        // в битах
        DWORD file_size = GetFileSize(original_file, NULL);

        // создаем вспомогательные переменные
        // для чтения данных из файла, и переноса
        // в переменную внутри программы,
        // для этого создаем числовую переменную
        // current_read_position (нужна для функции
        // ReadFile, для реализации частичного, или
        // последовательного (полного) чтения файла),
        // в данном случае переменная не используется,
        // но обязательна для функции
        DWORD current_read_position = 0;

        // создаем вспомогательный обработчик для создания
        // переменной tmp_result, с которым ассоциируем результат
        // выделения памяти в программе, размером в file_size,
        // при этом сразу заполняем выделенную память нулями
        HGLOBAL handler_tmp_result = GlobalAlloc(GHND, file_size);

        // фиксируем выделенный фрагмент памяти (для защиты от
        // использования в других решениях, внутри нашей программы),
        // в качестве временного хранилища (то есть для сохранения
        // целостности загружаемых из файлов данных), который сразу 
        // описываем как тип данных LPSTR (функция ReadFile
        // может принимать в себя любой тип данных переменной,
        // в которую нужно направлять прочитанное)
        LPSTR tmp_result = (LPSTR)GlobalLock(handler_tmp_result);

        // вызываем функцию ReadFile (в качестве аргументов передаем
        // переменную с "файловым потоком", хранилище для перемещения считанных
        // данных, общие количество байтов, которые нужно прочитать, позицию, с
        // которой нужно начинать чтение (мы загружаем содержимое
        // файла целиком, и сразу помещаем в переменную tmp_result, но лучше
        // выполнять фрагментированное чтение (с фиксированным количеством
        // байтов, читаемых за 1 вызов функции, к примеру 1024) через промежуточную
        // переменную, в цикле (чтобы сразу интерпретировать, или дешифровывать
        // прочитанные данные), последней аргумент (NULL), предназначен для случаев,
        // когда файл открыт не в режиме чтения, а с мультидоступом (чтение, запись,
        // изменение другими программами, и тд), для смещения в соответствующую
        // позицию байт
        ReadFile(original_file, tmp_result, file_size, &current_read_position, NULL);

        // разблокируем, ранее зафиксированный кусок памяти, так как
        // переменная уже наполнена (использовать ее просто невозможно)
        GlobalUnlock(handler_tmp_result);

        // закрываем файловый поток, так как файл больше не нужен
        CloseHandle(original_file);

        // вернем результат
        HText = tmp_result;

        // выводим сообщение
        MessageBox(NULL, TEXT("Текст был загружен из файла"), TEXT("Показать содержимое из текста"), 0);
        return tmp_result;

    }

    // добавим функцию для конвертирования строки string в строку LPCWSTR,
    // на самом деле у нас уже есть такая функция (в другом классе), но
    // так как функция не большая, ничего страшного не случиться если ее 
    // продублировать (кроме того, архитектура нашей программы не предполагает
    // использование компонентов программы между собой, так как программа
    // спроектированна по схеме зависимостей "все к одному")
    LPCWSTR ConvertToLPCWSTR(string a) {
        LPWSTR tmp_return = new WCHAR[a.length()];
        MultiByteToWideChar(
            CP_ACP,
            MB_ERR_INVALID_CHARS,
            a.c_str(),
            a.size(),
            tmp_return,
            a.length()
        );
        tmp_return[a.length()] = 0;
        return tmp_return;
    }

    // добавим функцию для добавления
    // текста в конец оригинального
    // содержимого файла
    void Append(string text)
    {
        // используем стандартную функцию
        // из класса string
        HText.append(text);
    }

    // добавим функцию для получения
    // конкретной буквы, исходя из индекса 
    // этой буквы в тексте
    string GetOneLetterByIndex(int letter_index)
    {
        string tmp_return = "";
        // for это разновидность цикла, внутри позволяет
        // сразу определить счетчик, условие, и операция для повтора
        for (int i = 0; i < HText.length(); i++)
        {
            // если индекс счетчика равен
            // индексу аргумента возвращаем результат
            // и завершаем цикл
            if (i == letter_index)
            {
                tmp_return = HText[letter_index];
                i = HText.length();
            }
        }
        return tmp_return;
    }

    // добавим функцию для добавления новых строк
    // в HStringsList
    void AddEnd(int count)
    {
        // получаем в переменную текущее количество
        // строк в HStringsList, к которому добавляем
        // count
        int a = Count() + count;

        // имзеняем размер на новый
        HStringsList.resize(a);
    }

    // добавим функцию для получения количества строк в HStringList
    int Count()
    {
        return HStringsList.size();
    }

    // добавим функцию для показа на экране
    // содержимого конкретной строки
    void ShowStringText(int string_index)
    {
        // вызываем диалоговое окно, в котором отображаем
        // содержимое строки из текста
        MessageBox(NULL, ConvertToLPCWSTR(HStringsList[string_index]), TEXT("Показать содержимое из текста"), 0);
    }

    // создадим функцию для разбора
    // текста файла по отдельным строкам
    void DetouchInToStringList()
    {
        //
        //
        // Сначала получаем количество строк из текста
        // (было бы проще сделать для этого отдельную функцию)
        //
        //

        // создаем переменную счетчик строк из текста
        int strings_count = 0;

        // если хранилище текста пустое
        // завершаем функцию
        if (HText.empty() == true)
        {
            // exit аналог прерывания функции
            // (ну точнее return выполняется
            // аналогично exit, но не суть)
            exit;
        }

        // создадим переменные для цикла
        int a = 0;
        int b = HText.length();

        // запускаем цикл (это инвертированный цикл),
        // он создан чтобы действия внутри цикла 
        // были выполнены хотя бы один раз, даже
        // если условие цикла не выполняется
        do {
            
            // если код символа (текущей буквы) соответствует коду
            // ключевого слова, которое означает символ (символ n 
            // через косую черту, я говорил об этом раньше "\n")
            // переноса на новую строку, выполняем код условия
            // (на самом деле это два кода #10+#13, 10 завершение
            // строки, 13 новая строка)
            if (HText[a] == 13)
            {
                strings_count = strings_count + 1;
            }
            a++;
        } while (a < b);

        // по завершении цикла добавляем последнюю строку
        strings_count = strings_count + 1;

        //
        //
        // Теперь когда мы знаем количество строк в оригинальном тексте
        // изменяем размер HStringsList, вырезаем из текста переносы строк
        // и перемещаем этот текст в соответствующие строки массива HStringsList
        //
        //

        // переопределим количество строк в HStringsList
        HStringsList.resize(strings_count);

        // создаем (переопределим, они уже созданы) переменные
        a = 0;
        b = HText.length();

        // первый символ текста теряется (не понятно куда,
        // предположу кривизна компилятора, или программы в 
        // работе с памятью), поэтому добавим его
        string c = GetOneLetterByIndex(0);
        int d = 0;

        // запускаем цикл 
        do {

            // если код символа соответствует коду
            // ключевого слова, которое означает символ (\n)
            // переноса на новую строку, выполняем код условия
            if (HText[a] == 13)
            {
                // помещаем значение в строку в массиве строк
                HStringsList[d] = c;
                c = "";
                d++;
            }
            a++;

            // помещаем символ в переменную, которая
            // собирает строку, но при условии, что код символа
            // не соответствует символу переноса на новую строку
            if (HText[a] != '\n')
            {
                c = c + HText[a];
            }
        } while (a < b);

        // заполняем последнюю строку, так как
        // наша переменная strings_count содержи количество
        // строк, а счет массива HStringsList начинается с 0,
        // чтобы получить индекс последней строки strings_count - 1
        HStringsList[strings_count - 1] = c;
    }

    // создадим функцию для изменения
    // значений в HStringsList
    void ChangeInString(int index, string new_value)
    {
        HStringsList[index] = new_value;
    }

    // создадим функцию для получения содержимого строки
    string Strings(int index)
    {
        return HStringsList[index];
    }

    // и ее альтернативу для LPCWSTR
    LPCWSTR StringsA(int index)
    {
        return ConvertToLPCWSTR(HStringsList[index]);
    }

    // создадим функцию для сохранения файла
    void SaveToFile(LPCWSTR file_path)
    {
        // создаем вспомогательные переменные
        string tmp_buffer = "";
        int a = 0;
        int b = Count() - 1;

        // запускаем цикл для сборки
        // нового содержимого файла
        // из HStringsList
        while (a < b)
        {
            tmp_buffer = tmp_buffer + HStringsList[a] + "\n";
            a++;
        }

        // так как в последней строке указатель новой строки не нужен
        // добавляем последнюю строку без него
        tmp_buffer = tmp_buffer + HStringsList[a];

        // конвертируем новое содержимое в LPCWSTR (других функций под рукой нет)
        LPCWSTR tmp_result = ConvertToLPCWSTR(tmp_buffer);

        // получаем количество байтов для записи
        DWORD file_size = tmp_buffer.length() * sizeof(wchar_t);

        // создаем переменную (счетчик записанных байтов)
        DWORD current_read_position = 0;

        // создаем файловый поток (теперь GENERIC_WRITE в режиме записи)
        HANDLE original_file = CreateFileW(file_path, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

        // записываем в файл все за один раз (так лучше не делать)
        WriteFile(original_file, tmp_result, file_size, &current_read_position, NULL);

        // закрываем файловый поток
        CloseHandle(original_file);

        // вызываем сообщение
        MessageBox(NULL, TEXT("Текст был записан в файл"), TEXT("Показать содержимое из текста"), 0);
    }
};

// WindowsProject1.cpp : Определяет точку входа для приложения.
//

// этот кусок можно пропустить
// директива pragma once подразумевает
// исключение логического бага в программе,
// который может произойти из-за команды для
// подключения библиотек (файлов с заготовками кода)
// include, которая просто вставляет на свое место
// все содержимое файла, который был указан
// (включая и команды include внутри подключаемого
// файла) при вызове, из за чего могу возникать логические
// ошибки и множественные самоподключения (когда
// одна библиотека ссылается на вторую, а вторая на
// первую), в двух словах все исходники собираются
// в одни длинный исходный код (командами include),
// а команда pragma once удаляет все дубликаты,
// оставляя только самую первую include,
// лично я начинаю любой файл с pragma once,
// что бы не беспокоится о зависимостях, но это
// не обязательно (кароче пока не заморачивайтесь)
#pragma once 

// и начать отсюда
// подключаем вспомогательные библиотеки
// наборы готового кода как в этом файле, 
// где уже описанные какие-то функции (заготовки) для
// реализации и запуска нашей программы
#include "framework.h"
#include "WindowsProject1.h"
#include "windows.h"
#include "winuser.h" 
#include <string> 
#include <stdlib.h>  
using namespace std;

#include "Source.cpp"
#include "Source1.cpp"
#include "Source2.cpp"

// определим вспомогательный термин 
// (читай создадим разновидность переменной)
// под названием MAX_LOADSTRING и ассоциируем
// с ней число 999, теперь везде в коде, где 
// будет встречается термин MAX_LOADSTRING
// он будет заменятся на 999
#define MAX_LOADSTRING 999

// Глобальные переменные:
// 
// hInst это глобальная переменная экземпляра нашей программы
HINSTANCE hInst;                                // текущий экземпляр

// я сделаю глобальную переменную для простоты понимания
// с которой ассоциирую уникальный идентификатор нашего окна
// программы
HWND Form1;

// создадим новую переменную типа наша кнопка,
// с которой ассоциируем результат создания 
// нового экземпляра объекта (звездочка (*)
// после ObjectButton обозначает (для компилятора)
// что мы не вызываем одноименную функцию из файла Source1.cpp,
// а обращаемся к типу данных ObjectButton, после чего уже
// вызываем конструктор с функцией ObjectButton (не нужно сейчас над этим
// заворачивается все придет со временем)

// Создадим еще несколько объектов кнопка
ObjectButton* lbl_text_hello = new ObjectButton(400, 50, 150, 200);
ObjectButton* btn_change_windows_size = new ObjectButton(150, 50, 50, 320);
ObjectButton* lbl_text_hide_button = new ObjectButton(550, 50, 210, 380);
ObjectButton* btn_show_message = new ObjectButton(150, 50, 50, 440);
ObjectButton* btn_exit = new ObjectButton(150, 50, 50, 560);

ObjectButton* btn_load_file = new ObjectButton(150, 50, 50, 380);
ObjectButton* btn_save_file = new ObjectButton(150, 50, 50, 440);
ObjectButton* btn_show_file = new ObjectButton(150, 50, 50, 500);
ObjectButton* btn_add_one = new ObjectButton(150, 50, 210, 500);

// теперь создадим новый экземпляр нашего объекта ObjectTextFileLoader
ObjectTextFileLoader* TextLoader1 = new ObjectTextFileLoader((LPWSTR)L"test.txt");

// создадим функцию, которая будет меня положение окна программы,
// и размер окна программы, в качестве параметров в функцию будем
// передавать размер окна программы (двумя параметрами - ширина и высота)
void execute_application_postion_and_size(HWND Form, int width, int height) {

    // системная функция ожидания
    // в качестве параметра принимает
    // период ожидания в мс (1000 
    // соответствует 1 секунде)
    Sleep(1000);

    // создадим переменные, с которыми ассоциируем
    // результат выполнения функции для получения
    // информации о компьютере, с параметров SM_CXSCREEN,
    // требующим ширину экрана в пикселях
    int screen_width = GetSystemMetrics(SM_CXSCREEN);

    // аналогично для высоты экрана
    int screen_height = GetSystemMetrics(SM_CYSCREEN);

    // создадим две переменные, с новыми размерами окна
    int program_width = width;
    int program_height = height;

    int program_left = (screen_width / 2) - (program_width / 2);
    int program_top = (screen_height / 2) - (program_height / 2);

    // изменим положение окна (при помощи готовой функции),
    // разместив окно по центру экрана
    SetWindowPos(
        Form,
        HWND_TOP,
        program_left,
        program_top,
        program_width,
        program_height,
        SWP_ASYNCWINDOWPOS
    );
}
// опишем ее альтернативный вариант без аргументов
void execute_application_postion_and_sizeA() {
    execute_application_postion_and_size(Form1, 1024, 700);
}

// опишем вспомогательную функцию для начальной отрисовки
void ExecuteMyBotton(ObjectButton* btn, HDC Canvas) {
    if (btn->help_button_first_draw_status == 0) {
        btn->Left = btn->Left - 8;
        btn->Top = btn->Top - 51;
        btn->Create(Form1, Canvas);
        btn->Left = btn->Left + 8;
        btn->Top = btn->Top + 51;
    }
}

// опишем функцию выхода из программы              
void ExitFromProgram() {

    // вызовем функцию для завершения программы,
    // все программы во всех системах (на всех языках)
    // завершаются кодом 1, в случае завершения без
    // сбоев, и 0 (со сбоями)
    PostQuitMessage(1);
}

// опишем функцию для загрузки файла test.txt из
// папки с программой (если файл находится в одной
// директории с программой не надо указывает полный путь)
void LoadFileFromComputer()
{ 

    // создадим переменную пути
    // я использую путь к моему файлу на диске
    // (прямой), потому что для указания релитивного
    // пути нужyа библиотека, которой нет в стандартном
    // проекте программы (который создан в стандарте
    // с++ 14), в то же время функции из библиотеки 
    // shellapi не представляется возможным использовать 
    // так как они не имеют полной обратной совместимости
    // с windows 10 и ограничения на размер пути, 
    // такой вот порочный круг, а еще мне лень, поэтому так,
    // насколько я помню вызов стандартного диалога выбора
    // файла решает эту проблему (но эт не точно, так как я
    // использую другой язык (в повседневности), а с++ (нативным)
    // давно не работаю, двойной \\ слеш в пути потому 
    // что символ \ зарезервирован редактором для ключевых обозначений
    string file_path = "D:\\a\\test.txt";
     
    // загрузим файл   
    TextLoader1->LoadFromFile((LPWSTR)TextLoader1->ConvertToLPCWSTR(file_path));

    // разберем на строки
    TextLoader1->DetouchInToStringList();
}

// опшием функцию для сохранения файла test.txt
void SaveToFileInComputer()
{
    // создадим переменную с путем к файлу
    LPWSTR fp = (LPWSTR)L"D:\\a\\test.txt";

    // сохраним файл
    TextLoader1->SaveToFile(fp);
}

// создадим функцию для отображения содержимого 
void ShowContent()
{
    // соберем текст в переменную, 
    // выполним текстовую конкатенацию 
    // (от слова контакт),
    // функция std::to_string позволяет 
    // трансформировать число в строку
    string a = "Содержимое строки #" + std::to_string(TextLoader1->Count()) + " - " + TextLoader1->Strings(TextLoader1->Count() - 1);

    // вызовем диалог с сообщением
    MessageBox(NULL, TextLoader1->ConvertToLPCWSTR(a), TEXT("Показать содержимое из текста"), 0);
}

// создадим функцию для добавления строки в конец файла
void AddOneString()
{
    // добавим 1 строку в конец HStringList
    TextLoader1->AddEnd(1);

    // создадим переменную для текста строки
    string a = "New String #" + std::to_string(TextLoader1->Count());

    // изменим содержимое последний строки на содержимое переменной а
    TextLoader1->ChangeInString(TextLoader1->Count() - 1, a);

    // вызовем диалог с сообщением
    MessageBox(NULL, TEXT("Добавлена 1 строка в конец файла!"), TEXT("Показать содержимое из текста"), 0);
}

// в общем то создаем пару переменных типа "буквенный массив",
// и сразу задаем его длину в параметре [MAX_LOADSTRING]
WCHAR szTitle[MAX_LOADSTRING];                  // Текст строки заголовка
WCHAR szWindowClass[MAX_LOADSTRING];            // имя класса главного окна

// Отправить объявления функций, включенных в этот модуль кода:
// 
// эти вспомогательные функции сейчас не важны, по сути, они просто "нормализуют"
// нашу программу для системы, создают новый экземпляр окна (из заготовок в системе) 
// и добавляют мониторинг действий (нет смысла вдаваться в подробности, и забивать голову)
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);

// создаем функцию
// эта функция принимает в себя несколько параметров,
// это "точка входа", когда программа запускается, она 
// автоматически начинает выполнять эту функцию
//
// эта функция будет обеспечивать связь системы и нашей программы
// при помощи бесконечного цикла, который повторяется до тех пор, 
// пока программа запущена, и перехватывает сообщения от системы
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_WINDOWSPROJECT1, szWindowClass, MAX_LOADSTRING);

    // адаптируем нашу программу для системы при помощи функции
    // MyRegisterClass, в качестве параметра передаем идентификатор
    // нашего окна программы, который получаем из текущей функции 
    // (wWinMain) в параметре hInstance
    MyRegisterClass(hInstance);

    // Выполнить инициализацию приложения:

    // создаем условие, если функция вернула на место своего вызова
    // значение false, вызываем встроенное в идею функций ключевое слово
    // return, при встрече которого любая функция прекращает построчное выполнение
    // кода, и возвращаем ложь в функции wWinMain (в место вызова функции)
    if (!InitInstance(hInstance, nCmdShow))
    {
        return FALSE;
    }


    // это вспомогательный код для отлова событий нажатия клавиш,
    // ассоциируем с переменной hAccelTable (типа HACCEL) результат
    // выполнения функции LoadAccelerators, сама функция извлекает из
    // ресурсов нашего файла готовые схемы сочетания клавиш и названия функций
    // для этих сочетаний
    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_WINDOWSPROJECT1));

    // создадим переменную типа MSG (сложносоставной тип данных) под названием MSG
    // в эту переменную будут попадать команды, которые в цикле будут перехватываться 
    // универсальной функцией GetMessage
    MSG msg;

    // Цикл основного сообщения:

    // создаем цикл, до тех пор пока GetMessage, с пустыми параметрами 
    // (2,3,4, не нужно вдавятся сейчас в подробности почему)
    // возвращает какой-либо результат (в переменную msg) 
    // выполняем код в теле цикла
    //
    // важный момент, почему &msg (ассоциация значений), а не
    // просто msg (присвоение значений)? потому что если создать 
    // "условный" объект кнопка, задать ему какие-либо параметры, 
    // после чего создать еще один, и попробовать скопировать параметры 
    // простым присвоением, присвоены будут не параметры кнопки, 
    // а сама кнопка (объект), следовательно просто кнопка один 
    // будет также доступна под названием кнопка два
    while (GetMessage(&msg, nullptr, 0, 0))
        // это начало тела цикла
    {
        // нестандартная конструкция условия, она подразумевает
        // простую логику, если не "!" результат выполнения функции
        // TranslateAccelerator (функция для горячих клавиш)
        // то выполняем код в условии, иначе говоря, если 
        // нажатая клавиша не выполнила функцию, которая ей
        // назначена, то выполняем код условия, а именно обрабатываем 
        // горячую клавишу (не обязательно вдавятся в подробности 
        // нам сейчас это не нужно)
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            // код обработки нажатий горячих клавиш
            // которые были указаны в схеме, которая
            // была загружена из ресурсов ранее
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    // это конец тела цикла

    // возвращаем результат выполнения функции
    // в качестве подстановочного значение 
    // (которое встает в никуда) возвращаем параметры 
    // последней команды GetMessage
    return (int)msg.wParam;
}



//
//  ФУНКЦИЯ: MyRegisterClass()
//
//  ЦЕЛЬ: Регистрирует класс окна.
//

// выше уже была упомянута эта функция, она адаптирует
// в рамках системы нашу программу, вот, собственно, само 
// содержимое это функции, оно нам не интересно, двигаемся дальше
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(IDI_WINDOWSPROJECT1));
    wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wcex.lpszMenuName = MAKEINTRESOURCEW(IDC_WINDOWSPROJECT1);
    wcex.lpszClassName = szWindowClass;
    wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

    return RegisterClassExW(&wcex);
}

//
//   ФУНКЦИЯ: InitInstance(HINSTANCE, int)
//
//   ЦЕЛЬ: Сохраняет маркер экземпляра и создает главное окно
//
//   КОММЕНТАРИИ:
//
//        В этой функции маркер экземпляра сохраняется в глобальной переменной, а также
//        создается и выводится главное окно программы.
//

// я думаю из сгенерированных комментариев понятно, для чего эта функция
// так же выше было сказано об этой функции, ее тоже можно пропустить
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
    hInst = hInstance; // Сохранить маркер экземпляра в глобальной переменной

    // разве что вот ключевая функция для создания окна, которая называется
    // CreateWindow (с модификатором W, то есть одна из вариаций этой функции)
    // и возвращает идентификатор на место своего вызова, который мы ассоциируем
    // с глобальной переменной, в которой держим уникальный идентификатор нашего окна
    // программы
    HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);

    // добавим условие, если "не hWnd" (то есть
    // нет ассоциированного объекта) возвращаем FALSE
    // и завершаем выполнение функции
    if (!hWnd)
    {
        return FALSE;
    }

    // после создания окна программы вызываем функции для отображения
    // окна программы и его перерисовки
    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);

    return TRUE;
}

//
//  ФУНКЦИЯ: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  ЦЕЛЬ: Обрабатывает сообщения в главном окне.
//
//  WM_COMMAND  - обработать меню приложения
//  WM_PAINT    - Отрисовка главного окна
//  WM_DESTROY  - отправить сообщение о выходе и вернуться
//
//
// еще одна сгенерированная функция, эта функция подвязывается
// к нашей форме, и обрабатывает события нашей формы (к примеру
// изменение размера окна, тык мышкой, активность формы и тд)
// это основная функция нашей программы
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    // добавим ассоциацию идентификатора окна программы
    // с нашей глобальной переменной, в которой храним
    // указатель на идентификатор
    Form1 = hWnd;

    // switch разновидность условия, не совсем понятно
    // целесообразность использования альтернативного
    // условного конструктора, поскольку то же самое 
    // можно было описать и конструкцией if (но предположу
    // что несмотря на то что switch не является "канонистической 
    // конструкцией, она обеспечивает одно единственное выполнение
    // условия, затем завершает, это может обеспечивает стабильность,
    // избегая множественных срабатываний на одну команду message)

    // в данном случае условие обрабатывает сообщения,
    // которые получает из GetMessage, в соответствии
    // с определенным содержимым message (который передается
    // в параметрах функции), и если значение message соответствует
    // какой либо конструкции case, выполняет этот фрагмент кода
    switch (message)
    {
        // не стоит забывать про зажатую Ctrl и левый тык мышкой
        // это перекинет в файл, где описано это ключевое слово
        //
        // WM_COMMAND это универсальное событие обработки команд
        // (к примеру отправленных через SendMessage)	
        case WM_COMMAND:
        {
            // тут обработка элементов меню
            // сами элементы в ресурсах файла, 
            //сгенерированы автоматически
            int wmId = LOWORD(wParam);
            // Разобрать выбор в меню:
            switch (wmId)
            {
            case IDM_ABOUT:
                DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
                break;
            case IDM_EXIT:
                DestroyWindow(hWnd);
                break;
            default:
                return DefWindowProc(hWnd, message, wParam, lParam);
            }
        }
        break;
        //
        // 
        // дополним наш код новым условием обработки
        // если message соответствует значению WM_LBUTTONDOWN
        // выполняем код в условии (WM_LBUTTONDOWN левый тык мышки)
        //
        //
        // это событие создания окна программы
        // в нем ассоциируем со свойством нашего объекта кнопка (под
        // названием ButtonClick, ссылку на функцию, которую мы недавно 
        // описали, а также настраиваем другие нужные параметры)
        case WM_CREATE: {
            execute_application_postion_and_size(Form1, 900, 700);

            btn_change_windows_size->ButtonClick = &execute_application_postion_and_sizeA;
            btn_change_windows_size->Caption = TEXT("Изменить размер окна");

            lbl_text_hello->Caption = TEXT("Я у мамки программииииист!");
            lbl_text_hello->cfg_enable_border = 0;
            lbl_text_hello->cfg_text_size = 48;
            lbl_text_hello->TextColor = RGB(126, 134, 231);


            lbl_text_hide_button->Caption = TEXT("<- Нажми Esc чтобы скрыть эту кнопку и Q чтобы снова показать!");
            lbl_text_hide_button->cfg_enable_border = 0;
            lbl_text_hide_button->cfg_text_size = 24;
            lbl_text_hide_button->TextColor = RGB(126, 190, 231);

            btn_exit->Caption = TEXT("Выход");
            btn_exit->TextColor = RGB(255, 52, 9);
            btn_exit->BorderColor = RGB(255, 52, 9);
            btn_exit->ButtonClick = &ExitFromProgram;

            btn_load_file->Caption = TEXT("Открыть файл");
            btn_load_file->ButtonClick = &LoadFileFromComputer;

            btn_show_file->Caption = TEXT("Последняя строка");
            btn_show_file->ButtonClick = &ShowContent;

            btn_save_file->Caption = TEXT("Сохранить");
            btn_save_file->ButtonClick = &SaveToFileInComputer;

            btn_add_one->Caption = TEXT("Добавить строку");
            btn_add_one->ButtonClick = &AddOneString;
        }
        break;

        // добавим событие нажатия кнопки клавиатуры
        // (есть несколько состояний, нажимается, зажата, отпускается),
        // внутри события добавим код, который будет проверять полученное
        // (в wParam) значение, во время вызова события WM_KEYDOWN
        case WM_KEYDOWN: {

            // создаем условие, если нажата клавиша Esc,
            // удаляем с экрана кнопку
            if (wParam == VK_ESCAPE)
            {
                btn_load_file->ClearButtonDraw(Form1);
            }

            // добавим еще одно
            // 
            // если функция (из библиотек), дял получения
            // текущей нажатой клавиши с заданным кодом клавиши Q (0x51)
            // вернула код, соответствующий состоянию нажатия и удерживания,
            // снова отрисовываем кнопку (при помощи изменения вспомогательного
            // свойства help_button_active_status, которое намеренно устанавливаем
            // в 1, чтобы функция (ActiveButtonAnimate) подумала, что сейчас кнопка 
            // отрисаована в активном состоянии), получив область рисования при помощи
            // другой функции из библиотек (GetWindowDC), конструкция условия
            // использует & потому что мы ассоциируем битовые данные (коды состояния
            // клавиш), а компилятор не способен это трансформировать в логическое условие
            // соответствия (==), функция GetAsyncKeyState возвращает на место своего вызова
            // код, дополняющий 0x8000 таким образом чтобы вместе они сделали 0x0001, или
            // битовое выполнение конструкции условия, через параметр истины (отправку кода
            // "истины" в условие), соответствующий истине в архитектуре конструкции if (не надо над 
            // этим заморачиваться и забивать себе голову)
            if (0x8000 & GetAsyncKeyState(0x51)) {
                HDC hdc = GetWindowDC(Form1);
                btn_load_file->help_button_active_status = 1;
                btn_load_file->ActiveButtonAnimate(Form1, hdc);
            }

        }
        break;

        // добавим событие срабатывающие при перемещении
        // мыши, в него добавим функцию, которая вызывает
        // проверку и анимацию кнопки, так как наша функция требует
        // в себя область рисования, получаем идентификатор
        // области рисования в переменную соответствующего типа
        // по результату вызова функции GetWindowDC (в которую
        // передаем идентификатор окна программы)
        case WM_MOUSEMOVE: {
            HDC hdc = GetWindowDC(Form1);
            btn_change_windows_size->ActiveButtonAnimate(Form1, hdc);
            btn_exit->ActiveButtonAnimate(Form1, hdc);

            btn_load_file->ActiveButtonAnimate(Form1, hdc);
            btn_show_file->ActiveButtonAnimate(Form1, hdc);
            btn_save_file->ActiveButtonAnimate(Form1, hdc);
            btn_add_one->ActiveButtonAnimate(Form1, hdc);
        }
        break;

        // добавим событие, выполняющееся при нажатии левой кнопки мыши
        // внутри события добавим срабатывание функции 
        // CheckMouseCoordinatesBeforeStartClickFunction
        case WM_LBUTTONDOWN: 
        {
            btn_change_windows_size->CheckMouseCoordinatesBeforeStartClickFunction(Form1);
            btn_exit->CheckMouseCoordinatesBeforeStartClickFunction(Form1);
             
            btn_load_file->CheckMouseCoordinatesBeforeStartClickFunction(Form1);
            btn_show_file->CheckMouseCoordinatesBeforeStartClickFunction(Form1);
            btn_save_file->CheckMouseCoordinatesBeforeStartClickFunction(Form1);
            btn_add_one->CheckMouseCoordinatesBeforeStartClickFunction(Form1);
        }
        break;

        // если условие соответствует событию отрисовки выполняем код внутри
        case WM_PAINT:
        {
            // создаем переменную типа параметры
            // области рисования
            PAINTSTRUCT ps;

            // создаем переменную типа область рисования
            // и ассоциируем с ней результат выполнения функции
            // BeginPaint (в параметрах которой передаем
            // идентификатор нашего окна, и ассоциируем данные
            // из переменной с параметрами
            HDC hdc = BeginPaint(hWnd, &ps);

            // добавим условие, если значение свойства
            // help_button_first_draw_status равно 0,
            // значит функция Create еще никогда не выполнялась,
            // после создания нового экземпляра объекта, выполним
            // ее, при этом вычитая размеры бордюра и меню, так как
            // событие отрисовки формы вызывается много раз,
            // в том числе до того, как буду объявлены объекты меню и
            // бардюра окна программы
            if (lbl_text_hello->help_button_first_draw_status == 0) {
                lbl_text_hello->Left = lbl_text_hello->Left - 8;
                lbl_text_hello->Top = lbl_text_hello->Top - 51;
                lbl_text_hello->Create(Form1, hdc);
                lbl_text_hello->Left = lbl_text_hello->Left + 8;
                lbl_text_hello->Top = lbl_text_hello->Top + 51;
            }

            // чтобы не дублировать код исключения (описан сверху),
            // и не вмешивается в целостность нашего класса кнопки
            // имеет смысл описать функцию, которая будет в себя
            // принимать переменную с объектом кнопка, и в функции
            // делать тоже самое, а в месте, где нужен этот код
            // вставим эту функцию
            ExecuteMyBotton(btn_change_windows_size, hdc);
            ExecuteMyBotton(lbl_text_hello, hdc);
            ExecuteMyBotton(lbl_text_hide_button, hdc);
            ExecuteMyBotton(btn_exit, hdc);

            ExecuteMyBotton(btn_load_file, hdc);
            ExecuteMyBotton(btn_show_file, hdc);
            ExecuteMyBotton(btn_save_file, hdc);
            ExecuteMyBotton(btn_add_one, hdc);


            // TODO: Добавьте сюда любой код прорисовки, использующий HDC...
            // завершаем процесс рисования,
            // вызывая специальную функцию
            EndPaint(hWnd, &ps);
        }
        break;

        // если переменная message 
        // содержит WM_DESTROY
        // выполняем код для завершения
        // работы приложения
        case WM_DESTROY:
            PostQuitMessage(0);
            break;
            // если message не содержит никаких сообщений
            // (или сообщения не соответствуют ни одному из условий)
            // выполняем другой код, функцию, которая гарантирует обработку
            // "неопределенного" message, она нас тоже пока не интересует
            // (но может понадобится, так как мы можем ее "переописать",
            // для каких-либо наших задач)
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
        }


        // вернем результат выполнения функции 0
        // можно изменить на 1 чтобы мониторить 
        // работоспособность программы, исходя
        // из возвращаемого значения этой функции
        // (то есть если функция WndProc выполнилась
        // и не вернула на место вызова 1, значит
        // какое то решение не работает, для этого
        // просто можно создать переменную (в начале
        // блока кода, с которой ассоциировать что
        // нибудь (к примеру 0), и если функция смогла
        // выполнить свой код до этой позиции, возвращяем 1
    return 0;
}

// Обработчик сообщений для окна "О программе".
// аналогично только не для основного окна программы,
// а для диалога "Об программе", его разбирать смысла нет
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}