Управление состоянием приложения
Оконная процедура — это просто функция, которая вызывается для каждого сообщения, поэтому она изначально не содержит состояния. Поэтому вам нужен способ отслеживания состояния приложения от одного вызова функции к следующему.
Самый простой подход — поместить все в глобальные переменные. Это достаточно хорошо подходит для небольших программ, и во многих примерах пакета SDK используется этот подход. Однако в большой программе это приводит к распространению глобальных переменных. Кроме того, у вас может быть несколько окон, каждое из которых имеет собственную процедуру окна. Отслеживание того, какое окно должно обращаться к тем или иным переменным, становится запутанным и подверженным ошибкам.
Функция CreateWindowEx предоставляет способ передачи любой структуры данных в окно. При вызове этой функции она отправляет следующие два сообщения в процедуру окна:
Эти сообщения отправляются в указанном порядке. (Это не единственные два сообщения, отправленные во время CreateWindowEx, но мы можем игнорировать остальные в этом обсуждении.)
Сообщение WM_NCCREATE и WM_CREATE отправляются до того, как окно станет видимым. Это делает их хорошим местом для инициализации пользовательского интерфейса, например для определения начального макета окна.
Последний параметр CreateWindowEx — это указатель типа void*. В этом параметре можно передать любое значение указателя. Когда процедура окна обрабатывает WM_NCCREATE или WM_CREATE сообщение, она может извлечь это значение из данных сообщения.
Давайте посмотрим, как использовать этот параметр для передачи данных приложения в окно. Сначала определите класс или структуру, содержащую сведения о состоянии.
// Define a structure to hold some state information.
struct StateInfo {
// ... (struct members not shown)
};
При вызове Метода CreateWindowEx передайте указатель на эту структуру в последнем параметре void* .
StateInfo *pState = new (std::nothrow) StateInfo;
if (pState == NULL)
{
return 0;
}
// Initialize the structure members (not shown).
HWND hwnd = CreateWindowEx(
0, // Optional window styles.
CLASS_NAME, // Window class
L"Learn to Program Windows", // Window text
WS_OVERLAPPEDWINDOW, // Window style
// Size and position
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
NULL, // Parent window
NULL, // Menu
hInstance, // Instance handle
pState // Additional application data
);
При получении сообщений WM_NCCREATE и WM_CREATE параметр lParam каждого сообщения является указателем на структуру CREATESTRUCT . Структура CREATESTRUCT , в свою очередь, содержит указатель, переданный в CreateWindowEx.
Вот как извлечь указатель на структуру данных. Сначала получите структуру CREATESTRUCT путем приведения параметра lParam .
CREATESTRUCT *pCreate = reinterpret_cast<CREATESTRUCT*>(lParam);
Элемент lpCreateParams структуры CREATESTRUCT — это исходный указатель void, указанный в createWindowEx. Получите указатель на собственную структуру данных, выполнив приведение lpCreateParams.
pState = reinterpret_cast<StateInfo*>(pCreate->lpCreateParams);
Затем вызовите функцию SetWindowLongPtr и передайте указатель на структуру данных.
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)pState);
Целью последнего вызова функции является сохранение указателя StateInfo в данных экземпляра для окна. После этого вы всегда сможете вернуть указатель из окна, вызвав Метод GetWindowLongPtr:
LONG_PTR ptr = GetWindowLongPtr(hwnd, GWLP_USERDATA);
StateInfo *pState = reinterpret_cast<StateInfo*>(ptr);
Каждое окно имеет собственные данные экземпляра, поэтому можно создать несколько окон и предоставить каждому окну собственный экземпляр структуры данных. Этот подход особенно полезен, если вы определяете класс окон и создаете несколько окон этого класса, например, если вы создаете пользовательский класс элемента управления. Удобно упаковать вызов GetWindowLongPtr в небольшую вспомогательную функцию.
inline StateInfo* GetAppState(HWND hwnd)
{
LONG_PTR ptr = GetWindowLongPtr(hwnd, GWLP_USERDATA);
StateInfo *pState = reinterpret_cast<StateInfo*>(ptr);
return pState;
}
Теперь вы можете написать процедуру окна следующим образом.
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
StateInfo *pState;
if (uMsg == WM_CREATE)
{
CREATESTRUCT *pCreate = reinterpret_cast<CREATESTRUCT*>(lParam);
pState = reinterpret_cast<StateInfo*>(pCreate->lpCreateParams);
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)pState);
}
else
{
pState = GetAppState(hwnd);
}
switch (uMsg)
{
// Remainder of the window procedure not shown ...
}
return TRUE;
}
Подход Object-Oriented
Мы можем расширить этот подход еще больше. Мы уже определили структуру данных для хранения сведений о состоянии окна. Имеет смысл предоставить эту структуру данных с помощью функций-членов (методов), которые работают с данными. Это, естественно, приводит к разработке, в которой структура (или класс) отвечает за все операции в окне. Затем процедура окна станет частью класса .
Другими словами, мы хотели бы перейти к следующему:
// pseudocode
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
StateInfo *pState;
/* Get pState from the HWND. */
switch (uMsg)
{
case WM_SIZE:
HandleResize(pState, ...);
break;
case WM_PAINT:
HandlePaint(pState, ...);
break;
// And so forth.
}
}
На эту:
// pseudocode
LRESULT MyWindow::WindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case WM_SIZE:
this->HandleResize(...);
break;
case WM_PAINT:
this->HandlePaint(...);
break;
}
}
Единственная проблема заключается в том, как подключить MyWindow::WindowProc метод . Функция RegisterClass ожидает, что процедура window будет указателем функции. В этом контексте невозможно передать указатель на (нестатическую) функцию-член. Однако можно передать указатель на статическую функцию-член, а затем делегировать функции-члену. Ниже приведен шаблон класса, демонстрирующий такой подход:
template <class DERIVED_TYPE>
class BaseWindow
{
public:
static LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
DERIVED_TYPE *pThis = NULL;
if (uMsg == WM_NCCREATE)
{
CREATESTRUCT* pCreate = (CREATESTRUCT*)lParam;
pThis = (DERIVED_TYPE*)pCreate->lpCreateParams;
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)pThis);
pThis->m_hwnd = hwnd;
}
else
{
pThis = (DERIVED_TYPE*)GetWindowLongPtr(hwnd, GWLP_USERDATA);
}
if (pThis)
{
return pThis->HandleMessage(uMsg, wParam, lParam);
}
else
{
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
}
BaseWindow() : m_hwnd(NULL) { }
BOOL Create(
PCWSTR lpWindowName,
DWORD dwStyle,
DWORD dwExStyle = 0,
int x = CW_USEDEFAULT,
int y = CW_USEDEFAULT,
int nWidth = CW_USEDEFAULT,
int nHeight = CW_USEDEFAULT,
HWND hWndParent = 0,
HMENU hMenu = 0
)
{
WNDCLASS wc = {0};
wc.lpfnWndProc = DERIVED_TYPE::WindowProc;
wc.hInstance = GetModuleHandle(NULL);
wc.lpszClassName = ClassName();
RegisterClass(&wc);
m_hwnd = CreateWindowEx(
dwExStyle, ClassName(), lpWindowName, dwStyle, x, y,
nWidth, nHeight, hWndParent, hMenu, GetModuleHandle(NULL), this
);
return (m_hwnd ? TRUE : FALSE);
}
HWND Window() const { return m_hwnd; }
protected:
virtual PCWSTR ClassName() const = 0;
virtual LRESULT HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam) = 0;
HWND m_hwnd;
};
Класс BaseWindow является абстрактным базовым классом, производным от которого являются определенные классы окон. Например, вот объявление простого класса, производного от BaseWindow:
class MainWindow : public BaseWindow<MainWindow>
{
public:
PCWSTR ClassName() const { return L"Sample Window Class"; }
LRESULT HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam);
};
Чтобы создать окно, вызовите BaseWindow::Create:
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, PWSTR pCmdLine, int nCmdShow)
{
MainWindow win;
if (!win.Create(L"Learn to Program Windows", WS_OVERLAPPEDWINDOW))
{
return 0;
}
ShowWindow(win.Window(), nCmdShow);
// Run the message loop.
MSG msg = { };
while (GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return 0;
}
Метод pure-virtual BaseWindow::HandleMessage используется для реализации процедуры окна. Например, следующая реализация эквивалентна процедуре окна, показанной в начале модуля 1.
LRESULT MainWindow::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case WM_DESTROY:
PostQuitMessage(0);
return 0;
case WM_PAINT:
{
PAINTSTRUCT ps;
HDC hdc = BeginPaint(m_hwnd, &ps);
FillRect(hdc, &ps.rcPaint, (HBRUSH) (COLOR_WINDOW+1));
EndPaint(m_hwnd, &ps);
}
return 0;
default:
return DefWindowProc(m_hwnd, uMsg, wParam, lParam);
}
return TRUE;
}
Обратите внимание, что дескриптор окна хранится в переменной-члене (m_hwnd), поэтому нам не нужно передавать его в качестве параметра в HandleMessage.
Многие существующие платформы программирования Windows, такие как Microsoft Foundation Classes (MFC) и библиотека активных шаблонов (ATL), используют подходы, которые в основном похожи на приведенные здесь. Конечно, полностью обобщенная платформа, такая как MFC, является более сложной, чем этот относительно упрощенный пример.
Следующая
Модуль 2. Использование COM в программе Windows