Загрузка...
 

Создание приложений (С++, Win32)


Содержание

Введение

В 80-90-х годах XX века игрокодеры полагались только на свои навыки программирования под MS DOS (если игра разрабатывалась под эту ОС), стремясь любыми путями получить плавное движение игровой анимации.1. В те времена Windows являлась операционной системой, ориентированной на бизнес-приложения. Но никак не на игры.
Ситуация изменилась с выходом ОС MS Windows 95 и появлением первых версий DirectX.

Под платформой Win32 подразумеваются все 32-разрядные (32-битные) операционные системы семейства MS Windows (9x/NT/2000/XP/Vista/7). На тему программирования под MS Windows написана не одна сотня книг (многие из которых на русском языке). Настоятельно рекомендуется прочитать хотя бы пару из них. Не факт, что всё усвоишь, но основные моменты всё равно запомнишь.

Программирование под Windows

Для создания приложений под ОС MS Windows необходимо:

  • Компьютер с установленной ОС Windows.
  • Компилятор языка.

В нашем случае C++. Удобнее использовать интегрированную среду разработки (ИСР, IDE), в состав которой входит нужный компилятор. Хороший пример - MS Visual C++ 2010. О том, где её взять и как установить читай здесь: Устанавливаем Microsoft Visual C plus plus 2010 Express.

  • Windows SDK (Software Development Kit).

Обычно всего устанавливается в наборе с MS Visual C++. Содержит необходимые заголовочные файлы и библиотеки для создания Windows-приложений. Компания Microsoft прилагает немало усилий для того, чтобы ОС Windows была удобной и стабильной платформой, доступной для программирования. Собственно для этого и был придуман Microsoft SDK, представляющий собой набор стандартов, на основе которых должны создаваться Windows-приложения. Одним из таких стандартов является стандарт оформления кода (Coding covention).

Стандарт оформления кода (Coding convention)

...от Microsoft весьма объёмен. Не нужно во всём строго ему следовать. Но рациональное зерно в нём есть. Цель данного стандарта - приучить программеров к единообразному объявлению переменных, однотипному написанию имён функций, указанию типов... Стандарт призван повысить читабельность исходного кода, который в крупных компаниях разрабатывается (и, следовательно, должен быть понят) группой программеров.

Венгерская нотация (Hungarian Notation)

Соглашения по написанию кода от Microsoft включают в себя свод указаний по объявлению переменных, названный впоследствии Венгерской нотацией (в честь своего венгерского создателя Чарльза Симоний (Charles Simonyi)). Этот без преувеличения гениальный метод предлагает обозначать имена переменных специальными префиксами, отражающими соответствующие типы данных. В литературе по Windows-программингу авторы стараются придерживаться Венгерской нотации. Но, тем не менее, строго ей не придерживаются. Вот далеко не полный список данных префиксов:

Префикс Тип данных Пример
f Boolean BOOL fFlag;
b Byte char bVariable;
dw Double word (long) long dwValue;
h 32-bit идентификатор экземпляра (handle) long hWindow;
i Integer int iNumber;
p Pointer void *pData;
I Interface IUnknown *IInterface;
g_ Global char g_GlobalVariable;
m_ Member short m_MemberData;

Работа со "странными" типами данных Windows

Пожалуй самое сложное в изучении Windows-программировании - это усвоение специфических типов данных, встречающихся в каждом оконном приложении.2 Один из наиболее часто встречающихся типов - handle, представляющий собой уникальный номер, присваиваемый окнам либо его объектам (значок, кнопка, заголовок и т.д.). Хэндлы очень важны, т.к. окна и его объекты часто перемещаются внутри системной памяти Windows, т.е. их адрес постоянно изменяется. Хэндл предоставляет объекту постоянную ссылку, не зависящую от реального расположения объекта в памяти. Хэндлы используются повсеместно в Win32 API.
Помимо этого Win32 API предоставляет множество уникальных типов данных (data types), которые на первый взгляд вообще не похожи на типы данных. Их главной особенностью является то, что их имена всегда пишутся заглавными (большими) буквами.
Поэтому их легко найти в исходном коде. Пример: RECT, HWND. Тип HWND представляет собой хэндл (handle) окна.
Для того, чтобы начать работать типами данных Win32, в исходный код необходимо подключить специальный заголовочный файл:

#include <windows.h>

(Идёт в наборе с любой IDE под Windows.)
Наиболее часто применяемые типы данных Windows:

Макрос Описание
BOOL Булево значение (TRUE или FALSE).
BYTE 8-битное целое число без знака (unsigned int).
DWORD 32-битное целое число без знака (unsigned long).
LONG 32-битное целое число сознаком (signed long).
LPARAM 32-битное значение, передаваемое в качестве параметра в оконную процедуру (window procedure) или функцию обратного вызова (callback function).
WPARAM Значение, передаваемое в качестве параметра в оконную процедуру (window procedure) или функцию обратного вызова (callback function).
LPCSTR 32-битный указатель на неизменяемую строку символов (constant character string).
LPSTR 32-битный указатель на строку символов (character string).
LPVOID 32-битный указатель на неуказанный тип (unspecified type).
LRESULT 32-битное значение, возвращаемое из оконной процедуры (window procedure) или функции обратного вызова (callback function).
UINT 32-битное беззнаковое целое в Win32 (unsigned integer).
WNDPROC 32-битный указатель на оконную процедуру (window procedure).
WORD 16-битное беззнаковое целое (unsigned short).

Базовое приложение Windows

Базовое приложение:

  • Проект, содержащий в себе минимальную, необходимую для работы (простого отображения окна) функциональность.
  • Имеет минимальный объём исходного кода. Часто весь исходный код содержится в единственном файле (традиционно он называется Main.cpp или WinMain.cpp).
  • Служит "отправной точкой" для создания любых других приложений (включая компьютерные игры) путём добавления в него различных функций, переменных, классов и т.д.
  • Иногда в литературе его также называют шаблоном Windows-приложения.


Для создания базового приложения в MS Visual C++ (все версии) существуют специальные мастера (wizards). Для вызова списка этих мастеров достаточно создать новый проект, выбрав в Главном меню IDE Файл->Создать->Проект. После ввода имени Проекта и нажатия <ОК>, Мастер приложений последовательно покажет окно приветствия и окно Параметры приложения, в котором (для автоматической генерации исходного кода) в разделе Дополнительные параметры необходимо снять флажок с пункта "Пустой проект". Вся процедура (на примере создания консольного приложения) неплохо описана здесь(external link). После этого созданный Проект можно просмотреть, отредактировать или сразу отправить на компиляцию (F5).

Закрыть
noteПримечание

Генерируемый MS Visual C++ исходный код базового приложения далёк от идеала (он состоит из 4 и более файлов, включает в себя дополнительные аргументы, "крайне необходимые" по мнению разработчиков IDE) и не является единственно правильным. Более того, исходный код базового приложения сильно разнится в разных изданиях и учебных курсах. Все эти версии, в общем-то, равноценны (по быстродействию, эффективности и т.д.). Главное здесь - чтобы код был минимален по объёму и доступен для понимания даже начинающим программистам. Та же ситуация с оконными базовыми приложениями (только вариантов кода здесь значительно больше). Во всех случаях рекомендуется начинать новый проект с "Пустого проекта" и потом уже самостоятельно добавлять в него необходимые исходные и заголовочные файлы.


Все приложения Windows делятся на 2 основных типа:

  • Консольные приложения(external link). Внешне они выглядят как программы с текстовым интерфейсом, но способны обращаться к большинству функций Windows. Практически не изменились со времён MS-DOS: всё те же серые строки символов на чёрном фоне. В OS Windows консольные приложения обычно запускают из Командной строки (Пуск->Все программы->Стандартные->Командная строка), которая тоже является консольным приложением. В MS Windows 98 Командная строка называется Сеанс MS-DOS.
  • Оконные приложения. Собственно, для чего и задумывалась MS Windows, начиная с её первой версии. Окна могут изменять свои размеры, приобретать и терять фокус, перекрывать друг друга. Также они имеют стандартные атрибуты: кнопки "Свернуть", "Развернуть", "Закрыть"; строку заголовка; строку состояния и т.д. Все современные игры для ОС MS Windows также являются оконными приложениями (как правило, развёрнутыми на весь экран).

Консольное базовое приложение

Исходный код простейшего консольного приложения содержится в одном файле (в нашем случае это Main.cpp) и выглядит так:

Листинг 1. Main.cpp
int main()		// Главная функция программы
{
return 0;		// Функция типа int обязана вернуть какое-либо значение
}

Да, это весь код.)) Приложение, ведь, ничего не делает. Нам даже не понадобилось подключать заголовочные файлы с помощью директивы #include.
Скомпилируем его. Для этого:

  • Запустим MS Visual C++ 2010 (подойдут и другие версии этой IDE) и cоздадим новый проект, выбрав в Главном меню IDE Файл->Создать->Проект.

О том, как установить MS Visual C++ 2010 читаем здесь.

  • В окне "Создать проект" выбираем мастер: "Консольное приложение Win32", в строке "Имя" пишем название проекта (в нашем случае Test01). Строки "Расположение" и "Имя Решения" заполняются автоматически (при необходимости изменяем). Жмём "OK", "Далее".

Image

  • На странице "Параметры приложения": оставляем "Консольное приложение" и отмечаем пункт "Пустой проект". Жмём "Готово".

Image
Проект создан. Так как это "Пустой проект", он не содержит в себе никаких файлов. В левой части расположен "Обозреватель решений". Если его нет, в главном меню выбираем: Вид->Другие окна->Обозреватель решений. Или комбинация горячих клавиш Ctrl+Alt+L. В Обозревателе решений видна древовидная структура Проектов, входящих в данное Решение. Чуть ниже названия Проекта видим специально заготовленные папки (в MSVC++2010 они называются "фильтры") для файлов Проекта:
Таблица 1

Внешние зависимости Чаще всего здесь размещаются заголовочные файлы различных сторонних библиотек. Причём, они представлены здесь в виде ссылок. "Физически" файлы, как правило, находятся за пределами каталога Проекта и не являются его частью. Содержимое каталога "Внешние зависимости" (если внимательно посмотреть, то он тоже является своеобразным ярлыком или ссылкой) генерируется автоматически в процессе линковки и поиска так называемых внешних "зависимых" библиотек.
Заголовочные файлы Содержит заголовочные файлы Проекта (.h).
Файлы исходного кода Содержит исходные файлы Проекта (.cpp).
Файлы ресурсов Содержит так называемые "бинарные" ресурсы (формы, иконки, звуки и т.д.)
  • Правой кнопкой мыши по фильтру "Файлы исходного кода" -> во всплывающем меню выбираем: Добавить -> Создать элемент.

Image

  • В окне "Добавление нового элемента" отмечаем "Файл C++ (.cpp)" и в строке "Имя" вводим Main. Жмём "Добавить".

Image
Добавленный файл Main.cpp сразу же открывается в редакторе кода.

  • Последовательно вводим все строки исходного кода из Листинга 1, представленного чуть выше (без номеров строк на сером фоне). Настоятельно рекомендуется вводить код вручную (не с помощью копировать/вставить), - только так можно научиться программировать (лучше запоминаешь структуру исходного кода, ключевые слова C++ и, конечно, привыкаешь ставить символ ";" в конце каждой строки).
  • Запускаем компиляцию (кнопка с зелёным треугольником на Панели инструментов или <F5> на клавиатуре).

