5. Прикладной интерфейс для WINDOWS

5. Прикладной интерфейс для WINDOWS

Данная глава посвящена программированию на языке С++ в операционной системе Windows . Операционная система Windows ( NT /95/98/2000) ориентирована на многооконный интерфейс. После загрузки в память программа пользователя ожидает сообщения, посылаемого ей операционной системой Windows . Для приема сообщения программа запускает цикл обработки сообщений. В этом цикле сообщения выбираются из очереди сообщений для данной программы и направляются обратно к операционной системе Windows , которая вызывает оконную функцию, передавая ей эти сообщения в качестве параметров.
Программа получает доступ к ресурсам Windows , используя множество функций API ( Application Program Interface – Программный Интерфейс Приложений). Поддержку независимого от графического оборудования обмена обеспечивает GDI ( Graphics Device Interface – Интерфейс Графических Устройств), который является подмножеством API .
 
5.1. Приложения Windows
 
Поскольку Windows поддерживает 32 – разрядную адресацию, некоторые типы данных изменили свою размерность: типы int и unsigned стали 32 – битными, при объявлении указателей не требуется их определение как near или far (если такие определения встречаются, то они игнорируются).
Компоненты окна . Каждое окно имеет рамку, определяющую его границы. В верхнем левом углу находится иконка ( пиктограмма) системного меню. Щелчок мыши на этой пиктограмме открывает системное меню. Справа от иконки находится заголовок окна . В правом верхнем углу – кнопки минимизации, полноэкранной развертки и закрытия окна. Действие программы отображается в рабочей области. Многие окна имеют горизонтальные и вертикальные линейки прокрутки.
Главная подпрограмма и оконные функции. Приложения, использующие API , начинают свое выполнение с вызова WinMain() вместо вызова main() . Подпрограмма WinMain() является главной и должна быть описана как WINAPI . Когда операционная система Windows посылает сообщения приложению, она вызывает оконные функции и сообщения передает через параметры этих функций. Все оконные функции должны объявляться как LRESULT CALLBACK .
 
5.2. Каркас приложения
 
Главная подпрограмма WinMain() должна выполнять следующие действия:
•  определить класс окна (заполнить поля фрейма);
· зарегистрировать окно в системе Windows ;
•  создать окно данного класса;
•  вывести окно на экран;
•  запустить цикл обработки сообщений.
Оконная функция WindowFunc() должна обрабатывать все сообщения, относящиеся к данному окну. В приведенном ниже примере обрабатывается лишь сообщение WM_DESTROY о закрытии окна. Фрейм окна определен структурой WNDCLASS wcl . Окно создается с помощью функции CreateWindow() .
Добавлены типы данных:
HANDLE – число, идентифицирующее некоторый ресурс (32 бита),
HWND – 32 – разрядное целое число, используемое как дескриптор окна,
WORD – 16 – разрядное короткое целое без знака,
DWORD – длинное целое без знака,
UINT – 32 – разрядное беззнаковое целое,
BOOL – принимает значения 0 или 1, так называемый булевый тип,
BYTE – 8 – разрядное целое без знака,
LPSTR – указатель на строку,
LPCSTR – постояный указатель на строку.
Ниже приведём текст программы, реализующей каркас приложения:
#include <windows.h>
#include <string.h>
// 1. Набрать данный текст, вызвав bcw
// 2. Создать проект: File -> New -> Project
// (ввести имя, например karkas.ide вместо proj0001.ide)
// 3. Удалить *.def
// 4. Нажать [Ctrl]+ F9
 
#include<stdio.h>
LRESULT CALLBACK WindowFunc(HWND,UINT,WPARAM,LPARAM);
 
char szwinname[] = "May Window";
 