Image
Скомпилированная программа при запуске в среде Windows на долю секунды покажет чёрное окно консоли и сразу закроется.

Немного изменим нашу программу, добавив возможность выводить на экран текстовое сообщение:

Листинг 2. Main.cpp
// Базовое консольное приложение Windows
// Выводит строку текста на экран

#include <iostream>	// Подключаем заголовочный файл iostream.h из недр MS Visual C++.
//Без него функция std::cout не будет работать.

int main()		// Главная функция программы
{
	std::cout << "Hello, world!";	// выводим сообщение на экран

	return 0;		// Функция типа int обязана вернуть какое-либо значение
}

Комментарии при компилировании отбрасываются, так что, в принципе, они могут быть любыми. Комментируй всё, что только можно в своём коде, - и ты сам, и твои последователи скажут тебе потом спасибо.

  • Снова компилируем Проект.

По окончании компиляции мы также лишь на мгновение увидим окно программы, так и не увидев текстовую строку. Чтобы её всё-таки увидеть, запустим программу через интерпретатор командной строки, который есть во всех версиях MS Windows:

  • Пуск->Все программы->Стандартные->Командная строка.
  • Проводником открываем каталог с исполняемым (Test01.exe) файлом программы, расположенном в нашем случае по адресу: C:\Users\<Имя пользователя>\Documents\Visual Studio 2010\Projects\Test01\Debug.
  • Перетаскиваем мышью Test01.exe в открытое окно Командной строки и жмём <Enter>.

Image
В итоге: Консольные приложения очень просты в программировании, но не стоит их недооценивать. Вывод текста на экран - это лишь верхушка айсберга тех возможностей, которыми они обладают. Консольные приложения могут содержать в себе функции, классы, переменные. Их часто используют в математических расчётах и как программное "ядро", в дополнение к которому создают оконное приложение, которое пользуется его функционалом.

Оконное базовое приложение (WinAPI)

Вся суть Windows-программирования заключается в двух шагах:

  • Разработать внешний вид окна (его расположение на экране, наличие кнопок, строк редактирования и др. элементов).
  • Оснастить окно функциональностью.

Исходный код простейшего оконного приложения:

  • Может сильно отличаться в разных источниках. Во всех случаях на выходе (после компиляции) будем иметь одно и то же приложение, показывающее окно.
  • Можно разместить в одном файле, не считая подключения внешних заголовочных файлов.

Что мы и сделаем. Один из вариантов исходного кода выглядит так (реально компилируется в MSVC++2010 при указании в настройках Проекта пункта "Набор символов: Использовать многобайтовую кодировку"):

Листинг 3. Main.cpp
// Файл: Main.cpp 
// Описание: Шаблон оконного приложения Windows. Простейшее (базовое) приложение Windows,
// выводящее на экран окно.
// www.igrocoder.ru 2015
// При использовании просьба указывать ссылку на источник.

#define STRICT
#define WIN32_LEAN_AND_MEAN	// Уменьшаем кол-во используемых компонентов в программе.

#include <windows.h>
#include <windowsx.h>

// Объявление оконной процедуры
LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

// Реализация главной функции программы
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
	HWND hWnd;			// Дескриптор окна
	MSG msg;			// Структура сообщения

	WNDCLASSEX wndClass;	// Объявляем экземпляр класса программы на базе WNDCLASSEX

   // Заполняем структуру оконного класса
	wndClass.cbSize=sizeof(wndClass);
	wndClass.style=CS_CLASSDC;	// Поочерёдный доступ к контексту устройства (Device Context)
	wndClass.lpfnWndProc=WindowProc;		// Оконная процедура
	wndClass.cbClsExtra=0;
	wndClass.cbWndExtra=0;
	wndClass.hInstance=hInstance;			// Экземпляр окна
	wndClass.hIcon=LoadIcon(NULL, IDI_APPLICATION);		// Пиктограмма приложения
	wndClass.hIconSm=LoadIcon(NULL, IDI_APPLICATION);	// Малая пиктограмма приложения
	wndClass.hCursor=NULL;		// Курсор при наведении на окно
	wndClass.hbrBackground=GetStockBrush(BLACK_BRUSH);	// Закрашиваем окно чёрным цветом
	wndClass.lpszMenuName=NULL;							// Дескриптор Главного меню окна. Сейчас оно не нужно
	wndClass.lpszClassName="GameClass"; // Обзываем оконный класс.
	
	// Если класс не зарегистрируется, досрочно прерываем выполнение программы
	if(!RegisterClassEx(&wndClass)) return FALSE;

	// Создание окна на основе зарегистрированного класса
	hWnd=CreateWindowEx(
		WS_EX_TOPMOST,		// Дополнительный стиль окна
		"GameClass",		// Класс окна.
		"My game title",			// Текст заголовка (на верхнем тулбаре).
		WS_OVERLAPPEDWINDOW,		// Обычное окно с кнопками в правом верхнем углу.
		0, 0,					// Координаты X и Y
		GetSystemMetrics(SM_CXSCREEN),	// Ширина окна
		GetSystemMetrics(SM_CYSCREEN),	// Высота окна
		NULL,							// Дескриптор родительского окна
		NULL,							// Дескриптор меню
		hInstance,						// Дескриптор экземпляра приложения
		NULL);							// Дополнительные данные

	if(hWnd==NULL) return(FALSE);

	// Собственно, показываем окно
	ShowWindow(hWnd, nCmdShow);
	UpdateWindow(hWnd);

	// Очищаем структуру сообщения
	ZeroMemory(&msg, sizeof(MSG));

	// Процедура выборки сообщений
	// Продолжаем бесконечно, пока не получим сообщение WM_QUIT (завершение).
	while(msg.message != WM_QUIT)
	{	// Просмотрим очередь: вдруг там ожидает сообщение...
		if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
	{
		// Есть сообщение! Обработаем его как обычно...
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
		else
		{
			// Нет сообщений, ожидающих обработки.
			// Значит приступим к выполнению критичных ко времени операций.
			// Например, займёмся рендерингом.
		}
	}

	//Удаляем регистрацию класса
	UnregisterClass("GameClass", hInstance);
	
	// Выходим из приложения
	return (msg.wParam);
}

// Оконная процедура
LRESULT CALLBACK WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch(msg)
	{
	case WM_DESTROY:			// В случае этого сообщения...
		PostQuitMessage(0);		// Говорим Windows закрыть приложение
		break;

		// В случае любых других сообщений...
	default: return DefWindowProc(hWnd, msg, wParam, lParam);
	}
	return 0;
}


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

Компилируем базовое оконное приложение

Прежде чем начать разбираться в коде, скомпилируем его. Для этого создадим новый Проект:

  • Запустим MS Visual C++ 2010 (подойдут и другие версии этой IDE) и cоздадим новый проект, выбрав в Главном меню IDE Файл->Создать->Проект.

О том, где взять и как установить MS Visual C++ 2010 читаем здесь.

  • В окне "Создать проект" выбираем: "Проект Win32", в строке "Имя" пишем название проекта (в нашем случае Test01). Строки "Расположение" и "Имя Решения" заполняются автоматически (при необходимости изменяем). Жмём "OK", "Далее".

Image

  • На странице "Параметры приложения": оставляем "Приложение Windows" и отмечаем пункт "Пустой проект". Жмём "Готово".

Image
Проект создан. Так как это "Пустой проект", он не содержит в себе никаких файлов. В левой части главного окна MS Visual C++ 2010 расположен "Обозреватель решений". (Если его нет, в главном меню выбираем: Вид->Другие окна->Обозреватель решений. Или комбинация горячих клавиш Ctrl+Alt+L.) В Обозревателе решений видна древовидная структура Проектов, входящих в данное Решение. Чуть ниже названия Проекта видим специально заготовленные папки (в MSVC++2010 они называются "фильтры") для файлов Проекта (см Таблицу 1).

  • В фильтр "Файлы исходного кода" добавляем файл Main.cpp, точно так, как это описано выше для консольного приложения.

Добавленный файл Main.cpp сразу же открывается в редакторе кода.

  • Вводим весь исходный код Листинга 3, показанного выше (без номеров строк на сером фоне) в только что созданный Main.cpp. Можно просто всё скопировать и вставить.


Устанавливаем многобайтовую кодировку (multibyte encoding)

Закрыть
noteПримечание

В MS Visual C++ 2010 в настройках по умолчанию стоит набор (кодировка) символов UNICODE. В MS Visual C++ 6.0 - напротив, по умолчанию стоит кодировка ANSI (многобайтовая). Данная настройка сильно влияет на типы используемых переменных, что приводит к заметным различиям в исходном коде.
Несмотря на то, что во всех случаях рекомендуется использовать кодировку UNICODE, поддерживаемую во всех современных ОС семейства MS Windows (начиная с Win 2000/XP), большинство книг по программированию игр на классическом C++ придерживаются именно многобайтовой кодировки. Чтобы сильно не переделывать исходные коды под UNICODE, все наши игровые Проекты мы настроим под многобайтовую кодировку. Для этого...

  • В Обозревателе решений щёлкаем по названию только что созданного Проекта Test01.
  • Во всплывающем меню выбираем "Свойства"
  • В появившемся окне установки свойств Проекта жмём "Свойства конфигурации", в правой части в строке "Набор символов" выставляем значение "Использовать многобайтовую кодировку".
  • Жмём ОК.

Image

Отключаем инкрементную компоновку (incremental linking)
Иначе при копиляции возможны ошибки вроде этой:

Error LNK1123: сбой при преобразовании в COFF: файл недопустим или поврежден
  • В Главном меню MS Visual C++ 2010 выбираем Проект -> Свойства.
  • В появившемся окне установки свойств Проекта жмём Свойства конфигурации -> Компоновщик -> Общие (Configuration Properties -> Linker -> General), в правой части в строке "Включить инкрементную компоновку" ставим значение "Нет (/INCREMENTAL:NO)".
  • Жмём ОК.


Компилируем проект

  • Скомпилируй Проект/Решение (кнопка с зелёным треугольником на Панели инструментов MSVC++ или <F5> на клавиатуре).

Image
Если весь код был введён без ошибок, после компиляции запустится приложение, отображающее окно с чёрным фоном. Большинство современных игр начинается на чёрном фоне.

Исследуем код

В исходном коде из Листинга 3 многие параметры можно измененять. Результаты изменения будут видны сразу после перекомпиляции (кнопка с зелёным треугольником на Панели инструментов MSVC++ или <F5> на клавиатуре). Например, изменим цвет фона окна с чёрного на серый. Для этого найди в исходном коде фрагмент, где мы заполняем структуру оконного класса:

<...>
	wndClass.hCursor=LoadCursor(NULL, IDC_ARROW);		// Курсор при наведении на окно
	wndClass.hbrBackground=GetStockBrush(BLACK_BRUSH);	// Закрашиваем окно чёрным цветом
	wndClass.lpszMenuName=NULL;							// Дескриптор Главного меню окна. Сейчас оно не нужно
	wndClass.lpszClassName="GameClass";
<...>

Согласно справочной системе MSDN(external link), параметр BLACK_BRUSH в строке wndClass.hbrBackground=GetStockBrush(BLACK_BRUSH) может принимать следующие значения:
Таблица 2

WHITE_BRUSH Белый фон окна.
BLACK_BRUSH Чёрный фон окна.
DKGRAY_BRUSH Тёмно-серый фон окна.
GRAY_BRUSH Серый фон окна.
HOLLOW_BRUSH Прозрачный цвет фона.
LTGRAY_BRUSH Светло-серый фон окна.

"Поиграй" с исходным кодом, подставляя разные значения параметра wndClass.hbrBackground и наблюдай за результатом после каждой перекомпиляции Проекта.
Как вариант, можно определить практически любой цвет, заменив эту строку кода на wndClass.hbrBackground=СreateSolidBrush(RGB(0,255,255)). Таким образом мы создали собственную "кисть" для закрашивания, определив параметры цвета в палитре RGB (Red, Green, Blue). Каждое из значений составного цвета (который получается путём смешивания красного, зелёного и красного компонентов в разных пропорциях) изменяется от 0 до 255.
Смотри-ка, ты уже без пяти минут Windows-программист! Дальше будет ещё интереснее.

Поначалу кажется, что в программе множество функций. Однако основных (главных) функции здесь две:

  • WinMain - аналог функции Main, обязательной для каждого консольного приложения. Является точкой входа в программу.
  • WindowProc - называется оконной процедурой(external link) (название WindowProc, в принципе, выбрано произвольно, но желательно чтобы оно было "говорящим"). Обеспечивает реальную функциональность приложения.

На эту тему неплохо написано здесь: http://gamesmaker.ru/programming/c/vvedenie-v-winapi-chast-pervaya-sozdanie-okna/(external link).
Остальные небольшие функции реализуют реакцию программы на различные сообщения.
Весь процесс создания оконного Windows-приложения состоит из нескольких шагов:

  1. Регистрируем класс окна в ОС MS Windows. Для этого объявляем структуру типа WNDCLASSEX, заполняем должным образом её поля, после чего вызываем функцию RegisterClassEx.
  2. Создаём на базе зарегистрированного класса окна конкретный экземпляр окна (в нашем случае "GameClass") при помощи функции CreateWindowEx.
  3. Выводим окно на экран при помощи функции ShowWindow. При необходимости вызываем оконную процедуру для обновления рабочей области функцией UpdateWindow.
  4. Запускаем цикл выборки сообщений.

Но обо всём по порядку.
В начале Листинга 3 первое, что мы делаем - это указываем пару макроопределений и подключаем заголовочные файлы:

Фрагмент листинга 3. Main.cpp
...
#define STRICT
#define WIN32_LEAN_AND_MEAN	// Уменьшаем кол-во используемых компонентов в программе.

#include <windows.h>
#include <windowsx.h>
...

Определения (define - от англ. "определить") специальных макросов перед включением файла windows.h служат для:

  • STRICT обеспечивает более строгую проверку типов. Например, при определённом STRICT компилятор выдаст сообщение об ошибке при присваивании объекта типа HBRUSH объекту типа HCURSOR. Если же STRICT не определён, то никакой ошибки компилятор не увидит. Таким образом можно обезопасить себя от некоторых распространённых ошибок, связанных с присваиванием объекту одного типа значения объекта другого типа (обычно вследствие невнимательности).
  • WIN32_LEAN_AND_MEAN уменьшает количество используемых компонентов и тем самым сокращает время на компиляцию и конечный размер исполняемого файла.

Заголовочные файлы и директива include

Заголовочный файл windows.h является обязательным для любой Windows-программы. Для предыдущих версий ОС MS Windows он содержал огромное количество объявлений типов, прототипов функций и т.д. Сейчас он включает в себя лишь ссылки на другие заголовочные файлы (их достаточно много). Налицо децентрализация и разбиение исходного кода на несколько независимых файлов-модулей.
windowsx.h является его расширенной версией. В нём также содержится множество полезных макросов и, в частности, распаковщики сообщений.
Оба этих "заголовка" расположены в одном из подкаталогов установленной MS Visual C++. Так, например, если открыть windows.h с помощью блокнота или любого другого текстового редактора, в нём можно обнаружить ссылку на другой заголовочный файл windef.h. В нём определены практически все специальные типы Windows, многие из которых встречаются в Листинге 3. Там также видим определения:

windef.h
...
#define CALLBACK		__stdcall
#define WINAPI				__stdcall
...

Функции CALLBACK и WINAPI будут вызываться с помощью __stdcall - стандартного метода вызова функций Win32, представляющего собой нечто среднее между __cdecl и __pascal (традиционные методы для MS-DOS-программ).
Часто типы, определённые в windef.h являются просто новыми именами для старых, хорошо знакомых типов. Например:

windef.h
...
typedef		unsigned long		DWORD;
typedef		int								BOOL;
typedef		int								INT;
typedef		unsigned int			UINT;
...

С другими, специфичными для Windows типами, такими как HWND, HCURSOR, HBRUSH и многими другими, всё сложнее.

Функция WinMain

  • Вызывается операционной системой и является точкой входа в программу (Вообще она вызывается некоей стартовой функцией из стандартной библиотеки C/C++, но сейчас это неважно).
  • Представляет собой аналог функции main, которую используют при создании консольных приложений.
  • Возвращает целое значение. В случае наличия цикла выборки сообщений(external link) это должно быть поле структуры msg.wParam. Если его нет, то возвращается 0 (или не 0).
  • Её прототип (шаблон с указанием типов аргументов) выглядит так:
int WINAPI WinMain(
 hINSTANCE hInst,  // Идентификатор экземпляра окна (Instance handle)
 HINSTANCE hPrevInst,  // Идентификатор экземпляра предыдущего окна (Previous Instance handle). Было актуально в Win 3.11. Сейчас не используется.
 LPSTR lpzCmdLine,  // Командная строка с опциями (если есть).
 int nCmdShow  // Флаг показа окна.
);
  • Спецификатор WINAPI в заголовке WinMain указывает на то, что используется способ вызова, принятый в Win32 API. Способы вызова отличаются, например, порядком передачи аргументов (их соответствие принятым в ОС соглашениям очень важно).

''Таблица 3. Параметры функции WinMain"

Параметр Значение
HINSTANCE hInst Дескриптор текущего экземпляра приложения. Имеет тип HINSTANCE.
HINSTANCE hPrevInst Дескриптор предыдущего экземпляра приложения (если есть). Имеет тип HINSTANCE. В приложениях Win32 всегда равен NULL.
LPSTR lpzCmdLine Содержит командную строку запущенного приложения (исключая название этого приложения), со списком дополнительных аргументов (если есть). Имеет тип LPSTR (в конце всегда должен стоять символ "0").
int nCmdShow Указывает на способ отображения главного окна программы.

Дескриптор экземпляра представляет собой уникальное значение и служит своеобразным идентификатором для поиска данной программы среди других запущенных приложений. Всякий раз при запуске оконного приложения Windows автоматически присваивает ему идентификатор экземпляра (instance handler), с помощью которого можно обращатся к процессу, созданному данным приложением. Самое ценное, что даёт идентификатор экземпляра - это возможность запускать несколько копий одного и того же приложения одновременно. При этом к ним надо как то обращаться. Обращение к ним как раз и проиходит через идентификатор экземпляра.
Windows-приложение может получать опции командной строки (command-line options; прямо как DOS-приложения). Оно получает их в виде указателя на строку (string pointer) lpCmdLine, которая парсится. В то же время параметры в Windows-приложениях довольно редки.
Последний параметр int nCmdShow может принимать следующие значения:
Таблица 4

Значение Описание
SW_SHOW Окно активируется, используя текущие значения размера и положения.
SW_MAXIMIZE Окно развёрнуто на весь экран (максимизировано).
SW_MINIMIZE Окно свёрнуто (минимизировано) и активировано следующее окно.
SW_SHOWMINIMIZED Окно сворачивается (отображается в виде кнопки на Панели задач).
SW_SHOWMAXIMIZED Окно разворачивается на весь экран.
SW_RESTORE Восстанавливает исходные размеры окна как после минимизирования, так и после разворачивания на весь экран.
SW_HIDE Окно скрывается и активизируется другое окно.
SW_SHOWNORMAL Окно активизируется и отображается на экране. Если оно было развёрнуто или свёрнуто, то восстанавливается прежнее состояние. По умолчанию именно этот флаг используется при первом вызове функции ShowWindow().
SW_SHOWNA Окно отображаетося как есть (с текущими установками размера и положения на экране). Данный флаг никак не влияет на окно, активное в данный момент.

На данном этапе мы заполнили данные, контролирующие выполнение приложения. После этого идёт процесс создания окна.

Заполняем структуру оконного класса

В ОС Windows при создании любого окна необходимо указать так называемый класс окна - специальную структуру, хранящуюся внутри ОС и задающую основные характеристики поведения всех окон своего класса. В то же время отличительные особенности каждого конкретного окна будут определены позднее, в момент его создания.

Сразу после объявления структуры (WNDCLASSEX wndClass;), начинаем заполнять все 12 её полей.

Закрыть
noteОбрати внимание

Структура данных WNDCLASSEX является немного расширенной версией своей предшественницы - WNDCLASS. В WNDCLASSEX появилось всего 2 новых элемента: cbSize (для указания размера структуры; здесь почти всегда стоит вызов функции sizeof(WNDCLASSEX)) и hIconSm (для указания малого значка приложения).


В Листинге 3 структура данных (data structure) WNDCLASSEX характеризует класс приложения, на базе которого будет создано окно программы:

Фрагмент Листинга 3. Main.cpp
...
// Реализация главной функции программы
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
	HWND hWnd;			// Дескриптор окна
	MSG msg;			// Структура сообщения
	WNDCLASSEX wndClass;	// Объявляем экземпляр класса программы на базе WNDCLASSEX
	wndClass.cbSize=sizeof(wndClass);
	wndClass.style=CS_CLASSDC;	// Поочерёдный доступ к контексту устройства (Device Context)
	wndClass.lpfnWndProc=WindowProc;		// Оконная процедура
	wndClass.cbClsExtra=0;
	wndClass.cbWndExtra=0;
	wndClass.hInstance=hInstance;			// Экземпляр окна
	wndClass.hIcon=LoadIcon(NULL, IDI_APPLICATION);		// Пиктограмма приложения
	wndClass.hIconSm=LoadIcon(NULL, IDI_APPLICATION);	// Малая пиктограмма приложения
	wndClass.hCursor=NULL;		// Курсор при наведении на окно
	wndClass.hbrBackground=GetStockBrush(BLACK_BRUSH);	// Закрашиваем окно чёрным цветом
	wndClass.lpszMenuName=NULL;							// Дескриптор Главного меню окна. Сейчас оно не нужно
	wndClass.lpszClassName="GameClass"; // Обзываем оконный класс.
}
...


Прототип структуры данных WNDCLASSEX выглядит так:

Прототип структуры данных WNDCLASSEX
typedef struct _WNDCLASSEX
{
	UINT	cbSize;
	UINT	style;
	WNDPROC	lpfnWndProc;
	int		cbClsExtra;
	int		cbWndExtra;
	HANDLE	hInstance;
	HICON	hIcon;
	HCURSOR	hCursor;
	HBRUSH	hbrBackground;
	LPCSTR	lpszMenuName;
	LPCSTR	lpszClassName;
	HICON	hIconSm;
} WNDCLASSEX;

Напомню, что тип данных UINT - это Unsigned Integer (беззнаковое целое). Это означает, что числа данного типа не могут быть отрицательными.
Рассмотрим описание полей структуры WNDCLASSEX:
Таблица 5