int WINAPI WinMain(HINSTANCE hthisinst,
HINSTANCE hprevinst,
LPSTR lpszargs,
int nwinmode)
{
HWND hwnd ; // дескриптор (заголовок) окна, т.е. номер,
// единственным образом идентифицирующий окно
MSG msg; // сообщение состоит из HWND окна,
// получающего сообщение, UINT (номер) сообщения
// LPARAM , WPARAM , DWORD time , POINT pt -позиция курсора
WNDCLASS wcl ;
 
wcl . hInstance = hthisinst ; // дескриптор данного приложения
wcl . lpszClassName = szwinname ; // имя класса окна
wcl . lpfnWndProc = WindowFunc ; // оконная функция
wcl.style = 0; // стиль по умолчанию
 
wcl.hIcon = LoadIcon (NULL, IDI_APPLICATION);// как exe - MSDOS
// IDI_ASTERISK - перевернутый воскл знак (информация)
// IDI_EXCLAMATION - внимание (воскл знак в желтом тр-ке)
// ID_HAND - знак стоп (два скрещенных отрезка в красном круге)
// IDI_QUESTION - вопрос в белом круге
wcl . hCursor = LoadCursor ( NULL , IDC _ ARROW ); // курсор выводится как стрелка
// CROSS (+), IBEAM (верт черта), ( WAIT ) пес часы
wcl.lpszMenuName = NULL;
 
wcl.cbClsExtra = 0;
wcl.cbWndExtra = 0;
 
// цвет окна белый
wcl.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
if(!RegisterClass(&wcl)) // регистрация окна
return 0;
 
hwnd = CreateWindow(szwinname,
"KARKAS",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
HWND_DESKTOP,
NULL,hthisinst,
NULL);
ShowWindow(hwnd,nwinmode); // показать окно
UpdateWindow(hwnd); // перерисовать содержимое
 
while(GetMessage(&msg,NULL,0,0))
{
TranslateMessage(&msg);// транслировать клавиши
// если убрать, то не будет реагировать на клавиши
DispatchMessage(&msg);// вернуть управление Windows
}
return msg.wParam;
}
 
LRESULT CALLBACK WindowFunc(HWND hwnd,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
switch(message)
{
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd,message,wParam,lParam);
}
return 0;
}
 
Обсудим приведённый выше текст программы.
Выполнение программы начинается с WinMain() , имеющей четыре параметра:
•  hthisinst – дескриптор текущего экземпляра приложения (в системе Windows могут работать несколько экземпляров одной и той же программы);
•  hprevinst – всегда равен NULL , в Windows 3.1 мог принимать ненулевые значения, если ранее были запущены другие экземпляры данного приложения;
•  lpszargs – указатель на строку, содержащую аргументы программы при ее запуске;
•  nwinmode – определяет способ визуализации окна при запуске программы.
Затем определяется и регистрируется класс окна, содержащий поля (классом называют фрейм):
 
UINT style ; // тип окна
WNDPROC lpfnWndProc ; // адрес оконной функции
int cbClsExtra ; // дополнительные данные для класса
int cbWndExtra ; // дополнительные данные для окна
HINSTANCE hInstance ; // дескриптор экземпляра приложения
HICON hIcon ; // дескриптор иконки
HCURSOR hCursor ; // дескриптор курсора мыши
HBRUSH hbrBackground ; // цвет заполнения окна
LPCSTR lpszMenuName ; // имя главного меню
LPCSTR lpszClassName ; // имя класса окна
 
В данном случае меню не требуется, и имя главного меню будет равно NULL .
Создание окна осуществляется с помощью функции
 
HWND CreateWindow (
LPCSTR lpClassName , // имя класса окна
LPCSTR lpWinName , // заголовок окна
DWORD dwStyle , // стиль окна
int x , int y , // координаты верхнего левого угла
int Width, int Height, // размеры окна
HWND hParent, // дескриптор родительского окна
HMENU hMenu, // дескриптор главного меню
HINSTANCE hThisInst, // дескриптор приложения
LPVOID lpszAdditional); // указатель на доп . информацию
 
В нашем случае для параметров x , y , Width , Height используется значение, заданное макросом CW_USEDEFAULT , позволяющее системе самостоятельно выбирать координаты и размеры окна. Если окно не имеет родительского окна, то hParent должен быть равен HWND_DESKTOP или NULL . Поскольку главного меню нет, то hMenu = NULL . Аналогично указатель на дополнительную информацию равен NULL .
Для стиля (или типа) создаваемого окна используется макрос WS_OVERLAPPEDWINDOW , определяющий стандартное окно, имеющее системное меню, заголовок, рамку для изменения размеров, а также кнопки минимизации, развертки и закрытия. Используется наиболее общий стиль. Можно создавать окна, имеющие другие стили. Для этого применяют комбинации стилевых макросов. Наиболее широко используются стили:
 
WS _ OVERLAPPED - стандартное окно с рамкой,
WS _ MAXIMIZEBOX - наличие кнопки развертки,
WS _ MINIMIZEBOX - наличие кнопки минимизации,
WS _ SYSMENU - наличие системного меню,
WS _ HSCROLL - наличие горизонтальной панели прокрутки,
WS _ VSCROLL - наличие вертикальной панели прокрутки.
 