Поле структуры Назначение поля
cbSize Беззнаковое целое, в котором содержится размер структуры в байтах. В нашем случае в значении стоит служебная функция sizeof, самостоятельно подсчитывающая размер всей структуры wndClass.
style Беззнаковое целое, указывающее на стиль класса окна. Несколько стилей могут объединяться логической операцией ИЛИ (символ прямой вертикакльной черты "|"). Два самых распространённых стиля - CS_HREDRAW и CS_VREDRAW указывают на необходимость перерисовки окна при изменении его ширины и высоты. Стиль CS_DBLCLKS позволяет окну, созданному на базе этого класса, обрабатывать двойные щелчки мыши. Полный список значений смотри в Таблице 6.
lpfnWndProc Указатель на оконную процедуру (в нашем случае она называется WindowProc). Окна, созданные на базе одного класса, используют одну и ту же оконную процедуру. Именно поэтому прототип оконной процедуры был объявлен ПЕРЕД функцией WinMain.
cbClsExtra, cbWndExtra Дополнительные параметры оконного класса и окна соответственно. В теории здесь указывается число байт, дополнительно ("экстренно") выделяемых оконному классу и его окну соответственно. На практике данные флаги, в общем-то, нигде в программировании не используются. И в нашем случае оба параметра выставляем в 0.
hInstance Дескриптор окна приложения, внутри которого располагается оконная процедура для оконного класса. Значение берётся из первого параметра функции WinMain.
hIcon, hIconSm Дескрипторы значков класса окна (большого и малого). Малый значок отображается в заголовке окна и на кнопке в панели задач. Для загрузки ресурсов в обоих случаях используется функция LoadIcon, где первый параметр - дескриптор приложения, второй - имя ресурса, содержащего значок (иконку). В нашем случае дескриптор равен NULL. Значит в этом случае будут использоваться стандартные значки. Возможные значения второго праметра для стандартных ресурсов: IDI_APPLICATION, IDI_ASTERISK, IDI_ERROR, IDI_EXCLAMATION, IDI_HAND, IDI_INFORMATION, IDI_QUESTION, IDI_WARNING, IDI_WINLOGO.
hCursor Дескриптор курсора (указателя) мыши класса окна. Для загрузки соответствующего ресурса используется функция LoadCursor с параметрами, аналогичными LoadIcon. Если первый параметр равен NULL, то в качестве второго параметра могут использоваться стандартные ресурсы указателей мыши: IDC_ARROW, IDC_UPARROW, IDC_CROSS, IDC_IBEAM, IDC_APPSTARTING, IDC_WAIT, IDC_HELP, IDC_NO, IDC_SIZEALL, IDC_SIZENESW, IDC_SIZENS, IDC_SIZENWSE, IDC_SIZEWE.
hbrBackground Дескриптор кисти для заливки фона окна. В нашем случае стоит значение GetStockBrush(BLACK_BRUSH), которое заливает клиентскую область окна чёрным цветом.
lpszMenuName Указатель на строку с именем ресурса меню (lpsz означает, что эта строка всегда должна оканчиваться нулём). В нашем случае он равен NULL, то есть окно будет без меню.
lpszClassName Указатель на имя вновь создаваемого класса окна (lpsz означает, что эта строка всегда должна оканчиваться нулём). В нашем случае GameClass. Его мы передадим в качестве второго параметра функции CreateWindowEx.


Таблица 6. Возможные значения параметра style структуры WNDCLASSEX3