Для отображения окна на экран используется функция
 
BOOL ShowWindow(HWND hwnd, int nHow);
параметры которой задают дескриптор окна ( hwnd ) и способ отображения nHow . Можно использовать следующие способы отображения:
 
SW _ HIDE - скрыть окно,
SW _ MAXIMIZE - развернуть окно до полноэкранного,
SW _ MINIMIZE - свернуть окно до иконки,
SW _ RESTORE - отобразить окно в нормальном представлении.
 
Вызов функции UpdateWindow() означает немедленную перерисовку окна, и Windows в этом случае направляет программе сообщение, указывающее на необходимость перерисовки.
Последней частью программы WinMain() является цикл обработки сообщений. Целью этого цикла является получение и обработка сообщений, передаваемых операционной системой. Эти сообщения ставятся в очередь сообщений приложения, откуда они потом выбираются функцией
BOOL GetMessage(LPMSG msg, HWND hwnd, UINT min, UINT max);
Выбираемые из очереди сообщения сохраняются по адресу msg , где находится структура:
struct MSG
{
HWND hwnd ; // окно, для которого назначено сообщение
UINT message ; // само сообщение
WPARAM wParam ; // параметры
LPARAM lParam ; // сообщения
DWORD time ; // время посылки сообщения
POINT pt ; // положение курсора мыши
}
Структура, определяющая координаты курсора мыши, описывается следующим образом
struct POINT
{
LONG x,y; // координаты
}
Параметр hwnd функции GetMessage() является дескриптором окна, для которого эта функция получает сообщения. Если требуется получать сообщения, адресованные всем окнам приложения, то hwnd должен быть равен NULL . Остальные два параметра определяют диапазон получаемых сообщений. Если они равны 0 , то программа получает все сообщения. Подпрограмма GetMessage() возвращает 0 , когда пользователь завершает работу.
Функция TranslateMessage() транслирует виртуальные коды клавиш, генерируемые системой Windows , в клавиатурные сообщения.
Когда сообщение получено и преобразовано, функция DispatchMessage() возвращает его обратно к Windows . Затем это сообщение будет передано системой Windows в оконную функцию приложения. В конце работы программа возвращает значение msg.wParam .
В нашем примере оконная функция имеет имя WindowsFunc() . Ее параметрами являются первые четыре поля структуры MSG . В нашем примере оконная функция обрабатывает единственное сообщение WM_DESTROY – завершить работу программы. Она обрабатывает его с помощью функции PostQuitMessage() , приводящей к передаче сообщения WM_QUIT приложению. Получив это сообщение, GetMessage() возвращает 0 и завершает тем самым цикл обработки сообщений.
Заметим, что при создании проекта приложения с помощью выбора опций File ® New ® Project и включения имени, например karkas.ide , требуется создать пустой файл karkas.def , или удалить его из списка файлов, используемых при компиляции.
 
5.3. Обработка сообщений в системе Windows
 
Сообщения обрабатываются оконной функцией. Типы сообщений представляются 32-разрядными словами. Для идентификации этих чисел применяются макроимена. Наиболее часто используются следующие макроимена сообщений:
 
WM _ CHAR - нажата клавиша;
WM _ PAINT - запрос на перерисовку окна;
WM _ LBUTTONDOWN - нажата левая кнопка мыши;
WM _ RBUTTONDOWN - нажата правая кнопка мыши;
WM _ COMMAND - выбрана команда меню;
WM _ TIMER - истечение заданного интервала времени.
 
Каждое сообщение имеет два 32-разрядных параметра типов WPARAM и LPARAM . Обработку сообщений выполняет оконная функция, имеющая четыре параметра: дескриптор окна, сообщение и два указанных выше параметра.
Для доступа к младшему и страшему словам 32-битного двойного слова применяются функции LOWORD и HIWORD . Например, операции
x = LOWORD ( lParam );
y = HIWORD ( lParam );
записывают в ( x , y ) координаты курсора мыши в случаях обработки сообщения о нажатии левой или правой кнопки мыши.
Обработка нажатия клавиши . Для сообщения WM_CHAR параметр wParam содержит ASCII – код нажатой клавиши, LOWORD(lParam) – количество повторов, генерируемых при удержании клавиши в нажатом состоянии, HIWORD(lParam) содержит следующую информацию, определенную значениями битов:
15: 1 – клавиша отпущена, 0 – нажата;
14: устанавливается, если клавиша уже была нажата перед посылкой сообщения;
13: дополнительно нажата клавиша ALT ;
12-9: используется системой;
8: нажата дополнительная или функциональная часть клавиатуры;
7-0: scan – код клавиши.
Для того чтобы добавить в написанный выше каркас приложения обработку события WM_CHAR , определим массив символов для ввода и подключим библиотеки обработки строки и вывода на экран:
#include <string.h>
#include <stdio.h>
char str [80] = “”; // буфер для строки ввода
 
Добавив обработку события WM_CHAR , получаем следующую оконную функцию:
 
LRESULT CALLBACK WindowFunc(HWND hwnd,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
HDC hdc;
switch(message)
{
case WM_CHAR:
hdc = GetDC ( hwnd ); // получить контекст устройства
TextOut ( hdc , 1, 1, “ “, 2); // стереть старый символ
sprintf ( str , “% c ”, ( char ) wParam ); // записать в буфер новый символ
TextOut ( hdc , 1, 1, str , strlen ( str )); // вывести на экран
ReleaseDC ( hwnd , hdc ); // освободить контекст устройства
break;
case WM_DESTROY:
PostQuitMessage(0); // сообщение о завершении
break;
default: // обработка остальных сообщений
return DefWindowProc(hwnd, message, wParam, lParam);
}
return 0;
}
 
Контекст устройства. Функция GetDC() устанавливает связь программы с экраном. Значение, возвращаемое этой функцией, называется контекстом устройства . Ниже дадим более точное определение.
Контекст устройства – это структура данных, связывающая приложение с драйвером устройства и полностью определяющая состояние драйвера и способ вывода информации.
Программа может вывести информацию на экран, только получив контекст устройства. По окончании процесса вывода она должна этот контекст освободить, вызвав ReleaseDC() .
Эти функции имеют следующие прототипы:
 
HDC GetDC(HWND hwnd);
int ReleaseDC(HWND hwnd, HDC hdc);
Тип HDC означает дескриптор контекста устройства. Функция ReleaseDC() возвращает ненулевое значение, если она завершилась успешно.
Текст на экран выводит функция, имеющая следующий прототип:
 
BOOL TextOut(HDC hdc, int x, int y, LPSTR lpstr, int nlength);
На экран выводится nlength символов строки, указатель на которую равен lpstr . Координаты задаются относительно начала рабочей области, а не экрана.
Обработка запроса на перерисовку окна . Если нажать кнопку минимизации окна, а затем вновь распахнуть окно, то символы, записанные в окне с помощью TextOut() , будут потеряны. Система Windows , как правило, не запоминает содержимое окна, но каждый раз, когда надо перерисовать окно, она посылает оконной функции сообщение WM_PAINT .
В некоторых случаях при перемещении и при изменении размеров окна система сохраняет и перерисовывает содержимое окна, но это не касается случая, когда окно минимизируется или перекрывается другим окном, а потом делается попытка восстановить его в исходное состояние. Для того чтобы обрабатывать сообщение WM_PAINT , добавим соответствующий этому сообщению случай в оператор switch функции окна:
 
case WM_PAINT:
hdc = BeginPaint(hwnd, &paintstruct); // получить DC
TextOut(hdc, 1, 1, str, strlen(str));
EndPaint(hwnd, &paintstruct); // освободить DC
break;
 
В данном случае применяются другие функции получения и освобождения контекста устройства. Они имеют дополнительный параметр, равный адресу структуры.
 
struct PAINTSTRUCT
{
HDC hdc ; // дескриптор DC
BOOL fErase ; // true , если перерисовывается заполнение окна
RECT rcPaint ; // координаты области перерисовки
BOOL fRestore , fIncUpdate ; // резерв
BYTE rgbReserved [32]; // резерв
}
 
Здесь тип RECT описывает структуру
struct RECT
{
LONG left, top, right, bottom;
}
 
Для обработки сообщения WM_PAINT добавим определение
 
PAINTSTRUCT paintstruct ;
В результате получаем приведённую ниже оконную функцию:
 