Значение Описание
CS_BYTEALIGNCLIENT Выравнивает клиентскую область окна (window's client area; content area) на основании байтовой границы (byte boundary) по оси X. Это влияет на положение окна по горизонтали и на его ширину (width). Используется редко.
CS_BYTEALIGNWINDOW Выравнивает окно на основании байтовой границы (byte boundary) по оси X. Это влияет на положение окна по горизонтали и на его ширину (width). Используется редко.
CS_CLASSDC Говорит Windows выделять ресурсы прорисовки всем окнам данного класса. Используется при создании DirectX-приложений. Данный стиль выделяет (allocates) единый контекст устройства (device context), который будет применяться во всех окнах, созданных на основе данной структуры оконного класса. В общих чертах, в ОС Windows можно создавать несколько оконных классов одного типа в разных потоках (threads). В то время, как в ОС могут одновременно существовать несколько копий оконного класса, возможна ситуация, когда несколько потоков попытаются одновременно получить доступ к общему контексту устройства. При использовании данного стиля, доступ к контексту устройства в данный момент времени получает только 1 поток, в то время как остальные блокируются, ожидая своей очереди.
CS_DBLCLKS Здесь всё просто. При указании данного стиля, всякий раз, когда пользователь сделает двойной щелчок мышью в области окна, ОС Windows будет посылать сообщение о двойном щелчке мышью (double click). Сперва это может показаться ненужным, но многие приложения замеряют время каждого щелчка мышью в области окна для определения двойных щелчков, вместо того, чтобы просто использовать данный стиль.
CS_GLOBALCLASS Данный стиль разрешает создание глобального класса окна. В игрокодинге не используется. Более подробная информация по данному стилю есть в MSDN.
CS_HREDRAW Заставляет перерисовывать клиентскую область окна всякий раз при изменении его ширины. В программировании DirectX-приложений не применяется.
CS_VREDRAW Заставляет перерисовывать клиентскую область окна всякий раз при изменении его высоты. В программировании DirectX-приложений не применяется.
CS_NOCLOSE Скрывает кнопку с крестиком в верхнем правом углу тулбара окна.
CS_OWNDC Выделяет отдельный уникальный контекст устройства для каждого окна, создаваемого на основе данного оконного класса.
CS_PARENTDC При указании данного стиля дочернее окно (child window) имеет общую область отсечения (clipping area) с родительским окном (parent window). Это позволяет дочернему окну рисовать в родительском окне. Но это не значит, что дочернее окно использует контекст устройства родительского окна. Вместо этого дочернее окно получает свой собственный контекст устройства из системного пула. Данный флаг применяется в основном для увеличения быстродействия приложения.
CS_SAVEBITS Сохраняет в памяти картинку (bitmap) области, расположенной под окном. Данный флаг препятствует отправке сообщения WM_PAINT любым окнам, расположенным под данным окном.

В некоторых источниках по DirectX-программированию структуру оконного класса не расписывают так подробно, выставив "декоративные" параметры в NULL:

// Структура оконного класса DirectX-приложения
WNDCLASSEX wcex = (sizeof(WNDCLASSEX), CS_CLASSDC,
  WindowProc, 0L, 0L, hInstance,
  NULL, NULL, NULL, NULL,
  "GameClass", NULL);

При создании окна обычного (не DirectX) приложения структура оконного класса будет выглядеть по-другому:

// Структура оконного класса обычного (не DirectX) приложения.
WNDCLASSEX wcex = (sizeof(WNDCLASSEX), CS_HREDRAW|CS_VREDRAW,
  WindowProc, 0L, 0L, hInstance,
  LoadIcon(NULL, IDI_APPLICATION),
  LoadCursor(NULL, IDC_ARROW),
  (HBRUSH)GetStockObject(BLACK_BRUSH), NULL,
  "AppClass", NULL);

Регистрация оконного класса

После заполнения полей структуры WNDCLASSEX происходит её регистрация путём вызова функции RegisterClassEx, где в качестве параметра стоит указатель на имя уже заполненной структуры (wndClass):

Фрагмент Листинга 3. Main.cpp
...
	// Если класс не зарегистрируется, досрочно прерываем выполнение программы
	if(!RegisterClassEx(&wndClass)) return FALSE;
...

Сама функция "обрамлена" условным переходом if, которая возвращает FALSE в случае неудачи и досрочно завершает работу программы.

Закрыть
noteПроверка с условным переходом if

Подобные проверки являются отличным средством и помогают обезопасить себя от множества "непонятных" вылетов, аварийного завершения приложения, а главное - от утечек памяти (например, в случае неудачной регистрации структуры оконного класса). Опытные программисты ставят такие проверки везде, где только можно.

С момента регистрации новый оконный класс становится известным операционной системе, и теперь на его базе можно создавать окна.

Создание окна

Создание окна осуществляется с помощью функции CreateWindowEx. Вот её прототип:

Прототип функции CreateWindowEx
HWND	CreateWindowEx(
		DWORD	dwExStyle,					// Дополнительный стиль окна
		LPCSTR lpClassName,				// Класс окна (в нашем случае GameClass)
		LPCSTR	lpWindowName,		// Имя окна. В принципе, любое. Пишется в заголовке окна
		DWORD dwStyle,					// Основной стиль окна
		int x,	int y,								// Координаты расположения окна
		int nWidth, int nHeight,		// Ширина и высота
		HWND	hWndParent,			// Дескриптор родительского окна (если есть)
		HMENU hMenu,					// Дескриптор меню (если есть)
		HINSTANCE hInstance,		// Дескриптор экземпляра окна
		LPVOID lpParam						// Дополнительные параметры
);

Сравним этот прототип с реальной функцией CreateWindowEx из Листинга 3:

Фрагмент Листинга 3. Main.cpp
...
	// Создание окна на основе зарегистрированного класса
hWnd=CreateWindowEx(
	WS_EX_TOPMOST,		// Дополнительный стиль окна
	"GameClass",				// Класс окна.
	"My game title",			// Текст заголовка (на верхнем тулбаре).
	WS_OVERLAPPEDWINDOW,		// Обычное окно с кнопками в правом верхнем углу.
	0, 0,							// Координаты X и Y
	GetSystemMetrics(SM_CXSCREEN),	// Ширина окна
	GetSystemMetrics(SM_CYSCREEN),	// Высота окна
	NULL,							// Дескриптор родительского окна
	NULL,							// Дескриптор меню
	hInstance,						// Дескриптор экземпляра приложения
	NULL);							// Дополнительные данные

	if(hWnd==NULL) return(FALSE);
...

В комментариях, в принципе, всё доступно объясняется. Но отметим ещё несколько моментов:

  • Четвёртый параметр DWORD dwStyle (в нашем случае он имеет значение WS_OVERLAPPEDWINDOW) указывает на основной стиль окна.
Закрыть
noteПримечание

При создании DirectX-приложений всегда ставят значение WS_OVERLAPPEDWINDOW, позволяющее и пользователю, и DirectX свободно изменять размеры окна по своему усмотрению.

Значений может быть несколько. В этом случае их разделяют знаком логического ИЛИ (символ прямой черты "|"). Так вот, этот параметр может принимать следующие значения:
Таблица 7

Значение параметра Описание
WS_BORDER Создание окна с рамкой.
WS_CAPTION Создание окна с заголовком (невозможно использовать одновременно со стилем WS_DLGFRAME).
WS_CHILD Окно является дочерним. Запрещено использовать вместе со стилем WS_POPUP.
WS_CHILDWINDOW Окно является дочерним. Запрещено использовать вместе со стилем WS_POPUP.
WS_CLIPSIBLINGS Используется совместно со стилем WS_CHILD для отрисовки в дочернем окне областей клипа, перекрываемых другими окнами.
WS_CHILDWINDOW Создание дочернего окна (невозможно использовать одновременно со стилем WS_POPUP).
WS_POPUP Создает popup-окно (невозможно использовать совместно со стилем WS_CHILD.
WS_POPUPWINDOW Создает popup-окно, имеющее стили WS_BORDER, WS_POPUP, WS_SYSMENU.
WS_CLIPCHILDREN Исключает область, занятую дочерним окном, при отрисовке элементов в родительском окне.
WS_DISABLED Создает окно, которое недоступно (любой пользовательский ввод запрещён).
WS_DLGFRAME Создает окно с двойной рамкой, без заголовка.
WS_GROUP Назначает окно в качестве первого в группе окон. Используется для переключения между окнами с помощью клавиши Tab. Все последующие окна данного класса определяется в эту же группу.
WS_HSCROLL Создает окно с горизонтальной полосой прокрутки.
WS_MAXIMIZE Создает окно максимального размера.
WS_MAXIMIZEBOX Создает окно с кнопкой развертывания окна.
WS_MINIMIZE Создает первоначально свернутое окно (используется только со стилем WS_OWERLAPPED).
WS_ICONIC Создает первоначально свернутое окно (используется только со стилем WS_OWERLAPPED).
WS_OVERLAPPED Создает перекрывающееся окно (которое, как правило, имеет заголовок и WS_TILED рамку).
WS_OVERLAPPEDWINDOW Создает перекрывающееся окно, имеющее стили WS_OVERLAPPED, WS_CAPTION, WS_SYSMENU, WS_THICKFRAME, WS_MINIMIZEBOX, WS_MAXIMIZEBOX.
WS_TILED Тоже самое что WS_OVERLAPPEDWINDOW.
WS_MINIMIZEBOX Создает окно с кнопкой свертывания.
WS_SYSMENU Создает окно с кнопкой системного меню (можно использовать только с окнами имеющими строку заголовка).
WS_TABSTOP Определяет элементы управления, переход к которым может быть выполнен по клавише TAB.
WS_THICKFRAME Создает окно с рамкой, используемой для изменения размера окна.
WS_SIZEBOX Пользователь может изменять размеры окна. Используется совместно с WS_THICKFRAME.
WS_VISIBLE Создает первоначально неотображаемое окно.
WS_VSCROLL Создает окно с вертикальной полосой прокрутки.

Поэкспериментируй с исходным кодом из Листинга 3, подставляя различные значения этого параметра и отправляя после этого код на перекомпиляцию. В нашем случае здесь стоит значение WS_OVERLAPPEDWINDOW.

  • Первый параметр DWORD dwExStyle (в нашем случае он имеет значение WS_EX_TOPMOST) указывет на дополнительный (расширенный) стиль окна. Значений может быть несколько. В этом случае их разделяют знаком логического ИЛИ (символ прямой черты "|"). Так вот, согласно MSDN(external link), этот параметр может принимать следующие значения:

Таблица 8

Значение параметра Описание
WS_EX_LEFT Окно выравнено по левому краю (данное значение принято по умолчанию).
WS_EX_RIGHT Окно выравнено по правому краю.
WS_EX_LEFTSCROLLBAR Полоса прокрутки (scrollbar) расположена слева. Полезна для языков, которые читаются справа налево.
WS_EX_RIGHTSCROLLBAR Полоса прокрутки (scrollbar) расположена справа. Принято по умолчанию во всех европейских дистрибутивах Windows.
WS_EX_ACCEPTFILES Окно поддерживает Drag'n'Drop (перетаскивание на него файлов).
WS_EX_APPWINDOW Выставляет видимое окно на верхнюю строчку в диспетчере задач (taskbar).
WS_EX_CAPTIONOKBTN Добавляет кнопку OK на строку заголовка окна.
WS_EX_CLIENTEDGE Окно имеет бордер (рамку) с "утопленными" границами.
WS_EX_CONTROLPARENT Разрешает навигацию по дочерним окнам с помощью клавиши Tab.
WS_EX_CONTEXTMENU Добавляет кнопку "Помощь" на строку заголовка окна.
WS_EX_DLGMODALFRAME Создаёт диалогове окно с двойной рамкой. Опционально окно может также иметь строку заголовка в том случае, если в параметре dwStyle указать значение WS_CAPTION.
WS_EX_INK Окно не издаёт звуков (например щелчков) когда по нему щёлкаешь мышью.
WS_EX_LAYOUTRTL Создаёт окно, где начало отсчёта горизонтальных координат расположено справа и будет увеличиваться справа налево (как в арабском письме).
WS_EX_LTRREADING Текст в окне будет отображаться слева направо. Принято по умолчанию во всех европейских дистрибутивах Windows.
WS_EX_NOACTIVATE Главное окно не может быть активировано. Если дочернее окно имеет этот стиль, щелчок по нему не активирует главное окно программы. Окно с эти стилем получает команды от мыши или стилуса, но активируются только дочерние окна. Поддерживается в Windows CE 2.0 и более поздних версиях.
WS_EX_NOANIMATION Окно не поддерживает плавного изменения размеров (с анимацией), и не имеет кнопки на панели задач. Поддерживается в Windows CE 2.0 и более поздних версиях.
WS_EX_NODRAG Окно не "подцепляется" (не перемещается) с помощью мыши или стилуса.
WS_EX_NOINHERITLAYOUT Окно с этим стилем не передаёт свою разметку дочерним окнам.
WS_EX_NOPARENTNOTIFY Блокирует отправку сообщения WM_PARENTNOTIFY родительскому окну при создании или закрытии окна-потомка.
WS_EX_OVERLAPPEDWINDOW Сочетает стили WS_EX_CLIENTEDGE и WS_EX_WINDOWEDGE. Часто используется в исходных текстах базового приложения при создании игр.
WS_EX_PALETTEWINDOW Сочетает стили WS_EX_WINDOWEDGE, WS_EX_TOOLWINDOW и WS_EX_TOPMOST.
WS_EX_RTLREADING Если язык ОС арабский, иврит или любой другой с написанием справа налево, текст в окне будет показываться справа налево. Для других языков ОС данный стиль будет игнорироваться.
WS_EX_STATICEDGE Создаёт окно с трёхмерной рамкой, предполагающее использование на нём элементов БЕЗ поддержки пользовательского ввода.
WS_EX_TOOLWINDOW Создаёт окно инструментов. Изначально задумывался для создания свободно перемещаемых ("плавающих") панелей инструментов в различных приложениях (яркий пример - Borland Delphi 5). Окно инструментов не отображается в Панели задач или в списке запущенных приложений, возникающем при нажатии ALT+TAB. Если окно инструментов имеет системное меню, оно не отображается в строке заголовка.
WS_EX_TOPMOST Окно с этим стилем должно располагаться поверх всех остальных окон, не имеющих такого статуса. Оно должно оставаться там даже когда неактивно. Чтобы добавить или удалить этот стиль, используй функцию SetWindowPos.
WS_EX_WINDOWEDGE Окно имеет рамку с выпуклым краем (выглядит как чуть приподнятое).

Поэкспериментируй с исходным кодом из Листинга 3, подставляя различные значения этого параметра и отправляя после этого код на перекомпиляцию. В нашем случае здесь стоит значение WS_EX_TOPMOST.

  • В пятом и шестом параметрах (int x, int y) в качестве координаты левого верхнего угла указывается точка (0,0). Это необходимо для того, чтобы окно занимало весь экран.
  • В седьмом и восьмом параметрах (int nWidth, int nHeight) указывается ширина и высота окна. В нашем случае эти размеры совпадают с шириной и высотой экрана (т.к. у нас окно развёрнуто на весь экран). Узнаём ширину и высоту экрана с помощью вспомогательной функции int GetSystemMetrics(int nIndex), получающей в качестве параметра специальные макросы SM_CXSCREEN (для ширины) или SM_CYSCREEN (для высоты), указывающие, что нужно узнать ширину и высоту в точках экрана первичного монитора (Primary display).

В результате успешного выполнения функция CreateWindowEx возвращает дескриптор типа HWND. В случае неудачи возвращается NULL.
Именно поэтому, сразу после описания функции CreateWindowEx, идёт проверка с условным оператором if. Если по окончании выполнения дескриптор приложения равен NULL, то досрочно завершаем выполнение программы методом RETURN.

Окно создано, но на экране оно не появится до тех пор, пока не будет вызвана функция ShowWindow (HWND hWnd, int nCmdShow):

Фрагмент листинга 3. Main.cpp
...
	// Собственно, показываем окно
	ShowWindow(hWnd, nCmdShow);
	UpdateWindow(hWnd);
...

В первом параметре она получает дескриптор вновь созданного окна (hWnd), а во втором - одну из констант с префиксом SW_ из Таблицы 4, указывающую на способ отображения окна. Но чаще всего здесь просто указывают параметр nCmdShow.
Функция UpdateWindow заставляет окно обновить свою клиентскую область всякий раз, когда происходит перемещение окна или изменяются его размеры.

Конвейер (цикл) выборки сообщений (Message pump)

  • Является "сердцем" любой Windows-программы.
  • Может строиться по-разному (часто на основе всевозможных ветвящихся алгоритмов).
  • Конструируется (объявляется) внутри функции WinMain.
  • В нашей программе выглядит так:
Фрагмент Листинга 3. Main.cpp
...
	// Очищаем структуру сообщения
	ZeroMemory(&msg, sizeof(MSG));

	// Процедура выборки сообщений
	// Продолжаем бесконечно, пока не получим сообщение WM_QUIT (завершение).
	while(msg.message != WM_QUIT)
	{	// Просмотрим очередь: вдруг там ожидает сообщение...
		if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
	{
		// Есть сообщение! Обработаем его как обычно...
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
		else
		{
			// Нет сообщений, ожидающих обработки.
			// Значит приступим к выполнению критичных ко времени операций.
			// Например, займёмся рендерингом.
		}
	}

	//Удаляем регистрацию класса
	UnregisterClass("GameClass", hInstance);
	
	// Выходим из приложения
	return (msg.wParam);
}
...

Здесь наше приложение входит в бесконечный цикл, ожидая сообщения от ОС Windows. Как только они поступают, то через функции GetMessage или PeekMessage переправляются в оконную процедуру для обработки.
В самом сердце цикла выборки сообщений расположена функция PeekMessage(). Вот её прототип:

Прототип функции PeekMessage()
BOOL PeekMessage
(  
	LPMSG lpMsg,		// Указатель на структуру MSG
	HWND hWnd,		// Указатель на окно (кому сообщение)
	UINT wMsgFilterMin,	// для маски минимум
	UINT wMsgFilterMax,	// для маски максимум
	INT wRemoveMsg		// Что делать с сообщением
);

Последний параметр здесь может принимать следующие значения:

Значение параметра Описание
PM_REMOVE Удалять сообщение из очереди.
PM_NOREMOVE Не удалять сообщение из очереди.

Функция PeekMessage вернёт ненулевое значение, если в очереди есть сообщения. Если фильтра нет, то будут получены все сообщения, при наличии фильтра только по фильтру.
Также вместо неё можно применить аналогичную по действию функцию GetMessage().

Закрыть
noteРазница между функциями PeekMessage и GetMessage

Функция GetMessage() является блокирующей. То есть она ожидает пока не будет получено сообщение из очереди. До этого момента программа стоит. Что делать, если надо просто проверить есть ли сообщение в очереди? (Например, чтобы занять программу в этот момент другими действиями, например, упаковкой базы данных.) Для этого и есть функция PeekMessage(). Она проверяет есть ли в очереди сообщение и программа выполняется дальше.

Обрати внимание, что GetMessage() вернет WM_QUIT даже при наличии фильтра (оператора switch...case).
MS Windows является событийно-ориентированной операционной системой. Она устроена так, что на протяжении всего времени "жизни" запущенного приложения оно постоянно "бомбардируюется" всевозможными сообщениями, информирующими обо всех изменениях, происходящих в рабочем окружении ОС (сдвинулся курсор мыши, запустили другое приложение и т.д.). Эти сообщения выбираются из очереди сообщений(external link) (Message queue), которую ОС организует для каждой программы, а затем передаются в оконную процедуру (в нашем случае это функция WindowProc) для обработки. БОльшая часть из этих сообщений абсолютно "не интересна" нашему приложению и они передаются обратно Windows для так называемой обработки по умолчанию.
Чтобы сообщение было получено программой, в наличии должны иметься 2 компонента:

  • Точка назначения (участок кода, которому собственно и передаются сообщения). В нашем случае это оконная процедура WindowProc). Именно она получает в качестве аргумента сообщение, адресованное окну, с которым она связана (+ параметры этого сообщения).
  • Механизм передачи (программа должна сама организовать выборку сообщений из всей очереди). Может быть синхронным и асинхронным:

Таблица 9. Виды механизмов (способов) передачи сообщений

Синхронный Реализуется в случае вызова оконной процедуры непосредственно операционной системой Windows. Яркий пример - функция UpdateWindow, вызывающей оконную процедуру, и передавая ей в качестве параметра сообщение WM_PAINT (оно требует прорисовать рабочую область окна). Другой способ послать оконной процедуре синхронное сообщение - воспользоваться функцией SendMessage (см. её прототип сразу под этой таблицей). Она посылает указанное сообщение в окно, определяемое дескриптором hWnd, и НЕ возвращает управление до тех пор, пока не произойдёт возврат из оконной процедуры. Синхронность в данном случае подразумевает возможность предсказать, в какой момент времени (точнее, после какого оператора) произойдёт обработка сообщения.
Асинхронный Реализуется при помощи очереди сообщений, организуемой для каждого приложения (точнее, для каждого потока приложения, который может принимать пользовательский ввод). ОС MS Windows помещает в эту очередь все сообщения. Лишь небольшая их часть может относиться к работающей программе. Приложение выбирает из этой очереди адресованные ему сообщения и обрабатывает их по мере поступления.

Прототип функции SendMessage
LRESULT	SendMessage(
		HWND hWnd,		// Дескриптор окна
		UINT Msg,			// Номер сообщения
		WPARAM wParam,		// Первый параметр
		WPARAM lParam		// Второй параметр
);


БОльшую часть сообщений в очередь помещает операционная система (например, в ответ на действия пользователя). Но есть функции, позволяющие это сделать и самому приложению. Одна из них PostMessage. Вот её прототип:

Прототип функции PostMessage
LRESULT	PostMessage(
		HWND hWnd,		// Дескриптор окна
		UINT Msg,			// Номер сообщения
		WPARAM wParam,		// Первый параметр
		WPARAM lParam		// Второй параметр
);


Разница между SendMessage и PostMessage состоит в том, что:

  • функция SendMessage непосредственно вызывает оконную процедуру, передавая ей нужное сообщение;
  • функция PostMessage помещает это сообщение в очередь, связанную с создавшим окно программным потоком (thread), и, не дожидаясь обработки сообщения, возвращает управление вызывающей функции. А уже само приложение затем извлечёт сообщение из очереди и должным образом обработает. Именно такую схему называют циклом выборки сообщений.

В нашем случае в этом цикле стоит функция PeekMessage.
В конце этого цикла стоят две функции со следующими прототипами:
BOOL TranslateMessage(CONST MSG *lpMsg)
LONG DispatchMessage(CONST MSG *lpMsg)
Обе они получают в качестве параметра адрес структуры типа MSG, поля которой заполнены предварительным вызовом функции PeekMessage.

  • TranslateMessage обычно "транслирует" сообщения, связанные с пользовательским вводом (нажатие клавиш, перемещение мыши) в символьные данные (character data).

Как только сообщение было транслировано в символьные данные, его можно "запостить" в очередь сообщений (message queue):

  • DispatchMessage вызывает оконную процедуру, передавая ей информацию о сообщении, полученную при помощи функции PeekMessage. Функция передаёт (помещает) оттранслированные сообщения в очередь сообщений оконной процедуры приложения.

Сам цикл выборки сообщений "обрамлён" циклом while do else, где в условии стоит ненаступление события WM_QUIT, прерывающего выполнение цикла и завершающего работу приложения, что и делает оператор return (msg.wParam).

Оконная процедура и обработка сообщений

Из-за используемой Windows схемы "Не зови меня, я сама тебе позову" нам необходимо оснастить наше приложение процедурой выборки сообщений (window message procedure более известная как оконная процедура), которая будет принимать входящий поток сообщений. Если функция WinMain представляет своего рода "мотор" программы, то оконная процедура наделяет приложение настоящей функциональностью. Именно в ней обрабатываются сообщения, переданные с помощью функции DispatchMessage. Большинство приложений отличаются друг от друга главным образом реакцией на сообщения, которые им посылает ОС MS Windows. Вот прототип оконной процедуры (название произвольное; в нашем случае - WindowProc):

Прототип функции WindowProc
LRESULT CALLBACK WindowProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

Здесь немного параметров:
hWnd - дескриптор окна, которому и принадлежит оконная процедура. uMsg - поступившее на обработку сообщение.
wParam и lParam содержат информацию, относящуюся к сообщению (это могут быть различные значения переменных или указатели).
В нашем случае исходный код оконной процедуры выглядит так:

Фрагмент Листинга 3. Main.cpp
...
	// Оконная процедура
LRESULT CALLBACK WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch(msg)
	{
	case WM_DESTROY:			// В случае этого сообщения...
		PostQuitMessage(0);		// Говорим Windows закрыть приложение
		break;

		// В случае любых других сообщений...
	default: return DefWindowProc(hWnd, msg, wParam, lParam);
	}
	return 0;
}
...