LRESULT CALLBACK WindowFunc(HWND hwnd,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
HDC hdc; // контекст устройства
PAINTSTRUCT paintstruct;
switch(message)
{
case WM_CHAR:
hdc = GetDC ( hwnd ); // получить контекст устройства
TextOut ( hdc , 1, 1, “ “, 2); // стереть старый символ
sprintf ( str , “% c ”, ( char ) wParam ); // записать в буфер новый символ
TextOut ( hdc , 1, 1, str , strlen ( str )); // вывести на экран
ReleaseDC ( hwnd , hdc ); // освободить контекст устройства
break;
case WM_PAINT:
hdc = BeginPaint(hwnd, &paintstruct); // получить DC
TextOut(hdc, 1, 1, str, strlen(str));
EndPaint(hwnd, &paintstruct); // освободить DC
break;
case WM_DESTROY:
PostQuitMessage(0); // сообщение о завершении
break;
default: // обработка остальных сообщений
return DefWindowProc(hwnd, message, wParam, lParam);
}
return 0;
}
 
В реальных программах обработка сообщения WM_PAINT может быть намного сложнее. Она выполняется одним из трех способов:
•  программа выводит при перерисовке информацию, полученную в результате некоторых вычислений;
•  последовательность событий запоминается и при необходимости воспроизводится вновь для перерисовки окна;
•  программа поддерживает виртуальный экран, который при перерисовке копируется в окно.
Обработка сообщений мыши . Рассмотрим наиболее часто употребляемые сообщения мыши WM_LBUTTONDOWN и WM_RBUTTONDOWN , которые поступают при нажатии соответственно левой и правой кнопок мыши. Для обработки этих сообщений в оконной функции добавим следующие строки:
 
case WM _ RBUTTONDOWN : // нажата правая кнопка мыши
hdc = GetDC ( hwnd ); // получить DC
strcpy ( str , “Нажата правая кнопка”);
TextOut(hdc, LOWORD(lParam), HIWORD(lParam), str, strlen(str));
ReleaseDC(hwnd, hdc); // освободить DC
break;
case WM_LBUTTONDOWN: // нажата левая кнопка мыши
hdc = GetDC(hwnd); // получить DC
strcpy(str, “ Нажата левая кнопка ”);
TextOut(hdc, LOWORD(lParam), HIWORD(lParam), str, strlen(str));
ReleaseDC(hwnd, hdc); // освободить DC
break;
 
При нажатии кнопки мыши координаты курсора x и y передаются в lParam . Поскольку текст в данном случае выводится, начиная с позиции ( LOWORD ( lParam ), HIWORD ( lParam )) , то при нажатии кнопки мыши сообщение об этом будет выводиться в текущей позиции курсора.
Параметр wParam будет содержать информацию, определенную комбинацией флагов:
 
MK _ CONTROL - в момент нажатия кнопки мыши была нажата клавиша [ Ctrl ];
MK _ SHIFT - то же для клавиши SHIFT ;
MK _ LBUTTON - была нажата левая кнопка мыши;
MK _ RBUTTON - была нажата правая кнопка мыши;
MK _ MBUTTON - была нажата средняя кнопка мыши.
 
Генерация сообщения WM_PAINT . Программа имеет возможность вызвать генерацию и посылку операционной системой сообщения о запросе на перерисовку окна. Операционная система передаст это сообщение в удобное для себя время. Это позволяет эффективно использовать время центрального процессора.
Чтобы заставить Windows послать сообщение WM_PAINT , программа должна вызвать функцию
 
BOOL InvalidateRect(HWND hwnd, CONST RECT *lpRect, BOOL fErase);
где hwnd – дескриптор окна, которому должно быть адресовано сообщение WM_PAINT , lpRect – указатель на структуру RECT , задающую прямоугольную область в окне, которая должна быть перерисована. Если lpRect = NULL , то окно перерисовывается полностью. Если fErase не равен нулю, то вначале выполняется перерисовка заполнения, т.е. содержимое перерисовываемой области вначале стирается.
Для демонстрации способа генерации запроса о перерисовке модифицируем каркасную программу следующим образом:
· добавим внешние переменные
char str [80] = “”;
int X = 1, Y = 1;
· главная программа не изменяется;
· перепишем оконную функцию таким образом, что вывод на экран производится с помощью обработки сообщения WM_PAINT . Выводится строка из буфера. При обработке других сообщений этот буфер заполняется и вызывается генерация сообщения WM_PAINT .
Ниже приведём текст модифицированной оконной функции.
 
LRESULT CALLBACK WindowFunc(HWND hwnd,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
HDC hdc;
PAINTSTRUCT paintstruct;
switch(message)
{
case WM _ CHAR :
X = Y = 1; // выводим в левом верхнем углу
sprintf(str, “%c”, (char)wParam); // заполнить буфер
InvalidateRect(hwnd, NULL, 1); // генерация WM_PAINT
break;
case WM_PAINT:
hdc = BeginPaint(hwnd, &paintstruct); // получить DC
TextOut(hdc, X, Y, str, strlen(str)); // вывод
EndPaint(hwnd, &paintstruct); // освободить DC
break;
case WM_RBUTTONDOWN: // нажата правая кнопка мыши
hdc = GetDC(hwnd); // получить DC
strcpy(str, “ Нажата правая кнопка ”);
TextOut(hdc, LOWORD(lParam), HIWORD(lParam), str, strlen(str));
ReleaseDC(hwnd, hdc); // освободить DC
break;
case WM_LBUTTONDOWN: // нажата левая кнопка мыши
hdc = GetDC(hwnd); // получить DC
strcpy(str, “ Нажата левая кнопка ”);
TextOut(hdc, LOWORD(lParam), HIWORD(lParam), str, strlen(str));
ReleaseDC(hwnd, hdc); // освободить DC
break;
case WM_DESTROY:
PostQuitMessage(0); // сообщение о завершении
break;
default: // обработка остальных сообщений
return DefWindowProc(hwnd, message, wParam, lParam);
}
return 0;
}
 
Генерация сообщений таймера . Можно устанавливать таймер, который с заданной периодичностью будет посылать программе сообщение WM_TIMER . Для установки таймера применяется функция
UINT SetTimer ( HWND hwnd , UINT nID , UINT wLength , TIMEPROC lpTFunc );
где hwnd – дескриптор окна, nID -идентификатор устанавливаемого таймера (можно использовать несколько таймеров), wLength – временной интервал в миллисекундах, lpTFunc – функция обработки сообщений таймера. Если TFunc = NULL , то для обработки сообщений таймера будет вызываться оконная функция. Для отключения таймера вызывается функция
 
BOOL KillTimer ( HWND hwnd , UINT nID );
где nID – идентификатор таймера, а hwnd – дескриптор окна, использующего таймер.
Например, если в программе, демонстрирующей генерацию WM_PAINT , поставить после вызова функции ShowWindow(hwnd, nWinMode); вызов подпрограммы установки таймера:
SetTimer ( hwnd , 1, 1000, NULL );
а после цикла обработки сообщений:
 
KillTimer ( hwnd , 1);
то вывод окна, в котором показывается день недели, месяц, число, время и год, осуществляется с помощью оконной функции:
 
LRESULT CALLBACK WindowFunc(HWND hwnd,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
HDC hdc;
PAINTSTRUCT paintstruct;
struct tm *newtime;
time_t t;
switch(message)
{
case WM_PAINT:
hdc = BeginPaint(hwnd, &paintstruct); // получить DC
TextOut(hdc, X, Y, str, strlen(str)); // вывод буфера
EndPaint(hwnd, &paintstruct); // освободить DC
break;
case WM_TIMER:
t = time(NULL);
newtime = localtime (& t ); //получить текущее время
strcpy(str, asctime(newtime)); // запись в буфер
str[strlen(str)-1] = ‘\0';
InvalidateRect(hwnd, NULL, 1);
break;
case WM_DESTROY:
PostQuitMessage(0); // сообщение о завершении
break;
default: // обработка остальных сообщений
return DefWindowProc(hwnd, message, wParam, lParam);
}
return 0;
}
 
Окна сообщений . Возможен вывод информации с ожиданием реакции пользователя. Это средство является самым простым элементом интерфейса и называется окном сообщения . Для создания этого элемента используется функция:
int MessageBox ( HWND hwnd , LPCSTR lpText , LPCSTR lpCaption , UINT wMBType );
где hwnd – дескриптор родительского окна, lpText – выводящаяся на экран строка внутри окна сообщения, lpCaption – заголовок окна сообщения. Параметр wMBType является комбинацией значений, определяющих свойства окна сообщения, включающих типы кнопок и дополнительную иконку рядом с текстом сообщения. Возвращаемые значения зависят от реакции пользователя: если нажата кнопка OK , то возвращается значение IDOK , Abort – IDABORT , Retry – IDRETRY , Ignore – IDIGNORE , Cancel – IDCANCEL , No – IDNO , Yes – IDYES .
Ниже приведены значения, используемые для параметра wMBType :
 