Внутри неё видим единственный оператор switch. А всё потому, что всё, что делает данная функция, это "просматривает" различные типы сообщений, которые в неё указаны, и проверяет, не совпадает ли какое-либо из этих сообщений с передаваемым. В нашем случае мы проверяем всего 1 сообщение на совпадение - WM_DESTROY. Получив данное сообщение, наше приложение вызывает внутреннюю функцию Windows PostQuitMessage, закрывающую его окно. То же самое происходит и при нажатии кнопки закрытия в правом верхнем углу окна приложения (в виде крестика).
При этом код сообщения передаётся в оконную процедуру в качестве параметра uMsg. Обычная (созданная нами) оконная процедура обрабатывает отдельные (указанные в ней) сообщения. А те, что не обрабатывает сама, передаёт в оконную процедуру по умолчанию, которая имеет прототип:

Прототип функции DefWindowProc
LRESULT DefWindowProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

Как видим, оконная процедура по умолчанию имеет тот же тип возвращаемого результата и такой же список параметров, что и обычная оконная процедура. Различие состоит в том, что код "умолчательной" оконной процедуры встроен в саму ОС MS Windows, и она умеет обрабатывать, в принципе, все сообщения. Основная задача функции DefWindowProc - выполнять действия по умолчанию (часто это означает не делать ничего). Тем не менее, согласно правилам Windows-программирования, любое необработанное явным образом (с помощью обычной оконной процедуры) сообщение необходимо передавать в оконную процедуру по умолчанию (функция DefWindowProc).

В начале Листинга 3 при заполнении структуры класса приложения мы произвели присваивание:

Фрагмент Листинга 3. Main.cpp
...
	wndClass.lpfnWndProc=WindowProc;		// Оконная процедура
...

Благодаря этому MS Windows знает оконную процедуру класса и пересылает в неё все адресуемые окну сообщения. Каждое сообщение сопровождается двумя параметрами с типами WPARAM, LPARAM. Они содержат упакованные в них характеристики сообщений. В Win32 оба эти параметра имеют размер 32 бита. Встроенные в ОС MS Windows распаковщики сообщений избавляют нас от необходимости работать с данными параметрами напрямую.

Событие, став сообщением, проходит несколько этапов обработки
Событие, став сообщением, проходит несколько этапов обработки

Код завершения работы приложения

При закрытии окна дерегистрируем (unregister) оконный класс и выходим из приложения:

Фрагмент листинга 3. Main.cpp
...
	//Удаляем регистрацию класса
	UnregisterClass("GameClass", hInstance);
	
	// Выходим из приложения
	return (msg.wParam);
...

Пишем текст в окне

Зачем? Исключительно в образовательных целях. Графика выводится на экран чуть сложнее. Да и игр совсем без текста не бывает.

Изменения в Main.cpp

В оконной процедуре стоит оператор switch..case, реагирующий на разный события.

  • В самом конце Main.cpp найди следующий фрагмент:
Фрагмент Main.cpp
...
// Оконная процедура
LRESULT CALLBACK WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch(msg)
	{
	case WM_DESTROY:			// В случае этого сообщения...
		PostQuitMessage(0);		// Говорим Windows закрыть приложение
		break;

		// В случае любых других сообщений...
	default: return DefWindowProc(hWnd, msg, wParam, lParam);
	}
	return 0;
}
...

Сейчас там прописана реакция на единственное событие WM_DESTROY, закрывающее окно программы. Данное событие должно всегда быть последним в списке.

  • Перед оператором switch добавь инициализирующие переменные, необходимые для отрисовки текста:

HDC hDC; // Контекст устройства
PAINTSTRUCT ps;
RECT rect;

  • Перед оператором case WM_DESTROY добавь второй оператор case и сопутствующий код:

case WM_PAINT: // При отрисовке окна...
hDC = BeginPaint(hWnd, &ps);
GetClientRect(hWnd, &rect);
DrawText(hDC, TEXT("Это тестовое приложение. Всем привет!"), -1, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
EndPaint(hWnd, &ps);
return 0;
После внесённых изменений оконная процедура будет выглядеть так:

Фрагмент Main.cpp
...
// Оконная процедура
LRESULT CALLBACK WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	HDC			hDC;	// Контекст устройства
	PAINTSTRUCT	ps;
	RECT		rect;
	
	switch(msg)
	{
	case WM_PAINT:		// При отрисовке окна...
		hDC = BeginPaint(hWnd, &ps);
		GetClientRect(hWnd, &rect);
		DrawText(hDC, TEXT("Это тестовое приложение. Всем привет!"), -1, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
		EndPaint(hWnd, &ps);
		return 0;
	case WM_DESTROY:			// В случае этого сообщения...
		PostQuitMessage(0);		// Говорим Windows закрыть приложение
		break;

		// В случае любых других сообщений...
	default: return DefWindowProc(hWnd, msg, wParam, lParam);
	}
...
  • Сохрани Решение/Проект (Файл -> Сохранить все).
  • Скомпилируй Проект/Решение (F5).

Если набрал код без ошибок, то после успешной компиляции на экране вновь покажется чёрное окно приложения с текстом, выравненным по центру. Смотри-ка, MSVC++ неплохо дружит с русскими кодировками даже при использовании многобайтовой кодировки (указанной в графе "Набор символов" в свойствах Проекта). А всё из-за специального макроса TEXT (см функцию DrawText), который выведет заданный текст одинаково даже на компах с азиатискими версиями ОС Windows.

Сообщения Windows (теория)

ОС Windows впервые представила концепцию, согласно которой операционная система сама информирует приложение, когда происходит что-то важное. Например, юзер переместил мышь. При этом автоматически создаётся событие (event), которое ОС Windows получает, обрабатывает и уже в виде сообщения (message) посылает приложению.
В ОС Windows есть глобальная очередь (global queue), в которой она сохраняет все поступившие сообщения. Она не спеша разбирает каждое из них и затем отправляет их запущенным приложениям. При получении сообщения приложение сохраняет его в своей собственной очереди сообщений (application message queue). Внутри каждой Windows-программы есть т.е. насос сообщений (message pump или message loop - цикл выборки сообщений), который последовательно сканирует каждое из них, выискивая подходящие сообщания для обработки. Как только такое появляется, цикл выборки сообщений приложения посылает его в специальную процедуру оконных сообщений (window message procedure), также расположенную в недрах программы. Эта функция обрабатывает единичные сообщения, большая часть которых пропускается или "отфутболивается" обратно в ОС Windows.

Закрыть
noteОбрати внимание

Все Windows-сообщения имеют специальный префикс WM_ в своём текстовом идентификаторе, образованный от "windows message".

В ОС MS Windows имеется огромное количество сообщений, которыми она непрерывно "бомбардирует" оконную процедуру. Лишь малая часть из них (иногда всего 2-3) необходима программисту для обработки в каждом конкретном случае. Большинство Windows-сообщений определены в файле winuser.h, расположенном в каталоге с установленной MS VC++. Вот самые распространённые из них:

Таблица 10. Сообщения, связанные с управлением окнами

WM_ACTIVATE Посылается в окно в случае его активации/деактивации.
WM_CREATE Посылается, когда совершается попытка создать окно при помощи функций CreateWindow или CreateWindowEx. Оконная процедура получает это сообщение ПОСЛЕ того, как окно создано, но ДО того, как оно появится на экране. В случае если оконная процедура в ответ на это сообщение возвращает значение -1, окно не создаётся и функция, использованная для создания окна, возвращает NULL.
WM_CLOSE Посылается в окно всякий раз, когда оно должно быть закрыто. Это сообщение может обрабатываться в случае, если приложению нужно выполнить определённые действия перед тем, как закрыться.
WM_DESTROY Посылается в удаляемое окно, когда оно уже убрано с экрана.
WM_MOVE Посылается в окно после того, как изменилось его положение на экране.
WM_SIZE Посылается в окно при изменении его размеров. Также посылается в окно всякий раз при его создании.
WM_QUIT Помещается в очередь сообщений после вызова функции PostQuitMessage и является командой для завершения приложения. Функция PeekMessage (иногда вместо неё применяют схожую функцию GetMessage), выбрав из очереди это сообщение, возвращает ноль. После этого цикл выборки сообщений прекращается, а вместе с ним завершается и работа программы.
WM_PAINT Посылается в окно при перерисовке всего его содержимого (либо участка этого окна). Является частью библиотеки GDI.


Таблица 11. Сообщения клавиатуры

WM_KEYDOWN Посылается в очередь сообщений, когда окно имеет клавиатурный фокус и несистемная клавиша была отпущена (отжата). Передаёт в оконную процедуру виртуальный код клавиши. Список виртуальных кодов клавиш содержится в файле winuser.h .
WM_KEYUP Посылается в очередь сообщений, когда окно имеет клавиатурный фокус и была нажата какая-либо несистемная клавиша. Передаёт в оконную процедуру виртуальный код клавиши.
WM_CHAR Помещается в очередь сообщений как результат выполнения функции TranslateMessage после распаковки сообщения о нажатой несистемной клавише WM_KEYDOWN.
WM_MOUSEMOVE Помещается в очередь сообщений, при перемещении указателя (курсора) мыши над окном.
WM_LBUTTONDOWN Помещается в очередь сообщений, когда нажимается левая кнопка мыши и курсор в это время находится над клиентской областью окна.
WM_LBUTTONUP Помещается в очередь сообщений, если левая кнопка мыши отпущена (отжата) и курсор в это время находится над клиентской областью окна.
WM_LBUTTONDBLCLK Помещается в очередь сообщений, когда произведён двойной щелчок левой кнопкой мыши и курсор в это время находится над клиентской областью окна.
WM_RBUTTONDOWN Помещается в очередь сообщений, когда нажимается правая кнопка мыши и курсор в это время находится над клиентской областью окна.
WM_RBUTTONUP Помещается в очередь сообщений, если правая кнопка мыши отпущена (отжата) и курсор в это время находится над клиентской областью окна.
WM_RBUTTONDBLCLK Помещается в очередь сообщений, когда произведён двойной щелчок правой кнопкой мыши и курсор в это время находится над клиентской областью окна.
WM_MBUTTONDOWN Помещается в очередь сообщений, когда нажимается средняя кнопка мыши и курсор в это время находится над клиентской областью окна.
WM_MBUTTONUP Помещается в очередь сообщений, если средняя кнопка мыши отпущена (отжата) и курсор в это время находится над клиентской областью окна.
WM_MBUTTONDBLCLK Помещается в очередь сообщений, когда произведён двойной щелчок средней кнопкой мыши и курсор в это время находится над клиентской областью окна.
WM_SETCURSOR Посылается в окно, если указатель мыши перемещается над окном и при этом мышь не была захвачена никаким другим окном. Часто используется для задания вида указателя мыши.


Таблица 12. Другие сообщения

WM_TIMER Помещается в очередь событий по истечении срока, указанного при создании таймера.
WM_СCOMMAND_T Посылается, когда был выбран какоц-либо пункт меню, обработан акселератор или когда дочерний элемент управления отправляет сообщение родительскому окну.


Если программер задумал обработать определённое сообщение Windows, ему необходимо выяснить тип параметров сообщения и другую доп. информацию о нём. Доп. информация (extra information) содержится в аргументах lParam и wParam сообщения. Подробная информация обо всех сообщениях Windows и их аргументах как всегда содержится в MSDN и в недрах Windows SDK.
В качестве примера разберём сообщение WM_MOUSEMOVE. Согласно документации Windows SDK, аргумент lParam является 32-битным значением. Нижние 16 бит (low-word) аргумента lParam содержат X-координату курсора мыши, а верхние 16 бит (hi-word) - Y-координату. Для извлечения значений low-word и hi-word использую макросы LOWORD и HIWORD соответственно:

int XCoordinate = LOWORD(lParam);
int YCoordinate = HIWORD(lParam);

Распаковщики сообщений

  • Представляют собой специальные макросы, определённые в файле windowsx.h.
  • Позволяют оформлять обработку каждого оконного сообщения (например в оконной процедуре) в виде отдельной функции.
  • Уменьшают объём исходного кода, улучшают его читабельность.
  • Повышают модульность программы, так как обработчик каждого сообщения может располагаться в отдельной функции, что способствует созданию более структурированных, а следовательно, более надёжных программ.
  • Позволяют писать хорошо структурированный код, что повышает его понимаемость и сопровождаемость.
  • При их использовании программист избавлен от необходимости заниматься явным приведением типов при обработке сообщений (этот процесс нередко приводит к ошибкам).

Рассмотрим пример оконной процедуры без применения распаковщиков сообщеий:

...
LRESULT WindowProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
{
	switch(msg)
	{
	case WM_CREATE:
		if(!SetTimer(hWnd,TIMER_ID, TIMER_RATE, NULL))
return (-1L);
	return (0L);
	case WM_TIMER:
		MessageBeep(0xFFFFFFFF);
	return (0L);
	case WM_DESTROY:
		KillTimer(hWnd, TIMER_ID);
		PostQuitMessage(0);
		Return (0L);
	default:
		return DefWindowProc(hWnd, msg, wParam, lParam);
	}
}
...

Как видим, даже при обработке 3-4 сообщений листинг выглядит громоздко. Более того:

  • Каждое сообщение несёт в себе дополнительную информацию в параметрах wParam и lParam (в данной процедуре они не используются, но вообще применяются довольно часто).
  • Для каждого сообщения дополнительная информация пакуется в wParam и lParam совершенно различными способами (их описание можно найти в документации).
  • Способ упаковки зависит и от версии Windows: Win16 и Win32 делают это для некоторых сообщений по-разному.

Для решения этих проблем и предназначены распаковщики сообщений (message crackers).
При применении распаковщиков сообщений фрагмент исходного кода

...
	case WM_CREATE:
		if(!SetTimer(hWnd,TIMER_ID, TIMER_RATE, NULL))
return (-1L);
	return (0L);
...

можно переписать так:

...
case WM_CREATE:
	return HANDLE_WM_CREATE(hWnd, wParam, lParam, FirstApp_OnCreate);
...

Здесь распаковщик преобразует lParam к типу LPCREATESTRUCT и передаёт переменную этого типа в функцию FirstApp_OnCreate (заранее подготовленную программистом).
Тот же оператор можно записать ещё проще:

...
HANDLE_MSG(hWnd, WM_CREATE, FirstApp_OnCreate);
...

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

Дополнительные возможности программирования Windows

Создав два приложения (консольное и оконное), мы затронули лишь верхушку айсберга Windows-программирования. Представленный ниже материал в принципе факультативен (=второстепенен). Но любой уважающий себя Windows-программер должен это знать. Кроме того, с помощью стандартных диалоговых окон часто создаются конфигураторы (= окна настроек видео и звука игры). Про многопоточность - вообще молчу. Если сумеешь повесить на отдельный процесс подзагрузку локации, не прерывая игровой процесс, цены тебе не будет как игрокодеру.

Окно сообщения (Message box) - это простейшее окно, с которым можно взаимодействовать. Его просто создать и им удобно прерывать выполнение программы для вывода предупреждений пользователю.
Окно сообщения (Message box) - это простейшее окно, с которым можно взаимодействовать. Его просто создать и им удобно прерывать выполнение программы для вывода предупреждений пользователю.

Всплывающее (модальное) окно сообщения (Message Box)

Донести информацию до пользователя часто бывает совсем не просто. Текст сообщения должен быть в отдельном окне. А создание окна, как мы выяснили, целая военно-морская операция. Для упрощения вывода сообщений были придуманы всплывающие окна. Всплывающее окно сообщения представляет собой специальное (сильно упрощённое) окно, у которого есть строка заголовка (caption), само сообщение, значок (иконка; опционально) и до трёх кнопок. Будучи выведенным на экран, окно сообщения просто ждёт от пользователя клика по своей кнопке. Как только это произойдёт, окно сообщения закрывается и передаёт выполнение исполняемому коду приложения, которое его вызвало.
Создать окно сообщения совсем нетрудно. Вот его прототип:

int MessageBox(
 HWND hWnd,  // Родительское окно. Или NULL, если его нет.
 LPCSTR lpText,  // Выводимое сообщение.
 LPCSTR lpCaption  // Текст заголовка окна.
 UINT uType);  // Настройки кнопок и значка окна сообщения.

Параметр uType представляет собой комбинацию флагов, определяющих, какие кнопку и значок показать в окне сообщения. Флаги могут объединяться логическим ИЛИ (|). Вот далеко не полный список флагов:
Таблица 13. Возможные значения параметра uType окна MessageBox

MB_OK Показывает кнопку OK.
MB_OKCANCEL Показывает кнопки OK и Cancel (отмена).
MB_RETRYCANCEL Показывает кнопки OK и Retry (повторить).
MB_YESNO Показывает кнопки YES и NO.
MB_YESNOCANCEL Показывает кнопки YES, NO и Cancel (отмена).
MB_ABORTRETRYFAIL Показывает кнопки ABORT (отмена), RETRY (повторить) и FAIL (отмена).
MB_ICONEXCLAMATION Показывает значок с восклицательным знаком.
MB_ICONCONFIRMATION Показывает значок с маленькой i.
MB_ICONQUESTION Показывает значок со знаком вопроса.
MB_IConstop Показывает значок со знаком STOP.
MB_DEFBUTTON1 Первая кнопка жмётся по умолчанию при нажатии Enter.
MB_DEFBUTTON2 Вторая кнопка жмётся по умолчанию при нажатии Enter.
MB_DEFBUTTON3 Третья кнопка жмётся по умолчанию при нажатии Enter.

Полный список как всегда ищем в MSDN.
После нажатия пользователем одной из кнопок окно сообщения возвращает одно из следующих значений:
Таблица 14. Значения, возвращаемые окном сообщения

IDABORT Нажата кнопка ABORT.
IDCANCEL Нажата кнопка CANCEL.
IDIGNORE Нажата кнопка IGNORE.
IDYES Нажата кнопка YES (Да).
IDNO Нажата кнопка NO (Нет).
IDOK Нажата кнопка OK.
IDRETRY Нажата кнопка RETRY (повторить).

Вот пример окна сообщения, предлагающего пользователю нажать одну из двух кнопок YES или NO. Например при запросе о выходе из программы:

int Result = MessageBox(
 NULL,
 "Выйти из программы без сохранения изменений?",
 "Выход из программы",
 MB_YESNO | MB_ICONQUESTION);

Для пущей убедительности окно сообщения оформляется значком с вопросительным знаком. При нажатии YES (Да) возвращается значение IDYES. При нажатии NO (Нет) возвращается IDNO.

Диалоговые окна (Dialog Boxes)

  • Являются ещё одной продвинутой фичей Windows.
  • Представляют собой оконные приложения, созданные с использованием специальных шаблонов (template), разработанных с помощью редактора ресурсов.
Закрыть
noteОбрати внимание

В бесплатной MSVC++2010 Express редактор ресурсов вырезан напрочь. Поэтому для создания специального скрипта ресурсов воспользуемся сторонним приложением ResEdit, которое нетрудно найти в Интернете или скачать здесь(external link). На igrocoder.ru есть хорошая статья по этой проге: Работа с двоичными ресурсами (.rc) в MS Visual C plus plus 2010 Express.

У диалоговых окон есть куча преимуществ:

  • Удобное размещение элементов управления на форме (почти как в Delphi).
  • На одном шаблоне можно быстро создать одно или несколько диалоговых окон.
  • Диалоговые окна, подобно обычным окнам, используют для обработки поступающих сообщений процедуру выборки сообщений (window message procedure).

Но есть и отличия. Например, при создании диалоговое окно получает сообщение WM_INITDIALOG вместо WM_CREATE.
Рассмотрим прототип диалогового окна:

HWND CreateDialog(
 HINSTANCE hInstance,  // Дескриптор экземпляра приложения (Handle to applivation instance).
 LPCSTR lpTemplate,  // Указатель на шаблон (template) диалогового окна.
 HWND hWndParent,  // Дескриптор родительского окна.
 DLGPROC lpDialogFunc);  // Процедура выборки сообщений диалогового окна.

Файл с двоичными ресурсами готовится заранее и содержит шаблон диалога (обычно это форма с нанесёнными на неё элементами управления). Каждый шаблон имеет уникальный идентификатор. Для создания окна из шаблона диалогового окна мы передаём в функцию CreateDialog в качестве параметров:

  • уникальный идентификатор
  • дескриптор экземпляра окна (application's instance handle)
  • процедуру выборки сообщений (message procedure).

По выполнении функция CreateDialog возвращает дескриптор (handle) созданного диалогового окна.
Рассмотрим подробнее процесс создания двоичных ресурсов.

Двоичные ресурсы Windows (Binary resources)

(Двоичные) ресурсы представляют собой данные, размещаемые в "хвосте" исполняемого файла.
К стандартным ресурсам Windows относятся:

  • Диалоговые окна (Dialog)
  • Значки (Icons)
  • Определения меню (Menu)
  • Определения панелей инструментов (Toolbar)
  • Растровые изображения (Bitmap)
  • Курсоры мыши (Cursor)

Кроме стандартных, программист может сам определить свои собственные ресурсы. Игрокодеру достаточно знать лишь сам принцип добавления различных двоичных ресурсов в приложение.

Закрыть
noteОбрати внимание

В бесплатной MSVC++2010 Express редактор ресурсов вырезан напрочь. Поэтому для создания специального скрипта ресурсов воспользуемся сторонним приложением ResEdit, которое нетрудно найти в Интернете или скачать здесь(external link). На igrocoder.ru есть хорошая статья по этой проге: Работа с двоичными ресурсами (.rc) в MS Visual C plus plus 2010 Express.

Потоки и мультипоточность (Threads and Multithreading).

Windows 95 впервые представила программерам идею выполнения на одном компе несколько задач одновременно (т.е. многозадачность). Вообще, Windows 95 на самом деле не была многозадачной, т.к. в ней использовалась т.н. вытесняющая (preemptive) многозадачность. Это когда ОС выполняет несколько программ поочерёдно и малыми порциями. Суть такой многозадачности в том, что несколько приложений (или процессов) выполняются в одно и то же время, но каждое из них поочерёдно получает доступ к процессору на малый промежуток времени, называемый временной срез (time slice). Всё это происходит настолько быстро, что создаётся иллюзия того, что несколько программ выполняются одновременно на одном компе.

Многозадачность также позволяет разбивать каждый процесс на несколько других процессов, называемых потоками (threads). Каждый поток имеет своё назначение. Например, один сканирует данные сети, другой обрабатывает пользовательский ввод и при необходимости воспроизводит звуки и т.д.. Использование в приложении более одного потока называется многопоточностью (multithreading). В общих чертах поток представляет собой функцию, выполняющуюся параллельно с основным приложением. В игрокодинге потоки обысно создают при работе со звуком и сетью.

Создать дополнительные потоки в приложении совсем нетрудно. Для этого создаётся специальная т.н. функция потока (thread function) (с использованием её специального прототипа), содержащая выполняемый код. Вот её прототип:

DWORD WINAPI ThreadProc(LPVOID lpParameter);

Здесь параметр lpParameter - это определённый пользователем указатель (user-defined pointer), который указывается при создании потока.
Сам поток создаётся функцией CreateThread:

Прототип функции CreateThread
HANDLE CreateThread(
 LPSECURITY_ATTRIBUTES lpThreadAbilities, // NULL
 DWORD dwStackSize,  // 0
 LPTHREAD_START_ROUTINE lpStartAddress,  // Функция потока
 LPVOID lpParameter,  // Указатель, предоставляемый пользователем. Можкт быть NULL
 DWORD dwCreationFlags,  // 0
 LPDWORD lpThreadId);  // Получает идентификатор потока (thread identifier)

Вместо того, чтобы вдаваться в детали этой сложной функции, рассмотрим пример её применения. Ниже представлен пример создания простой функции потока (= поточная функция) и вызов для её инициализации:

// Какая-то поточная функция
DWORD WINAPI MyThread(LPVOID lpParameter)
{...
 BOOL *Active;

 Active = (BOOL*)lpParameter;
 *Active = TRUE;  // Флаг потока активен
 ...
 // Здесь какой-то код
 ...
 // Уничтожаем поток
 *Active = FALSE // Помечаем поток как неактивный.
 ExitThread(0);  // Специальный вызов, закрывающий поток.
}

void InitThread()
{
 HANDLE hThread;
 DWORD ThreadId;
 BOOL Active;

 // Создаём поток, передавая переменную, определённую пользователем,
 // которая используется для хранения статуса потока.
 hThread = CreateThread(NULL, 0,
     (LPTHREAD_START_ROUTINE)MyThread, (void*)&Active,
      0, &ThreadId);

 // В то время, как поток активен..
 while(Active=TRUE)
 {
  // Делаем что-то.
 }

 // Закрыывем дескриптор потока
 CloseHandle(hThread);
}

Закрыть
noteОбрати внимание

Возвращаемым значением функции InitThread является дескриптор (handle), который при завершении обязательно должен быть закрыт. Так система освободит занятые ресурсы. Для этого вызывают функцию CloseHandle.


Представленный выше код создаёт поток, который начинает свою работу сразу после завершения выполения функции CreateThread.

Закрыть
noteОбрати внимание

ExitThread() - единственная функция, останавливающая работу потока. Вызывается из самого потока. Для завершения потока из внешнего кода применяют функцию TerminateThread(). Но применять TerminateThread нежелательно, т.к. она чрезмерно расходует ресурсы и может привести к аварийному завершению программы. Функция TerminateThread запрашивает 2 аргумента: дескриптор потока (thread handle) и код завершения (termination code; обычно 0).


Во время вызова функции CreateThread в параметре мы передаём указатель на переменную типа BOOL, которая отслеживает состояние потока (значение TRUE означает, что поток активен; FALSE - неактивен). По завершении выполнения потока данный флаг принимает значение FALSE. Затем поток уничтожается путём вызова функции ExitThread(), единственный параметр которой - код завершения, или по-другому "причина", по которой поток завершает свою работу. Обычно здесь всегда ставят 0.

Критические секции (Critical sections)

В свете того, что Windows - многозадачная ОС, приложения в ней могут конфликтовать друг с другом. Особенно если это приложения с несколькими потоками. Представь ситуацию, когда один поток заполняет структуру данных оч. важными данными, когда в это же время второй поток пытается получить доступ или изменить эти данные.
Есть способ убедиться в том, что только 1 поток (или процесс) в настоящее время имеет доступ к объекту данных. Для этого были придуманы критические секции (critical sections). Во время применения критической секции, фрагмент выполняемого кода становится недоступен для всех других процессов, которые пытаются получить к нему доступ (доступ к памяти приложения, которую по умолчанию одновременно используют все его потоки). Это позволяет отдельному потоку индивидуально изменять данные приложения, не заботясь о том, что другие потоки помешают этому.
Для использования критической секции её надо сначала объявить, а затем инициализировать:

CRITICAL_SECTION CriticalSection;
InitializeCriticalSection(&CriticalSection);

Теперь можно войти в критическую секцию, обработать важные данные и затем покинуть критическую секцию:

EnterCriticalSection(&CriticalSection);
 // Выполняем всякие операции над важными данными
LeaveCriticalSection(&CriticalSection);

По завершении работы с критической секцией (например при закрытии приложения) мы освобождаем занятые ею ресурсы:

DeleteCriticalSection(&CriticalSection);

Есть и другие функции по работе с критическими секциями. Интернет тебе в помощь. Для целей игрокодинга хватит азов. Единственное, что надо помнить при использовании критических секций, это то, что код, расположенный в критической секции, должен выполняться быстро. Т.к. другие процессы в это время ожидают открытия доступа к нему, что может вызвать подвисания.

Источники:


1. Jim Adams. Programming Role Playing Games with DirectX 8.0. - Premier Press. 2002
2. Morrison M. Sams Teach Yourself Game Programming in 24 hours. - Sams Publishing. 2002
3. Todd Barron. Strategy Game Programming with DirectX 9.0. - Wordware Publishing Inc. 2003

Contributors to this page: slymentat .
Последнее изменение страницы Четверг 16 / Апрель, 2020 14:19:22 MSK автор slymentat.

Помочь проекту

Яндекс-деньги: 410011791055108