Ниже представлены результаты работы программы.

5.6. Пример программы, использующей список и окно ввода
 
Рассмотрим циклический список, элементы которого находятся в окне LISTBOX . Запись элементов в список производится из окна EDITTEXT . Вывод оконной функцией элементов циклического списка на экран осуществляется с помощью обработки сообщения WM_PAINT . Остальные опции в оконной функции заканчиваются генерацией сообщения о перерисовке окна.
Определения числовых идентификаторов содержатся в mydialog.h :
#define IDM_DIALOG1 100
#define IDM_DIALOG2 101
#define IDM_HELP 102
#define IDD_RED 103
#define IDD_GREEN 104
#define ID_EB1 400
#define ID_LB1 301
#define IDM_INSERT 200
#define IDM_DELETE 201
#define IDM_SHOW 202
 
Файл ресурсов mydialog.rc :
#include <windows.h>
#include "mydialog.h"
MYMENU MENU //меню
{
POPUP "List"
{
MENUITEM "I&nsert",IDM_INSERT
MENUITEM "&Delete",IDM_DELETE
MENUITEM "&Show",IDM_SHOW
}
MENUITEM "Help",IDM_HELP
}
MYMENU ACCELERATORS // акселераторы
{
VK_F2,IDM_INSERT,VIRTKEY
VK_F1,IDM_HELP,VIRTKEY
}
MYDB DIALOG 18,18,142,92
CAPTION "Insert & Show" //заголовок окна
STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
{
PUSHBUTTON " Конец ввода ",IDCANCEL,52,65,60,14, //кнопка Конец ввода
WS_CHILD | WS_VISIBLE | WS_TABSTOP
EDITTEXT ID_EB1, 68, 8, 72, 12, ES_LEFT | //editbox
ES_AUTOHSCROLL | WS_CHILD | WS_VISIBLE | WS_BORDER |
WS_TABSTOP
LISTBOX 301, 2,10,47,80, LBS_NOTIFY | //list box
WS_CHILD | WS_VISIBLE | WS_BORDER |
WS_VSCROLL | WS_TABSTOP
}
 
Текст программы mydialog.cpp
#include <windows.h>
#include <string.h>
#include <stdio.h>
#include "mydialog.h"
//объявим прототипы функций и глобальные переменные
LRESULT CALLBACK WindowFunc(HWND,UINT,WPARAM,LPARAM);
 
BOOL CALLBACK DialogFunc (HWND,UINT,WPARAM,LPARAM);
 
char szWinName[] = "Lists";
 
HINSTANCE hInst;
int X=0, Y=0;
int maxX,maxY;
HDC memdc;
HBITMAP hbit;
HBRUSH hbrush;
 
char str[80];
int i=1;
 
struct slink {char *e; slink *next;};
 
slink * abc 1= NULL ;
//операции со списком, вставка нового элемента, удаление элемента
slink *insert( slink *lst, char *a)
{
slink *prev=lst, *p= new slink;
p->e = new char[strlen(a)+1];
strcpy(p->e,a); p->e[strlen(a)+1]='\0';
p->next = NULL;
if(lst==NULL) return p;
while(lst->next!=NULL)
{
lst =lst->next;
}
lst->next = p;
return prev;
}
// удаление элемента
slink * del ( slink *lst)
{
slink *p=lst;
if(lst)
{
lst = lst->next; delete p;
}
return lst;
}
 
int WINAPI WinMain(HINSTANCE hThisInst,
HINSTANCE hPrevinst,
LPSTR lpszArgs,
int nWinMode)
{
HWND hwnd;
MSG msg;
WNDCLASS wcl;
HACCEL hAccel;
 
wcl.hInstance = hThisInst;
wcl.lpszClassName = szWinName;
wcl.lpfnWndProc= WindowFunc;
wcl.style = 0;
 
wcl.hIcon = LoadIcon (NULL, IDI_APPLICATION); //иконка
wcl.hCursor = LoadCursor(NULL,IDC_ARROW); //курсор
wcl.lpszMenuName = "MYMENU"; //меню
 
wcl.cbClsExtra = 0;
wcl.cbWndExtra = 0;
//фон
wcl.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
 
if(!RegisterClass(&wcl))
return 0;
//создадим окно
hwnd = CreateWindow(szWinName,
"Dialogs",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
HWND_DESKTOP,
NULL,
hThisInst,
NULL);
 
hInst = hThisInst;
hAccel = LoadAccelerators(hThisInst,"MYMENU");//подключим акселераторы
 
ShowWindow(hwnd,nWinMode); //отобразить окно
UpdateWindow(hwnd);
// обработка акселераторов
while(GetMessage(&msg,NULL,0,0))
{
if(!TranslateAccelerator(hwnd,hAccel,&msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
return msg.wParam;
}
 
LRESULT CALLBACK WindowFunc(HWND hwnd,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
HDC hdc;
PAINTSTRUCT paintstruct;
static TEXTMETRIC tm;
SIZE size;
slink* abc3 = abc1;
switch(message)
{
case WM_CREATE:
// получаем размеры окна
maxX= GetSystemMetrics(SM_CXSCREEN);
maxY= GetSystemMetrics(SM_CYSCREEN);
// строим растр , совместимый с окном
hdc = GetDC(hwnd); // получить DC
memdc= CreateCompatibleDC(hdc);
hbit= CreateCompatibleBitmap(hdc,maxX,maxY);
SelectObject(memdc,hbit);
hbrush=(HBRUSH)GetStockObject(WHITE_BRUSH);
SelectObject(memdc,hbrush);
PatBlt(memdc,0,0,maxX,maxY,PATCOPY);
ReleaseDC(hwnd,hdc); //освободить DC
break;
case WM_COMMAND:
switch (LOWORD (wParam))
{
case IDM_INSERT:
DialogBox(hInst,"MYDB",hwnd, (DLGPROC)DialogFunc);
break;
case IDM_DELETE:
GetTextMetrics(memdc,&tm);
X=Y=0;
PatBlt(memdc,0,0,maxX,maxY,PATCOPY);// очистка экрана
abc1= del (abc1);
abc3=abc1;
while(abc3!=NULL)
{
sprintf(str, "%s", abc3->e);
TextOut(memdc, X, Y, str, strlen(str));
Y = Y+ tm.tmHeight+tm.tmExternalLeading;
abc3=abc3->next;
}
InvalidateRect(hwnd,NULL,1);
break;
case IDM_SHOW:
GetTextMetrics(memdc,&tm);
X=Y=0;
PatBlt(memdc,0,0,maxX,maxY,PATCOPY);
abc3=abc1;
while(abc3!=NULL)
{
sprintf(str, "%s", abc3->e);
TextOut(memdc, X, Y, str, strlen(str));
Y = Y+ tm.tmHeight+tm.tmExternalLeading;
abc3=abc3->next;
}
InvalidateRect(hwnd,NULL,1);
break;
case IDM_HELP:
MessageBox(hwnd,"Help","Help",MB_OK);
break;
}
break;
case WM_PAINT:
hdc=BeginPaint(hwnd,&paintstruct); //get dc
BitBlt(hdc,0,0,maxX,maxY,memdc,0,0,SRCCOPY);
EndPaint(hwnd,&paintstruct); //release DC
break;
case WM_DESTROY:
DeleteDC(memdc);
PostQuitMessage (0); //сообщение о завершении
break ;
default : //обработка остальных сообщений
return DefWindowProc ( hwnd , message , wParam , lParam );
}
return 0;
}
BOOL CALLBACK DialogFunc(HWND hdwnd,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
long i;
HDC hdc;
slink* abc2;
switch(message)
{
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDCANCEL:
EndDialog(hdwnd,0);
return 1;
case ID_LB1:
if(HIWORD(wParam)==LBN_DBLCLK)
{
i = SendDlgItemMessage(hdwnd,ID_LB1,LB_GETCURSEL,0,0L);
sprintf(str,"Index of choused %d",i);
MessageBox(hdwnd,str,"Choice made",MB_OK);
}
return 1;
case IDOK:
GetDlgItemText(hdwnd, ID_EB1, str,80);
if (strlen(str))
{
abc1 = insert(abc1,str);
SendDlgItemMessage(hdwnd, ID_LB1,
LB_ADDSTRING,0,(LPARAM)str);
}
}
return 1;
case WM_INITDIALOG:
abc2 = abc1;
while (abc2!=NULL)
{
SendDlgItemMessage(hdwnd, ID_LB1,
LB_ADDSTRING,0,(LPARAM)(abc2->e));
abc2 = abc2->next;
} ;
return 1;
}
return 0;
}
Результат работы этой программы приведён на рис. 5.1.

 

Рис. 5.1. Схема диалога