WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!

Pages:     | 1 || 3 | 4 |   ...   | 12 |

«Ч. Петзолд Программирование для Windows® 95 в двух томах Том I «BHV — Санкт-Петербург» Дюссельдорф Киев Москва Санкт-Петербург Содержание ЧАСТЬ I ВВЕДЕНИЕ ...»

-- [ Страница 2 ] --

В WinMain вы должны определить структуру типа WNDCLASSEX, обычно это делается следующим образом:

WNDCLASSEX wndclass;

Затем задаются 12 полей структуры и вызывается RegisterClassEx:

RegisterClassEx(&wndclass);

Наиболее важными являются второе от конца и третье поля. Второе от конца поле является именем класса окна (который в программах, создающих одно окно, обычно совпадает с именем программы). Третье поле (lpfnWndProc) является адресом оконной процедуры, которая используется для всех окон, созданных на основе этого класса (в HELLOWIN.C оконной процедурой является функция WndProc). Другие поля описывают характеристики всех окон, создаваемых на основе этого класса окна.

Поле cbSize равно длине структуры. Инструкция:

wndclass.style = CS_HREDRAW | CS_VREDRAW;

осуществляет объединение двух идентификаторов "стиля класса" (class style) с помощью поразрядной операции OR языка С. В заголовочных файлах Windows, идентификаторы, начинающиеся с префикса CS, задаются в виде 32-разрядной константы, только один из разрядов которой установлен в 1. Например, CS_VREDRAW задан как 0x0001, а CS_HREDRAW как 0x0002. Заданные таким образом идентификаторы иногда называют "поразрядными флагами" (bit flags). Объединяются поразрядные флаги с помощью операции OR языка С.

Эти два идентификатора стиля класса показывают, что все окна, созданные на основе данного класса должны целиком перерисовываться при изменении горизонтального (CS_HREDRAW) или вертикального (CS_VREDRAW) размеров окна. Если вы измените размер окна HELLOWIN, то увидите, что строка текста переместится в новый центр окна. Эти два идентификатора гарантируют, что это случится. Далее мы подробно рассмотрим, как оконная процедура уведомляется об изменении размера окна.

Третье поле структуры WNDCLASSEX инициализируется с помощью инструкции:

wndclass.lpfnWndProc = WndProc;

Эта инструкция устанавливает оконную WndProc как оконную процедуру данного окна, которая является второй функцией в HELLOWIN.С. Эта оконная процедура будет обрабатывать все сообщения всем окнам, созданным на основе данного класса окна. Как уже упоминалось, приставка lpfn означает "длинный указатель на функцию".

Следующие две инструкции:

wndclass.cbClsExtra = 0;

wndclass.cbWndExtra = 0;

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

В следующем поле находится просто описатель экземпляра программы (который является одним из параметров WinMain):

wndclass.hInstance = hInstance;

Инструкции:

wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);

и wndclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

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

Для получения описателя стандартного значка, вы вызываете LoadIcon, установив первый параметр в NULL. (При загрузке вашего собственного пользовательского значка, этот параметр должен быть установлен равным описателю экземпляра программы.) Второй идентификатор, начинающийся с префикса IDI ("идентификатор для значка" — ID for icon) определяется в заголовочных файлах Windows. Значок IDI_APPLICATION — это просто маленькое изображение окна. Функция LoadIcon возвращает описатель этого значка. Фактически нам не важно конкретное значение этого описателя. Оно просто используется для установки значений полей wndclass.hIcon и wndclass.hIconSm. Эти поля определяются в структуре WNDCLASSEX как поля типа HICON, что означает "описатель значка" (handle to an icon).

Инструкция:

wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);

очень похожа на две предыдущие инструкции. Функция LoadCursor загружает стандартный курсор IDC_ARROW и возвращает описатель курсора. Этот описатель присваивается полю hCursor структуры WNDCLASSEX. Когда курсор мыши оказывается в рабочей области окна, созданного на основе данного класса, он превращается в маленькую стрелку.

Следующее поле задает цвет фона рабочей области окон, созданных на основе данного класса. Префикс hbr имени поля hbrBackground означает "описатель кисти" (handle to a brush). Кисть — это графический объект, который представляет собой шаблон пикселей различных цветов, используемый для закрашивания области. В Windows имеется несколько стандартных, или предопределенных (stock) кистей. Вызов GetStockObject, показанный здесь, возвращает описатель белой кисти:

wndclass.hbrBackground = GetStockObject(WHITE_BRUSH);

Это означает, что фон рабочей области окна будет плотного белого цвета, что является стандартным выбором.

Следующее поле задает меню класса окна. В приложении HELLOWIN меню отсутствует, поэтому поле установлено в NULL:

wndclass.lpszMenuName = NULL;

На последнем этапе классу должно быть присвоено имя. Для простой программы оно может быть просто именем программы, которым в нашем случае является строка "HelloWin", хранящаяся в переменной szAppName:

wndclass.lpszClassName = szAppName;

После того как инициализированы все 12 полей структуры, HELLOWIN регистрирует класс окна путем вызова функции RegisterClassEx. Единственным параметром функции является указатель на структуру WNDCLASSEX:

RegisterClassEx(&wndclass);

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

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

Вместо использования структуры данных, как это делается в случае использования функции RegisterClassEx, вызов функции CreateWindow требует, чтобы вся информация передавалась функции в качестве параметров. Далее представлен вызов функции CreateWindow в HELLOWIN.C:

hwnd = CreateWindow( szAppName, //имя класса окна "The Hello Program", //заголовок окна WS_OVERLAPPEDWINDOW, //стиль окна CW_USEDEFAULT, //начальное положение по x CW_USEDEFAULT, //начальное положение по y CW_USEDEFAULT, //начальный размер по x CW_USEDEFAULT, //начальный размер по y NULL, //описатель родительского окна NULL, //описатель меню окна hInstance, //описатель экземпляра программы NULL );

//параметры создания Для удобства восприятия, использовались символ // и однострочные комментарии для описания параметров функции CreateWindow.

Параметр с комментарием "имя класса окна" — szAppName содержит строку "HelloWin", являющуюся именем только что зарегистрированного класса окна. Таким образом, этот параметр связывает окно с классом окна.

Окно, созданное нашей программой, является обычным перекрывающимся окном с заголовком, системным меню слева на строке заголовка, иконками для сворачивания, разворачивания и закрытия окна справа на строке заголовка и рамкой окна. Это стандартный стиль окон, он называется WS_OVERLAPPEDWINDOW и помечен комментарием "стиль окна". Комментарием "заголовок окна" отмечен текст, который появится в строке заголовка.

Параметры с комментариями "начальное положение по x" и "начальное положение по y" задают начальные координаты верхнего левого угла окна относительно левого верхнего угла экрана. Устанавливая для этих параметров идентификатор CW_USEDEFAULT, мы сообщаем Windows, что хотим использовать для перекрывающегося окна задаваемое по умолчанию начальное положение. (CW_USEDEFAULT задается равным 0x80000000.) По умолчанию Windows располагает следующие друг за другом перекрывающиеся окна, равномерно отступая по горизонтали и вертикали от верхнего левого угла экрана. Примерно также задают ширину и высоту окна параметры с комментариями "начальный размер по x" и "начальный размер по y". CW_USEDEFAULT снова означает, что мы хотим, чтобы Windows использовала задаваемый по умолчанию размер окна.

Параметр с комментарием "описатель родительского окна" устанавливается в NULL, поскольку у нашего окна отсутствует родительское окно. (Если между двумя окнами существует связь типа родительское-дочернее, дочернее окно всегда появляется только на поверхности родительского.) Параметр с комментарием "описатель меню окна" также установлен в NULL, поскольку у нашего окна нет меню. В параметр с комментарием "описатель экземпляра программы" помещается описатель экземпляра, переданный программе в качестве параметра функции WinMain. И наконец, параметр с комментарием "параметры создания" установлен в NULL. При необходимости этот параметр используется в качестве указателя на какие-нибудь данные, на которые программа в дальнейшем могла бы ссылаться.

Вызов CreateWindow возвращает описатель созданного окна. Этот описатель хранится в переменной hwnd, которая имеет тип HWND (описатель окна — handle to a window). У каждого окна в Windows имеется описатель. В вашей программе описатель используется для того, чтобы ссылаться на окно. Для многих функций Windows в качестве параметра требуется hwnd, благодаря этому Windows знает, к какому окну применить функцию. Если программа создает несколько окон, то каждое из них имеет свой описатель. Описатель окна — это один из важнейших описателей, которыми оперирует программа для Windows.

Отображение окна К тому времени, когда функция CreateWindow возвращает управление программе, окно уже создано внутри Windows. Однако, на экране монитора оно еще не появилось. Необходимы еще два вызова. Первый из них:

ShowWindow(hwnd, iCmdShow);

Первым параметром является описатель только что созданного функцией CreateWindow окна. Вторым параметром является величина iCmdShow, передаваемая в качестве параметра функции WinMain. Он задает начальный вид окна на экране. Если iCmdShow имеет значение SW_SHOWNORMAL (т. е. 1), на экран выводится обычное окно. Если iCmdShow имеет значение SW_SHOWMINNOACTIVE (т. е. 7), то окно не выводится, а на панели задач появляются его имя и иконка.

Функция ShowWindow выводит окно на экран. Если второй параметр ShowWindow имеет значение SW_SHOWNORMAL, то фон рабочей области окна закрашивается той кистью, которая задана в классе окна. Вызов функции:

UpdateWindow(hwnd);

вызывает затем перерисовку рабочей области. Для этого в оконную процедуру (функция WndProc в HELLOWIN.C) посылается сообщение WM_PAINT. Вскоре мы изучим, как WndProc обрабатывает это сообщение.

Цикл обработки сообщений После вызова функции UpdateWindow, окно окончательно выведено на экран. Теперь программа должна подготовить себя для получения информации от пользователя через клавиатуру и мышь. Windows поддерживает "очередь сообщений" (message queue) для каждой программы, работающей в данный момент в системе Windows.

Когда происходит ввод информации, Windows преобразует ее в "сообщение", которое помещается в очередь сообщений программы.

Программа извлекает сообщения из очереди сообщений, выполняя блок команд, известный как "цикл обработки сообщений" (message loop):

while(GetMessage(&msg, NULL, 0, 0)) { TranslateMessage(&msg);

DispatchMessage(&msg);

} return msg.wParam;

Переменная msg — это структура типа MSG, которая определяется в заголовочных файлах Windows следующим образом:

typedef struct tagMSG { HWND hwnd;

UINT message;

WPARAM wParam;

LPARAM lParam;

DWORD time;

POINT pt;

} MSG;

Тип данных POINT — это тип данных другой структуры, которая определяется так:

typedef struct tagPOINT { LONG x;

LONG y;

} POINT;

Вызов функции GetMessage, с которого начинается цикл обработки сообщений, извлекает сообщение из очереди сообщений:

GetMessage(&msg, NULL, 0, 0) Этот вызов передает Windows указатель на структуру msg типа MSG. Второй, третий и четвертый параметры, NULL или 0, показывают, что программа получает все сообщения от всех окон, созданных этой программой.

Windows заполняет поля структуры сообщений информацией об очередном сообщении из очереди сообщений.

Поля этой структуры следующие:

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

• message — идентификатор сообщения. Это число, которое идентифицирует сообщение. Для каждого сообщения имеется соответствующий ему идентификатор, который задается в заголовочных файлах Windows и начинается с префикса WM (оконное сообщение — window message). Например, если вы установите указатель мыши в рабочей области программы HELLOWIN и нажмете левую кнопку мыши, Windows поставит сообщение в очередь сообщений с полем message равным WM_LBUTTONDOWN, значение которого 0x0201.

• wParam — 32-разрядный параметр сообщения (message parameter), смысл и значение которого зависят от особенностей сообщения.

• lParam — другой 32-разрядный параметр, зависящий от сообщения.

• time — время, когда сообщение было помещено в очередь сообщений.

• pt — координаты курсора мыши в момент помещения сообщения в очередь сообщений.

Если поле message сообщения, извлеченного из очереди сообщений, равно любому значению, кроме WM_QUIT (т. е., 0x0012), то функция GetMessage возвращает ненулевое значение. Сообщение WM_QUIT заставляет программу прервать цикл обработки сообщений. На этом программа заканчивается, возвращая число wParam структуры msg.

Инструкция:

TranslateMessage(&msg);

передает структуру msg обратно в Windows для преобразования какого-либо сообщения с клавиатуры. (Более подробно об этом будет рассказано в главе 5.) Инструкция:

DispatchMessage(&msg);

также передает структуру msg обратно в Windows. Windows отправляет сообщение для его обработки соответствующей оконной процедуре — таким образом, Windows вызывает оконную процедуру. Такой оконной процедурой в HELLOWIN является функция WndProc. После того, как WndProc обработает сообщение, оно возвращается в Windows, которая все еще обслуживает вызов функции DispatchMessage. Когда Windows возвращает управление в программу HELLOWIN к следующему за вызовом DispatchMessage коду, цикл обработки сообщений в очередной раз возобновляет работу, вызывая GetMessage.

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

Реальная работа начинается в оконной процедуре, которую программисты обычно называют "window proc".

Оконная процедура определяет то, что выводится в рабочую область окна и то, как окну реагировать на пользовательский ввод.

В программе HELLOWIN оконной процедурой является функция WndProc. Оконной процедуре можно назначить любое имя (любое, конечно, в той степени, в которой оно не будет конфликтовать с другими именами). В программе для Windows может содержаться более одной оконной процедуры. Оконная процедура всегда связана с определенным классом окна, который вы регистрируете, вызывая RegisterClassEx. Функция CreateWindow создает окно на основе определенного класса окна. На основе одного и того же класса можно создать несколько окон.

Оконная процедура всегда определяется следующим образом:

LRESULT CALLBACK WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam) Отметьте, что четыре параметра оконной процедуры идентичны первым четырем полям структуры MSG.

Первым параметром является hwnd, описатель получающего сообщение окна. Это тот же описатель, который возвращает функция CreateWindow. Для программы типа HELLOWIN, в которой создается только одно окно, имеется только один известный программе описатель окна. Если же в программе создается несколько окон на основе одного и того же класса окна (и следовательно одной и той же оконной процедуры), тогда hwnd идентифицирует конкретное окно, которое получает сообщение.

Вторым параметром является число (точнее 32-разрядное беззнаковое целое или UINT), которое идентифицирует сообщение. Два последних параметра (wParam типа WPARAM и lParam LPARAM) представляют дополнительную информацию о сообщении. Они называются "параметрами сообщения" (message parameters). Конкретное значение этих параметров определяется типом сообщения.

Обработка сообщений Каждое получаемое окном сообщение идентифицируется номером, который содержится в параметре iMsg оконной процедуры. В заголовочных файлах Windows определены идентификаторы, начинающиеся с префикса WM ("window message") для каждого типа сообщений.

Обычно программисты для Windows используют конструкции switch и case для определения того, какое сообщение получила оконная процедура и то, как его обрабатывать. Если оконная процедура обрабатывает сообщение, то ее возвращаемым значением должен быть 0. Все сообщения, не обрабатываемые оконной процедурой, должны передаваться функции Windows, которая называется DefWindowProc. Значение, возвращаемое функцией DefWindowProc, должно быть возвращаемым значением оконной процедуры.

В HELLOWIN функция WndProc обрабатывает только три сообщения: WM_CREATE, WM_PAINT и WM_DESTROY. Оконная процедура выглядит следующим образом:

switch(iMsg) { case WM_CREATE:

[process WM_CREATE message] return 0;

case WM_PAINT:

[process WM_PAINT message] return 0;

case WM_DESTROY:

[process WM_DESTROY message] return 0;

} return DefWindowProc(hwnd, iMsg, wParam, lParam);

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

Воспроизведение звукового файла Самое первое сообщение, которое получает оконная процедура — и первое, которое обрабатывает функция WndProc — это WM_CREATE. WndProc получает это сообщение тогда, когда Windows обрабатывает функцию CreateWindow в WinMain. Таким образом, когда HELLOWIN вызывает CreateWindow, Windows делает то, что должна делать, т. е. Windows вызывает WndProc с описателем окна в качестве первого параметра и с WM_CREATE в качестве второго. WndProc обрабатывает сообщение WM_CREATE и передает управление обратно в Windows. Теперь Windows может вернуться после вызова CreateWindow обратно в HELLOWIN, чтобы продолжить работу в WinMain.

Часто оконная процедура выполняет разовую инициализацию окна, когда обрабатывается сообщение.

WM_CREATE. HELLOWIN предпочитает обрабатывать это сообщение путем воспроизведения звукового файла HELLOWIN.WAV. Это делается с помощью функции PlaySound. Первым параметром этой функции является имя файла. Это также может быть другое имя (sound alias name), которое задается в секции Sounds панели управления (Control Panel) или определяется ресурсом программы. Второй параметр используется только при условии, что звуковой файл является ресурсом. Третий параметр задает две опции. В нашем случае, когда первый параметр — это имя файла, звук должен воспроизводиться асинхронно, т. е. функция PlaySound возвратит свое значение как только начнет воспроизводиться звуковой файл, не ожидая окончания воспроизведения.

WndProc завершает обработку WM_CREATE с нулевым возвращаемым значением.

Сообщение WM_PAINT Сообщение WM_PAINT функция WndProc обрабатывает вторым. Это сообщение крайне важно для программирования под Windows. Оно сообщает программе, что часть или вся рабочая область окна недействительна (invalid), и ее следует перерисовать.

Как рабочая область становится недействительной? При первом создании окна недействительна вся рабочая зона, поскольку программа еще ничего в окне не нарисовала. Сообщение WM_PAINT (которое обычно посылается, когда программа вызывает UpdateWindow в WinMain) заставляет оконную процедуру что-то нарисовать в рабочей области.

Когда вы изменяете размер окна, рабочая область также становится недействительной. Вспомните, что в параметр style структуры wndclass программы HELLOWIN помещены флаги CS_HREDRAW и CS_VREDRAW. Они заставляют Windows при изменении размеров окна считать недействительным все окно. Затем оконная процедура получает сообщение WM_PAINT.

Когда вы минимизируете окно программы HELLOWIN, а затем снова его восстанавливаете до начального размера, то в Windows содержимое рабочей области не сохраняется. В графической среде это привело бы к тому, что пришлось бы хранить слишком много данных. Вместо этого, Windows делает недействительным все окно. Оконная процедура получает сообщение WM_PAINT и сама восстанавливает содержимое окна.

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

Обработка сообщения WM_PAINT почти всегда начинается с вызова функции BeginPaint:

hdc = BeginPaint(hwnd, &ps);

и заканчивается вызовом функции EndPaint:

EndPaint(hwnd, &ps);

В обеих функциях первый параметр — это описатель окна программы, а второй — это указатель на структуру типа PAINTSTRUCT. В структуре PAINTSTRUCT содержится некоторая информация, которую оконная процедура может использовать для рисования в рабочей области. (В следующей главе будет рассказано о полях этой структуры.) При обработке вызова BeginPaint, Windows обновляет фон рабочей области, если он еще не обновлен. Обновление фона осуществляется с помощью кисти, заданной в поле hbrBackground структуры WNDCLASSEX, которая использовалась при регистрации класса окна. В случае нашей программы HELLOWIN подготовлена белая кисть и это означает, что Windows обновит фон окна, закрасив его белым цветом. Вызов BeginPaint делает всю рабочую область действительной (не требующей перерисовки) и возвращает описатель контекста устройства. Контекст устройства описывает физическое устройство вывода информации (например, дисплей) и его драйвер. Описатель контекста устройства необходим вам для вывода в рабочую область окна текста и графики. Используя описатель контекста устройства, возвращаемого функцией BeginPaint, вы не сможете рисовать вне рабочей области, даже не пытайтесь. Функция EndPaint освобождает описатель контекста устройства, после чего его значение нельзя использовать.

Если оконная процедура не обрабатывает сообщения WM_PAINT (что бывает крайне редко), они должны передаваться в DefWindowProc. Функция DefWindowProc просто по очереди вызывает BeginPaint и EndPaint и, таким образом, рабочая область устанавливается в действительное состояние, т. е. состояние, не требующее перерисовки.

После того, как WndProc вызвала BeginPaint, она вызывает GetClientRect:

GetClientRect(hwnd, &rect);

Первый параметр — это описатель окна программы. Второй параметр — это указатель на переменную rect, для которой в WndProc задан тип RECT.

RECT — это структура "прямоугольник" (rectangle), определенная в заголовочных файлах Windows. Она имеет четыре поля типа LONG, имена полей: left, top, right и bottom. GetClientRect помещает в эти четыре поля размер рабочей области окна. Поля left и top всегда устанавливаются в 0. В полях right и bottom устанавливается ширина и высота рабочей области в пикселях.

WndProc никак не использует структуру RECT, за исключением передачи указателя на нее в качестве четвертого параметра функции DrawText:

DrawText(hdc, "Hello, Windows 95!", -1, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);

DrawText (как подсказывает ее имя) рисует текст. Поскольку эта функция что-то рисует, то первый параметр — это описатель контекста устройства, возвращенный функцией BeginPaint. Вторым параметром является рисуемый текст, а третий параметр установлен в —1, чтобы показать, что строка текста заканчивается нулевым символом.

Последний параметр — это набор флагов, значения которых задано в заголовочных файлах Windows. Флаги показывают, что текст следует выводить в одну строку, по центру относительно горизонтали и вертикали и внутри прямоугольной области, размер которой задан четвертым параметром. Вызов этой функции приводит, таким образом, к появлению строки "Hello, Windows 95!" в центре рабочей области.

Когда рабочая область становится недействительной (как это происходит при изменении размеров окна), WndProc получает новое сообщение WM_PAINT. Новый размер окна WndProc получает, вызвав функцию GetClientRect, и снова рисует текст в центре окна.

Сообщение WM_DESTROY Еще одним важным сообщением является сообщение WM_DESTROY. Это сообщение показывает, что Windows находится в процессе ликвидации окна в ответ на полученную от пользователя команду. Пользователь вызывает поступление этого сообщения, если щелкнет на кнопке Close, или выберет Close из системного меню программы, или нажмет +.

HELLOWIN стандартно реагирует на это сообщение, вызывая:

PostQuitMessage(0);

Эта функция ставит сообщение WM_QUIT в очередь сообщений программы. Как уже упоминалось, функция GetMessage возвращает ненулевое значение при любом сообщении, полученном из очереди сообщений за исключением WM_QUIT. Когда GetMessage получает сообщение WM_QUIT, функция возвращает 0. Это заставляет WinMain прервать цикл обработки сообщений и выйти в систему, закончив программу.

Сложности программирования для Windows Даже с учетом авторских пояснений структура и принципы работы программы Hellowin, вполне вероятно, так и останутся для вас немного загадочными. В короткой программе на С, написанной для обычной среды, вся программа целиком может поместиться в функции main. В HELLOWIN WinMain содержит только надстройку программы, необходимую для регистрации класса окна, создания окна и получения и передачи сообщений из/в очередь сообщений.

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

Не вызывай меня, я вызову тебя Как уже упоминалось, программисты хорошо знакомы с понятием вызова операционной системы для выполнения каких-то действий. Например, программисты на С используют функцию fopen для открытия файла. Библиотечные функции, поставляемые с компилятором, содержат код, который фактически вызывает для открытия файла операционную систему. Здесь все просто.

Но операционная система Windows ведет себя иначе. Хотя в Windows имеется свыше тысячи доступных программисту функций, Windows также и сама посылает вызовы вашей программе, особенно оконной процедуре, которую мы назвали WndProc. Оконная процедура связана с классом окна, который программа регистрирует с помощью вызова функции RegisterClassEx. Окно, создаваемое на основе этого класса, использует оконную процедуру для обработки всех сообщений окна. Windows посылает сообщения окну, вызывая оконную процедуру.

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

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

Фактически, идея функции, находящейся в программе, но которая вызывается не из самой программы, не является абсолютно новой в традиционном программировании. Функция signal в С может перехватить +. Вы можете иметь опыт с перехватом аппаратных прерываний с помощью языка ассемблера или одной из конструкций ON в Microsoft BASIC. Драйвер мыши фирмы Microsoft позволяет работать с этой мышью программам, сделанным не для Windows.

В Windows эта идея расширена и пронизывает всю систему. Любое событие, относящееся к окну, передается оконной процедуре в виде сообщения. Затем оконная процедура соответствующим образом реагирует на это сообщение или передает сообщение в DefWindowProc для обработки его по умолчанию.

Параметры wParam и lParam оконной процедуры не используются в HELLOWIN кроме как параметры для DefWindowProc. Эти параметры дают оконной процедуре дополнительную информацию о сообщении. Значение этих параметров зависит от самого сообщения.

Давайте рассмотрим пример. Когда меняется размер рабочей области окна, Windows вызывает оконную процедуру.

Параметр hwnd оконной процедуры — это описатель окна, изменившего размер. Параметр iMsg равен WM_SIZE.

Параметр wParam для сообщения WM_SIZE равен одной из величин SIZENORMAL, SIZEICONIC, SIZEFULLSCREEN, SIZEZOOMSHOW или SIZEZOOMHIDE (определяемых в заголовочных файлах Windows как числа от 0 до 4). Параметр wParam показывает, будет ли окно свернуто, развернуто или скрыто (в результате развертывания другого окна). Параметр lParam определяет новый размер окна. Новая ширина (16-разрядное значение) и новая высота (16-разрядное значение) объединяются вместе в 32-разрядный параметр lParam. В заголовочных файлах Windows имеется макрос, который позволяет выделить оба эти значения из lParam. Мы это проделаем в следующей главе.

Иногда, в результате обработки сообщения функцией DefWindowProc, генерируются другие сообщения. Например, предположим, что вы запускаете HELLOWIN и выбираете Close из системного меню программы, используя клавиатуру или мышь. DefWindowProc обрабатывает эту информацию. Когда она определяет, что вы выбрали опцию Close, то отправляет сообщение WM_SYSCOMMAND оконной процедуре. WndProc передает это сообщение DefWindowProc. DefWindowProc реагирует на него, отправляя сообщение WM_CLOSE оконной процедуре. WndProc снова передает это сообщение DefWindowProc. DefWindowProc реагирует на сообщение WM_CLOSE, вызывая функцию DestroyWindow. DestroyWindow заставляет Windows отправить сообщение WM_DESTROY оконной процедуре. И наконец, WndProc реагирует на это сообщение, вызывая функцию PostQuitMessage путем постановки сообщения WM_QUIT в очередь сообщений. Это сообщение прерывает цикл обработки сообщений в WinMain и программа заканчивается.

Синхронные и асинхронные сообщения Ранее было рассказано о передаче окну сообщений, что означает вызов операционной системой Windows оконной процедуры. Но в программах для Windows имеется цикл обработки сообщений, который берет сообщения из очереди сообщений, вызывая функцию GetMessage, и отправляет их оконной процедуре, вызывая функцию DispatchMessage.

Так что же, буферизуются ли сообщения для Windows-программы (так же как в обычной программе буферизуется ввод с клавиатуры) и затем пересылаются дальше, или она (программа для Windows) получает сообщения непосредственно снаружи? И так, и этак.

Одни и те же сообщения могут быть и "синхронные" (queued), и "асинхронные" (nonqueued)1. Синхронными сообщениями называются сообщения, которые Windows помещает в очередь сообщений программы, и которые извлекаются и диспетчеризуются в цикле обработки сообщений. Асинхронные сообщения передаются непосредственно окну, когда Windows вызывает оконную процедуру. В результате оконная процедура получает все предназначенные для окна сообщения, как синхронные, так и асинхронные. Структура программ для Windows очень проста, поскольку у них имеется только одно центральное место обработки сообщений. Говорят, что синхронные сообщения помещаются в очередь сообщений (post), а асинхронные посылаются прямо в оконную процедуру (send).

Синхронными становятся сообщения, в основном, тогда, когда они являются результатом пользовательского ввода путем нажатия клавиш (например, WM_KEYDOWN и WM_KEYUP), это символы, введенные с клавиатуры (WM_CHAR), результат движения мыши (WM_MOUSEMOVE) и щелчков кнопки мыши (WM_LBOTTONDOWN).

Кроме этого синхронные сообщения включают в себя сообщение от таймера (WM_TIMER), сообщение о необходимости плановой перерисовки (WM_PAINT) и сообщение о выходе из программы (WM_QUIT).

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

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

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

Часто асинхронные сообщения являются результатом вызова определенных функций Windows или непосредственным результатом вызова функции SendMessage. (Кроме этого, сообщения могут помещаться в очередь сообщений посредством вызова функции PostMessage.) Например, когда WinMain вызывает функцию CreateWindow, Windows создает окно и для этого отправляет оконной процедуре асинхронное сообщение WM_CREATE. Когда WinMain вызывает ShowWindow, Windows отправляет оконной процедуре асинхронные сообщения WM_SIZE и WM_SHOWWINDOW. Когда WinMain вызывает UpdateWindow, Windows отправляет оконной процедуре асинхронное сообщение WM_PAINT.

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

Необходимо уточнить дальнейшее использование атрибутов сообщения "синхронное" и "асинхронное". Ставится сообщение в очередь или не ставится, определяется способом его отправки. В оригинальном тексте книги для указания конкретного способа отправки сообщения используются слова send (функция SendMessage) и post (функция PostMessage). Если для отправки сообщения используется функция SendMessage, то оно не ставится в очередь, оконная процедура вызывается непосредственно, а функция возвращает управление только после обработки сообщения оконной процедурой. Если для отправки сообщения используется функция PostMessage, то оно ставится в очередь, а функция возвращает управление немедленно.

Таким образом, используя терминологию автора, можно сказать:

• если сообщение отправляется с помощью функции SendMessage, то оно является асинхронным;

• если сообщение отправляется с помощью функции PostMessage, то оно является синхронным.

(Прим. перев.).

Цикл обработки сообщений и оконная процедура работают не параллельно. Когда оконная процедура обрабатывает сообщение, то это результат вызова функции DispatchMessage в WinMain. DispatchMessage не завершается до тех пор, пока оконная процедура не обработала сообщение.

Но заметьте, что оконная процедура должна быть повторно-входимой (reentrant). Это означает, что Windows часто вызывает WndProc с новым сообщением, как результат вызова функции DefWindowProc в WndProc с предыдущим сообщением. В большинстве случаев повторная входимость оконной процедуры не создает проблем, но об этом следует знать.

Например, предположим, что вы вводите переменную в процесс обработки сообщения оконной процедурой и затем вызываете функцию Windows. Можете ли вы быть уверены в том, что после возврата функцией своего значения, ваша переменная осталась той же самой? Конечно, нет — в том случае, если конкретная функция Windows, которую вы вызвали, стала источником другого сообщения, и оконная процедура изменила вашу переменную при обработке этого второго сообщения. Это одна из причин того, что при компиляции программ для Windows необходимо отключать некоторые возможности оптимизации.

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

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

Думайте о ближнем Windows 95 — это вытесняющая многозадачная среда. Это означает, что если программа работает слишком долго, то Windows может разрешить пользователю переключиться на другую программу. Это удобная вещь и одно из преимуществ Windows 95 по сравнению с предыдущими, основанными на DOS, версиями Windows.

Однако, поскольку Windows сконструирована определенным образом, эта вытесняющая многозадачность не всегда работает так, как бы вам хотелось. Например, предположим, что ваша программа тратит на обработку отдельного сообщения минуту или больше. Да, пользователь может переключиться на другую программу. Но пользователь ничего не в состоянии сделать с вашей программой. Пользователь не может переместить окно вашей программы, изменить его размер, закрыть его, т. е. вообще ничего. Так происходит потому, что, хотя ваша оконная процедура и должна выполнять все эти задачи, но она занята выполнением слишком долгой работы. Конечно, может показаться, что оконная процедура не выполняет операций по изменению размера и перемещению собственного окна, но, тем не менее, она это делает. Это часть работы функции DefWindowProc, которую, в свою очередь, необходимо считать частью оконной процедуры.

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

Кривая обучения Да, как вы, несомненно, поняли из этой главы, программирование для Windows определенно отличается от программирования для общепринятой среды типа MS-DOS. Никто не станет утверждать, что программировать для Windows легко.

При первом изучении программирования для Windows обычно делают то, что всегда делается при изучении новой операционной системы или нового языка программирования — пишется простая программа для вывода на экран содержимого файла. В общепринятой среде MS-DOS такая программа включает в себя обработку командной строки, простейший файловый Ввод/Вывод и форматирование вывода на экран. В отличии от этого, аналогичная программа для Windows превращается в монстра. Она требует изучения меню, окон диалога, полос прокрутки и т. д. Так как это ваша первая программа для Windows, то из-за необходимости сразу усвоить слишком большой объем материала, она обычно оказывается совершенно неправильной.

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

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

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

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

Глава 3 Рисование текста В предыдущей главе вы познакомились с простой программой для Windows 95, в оторой в центре окна или, если быть более точным, в центре рабочей области окна, выводилась одна текстовая строка. Очень важно понимать разницу между окном приложения и его рабочей областью: рабочая область — это часть всего окна приложения, в верхней части которой нет строки заголовка, у которой нет рамки окна, нет строки меню, нет полос прокрутки.

Короче говоря, рабочая область — это часть окна, на которой программа может рисовать и представлять визуальную информацию для пользователя.

Вы можете делать с рабочей областью вашей программы почти все, что захотите — все, за исключением того, что у вас отсутствует возможность задать ей определенный размер или оставить этот размер неизменным во время работы вашей программы. Если вы приспособились писать программы для MS-DOS, эти условия могут вас слегка огорчить. Вы можете больше не думать о рамках экранного пространства, т. е. о 25 (или 43, или 50) строках текста и 80 символов. Ваша программа должна делить экран с другими программами. Пользователь Windows управляет тем, как расположить на экране окна программ. Хотя вполне можно создать окно фиксированного размера (как это делается в программе калькулятора и сходных с ней программах), в подавляющем большинстве случаев размер окна — это величина переменная. Ваша программа должна учитывать размер окна и использовать рациональные способы работы с ним.

Здесь возможны два варианта. Рабочая область может оказаться недостаточной даже для того, чтобы поместилось только слово "Hello". Точно также она может оказаться на большом экране видеосистемы с высоким разрешением, и оказаться настолько большой, что в ней могли бы поместиться две полные страницы текста и, кроме этого, на экране еще осталось бы множество участков свободного пространства. Умение разумно поступать в обеих этих ситуациях — это важная часть программирования для Windows.

Хотя в Windows имеется очень широкий набор функций графического интерфейса устройства (GDI) для вывода графики на экран, в этой главе будет рассказано только о выводе простых текстовых строк. Не будут также рассматриваться различные шрифты и их размеры, имеющиеся в Windows, и будет использоваться только системный шрифт (system font), который Windows использует по умолчанию. Этого может показаться недостаточно, но на самом деле вполне хватает. Задачи, с которыми мы в этой главе столкнемся, и которые решим, относятся к программированию для Windows в целом. Если вы выводите на экран сочетание текста и графики (как, например, это происходит в программе Windows Calculator), размеры символов, задаваемые по умолчанию системным шрифтом Windows, часто определяют и размеры графики.

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

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

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

Например, окно диалога другого приложения может перекрыть часть вашей рабочей области. Хотя Windows будет пытаться сохранить и восстановить область экрана под окном диалога, это не всегда получается. После того как окно диалога удаляется с экрана, Windows выдаст запрос, требующий, чтобы ваша программа перерисовала эту часть рабочей области.

Windows — это операционная система, управляемая сообщениями. Windows уведомляет приложения о различных событиях путем постановки синхронных сообщений в очередь сообщений приложения или путем отправки асинхронных сообщений соответствующей процедуре окна. Посылая синхронное сообщение WM_PAINT, Windows уведомляет оконную процедуру о том, что часть рабочей области окна необходимо обновить.

Сообщение WM_PAINT Большинство программ для Windows вызывают функцию UpdateWindow при инициализации в WinMain, сразу перед входом в цикл обработки сообщений. Windows использует эту возможность для асинхронной отправки в оконную процедуру первого сообщения WM_PAINT. Это сообщение информирует оконную процедуру о том, что рабочая область готова к рисованию. После этого оконная процедура должна быть готова в любое время обработать дополнительные сообщения WM_PAINT и даже перерисовать, при необходимости, всю рабочую область окна. Оконная процедура получает сообщение WM_PAINT при возникновении одной из следующих ситуаций:

• Предварительно скрытая область окна открылась, когда пользователь передвинул окно или выполнил какие-то действия, в результате которых окно вновь стало видимым.

• Пользователь изменил размера окна (если в стиле класса окна установлены биты CS_HREDRAW и CS_HVREDRAW).

• В программе для прокрутки части рабочей области используются функции ScrollWindow или ScrollDC.

• Для генерации сообщения WM_PAINT в программе используются функции InvalidateRect или InvalidateRgn.

В некоторых случаях, когда часть рабочей области временно закрывается, Windows пытается сначала ее сохранить, а затем восстановить. Это не всегда возможно. В некоторых случаях Windows может послать синхронное сообщение WM_PAINT. Обычно это происходит, когда:

• Windows удаляет диалоговое окно или окно сообщения, которое перекрывало часть окна программы.

• Раскрывается пункт горизонтального меню и затем удаляется с экрана.

В некоторых случаях Windows всегда сохраняет перекрываемую область, а потом восстанавливает ее. Происходит это всегда, когда:

• Курсор мыши перемещается по рабочей области.

• Иконку перемещают по рабочей области.

Работа с сообщением WM_PAINT требует, чтобы вы изменили свое представление о том, как выводить информацию на экран. Ваша программа должна быть структурирована таким образом, чтобы в ней была собрана вся информация, необходимая для рисования в рабочей области, но рисование осуществлялось бы только "по запросу" — когда Windows отправит оконной процедуре синхронное сообщение WM_PAINT. Если вашей программе необходимо перерисовать свою рабочую область, она может заставить Windows сгенерировать сообщение WM_PAINT. Это может показаться не самым простым способом вывода информации на экран, но структура вашей программы от этого только улучшится.

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

Эту область называют "недействительном регионом" (invalid region) или "регионом обновления" (update region).

Появление недействительного региона в рабочей области вынуждает Windows поместить синхронное сообщение WM_PAINT в очередь сообщений приложения. Ваша оконная процедура получает сообщение WM_PAINT только тогда, когда часть вашей рабочей области недействительна, т. е. требует обновления.

В Windows для каждого окна поддерживается "структура информации о рисовании" (paint information structure). В этой структуре содержатся (помимо другой информации) координаты минимально возможного прямоугольника, содержащего недействительную область. Эта информация носит название "недействительного прямоугольника" (invalid rectangle);

иногда — "недействительного региона" (invalid region). Если еще один регион рабочей области становится недействительным перед обработкой сообщения WM_PAINT, Windows рассчитывает новый недействительный регион, который содержит оба эти региона и запоминает эту новую информацию в структуре информации о рисовании. Windows не помещает в очередь сообщений сразу несколько сообщений WM_PAINT.

Оконная процедура, вызывая функцию InvalidateRect, может задать недействительный прямоугольник в своей рабочей области. Если в очереди сообщений уже содержится сообщение WM_PAINT, Windows рассчитывает новый недействительный прямоугольник. В противном случае Windows помещает новое сообщение WM_PAINT в очередь сообщений. При принятии сообщения WM_PAINT (как мы позже увидим в этой главе), оконная процедура может получить координаты недействительного прямоугольника. Она также может получить эти координаты в любое другое время, вызвав функцию GetUpdateRect.

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

Введение в графический интерфейс устройства (GDI) Для рисования в рабочей области вашего окна, вы используете функции графического интерфейса устройства.

(Обзор GDI ждет нас в следующей главе). В Windows имеется несколько функций GDI для вывода строк текста в рабочей области окна. В главе 2 вы уже встречались с функцией DrawText, но гораздо более популярной функцией является TextOut. Формат этой функции следующий:

TextOut(hdc, x, y, psString, iLength);

Функция TextOut выводит на экран строку символов. Параметр psString — это указатель на строку символов, а iLength — длина строки символов. Параметры x и y определяют начальную позицию строки символов в рамках рабочей области. (Более подробно об этом будет рассказано в дальнейшем.) Параметр hdc — это "описатель контекста устройства" (handle to a device context), являющийся важной частью GDI. Практически каждой функции GDI в качестве первого параметра необходим этот описатель.

Контекст устройства Вспомните, описатель — это просто число, которое Windows использует для внутренней ссылки на объект. Вы получаете описатель от Windows и затем используете этот описатель в разных функциях. Описатель контекста устройства — это паспорт вашего окна для функций GDI. Этот описатель дает вам полную свободу при рисовании в рабочей области вашего окна, и вы можете сделать ее такой, как пожелаете.

Контекст устройства фактически является структурой данных, которая внутренне поддерживается GDI. Контекст устройства связан с конкретным устройством вывода информации, таким как принтер, плоттер или дисплей. Что касается дисплея, то в данном случае контекст устройства обычно связан с конкретным окном на экране.

Некоторые значения в контексте устройства являются графическими "атрибутами" (attributes). Эти атрибуты определяют некоторые особенности работы функций рисования GDI. Например, для функции TextOut эти атрибуты контекста устройства задают цвет текста, цвет фона для текста, процедуру преобразования координат x и y, передаваемых функции TextOut в координаты рабочей области, а также шрифт, используемый для вывода текста.

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

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

Получение описателя контекста устройства. Первый метод Этот метод используется при обработке сообщений WM_PAINT. Применяются две функции: BeginPaint и EndPaint. Для этих двух функций требуется описатель окна (передаваемый в оконную процедуру в качестве параметра) и адрес переменной типа структуры PAINTSTRUCT. Программисты, пишущие программы для Windows, обычно называют эту структурную переменную ps и определяют ее внутри оконной процедуры следующим образом:

PAINTSTRUCT ps;

Во время обработки сообщения WM_PAINT оконная процедура сначала вызывает BeginPaint для заполнения полей структуры ps. Возвращаемым значением функции BeginPaint является описатель контекста устройства.

Обычно он передается переменной с именем hdc. Эта переменная определяется в оконной процедуре следующим образом:

HDC hdc;

Тип данных HDC определяется как 32-разрядное беззнаковое целое. Затем программа может использовать функции GDI, например TextOut. Вызов функции EndPaint освобождает описатель контекста устройства.

Типовой процесс обработки сообщения WM_PAINT выглядит следующим образом:

case WM_PAINT:

hdc=BeginPaint(hwnd, &ps);

[использование функций GDI] EndPaint(hwnd, &ps);

return 0;

При обработке сообщения WM_PAINT в оконной процедуре функции BeginPaint и EndPaint должны обязательно вызываться парой. Если в оконной процедуре сообщения WM_PAINT не обрабатываются, то они должны передаваться в DefWindowProc (процедура обработки сообщений по умолчанию), реализованной в Windows.

DefWindowProc обрабатывает сообщения WM_PAINT следующим образом:

case WM_PAINT:

BeginPaint(hwnd, &ps);

EndPaint(hwnd, &ps);

return 0;

Следующие одна за другой функции BeginPaint и EndPaint просто превращают ранее недействительный регион в действительный. Но нельзя делать следующее:

case WM_PAINT:

return 0;

// ОШИБКА!!!

Windows помещает сообщение WM_PAINT в очередь сообщений, поскольку часть рабочей области окна недействительна (требует перерисовки). До тех пор пока вы не вызовете функции BeginPaint и EndPaint (или ValidateRect), Windows не сделает эту область действительной. Вместо этого Windows снова отправит вам сообщение WM_PAINT. И снова, и снова, и снова...

Структура информации о рисовании Ранее уже говорилось о структуре информации о рисовании, которая поддерживается в Windows для каждого окна.

Это PAINTSTRUCT. Структура определяется так:

typedef struct tagPAINTSTRUCT { HDC hdc;

BOOL fErase;

RECT rcPaint;

BOOL fRestore;

BOOL fIncUpdate;

BYTE rgbReserved[32];

} PAINTSTRUCT;

Windows заполняет поля этой структуры, когда ваша программа вызывает BeginPaint. Вам в программе можно использовать только первые три поля структуры. Остальные используются Windows.

Поле hdc — это описатель контекста устройства. Возвращаемым значением функции BeginPaint также является описатель контекста устройства, и такая избыточность характерна для Windows.

В подавляющем большинстве случаев, в поле fErase установлен флаг TRUE (т. е., ненулевое значение), означающий, что Windows обновит фон недействительного прямоугольника. Windows перерисует фон, используя кисть, заданную в поле hbrBackground структуры WNDCLASSEX, которую вы использовали при регистрации класса окна во время инициализации WinMain. Многие программы для Windows используют белую кисть:

wndclass.hbrBackground =(HBRUSH) GetStockObject(WHITE_BRUSH);

Однако, если вы, вызывая функцию InvalidateRect, делаете недействительным прямоугольник рабочей зоны вашей программы, то последний параметр этой функции определяет, хотите ли вы стирать фон. Если этот параметр равен FALSE (т. е. 0), Windows не будет стирать фон и поле fErase также будет равно FALSE.

Поле rcPaint структуры PAINTSTRUCT — это структура типа RECT. Как вы знаете из главы 2, структура RECT определяет прямоугольник. В ней имеется четыре поля: left, top, right и bottom. Поле rcPaint структуры PAINTSTRUCT определяет границы недействительного прямоугольника, как показано на рис. 3.1. Значения заданы в пикселях относительно левого верхнего угла рабочей области. Недействительный прямоугольник — это та область, которую вы хотите перерисовать. Хотя программа для Windows может просто перерисовать всю рабочую область окна при получении сообщения WM_PAINT, перерисовка только той области окна, которая задана этим прямоугольником, экономит время.

0 left right top Invalid rectangle (недействительный прямоугольник) bottom Client area (рабочая область) Рис. 3.1 Границы недействительного прямоугольника Прямоугольник rcPaint в PAINTSTRUCT — это не только недействительный прямоугольник, это также и "отсекающий" (clipping) прямоугольник. Это означает, что Windows рисует только внутри отсекающего прямоугольника. (Или точнее, если недействительная зона не является прямоугольником, Windows рисует только внутри этой зоны.) Когда вы используете описатель контекста устройства из структуры PAINTSTRUCT, Windows не будет рисовать вне прямоугольника rcPaint.

Чтобы при обработке сообщения WM_PAINT рисовать вне прямоугольника rcPaint, вы можете сделать вызов:

InvalidateRect(hWnd, NULL, TRUE);

перед вызовом BeginPaint. Это сделает недействительной всю рабочую область и обновит ее фон. Если же значение последнего параметра будет равно FALSE, то фон обновляться не будет. Все что там было, останется неизменным.

В программе HELLOWIN из главы 2 мы не думали о недействительных или отсекающих прямоугольниках при обработке сообщения WM_PAINT. Если оказывалось, что область вывода текста на экран находится внутри недействительного прямоугольника, то функция DrawText перерисовывала ее. Если при обработке вызова DrawText Windows не находит такие области, на экран ничего не выводится. Но такой поиск требует времени.

Программист, заботящийся об эффективности и быстродействии, захочет при обработке сообщений WM_PAINT использовать размеры недействительного прямоугольника, чтобы не обращаться лишний раз к вызовам GDI.

Получение описателя контекста устройства. Второй метод Вы также можете получить описатель контекста устройства, если хотите рисовать в рабочей области при обработке отличных от WM_PAINT сообщений, или если вам необходим описатель контекста устройства для других целей, например, для получения информации о самом контексте устройства. Вызывайте GetDC для получения описателя контекста устройства и ReleaseDC, если он вам больше не нужен:

hdc=GetDC(hwnd);

[использование функций GDI] ReleaseDC(hwnd, hdc);

Также как BeginPaint и EndPaint, функции GetDC и ReleaseDC следует вызывать парой. Если вы при обработке сообщения вызываете GetDC, то перед выходом из оконной процедуры необходимо вызвать ReleaseDC. Не вызывайте GetDC при обработке одного сообщения, а ReleaseDC при обработке другого.

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

Как правило, вы будете использовать вызовы функций GetDC и ReleaseDC в ответ на сообщения от клавиатуры (например, в программах текстовых редакторов) или на сообщения от манипулятора мышь (например, в программах рисования). Они позволяют обновлять рабочую область непосредственно в ответ на пользовательский ввод информации с клавиатуры или с помощью мыши, при этом специально делать недействительной часть окна для выдачи сообщений WM_PAINT. Однако, в ваших программах должно содержаться достаточно информации для обновления экрана в любой момент, когда вы получаете сообщение WM_PAINT.

Функция TextOut. Подробности Когда вы получаете описатель контекста устройства, Windows заполняет внутреннюю структуру контекста устройства задаваемыми по умолчанию значениями. Как вы увидите в следующих главах, эти задаваемые по умолчанию значения можно изменить с помощью функций GDI. Из тех функций GDI, которые нас интересуют прямо сейчас, рассмотрим TextOut:

TextOut(hdc, x, y, psString, iLength);

Давайте исследуем эту функцию более подробно.

Первый параметр — это описатель контекста устройства, являющийся возвращаемым значением либо функции GetDC, либо функции BeginPaint, полученный при обработке сообщения WM_PAINT.

Атрибуты контекста устройства управляют характеристиками выводимого на экран текста. Например, один атрибут контекста устройства задает цвет текста. Цвет, задаваемый по умолчанию — черный. Контекст устройства по умолчанию также определяет цвет фона — белый. Когда программа выводит текст на экран, Windows использует этот цвет фона для заполнения прямоугольной зоны вокруг каждого символа, эта зона называется знакоместом (character box).

Цвет фона текста не является цветом фона, который вы установили при определении класса окна. Фон в классе окна — это кисть, являющаяся шаблоном, которая может иметь, а может и не иметь чистый (без полутонов) цвет, и которую Windows использует для закрашивания рабочей области. Фон в классе окна не имеет отношения к структуре контекста устройства. При определении структуры класса окна в большинстве приложений Windows используется кисть WHITE_BRUSH, поэтому задаваемый по умолчанию в контексте устройства цвет фона оказывается таким же, как и цвет кисти, используемой Windows для закрашивания фона рабочей области.

Параметр psString — это указатель на символьную строку, а iLength — длина строки, т. е., число символов в строке. Строка не должна содержать никаких управляющих символов ASCII, таких как возврат каретки, перевод строки, табуляция или забой. Windows выводит такие управляющие символы в виде прямоугольников или закрашенных блоков. TextOut не определяет конца строки по нулевому символу, и поэтому для задания ее длины необходим параметр iLength.

Значения x и y в TextOut определяют точку начала строки текста внутри рабочей области. Значение x в горизонтальном направлении, значение y в вертикальном. Левый верхний угол первого символа строки имеет координаты (x, y). В контексте устройства по умолчанию исходной точкой отсчета (когда x и y равны 0) является левый верхний угол рабочей области. Если x и y в TextOut равны 0, строка текста начнет выводиться, начиная с левого верхнего угла рабочей области.

Координаты GDI в документации упоминаются как "логические координаты" (logical coordinates). Что именно это означает, мы более подробно изучим в следующей главе. Сейчас достаточно знать, что в Windows имеются различные "режимы отображения" (mapping mode), которые определяют, как логические координаты, заданные в функциях GDI, преобразуются в реальные физические координаты дисплея. Режим отображения определяется в контексте устройства. Задаваемый по умолчанию режим отображения называется MM_TEXT (идентификатор, заданный в заголовочных файлах Windows). В режиме отображения MM_TEXT логические единицы соответствуют физическим единицам, каковыми являются пиксели, задаваемые относительно левого верхнего угла рабочей области. Значения по координате x увеличиваются при движении вправо по рабочей области, а по y — при движении вниз. (См. рис. 3.2.) Система координат режима MM_TEXT эквивалентна системе координат, которую Windows использует для определения недействительного прямоугольника в структуре PAINTSTRUCT. Это очень удобно. (Однако это не относится к другим режимам отображения).

Values of x (значение х) Values of y (значение у ) Client area (рабочая область) Рис. 3.2 Координаты x и y в режиме отображения MM_TEXT Контекст устройства также определяет "регион отсечения" (clipping region). Как вы уже узнали, задаваемый по умолчанию регион отсечения — это или вся рабочая область, если описатель контекста устройства получен из функции GetDC, или недействительный регион, если описатель контекста устройства получен из функции BeginPaint. Windows не выведет на экран ту часть строки символов, которая лежит вне региона отсечения. Если часть символа находится внутри отсекающей зоны, Windows выводит на экран только эту часть. Вывести что-нибудь за пределы рабочей области вашего окна очень непросто, поэтому не беспокойтесь о том, что это случится по невнимательности.

Системный шрифт Контекст устройства также определяет шрифт, который Windows использует при выводе текста в рабочюю область. По умолчанию задается так называемый "системный шрифт" (system font) или (используя идентификатор заголовочных файлов Windows) SYSTEM_FONT. Системный шрифт — это шрифт, который Windows использует для текста заголовков, меню и окон диалога.

В ранних версиях Windows системный шрифт был фиксированным, т. е. у всех символов была одинаковая ширина, также как на пишущей машинке. Однако, начиная с Windows 3.0 (и до Windows 95 включительно), системный шрифт стал пропорциональным, т. е. разные символы имеют разную ширину. Например, символ W шире символа i. Так было сделано потому, что пропорциональный шрифт гораздо лучше читается, чем фиксированный. Но, как вы могли бы догадаться, изменение задаваемого по умолчанию шрифта с фиксированного на пропорциональный привело в негодность массу программ для первых версий Windows и потребовало от программистов изучить некоторые новые приемы работы с текстом.

Системный шрифт является "растровым шрифтом" (raster font). Это означает, что все символы определяются как пиксельные шаблоны. Распространяемые для продажи версии Windows включают в себя несколько системных шрифтов различных размеров для использования с различными видеоадаптерами. Когда производители новых видеоплат создают новый дисплейный драйвер, они также ответственны и за разработку системного шрифта, соответствующего разрешению дисплея. В противном случае, производителю пришлось бы указывать, какой именно системный шрифт из входящих в комплект Windows, может использоваться. Системный шрифт должен быть разработан таким образом, чтобы на экране помещалось, по крайней мере, 25 строк и 80 символов текста.

Только это гарантирует, что имеется некоторое соответствие между размером экрана и размером шрифта в Windows.

Размер символа Для вывода на экран нескольких строк текста с использованием функции TextOut, вам необходимо задать размеры символов шрифта. Следующие друг за другом строки текста вы размещаете на экране с учетом высоты символа, а колонки текста в рабочей области — исходя из усредненной ширины символов шрифта.

Размеры символов можно получить с помощью вызова функции GetTextMetrics. Для функции GetTextMetrics требуется описатель контекста устройства, поскольку ее возвращаемым значением является информация о шрифте, выбранном в данное время в контексте устройства. Windows копирует различные значения метрических параметров текста в структуру типа TEXTMETRIC. Значения определяются в единицах, зависящих от выбранного в контексте устройства режима отображения. Выбранным по умолчанию в контексте устройства режимом отображения является режим MM_TEXT, а единицами измерения являются пиксели.

Для использования функции GetTextMetrics, во-первых, необходимо определить структурную переменную (которую обычно называют tm):

TEXTMETRIC tm;

Далее нужно получить описатель контекста устройства и вызвать GetTextMetrics:

hdc = GetDC(hwnd);

GetTextMetrics(hdc, &tm);

ReleaseDC(hwnd, hdc);

Теперь вы можете проанализировать значения в структуре текстовых размеров и, возможно, сохранить несколько из них для использования в будущем.

Метрические параметры текста. Подробности Структура TEXTMETRIC обеспечивает полную информацию о выбранном в данный момент в контексте устройства шрифте. Вертикальный размер шрифта определяется только пятью величинами, как показано на рис. 3.3.

Эти величины вполне объяснимы. Значение tmInternalLeading — это величина пустого пространства, отведенного для указания специальных знаков над символом. Если это значение равно 0, то помеченные прописные буквы делаются немного меньше, чтобы специальный символ поместился внутри верхней части символа. Значение tmExternalLeading — это величина пустого пространства, которое разработчик шрифта установил для использования между строками символов. Вы можете согласиться или отклонить предложение разработчика при распределении пространства между строками текста.

В структуре TEXTMETRIC имеется два поля, описывающих ширину символа: tmAveCharWidth (усредненная ширина символов строки) и tmMaxCharWidth (ширина самого широкого символа шрифта). Для фиксированного шрифта эти две величины одинаковы.

В примерах программ этой главы используется другое значение ширины символа — средняя ширина прописных букв. Она может быть точно рассчитана как 150% от tmAveCharWidth.

tmExternalLeading tmInternalLeading tmAscent tmHeight Baseline tmDescent Рис. 3.3 Пять значений, определяющих вертикальный размер шрифта Важно понимать, что размеры системного шрифта зависят от разрешающей способности дисплея, на котором работает Windows. Система Windows обеспечивает независимый от оборудования графический интерфейс, но, тем не менее, вам необходимо помочь ей. Не пишите программы для Windows, опирающиеся на конкретные размеры символов. Не задавайте никаких фиксированных значений. Используйте функцию GetTextMetrics для получения этой информации.

Форматирование текста Поскольку размеры системного шрифта не меняются в рамках одного сеанса работы с системой Windows, вам необходимо вызвать функцию GetTextMetrics только один раз при выполнении программы. Хорошо сделать этот вызов при обработке сообщения WM_CREATE в оконной процедуре. Сообщение WM_CREATE — это первое сообщение, которое принимает оконная процедура. Windows вызывает вашу оконную процедуру с сообщением WM_CREATE, когда вы вызываете в WinMain функцию CreateWindow.

Предположим, что вы пишите программу для Windows, которая выводит на экран несколько строк текста, появляющихся друг за другом в направлении к нижней границе рабочей области. Вы хотите получить значения высоты и ширины символов. Внутри оконной процедуры вы можете определить две переменные для хранения средней ширины символов (cxChar) и полной высоты символов (cyChar):

static int cxChar, cyChar;

Префикс с, добавленный к именам переменных, означает "счетчик" (сount) и в сочетании с x или y относится к длине или ширине. Эти переменные определяются как статические, поскольку они должны оставаться без изменений при обработке оконной процедурой других сообщений (таких как WM_PAINT). Если эти переменные определяются как глобальные вне какой бы то ни было функции, то нет необходимости определять их как статические.

Здесь представлен код обработки сообщения WM_CREATE:

case WM_CREATE:

hdc = GetDC(hwnd);

GetTextMetrics(hdc, &tm);

cxChar = tm.tmAveCharWidth;

cyChar = tm.tmHeight + tm.tmExternalLeading;

ReleaseDC(hwnd, hdc);

return 0;

Если вы не хотите учитывать межстрочное пространство (external leading), то можно использовать:

cyChar = tm.tmHeight;

От вас зависит, как использовать полученный размер символов для расчета координат при выводе информации.

Самое простое — оставить пустое поле cyChar в верхней части рабочей области, и cxChar в ее левой части. Для вывода на экран нескольких строк текста с выравниванием по левому краю при вызове функции TextOut используйте следующее значение координаты x:

cxChar Значение координаты y в TextOut:

cyChar *(1 + i) где i — это номер строки, начиная с 0.

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

В Windows есть аналогичная функция sprintf. Она работает точно также, как и функция printf, отличие заключается в том, что форматируемая строка помещается в символьный массив. Для вывода строки на экран можно затем использовать функцию TextOut. Очень удобно то, что возвращаемым значением sprintf является длина строки — вы можете передать это значение в TextOut в качестве параметра iLength. Следующий фрагмент программы показывает типовое использование функций sprintf и TextOut :

int iLength;

char szBuffer[40];

[другие инструкции программы] iLength = sprintf(szBuffer, "Сумма %d и %d равна %d", nA, nB, nA + nB);

TextOut(hdc, x, y, szBuffer, iLength);

Для достаточно простых задач вы могли бы избежать вычисления iLength и объединить два оператора в один:

TextOut(hdc, x, y, szBuffer, sprintf(szBuffer, "Сумма %d и %d равна %d", nA, nB, nA + nB));

Это не очень красиво, но вполне работоспособно.

Если вам не нужно выводить числа с плавающей точкой, то вместо sprintf вам лучше использовать функцию wsprintf. Синтаксис функции wsprintf такой же, как и sprintf, но она включена в Windows, поэтому ее использование не увеличит размер вашего EXE-файла.

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

Информация, получаемая при вызове функции Windows GetSystemMetrics, достаточно полезна. Эта функция возвращает информацию о размере различных графических элементов Windows, таких как значки, курсоры, панели заголовков и полосы прокрутки. В функции GetSystemMetrics имеется один параметр, называемый "индекс" (index). Этот индекс — один из 73 целых идентификаторов, определяемых в заголовочных файлах Windows.

Возвращаемым значением GetSystemMetrics является целое, обычно это размер элемента, указанного в параметре.

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

Заголовочный файл назовем SYSMETS.H, он показан на рис. 3.4.

SYSMETS.H /*----------------------------------------------- SYSMETS.H -- System metrics display structure -----------------------------------------------*/ #define NUMLINES((int)(sizeof sysmetrics / sizeof sysmetrics [0])) struct { int iIndex;

char *szLabel;

char *szDesc;

} sysmetrics [] = { SM_CXSCREEN, "SM_CXSCREEN", "Screen width in pixels", SM_CYSCREEN, "SM_CYSCREEN", "Screen height in pixels", SM_CXVSCROLL, "SM_CXVSCROLL", "Vertical scroll arrow width", SM_CYHSCROLL, "SM_CYHSCROLL", "Horizontal scroll arrow height", SM_CYCAPTION, "SM_CYCAPTION", "Caption bar height", SM_CXBORDER, "SM_CXBORDER", "Window border width", SM_CYBORDER, "SM_CYBORDER", "Window border height", SM_CXDLGFRAME, "SM_CXDLGFRAME", "Dialog window frame width", SM_CYDLGFRAME, "SM_CYDLGFRAME", "Dialog window frame height", SM_CYVTHUMB, "SM_CYVTHUMB", "Vertical scroll thumb height", SM_CXHTHUMB, "SM_CXHTHUMB", "Horizontal scroll thumb width", SM_CXICON, "SM_CXICON", "Icon width", SM_CYICON, "SM_CYICON", "Icon height", SM_CXCURSOR, "SM_CXCURSOR", "Cursor width", SM_CYCURSOR, "SM_CYCURSOR", "Cursor height", SM_CYMENU, "SM_CYMENU", "Menu bar height", SM_CXFULLSCREEN, "SM_CXFULLSCREEN", "Full screen client area width", SM_CYFULLSCREEN, "SM_CYFULLSCREEN", "Full screen client area height", SM_CYKANJIWINDOW, "SM_CYKANJIWINDOW", "Kanji window height", SM_MOUSEPRESENT, "SM_MOUSEPRESENT", "Mouse present flag", SM_CYVSCROLL, "SM_CYVSCROLL", "Vertical scroll arrow height", SM_CXHSCROLL, "SM_CXHSCROLL", "Horizontal scroll arrow width", SM_DEBUG, "SM_DEBUG", "Debug version flag", SM_SWAPBUTTON, "SM_SWAPBUTTON", "Mouse buttons swapped flag", SM_RESERVED1, "SM_RESERVED1", "Reserved", SM_RESERVED2, "SM_RESERVED2", "Reserved", SM_RESERVED3, "SM_RESERVED3", "Reserved", SM_RESERVED4, "SM_RESERVED4", "Reserved", SM_CXMIN, "SM_CXMIN", "Minimum window width", SM_CYMIN, "SM_CYMIN", "Minimum window height", SM_CXSIZE, "SM_CXSIZE", "Minimize/Maximize icon width", SM_CYSIZE, "SM_CYSIZE", "Minimize/Maximize icon height", SM_CXFRAME, "SM_CXFRAME", "Window frame width", SM_CYFRAME, "SM_CYFRAME", "Window frame height", SM_CXMINTRACK, "SM_CXMINTRACK", "Minimum window tracking width", SM_CYMINTRACK, "SM_CYMINTRACK", "Minimum window tracking height", SM_CXDOUBLECLK, "SM_CXDOUBLECLK", "Double click x tolerance", SM_CYDOUBLECLK, "SM_CYDOUBLECLK", "Double click y tolerance", SM_CXICONSPACING, "SM_CXICONSPACING", "Horizontal icon spacing", SM_CYICONSPACING, "SM_CYICONSPACING", "Vertical icon spacing", SM_MENUDROPALIGNMENT, "SM_MENUDROPALIGNENT", "Left or right menu drop", SM_PENWINDOWS, "SM_PENWINDOWS", "Pen extensions installed", SM_DBCSENABLED, "SM_DBCSENABLED", "Double-Byte Char Set enabled", SM_CMOUSEBUTTONS, "SM_CMOUSEBUTTONS", "Number of mouse buttons", SM_SHOWSOUNDS, "SM_SHOWSOUNDS", "Present sounds visually" };

Рис. 3.4 SYSMETS.H Программа для вывода этой информации называется SYSMETS1. Файлы, необходимые для создания SYSMETS.EXE (make-файл и файл с исходным текстом на С) приведены на рис. 3.5. Большинство операторов должны быть теперь вам понятны. За исключением имени программы, make-файл идентичен make-файлу программы HELLOWIN. В SYSMETS1.С функция WinMain фактически идентична HELLOWIN.

SYSMETS1.MAK #------------------------ # SYSMETS1.MAK make file #------------------------ sysmets1.exe : sysmets1.obj $(LINKER) $(GUIFLAGS) -OUT:sysmets1.exe sysmets1.obj $(GUILIBS) sysmets1.obj : sysmets1.c sysmets.h $(CC) $(CFLAGS) sysmets1.c SYSMETS1.C /*---------------------------------------------------- SYSMETS1.C -- System Metrics Display Program No. (c) Charles Petzold, ----------------------------------------------------*/ #include #include #include "sysmets.h" LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow) { static char szAppName[] = "SysMets1";

HWND hwnd;

MSG msg;

WNDCLASSEX wndclass;

wndclass.cbSize = sizeof(wndclass);

wndclass.style = CS_HREDRAW | CS_VREDRAW;

wndclass.lpfnWndProc = WndProc;

wndclass.cbClsExtra = 0;

wndclass.cbWndExtra = 0;

wndclass.hInstance = hInstance;

wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);

wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);

wndclass.hbrBackground =(HBRUSH) GetStockObject(WHITE_BRUSH);

wndclass.lpszMenuName = NULL;

wndclass.lpszClassName = szAppName;

wndclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

RegisterClassEx(&wndclass);

hwnd = CreateWindow( szAppName, "Get System Metrics No. 1", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance, NULL );

ShowWindow(hwnd, iCmdShow);

UpdateWindow(hwnd);

while(GetMessage(&msg, NULL, 0, 0)) { TranslateMessage(&msg);

DispatchMessage(&msg);

} return msg.wParam;

} LRESULT CALLBACK WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam) { static int cxChar, cxCaps, cyChar;

char szBuffer[10];

HDC hdc;

int i;

PAINTSTRUCT ps;

TEXTMETRIC tm;

switch(iMsg) { case WM_CREATE :

hdc = GetDC(hwnd);

GetTextMetrics(hdc, &tm);

cxChar = tm.tmAveCharWidth;

cxCaps =(tm.tmPitchAndFamily & 1 ? 3 : 2) * cxChar / 2;

cyChar = tm.tmHeight + tm.tmExternalLeading;

ReleaseDC(hwnd, hdc);

return 0;

case WM_PAINT :

hdc = BeginPaint(hwnd, &ps);

for(i = 0;

i < NUMLINES;

i++) { TextOut( hdc, cxChar, cyChar *(1 + i), sysmetrics[i].szLabel, strlen(sysmetrics[i].szLabel) );

TextOut( hdc, cxChar + 22 * cxCaps, cyChar *(1 + i), sysmetrics[i].szDesc, strlen(sysmetrics[i].szDesc) );

SetTextAlign(hdc, TA_RIGHT | TA_TOP);

TextOut( hdc, cxChar + 22 * cxCaps + 40 * cxChar, cyChar *(1 + i), szBuffer, wsprintf( szBuffer, "%5d", GetSystemMetrics(sysmetrics[i].iIndex) ) );

SetTextAlign(hdc, TA_LEFT | TA_TOP);

} EndPaint(hwnd, &ps);

return 0;

case WM_DESTROY :

PostQuitMessage(0);

return 0;

} return DefWindowProc(hwnd, iMsg, wParam, lParam);

} Рис. 3.5 Программа SYSMETS На рис. 3.6 показано окно программы SYSMETS1, работающей на VGA. Из информации в окне программы следует, что ширина экрана составляет 640 пикселей, а высота 480 пикселей. Эти два значения, также как и многие другие значения, выведенные в окне, могут отличаться для различных типов дисплеев.

Рис. 3.6 Вывод информации программой SYSMETS Оконная процедура программы SYSMETS1.С Оконная процедура WndProc программы SYSMETS1.С обрабатывает три сообщения: WM_CREATE, WM_PAINT и WM_DESTROY. Сообщение WM_DESTROY обрабатывается точно также, как и в программе HELLOWIN, рассмотренной в главе 2.

Сообщение WM_CREATE является первым сообщением, получаемым оконной процедурой. Оно генерируется операционной системой Windows, когда функция CreateWindow создает окно. При обработке сообщения WM_CREATE SYSMETS1 получает контекст устройства для окна путем вызова функции GetDC, а также размеры текста для системного шрифта по умолчанию путем вызова функции GetTextMetrics. SYSMETS1 сохраняет усредненное значение ширины символа в cxChar и полную высоту символов (включая поле tmExternalLeading) в cyChar.

SYSMETS1 также сохраняет среднюю ширину символов верхнего регистра в статической переменной cxCaps. Для фиксированного шрифта cxCaps была бы равна cxChar. Для пропорционального шрифта cxCaps равна 150% от cxChar. Младший бит поля tmPitchAndFamily структуры TEXTMETRIC равен 1 для пропорционального шрифта и 0 для фиксированного. SYSMETS1 использует значение этого бита для расчета cxCaps из cxChar следующим образом:

cxCaps =(tm.tmPitchAndFamily & 1 ? 3 : 2) * cxChar / 2;

SYSMETS1 полностью выполняет процедуру рисования окна во время обработки сообщения WM_PAINT. Как правило, оконная процедура путем вызова BeginPaint, получает, в первую очередь, описатель контекста устройства. В цикле for обрабатываются все элементы структуры sysmetrics, определенной в SYSMETS.H. Три колонки текста выводятся на экран тремя функциями TextOut. В каждом случае третий параметр TextOut — это выражение:

cyChar *(1 + i) Этот параметр показывает в пикселях положение верхней границы строки символов относительно верхней границы рабочей области. Таким образом программа делает верхний отступ равным cyChar. Первая строка текста (если i равно 0) начинается на cyChar пикселей ниже верхней границы рабочей области.

Первая инструкция TextOut выводит на экран в первую колонку идентификаторы, написанные прописными буквами. Вторым параметром TextOut является cxChar. Он оставляет левый отступ между первым символом строки и левой границей рабочей области окна равным одному символу. Текст берется из поля szLabel структуры sysmetrics. Функция периода выполнения strlen языка С используется для получения длины строки, которая необходима в качестве последнего параметра для TextOut.

Вторая инструкция TextOut выводит на экран описание значений системных размеров. Эти описания хранятся в поле szDesc структуры sysmetrics. В этом случае второй параметр TextOut — это выражение:

cxChar + 22 * cxCaps Максимальная длина идентификаторов, выводимых на экран в первой колонке прописными буквами, составляет 20 символов, поэтому вторая колонка должна начинаться в позиции, по крайней мере, на 20* cxCaps правее начала первой колонки текста.

Третий оператор TextOut выводит на экран численные значения, полученные от функции GetTextMetrics.

Пропорциональный шрифт делает форматирование колонки, выравненных по правому краю чисел, слегка обманчивым. Каждая цифра от 0 до 9 имеют одну и ту же ширину, но эта ширина больше, чем ширина пробела.

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

Возможно, было бы проще, если бы мы выводили колонку выравненных по правому краю чисел, задав положение последней цифры, вместо первой. Это позволяет делать функция SetTextAlign. После вызова этой функции в программе SYSMETS1:

SetTextAlign(hdc, TA_RIGHT | TA_TOP);

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

Второй параметр функции TextOut для вывода колонки чисел — это выражение:

cxChar + 22 * cxCaps + 40 * cxChar Значение 40 * cxChar позволяет согласовать ширину второй колонки и ширину третьей колонки. Следующий за функцией TextOut другой вызов функции SetTextAlign возвращает все в исходное состояние на время до начала следующего цикла.

Не хватает места!

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

Программа SYSMETS1 ничего не знает о ширине рабочей области. Программа выводит текст, начиная от верхнего края окна и заставляет Windows отрезать все, что оказывается вне рамок рабочей области. Это нежелательно.

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

Размер рабочей области Если вы уже работаете с существующими приложениями для Windows, то обнаружите, что размер окон может меняться в очень широких пределах. Большинство (если предположить отсутствие в окнах меню или полос прокрутки) окон можно развернуть, и рабочая область займет весь экран, за исключением панели заголовка программы. Полный размер этой развернутой рабочей области становится доступным, благодаря функции GetSystemMetrics, использующей параметры SM_CXFULLSCREEN и SM_CYFULLSCREEN. Для дисплея типа VGA возвращаемые значения равны 640 и 461 пикселей. Минимальный размер окна может быть совершенно незначительным, иногда почти невидимым, когда рабочая область фактически исчезает.

Одним из наиболее общих способов определения размера рабочей области окна является обработка сообщения WM_SIZE в оконной процедуре. Windows посылает в оконную процедуру сообщение WM_SIZE при любом изменении размеров окна. Переменная lParam, переданная в оконную процедуру, содержит ширину рабочей области в младшем слове и высоту в старшем слове. Код программы для обработки этого сообщения часто выглядит следующим образом:

static int cxClient, cyClient;

[другие инструкции программы] case WM_SIZE:

cxClient = LOWORD(lParam);

cyClient = HIWORD(lParam);

return 0;

Макросы LOWORD и HIWORD определяются в заголовочных файлах Windows. Также как cxChar и cyChar, переменные cxClient и cyClient определяются внутри оконной процедуры в качестве статических, так как они используются позднее при обработке других сообщений.

В конечном итоге за сообщением WM_SIZE будет следовать сообщение WM_PAINT. Почему? Потому что при определении класса окна мы следующим образом задали стиль класса:

CS_HREDRAW | CS_VREDRAW Такой стиль класса указывает Windows на необходимость перерисовки как при горизонтальных изменениях размеров, так и при вертикальных.

Вы можете рассчитать полное число строк текста, которые помещаются внутри рабочей области окна по формуле:

cyClient / cyChar Результат может быть равен 0, если высота рабочей области слишком мала для вывода на экран целого символа.

Аналогично, примерное число строчных символов, которые вы сможете горизонтально изобразить в рабочей области равно:

cxClient / cxChar Если вы определяете cxChar и cyChar при обработке сообщения WM_CREATE, не беспокойтесь о возможном делении на 0 в этом выражении. Ваша оконная процедура получает сообщение WM_CREATE, когда WinMain вызывает CreateWindow. Первое сообщение WM_SIZE приходит несколько позднее, когда WinMain вызывает ShowWindow, благодаря этому cxChar и cyChar всегда являются положительными ненулевыми величинами.

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

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

Полосы прокрутки предназначены для просмотра информации как в вертикальном (движение вверх и вниз), так и в горизонтальном (движение вправо и влево) направлениях. Вы можете щелкнуть мышью на стрелке в любом конце полосы прокрутки или между стрелками. Бегунок ("scroll box" или "thumb") перемещается по длине полосы прокрутки, индицируя положение информации на экране относительно документа в целом. Вы также можете с помощью мыши переместить бегунок в конкретное положение. На рис. 3.7 показано рекомендуемое использование вертикальной полосы прокрутки для просмотра текста.

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

однако, программа фактически перемещает документ вверх относительно окна.

Документация Windows и идентификаторы ее заголовочных файлов основываются на точке зрения пользователя:

Прокрутка вверх означает движение к началу документа;

прокрутка вниз означает движение к концу.

Щелкните здесь для прокрутки на одну строку вверх Щелкните здесь для прокрутки на одну страницу вверх Переместите бегунок для перехода в нужное место Щелкните здесь для прокрутки на одну страницу вниз Щелкните здесь для прокрутки на одну строку вниз Рис. 3.7 Вертикальная полоса прокрутки Вставить в ваше окно приложения вертикальную или горизонтальную полосу прокрутки очень просто. Все, что вам нужно сделать, это включить идентификатор WS_VSCROLL (вертикальная прокрутка) и WS_HSCROLLW (горизонтальная прокрутка) или оба сразу в описание стиля окна в инструкции CreateWindow. Эти полосы прокрутки всегда размещаются у правого края или в нижней части окна и занимают всю высоту или ширину рабочей области. Рабочая область не включает в себя пространство, занятое полосами прокрутки. Ширина вертикальной полосы прокрутки и высота горизонтальной постоянны для конкретного дисплейного драйвера. Если вам необходимы эти значения, вы можете получить их (как вы могли бы заметить), вызвав функцию GetSystemMetrics.

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

Диапазон и положение полос прокрутки Каждая полоса прокрутки имеет соответствующий "диапазон" (range) (два целых, отражающих минимальное и максимальное значение) и "положение" (position) (местоположение бегунка внутри диапазона). Когда бегунок находится в крайней верхней (или крайней левой) части полосы прокрутки, положение бегунка соответствует минимальному значению диапазона. Крайнее правое (или крайнее нижнее) положение бегунка на полосе прокрутки соответствует максимальному значению диапазона.

По умолчанию устанавливается следующий диапазон полосы прокрутки: 0 (сверху или слева) и 100 (снизу или справа), но диапазон легко изменить на какое-нибудь более подходящее для вашей программы значение:

SetScrollRange(hwnd, iBar, iMin, iMax, bRedraw);

Параметр iBar равен либо SB_VERT, либо SB_HORZ, iMin и iMax являются минимальной и максимальной границами диапазона, а bRedraw устанавливается в TRUE, если Вы хотите, чтобы Windows перерисовала полосы прокрутки на основе вновь заданного диапазона.

Положение бегунка всегда дискретно. Например, полоса прокрутки с диапазоном от 0 до 4 имеет пять положений бегунка, как показано на рис. 3.8. Для установки нового положения бегунка внутри диапазона полосы прокрутки можно использовать функцию SetScrollPos:

SetScrollPos(hwnd, iBar, iPos, bRedraw);

Параметр iPos — это новое положение бегунка, оно должно быть задано внутри диапазона от iMin до iMax. Для получения текущего диапазона и положения полосы прокрутки в Windows используются похожие функции (GetScrollRange и GetScrollPos).

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

• Управляет логикой работы мыши с полосой прокрутки.

• Обеспечивает временную "инверсию цвета" при нажатии на кнопку мыши на полосе прокрутки.

• Перемещает бегунок в соответствие с тем, как внутри полосы прокрутки его перемещает пользователь.

• Отправляет сообщения полосы прокрутки в оконную процедуру для окна, содержащего полосу прокрутки.

Ниже представлены сферы ответственности вашей программы:

• Инициализация диапазона полосы прокрутки.

• Обработка сообщений полосы прокрутки.

• Обновление положения бегунка полосы прокрутки.

Положение Положение Положение Положение Положение Положение 0 Положение 1 Положение 2 Положение Положение Рис. 3.8 Полосы прокрутки с пятью положениями бегунков Сообщения полос прокрутки Windows посылает оконной процедуре асинхронные сообщения WM_VSCROLL и WM_HSCROLL, когда на полосе прокрутки щелкают мышью или перетаскивается бегунок. Каждое действие мыши на полосе прокрутки вызывает появление по крайней мере двух сообщений, одного при нажатии кнопки мыши и другого, когда ее отпускают.

Младшее слово параметра wParam, которое объединяет сообщения WM_VSCROLL и WM_HSCROLL — это число, показывающее, что мышь осуществляет какие-то действия на полосе прокрутки. Его значения соответствуют определенным идентификаторам, которые начинаются с SB_, что означает "полоса прокрутки" (scroll bar). Хотя в некоторых из этих идентификаторов используются слова "UP" и "DOWN", они применяются и к горизонтальным и к вертикальным полосам прокрутки, как показано на рис. 3.9. Ваша оконная процедура может получить множество сообщений типа SB_LINEUP, SB_PAGEUP, SB_LINEDOWN или SB_PSGEDOWN, если кнопка мыши остается нажатой при перемещении по полосе прокрутки. Сообщение SB_ENDSCROLL показывает, что кнопка мыши отпущена. Как правило, сообщения SB_ENDSCROLL можно игнорировать.

Если младшее слово параметра wParam равно SB_THUMBTRACK или SB_THUMBPOSITION, то старшее слово wParam определяет текущее положение полосы прокрутки. Это положение находится между минимальным и максимальным значениями диапазона полосы прокрутки. Во всех других случаях при работе с полосами прокрутки старшее слово wParam следует игнорировать. Вы также можете игнорировать параметр lParam, который обычно используется для полос прокрутки, создаваемых в окнах диалога.

Нажата: SB_LINEUP Отпущена: SB ENDSCROLL Нажата: SB_PAGEUP Отпущена: SB_ ENDSCROLL Нажата: SB_THUMBTRACK Отпущена:

Нажата: SB_PAGEDOWN Отпущена: SB_ENDSCROLL Нажата: SB_LINEDOWN Отпущена: SB_ENDSCROLL Рис. 3.9 Значения идентификаторов для параметра wParam сообщений полосы прокрутки В документации по Windows указано, что младшее слово wParam может также быть равно SB_TOP или SB_BOTTOM. Оно показывает, что полоса прокрутки была переведена в свое максимальное или минимальное положение. Однако, вы никогда не получите эти значения для полосы прокрутки, созданной в окне вашего приложения.

Обработка сообщений SB_THUMBTRACK и SB_THUMBPOSITION весьма проблематична. Если вы устанавливаете большой диапазон полосы прокрутки, а пользователь быстро перемещает бегунок по полосе, то Windows отправит вашей оконной функции множество сообщений SB_THUMBTRACK. Ваша программа столкнется с проблемой обработки этих сообщений. По этой причине в большинстве приложений Windows эти сообщения игнорируются, а действия предпринимаются только при получении сообщения SB_THUMBPOSITION, которое означает, что бегунок оставлен в покое.

Однако, если у вас есть возможность быстро обновлять содержимое экрана, вы можете захотеть включить в программу обработку сообщений SB_THUMBTRACK. Но знайте, что те пользователи, которые обнаружат, что ваша программа мгновенно реагирует на перемещение бегунка по полосе прокрутки, несомненно будут пытаться двигать его как можно быстрее, чтобы понаблюдать, сможет ли программа отследить это движение — и они будут несказанно удовлетворены, если этого не произойдет.

Прокрутка в программе SYSMETS Достаточно объяснений. Самое время использовать этот материал на практике. Давайте начнем с простого. Начнем мы с вертикальной прокрутки, поскольку требуется она гораздо чаще. Горизонтальная прокрутка может подождать. SYSMETS2 представлена на рис. 3.10.

Обновленный вызов функции CreateWindow добавляет вертикальную полосу прокрутки к окну, благодаря включению в описание стиля окна в CreateWindow идентификатора WS_VSCROLL:

WS_OVERLAPPEDWINDOW | WS_VSCROLL SYSMETS2.MAK #------------------------ # SYSMETS2.MAK make file #------------------------ sysmets2.exe : sysmets2.obj $(LINKER) $(GUIFLAGS) -OUT:sysmets2.exe sysmets2.obj $(GUILIBS) sysmets2.obj : sysmets2.c sysmets.h $(CC) $(CFLAGS) sysmets2.c SYSMETS2.C /*---------------------------------------------------- SYSMETS2.C -- System Metrics Display Program No. (c) Charles Petzold, ----------------------------------------------------*/ #include #include #include "sysmets.h" LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow) { static char szAppName[] = "SysMets2";

HWND hwnd;

MSG msg;

WNDCLASSEX wndclass;

wndclass.cbSize = sizeof(wndclass);

wndclass.style = CS_HREDRAW | CS_VREDRAW;

wndclass.lpfnWndProc = WndProc;

wndclass.cbClsExtra = 0;

wndclass.cbWndExtra = 0;

wndclass.hInstance = hInstance;

wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);

wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);

wndclass.hbrBackground =(HBRUSH) GetStockObject(WHITE_BRUSH);

wndclass.lpszMenuName = NULL;

wndclass.lpszClassName = szAppName;

wndclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

RegisterClassEx(&wndclass);

hwnd = CreateWindow( szAppName, "Get System Metrics No. 2", WS_OVERLAPPEDWINDOW | WS_VSCROLL, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance, NULL );

ShowWindow(hwnd, iCmdShow);

UpdateWindow(hwnd);

while(GetMessage(&msg, NULL, 0, 0)) { TranslateMessage(&msg);

DispatchMessage(&msg);

} return msg.wParam;

} LRESULT CALLBACK WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam) { static int cxChar, cxCaps, cyChar, cyClient, iVscrollPos;

char szBuffer[10];

HDC hdc;

int i, y;

PAINTSTRUCT ps;

TEXTMETRIC tm;

switch(iMsg) { case WM_CREATE :

hdc = GetDC(hwnd);

GetTextMetrics(hdc, &tm);

cxChar = tm.tmAveCharWidth;

cxCaps =(tm.tmPitchAndFamily & 1 ? 3 : 2) * cxChar / 2;

cyChar = tm.tmHeight + tm.tmExternalLeading;

ReleaseDC(hwnd, hdc);

SetScrollRange(hwnd, SB_VERT, 0, NUMLINES, FALSE);

SetScrollPos (hwnd, SB_VERT, iVscrollPos, TRUE);

return 0;

case WM_SIZE :

cyClient = HIWORD(lParam);

return 0;

case WM_VSCROLL :

switch(LOWORD(wParam)) { case SB_LINEUP :

iVscrollPos -= 1;

break;

case SB_LINEDOWN :

iVscrollPos += 1;

break;

case SB_PAGEUP :

iVscrollPos -= cyClient / cyChar;

break;

case SB_PAGEDOWN :

iVscrollPos += cyClient / cyChar;

break;

case SB_THUMBPOSITION :

iVscrollPos = HIWORD(wParam);

break;

default :

break;

} iVscrollPos = max(0, min(iVscrollPos, NUMLINES));

if (iVscrollPos != GetScrollPos(hwnd, SB_VERT)) { SetScrollPos(hwnd, SB_VERT, iVscrollPos, TRUE);

InvalidateRect(hwnd, NULL, TRUE);

} return 0;

case WM_PAINT :

hdc = BeginPaint(hwnd, &ps);

for(i = 0;

i < NUMLINES;

i++) { y = cyChar *(1 - iVscrollPos + i);

TextOut( hdc, cxChar, y, sysmetrics[i].szLabel, strlen(sysmetrics[i].szLabel) );

TextOut( hdc, cxChar + 22 * cxCaps, y, sysmetrics[i].szDesc, strlen(sysmetrics[i].szDesc) );

SetTextAlign(hdc, TA_RIGHT | TA_TOP);

TextOut( hdc, cxChar + 22 * cxCaps + 40 * cxChar, y, szBuffer, wsprintf( szBuffer, "%5d", GetSystemMetrics(sysmetrics[i].iIndex) ) );

SetTextAlign(hdc, TA_LEFT | TA_TOP);

} EndPaint(hwnd, &ps);

return 0;

case WM_DESTROY :

PostQuitMessage(0);

return 0;

} return DefWindowProc(hwnd, iMsg, wParam, lParam);

} Рис. 3.10 Программа SYSMETS К оконной процедуре WndProc добавляются две строки для установки диапазона и положения вертикальной полосы прокрутки во время обработки сообщения WM_CREATE:

SetScrollRange(hwnd, SB_VERT, 0, NUMLINES, FALSE);

SetScrollPass(hwnd, SB_VERT, iVscrollPos, TRUE);

Структура sysmetrics содержит NUMLINES строк текста, поэтому границы диапазона полосы прокрутки устанавливается от 0 до NUMLINES. Каждое положение полосы прокрутки соответствует строке текста в верхней части рабочей области. Если бегунок полосы прокрутки находится в положении 0, то в окне сверху остается пустая строка. При увеличении значения, определяющего положение полосы прокрутки, путем перемещения бегунка вниз, текст будет подниматься. Если положение бегунка полосы прокрутки находится в крайнем нижнем положении полосы, то последняя строка текста находится на самом верху рабочей области окна.

Для упрощения обработки сообщений WM_VSCROLL статическая переменная с именем iVscrollPos определяется внутри оконной процедуры WndProc. Эта переменная соответствует текущему положению бегунка полосы прокрутки. Что касается сообщений SB_LINEUP и SB_LINEDOWN, то все, что нужно сделать, это изменить положение прокрутки на 1. При получении сообщений SB_PAGEUP и SB_PAGEDOWN появляется возможность перемещать текст постранично (вернее "поэкранно"), или, что то же самое, изменять положение полосы прокрутки на величину, равную cyClient деленную на cyChar. Для SB_THUMBPOSITION новое положение бегунка определяется старшим словом wParam. Сообщения SB_ENDSCROLL и SB_THUMBTRACK игнорируются.

Затем параметр iVscrollPos устанавливается с использованием макросов min и max, чтобы гарантировать, что значение параметра будет находиться между минимальным и максимальным значениями диапазона. Если положение прокрутки изменилось, оно обновляется с помощью функции SetScrollPos и все окно делается недействительным путем вызова InvalidateRect.

При вызове функции InvalidateRect вырабатывается сообщение WM_PAINT. Когда исходная программа SYSMETS1 обрабатывала сообщение WM_PAINT, координата y для каждой строки рассчитывалась следующим образом:

cyChar *(1 + i) В SYSMETS2 эта формула выглядит так:

cyChar *(1 - iVscrollPos +i) Цикл по прежнему выводит на экран NUMLINES строк текста, но для значений параметра iVscrollPos от 2 и выше, цикл начинает выводить строки за пределами верхней границы рабочей области. Поскольку строки находятся за пределами рабочей области, Windows эти строки на экран не выводит.

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

Структурирование вашей программы для рисования Оконная процедура в SYSMETS2 не перерисовывает рабочую область после обработки сообщения полосы прокрутки. Вместо этого она вызывает функцию InvalidateRect для того, чтобы сделать рабочую область недействительной. Это заставляет Windows поместить сообщение WM_PAINT в очередь сообщений.

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

Вначале вы можете возмутиться по поводу этого высказывания, поскольку это так непохоже на нормальное программирование для PC. Нельзя отрицать, что иногда рисование в ответ на другие, отличные от WM_PAINT сообщения гораздо более удобно. (Программа KEYLOOK в главе 5 — именно такой пример). Но во многих случаях это просто не нужно, и, поскольку вы теперь специалист в области сбора всей необходимой для рисования информации в ответ на сообщение WM_PAINT, вы должны быть довольны результатами своей работы. Однако, вашей программе часто будет необходимо перерисовать только отдельную область экрана при обработке другого, отличного от WM_PAINT сообщения. В таком случае становится удобной функция InvalidateRect. Вы можете использовать ее, чтобы делать недействительными конкретные прямоугольные зоны рабочей области или рабочую область в целом.

Для некоторых приложений может оказаться недостаточным просто пометить некоторые зоны окна как недействительные для выработки сообщения WM_PAINT. После вызова функции InvalidateRect, Windows помещает сообщение WM_PAINT в очередь сообщений, и оконная процедура в конце концов его обрабатывает.

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

Если вы хотите немедленно обновить недействительную область, вы можете после вызова функции InvalidateRect вызвать UpdateWindow:

UpdateWindow(hwnd);

Вызов UpdateWindow приводит к немедленному вызову оконной процедуры с сообщением WM_PAINT в случае, если существует какая-либо недействительная зона в рабочей области окна. (Если вся рабочая область действительна, вызова оконной процедуры не произойдет.) Такие сообщения WM_PAINT минуют очередь сообщений. Оконная процедура вызывается прямо из Windows. После того как оконная процедура завершает перерисовку, она заканчивает свою работу, и Windows возвращает управление в программу на следующую после вызова UpdateWindow инструкцию.

Заметьте, что UpdateWindow — это та же самая функция, которая использовалась в WinMain для выработки первого сообщения WM_PAINT. При создании окна вся рабочая область является недействительной.

UpdateWindow заставляет оконную процедуру перерисовать ее.

Создание улучшенной прокрутки Поскольку программа SYSMETS2 слишком неэффективна, как модель для повторения ее в других программах, давайте модифицируем ее. SYSMETS3 — наша окончательная версия программы SYSMETS этой главы — показана на рис. 3.11. В этой версии добавлена горизонтальная полоса прокрутки для прокрутки рабочей области влево и вправо, и перерисовка рабочей области организована более эффективно.

SYSMETS3.MAK #------------------------ # SYSMETS3.MAK make file #------------------------ sysmets3.exe : sysmets3.obj $(LINKER) $(GUIFLAGS) -OUT:sysmets3.exe sysmets3.obj $(GUILIBS) sysmets3.obj : sysmets3.c sysmets.h $(CC) $(CFLAGS) sysmets3.c SYSMETS3.C /*---------------------------------------------------- SYSMETS3.C -- System Metrics Display Program No. (c) Charles Petzold, ----------------------------------------------------*/ #include #include "sysmets.h" LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow) { static char szAppName[] = "SysMets3";

HWND hwnd;

MSG msg;

WNDCLASSEX wndclass;

wndclass.cbSize = sizeof(wndclass);

wndclass.style = CS_HREDRAW | CS_VREDRAW;

wndclass.lpfnWndProc = WndProc;

wndclass.cbClsExtra = 0;

wndclass.cbWndExtra = 0;

wndclass.hInstance = hInstance;

wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);

wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);

wndclass.hbrBackground =(HBRUSH) GetStockObject(WHITE_BRUSH);

wndclass.lpszMenuName = NULL;

wndclass.lpszClassName = szAppName;

wndclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

RegisterClassEx(&wndclass);

hwnd = CreateWindow( szAppName, "Get System Metrics No. 3", WS_OVERLAPPEDWINDOW | WS_VSCROLL | WS_HSCROLL, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance, NULL );

ShowWindow(hwnd, iCmdShow);

UpdateWindow(hwnd);

while(GetMessage(&msg, NULL, 0, 0)) { TranslateMessage(&msg);

DispatchMessage(&msg);

} return msg.wParam;

} LRESULT CALLBACK WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam) { static int cxChar, cxCaps, cyChar, cxClient, cyClient, iMaxWidth, iVscrollPos, iVscrollMax, iHscrollPos, iHscrollMax;

char szBuffer[10];

HDC hdc;

int i, x, y, iPaintBeg, iPaintEnd, iVscrollInc, iHscrollInc;

PAINTSTRUCT ps;

TEXTMETRIC tm;

switch(iMsg) { case WM_CREATE :

hdc = GetDC(hwnd);

GetTextMetrics(hdc, &tm);

cxChar = tm.tmAveCharWidth;

cxCaps = (tm.tmPitchAndFamily & 1 ? 3 : 2) * cxChar / 2;

cyChar = tm.tmHeight + tm.tmExternalLeading;

ReleaseDC(hwnd, hdc);

iMaxWidth = 40 * cxChar + 22 * cxCaps;

return 0;

case WM_SIZE :

cxClient = LOWORD(lParam);

cyClient = HIWORD(lParam);

iVscrollMax = max(0, NUMLINES + 2 - cyClient / cyChar);

iVscrollPos = min(iVscrollPos, iVscrollMax);

SetScrollRange(hwnd, SB_VERT, 0, iVscrollMax, FALSE);

SetScrollPos(hwnd, SB_VERT, iVscrollPos, TRUE);

iHscrollMax = max(0, 2 +(iMaxWidth - cxClient) / cxChar);

iHscrollPos = min(iHscrollPos, iHscrollMax);

SetScrollRange(hwnd, SB_HORZ, 0, iHscrollMax, FALSE);

SetScrollPos(hwnd, SB_HORZ, iHscrollPos, TRUE);

return 0;

case WM_VSCROLL :

switch(LOWORD(wParam)) { case SB_TOP :

iVscrollInc = -iVscrollPos;

break;

case SB_BOTTOM :

iVscrollInc = iVscrollMax - iVscrollPos;

break;

case SB_LINEUP :

iVscrollInc = -1;

break;

case SB_LINEDOWN :

iVscrollInc = 1;

break;

case SB_PAGEUP :

iVscrollInc = min(-1, -cyClient / cyChar);

break;

case SB_PAGEDOWN :

iVscrollInc = max(1, cyClient / cyChar);

break;

case SB_THUMBTRACK :

iVscrollInc = HIWORD(wParam) - iVscrollPos;

break;

default :

iVscrollInc = 0;

} iVscrollInc = max( -iVscrollPos, min(iVscrollInc, iVscrollMax - iVscrollPos) );

if (iVscrollInc != 0) { iVscrollPos += iVscrollInc;

ScrollWindow(hwnd, 0, -cyChar * iVscrollInc, NULL, NULL);

SetScrollPos(hwnd, SB_VERT, iVscrollPos, TRUE);

UpdateWindow(hwnd);

} return 0;

case WM_HSCROLL :

switch(LOWORD(wParam)) { case SB_LINEUP :

iHscrollInc = -1;

break;

case SB_LINEDOWN :

iHscrollInc = 1;

break;

case SB_PAGEUP :

iHscrollInc = -8;

break;

case SB_PAGEDOWN :

iHscrollInc = 8;

break;

case SB_THUMBPOSITION :

iHscrollInc = HIWORD(wParam) - iHscrollPos;

break;

default :

iHscrollInc = 0;

} iHscrollInc = max( -iHscrollPos, min(iHscrollInc, iHscrollMax - iHscrollPos) );

if (iHscrollInc != 0) { iHscrollPos += iHscrollInc;

ScrollWindow(hwnd, -cxChar * iHscrollInc, 0, NULL, NULL);

SetScrollPos(hwnd, SB_HORZ, iHscrollPos, TRUE);

} return 0;

case WM_PAINT :

hdc = BeginPaint(hwnd, &ps);

iPaintBeg = max(0, iVscrollPos + ps.rcPaint.top / cyChar - 1);

iPaintEnd = min(NUMLINES, iVscrollPos + ps.rcPaint.bottom / cyChar);

for(i = iPaintBeg;

i < iPaintEnd;

i++) { x = cxChar *(1 - iHscrollPos);

y = cyChar *(1 - iVscrollPos + i);

TextOut( hdc, x, y, sysmetrics[i].szLabel, strlen(sysmetrics[i].szLabel) );

TextOut( hdc, x + 22 * cxCaps, y, sysmetrics[i].szDesc, strlen(sysmetrics[i].szDesc) );

SetTextAlign(hdc, TA_RIGHT | TA_TOP);

TextOut( hdc, x + 22 * cxCaps + 40 * cxChar, y, szBuffer, wsprintf( szBuffer, "%5d", GetSystemMetrics(sysmetrics[i].iIndex) ) );

SetTextAlign(hdc, TA_LEFT | TA_TOP);

} EndPaint(hwnd, &ps);

return 0;

case WM_DESTROY :

PostQuitMessage(0);

return 0;

} return DefWindowProc(hwnd, iMsg, wParam, lParam);

} Рис. 3.11 Программа SYSMETS Далее рассматриваются улучшения в программе SYSMETS3 и то, как они реализованы в программе:

• Вы не можете прокручивать экран так, чтобы последняя строка оказалась на самом верху рабочей зоны окна. Процесс прокрутки продолжается только до появления последней строки текста в нижней части рабочей области. Для этого необходимо, чтобы программа рассчитала новый диапазон полосы прокрутки (и, возможно, новое положение бегунка) при обработке сообщения WM_SIZE. Логика WM_SIZE вычисляет диапазон полосы прокрутки на основе числа строк текста и размера рабочей области. Такой подход приводит к уменьшению диапазона — необходимо только получить возможность вновь увидеть текст, оказавшийся вне рабочей области.

Это решение дает интересный результат. Предположим, что рабочая область окна достаточно велика, чтобы вывести на экран весь текст, включая верхний и нижний отступы. В таком случае, и минимальное и максимальное положение диапазона полосы прокрутки будут равны 0. Что с этой информацией будет делать Windows? Она удалит полосу прокрутки из окна! Она больше не нужна. Аналогично получается, если рабочая область достаточно широка для вывода текста со строкой в 60 знаков, тогда горизонтальная полоса прокрутки не появляется на экране.

• Для каждого действия с полосой прокрутки сначала рассчитывается приращение ее текущей позиции при обработке сообщений WM_VSCROLL и WM_HSCROLL. Это значение затем используется для прокрутки имеющегося в окне содержимого с помощью вызова функции ScrollWindow. Эта функция имеет следующий формат:

ScrollWindow(hwnd, xInc, yInc, pRect, pClipRect);

Значения xInc и yInc задают величину прокрутки в пикселях. В SYSMETS3 значения pRect и pClipRect устанавливаются в NULL для указания, что необходимо прокручивать всю рабочую область. Windows делает недействительным прямоугольную зону рабочей области, открываемую операцией прокрутки. Это приводит к выдаче сообщения WM_PAINT. InvalidateRect больше не нужна. (Отметьте, что функция ScrollWindow не является процедурой GDI, поскольку ей не нужен описатель контекста устройства. Это одна из немногих функций Windows, которая меняет вид рабочей области окна, не являясь функциями GDI.) • Обработчик сообщения WM_PAINT теперь определяет, какие строки находятся внутри недействительного прямоугольника и выводит только эти строки. Он делает это путем анализа координат верхней и нижней границ недействительного прямоугольника, хранящихся в структуре PAINTSTRUCT. Программа рисует только те строки текста, которые находятся внутри недействительного прямоугольника. Исходный текст программы более сложен, но она работает гораздо быстрее.

• Поскольку сообщения WM_PAINT стали обрабатываться быстрее, теперь, очевидно, есть смысл обрабатывать в SYSMETS3 действия SB_THUMBTRACK для сообщений WM_VSCROLL. Ранее программа игнорировала сообщения SB_THUMBTRACK (которые посылаются, когда пользователь перемещает бегунок полосы прокрутки), а реагировала только на сообщения SB_THUMBPOSITION, которые посылаются, когда пользователь прекращает перемещение бегунка. Сообщение WM_VSCROLL также приводит к вызову функции UpdateWindow для немедленного обновления рабочей области окна. Когда Вы перемещаете бегунок по вертикальной полосе прокрутки, SYSMETS3 непрерывно прокручивает и обновляет рабочую область. Вам самим предлагается решить, насколько быстро работает SYSMETS3 (и Windows), и насколько оправданны внесенные изменения.

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

В главе 5 вы узнаете, как использовать клавиатуру и как добавить в вашу программу интерфейс клавиатуры. Вы также увидите, что SYSMETS3 обрабатывает сообщения WM_VSCROLL, когда младшее слово в wParam равно SB_TOP и SB_BOTTOM. Уже упоминалось, что оконная процедура не получает эти сообщения от полос прокрутки, поэтому для данного случая эти коды излишни. Когда мы в главе 5 вернемся к этой программе, вы увидите смысл во включении в программу этих действий.

Глава 4 Главное о графике Графический интерфейс устройства (GDI) — подсистема Windows 95, отвечающая за отображение графики (включая текст) на видеотерминалах и принтерах. Как можно догадаться, GDI — очень важная компонента Windows. Не только приложения, разрабатываемые вами, активно используют GDI для отображения информации, но и Windows сама очень активно использует его для отображения элементов пользовательского интерфейса, таких как меню, полосы прокрутки, значки и курсоры мыши.

Вероятно, программисты, работающие с MS DOS и ранними версиями Windows по принципу "делаю, что хочу", часто пользовались возможностью работать, минуя GDI, и записывать информацию непосредственно в видеопамять. Пожалуйста, никогда не помышляйте об этом. Это может доставить вам много головной боли, привести к конфликтам с другими программами Windows 95, сделать ваши программы несовместимыми с будущими версиями операционной системы.

В отличие от некоторых новых особенностей Windows 95, GDI практически не менялся с самого начала.

Внутренне Windows 1.0, в основном, состояла из трех динамически подключаемых библиотек, KERNEL (ядро — обработка задач, управление памятью, файловый ввод/вывод), USER (интерфейс пользователя) и GDI. В более поздние версии Windows были включены дополнительные функциональные возможности GDI, сохраняя в основном совместимость с существующими программами, но основа GDI осталась без изменений.

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

Концепция GDI Графика в 32-битной Windows реализуется, в основном, функциями, экспортируемыми из GDI32.DLL, динамически подключаемой библиотеки, которая часто использует 16-битную динамически подключаемую библиотеку GDI.EXE. (Динамически подключаемые библиотеки в ранних версиях Windows чаще имели расширение EXE, а не DLL). Эти модули обращаются к различным функциям драйверов отображения —.DRV файлу для видеомониторов и, возможно, к одному или нескольким.DRV файлам драйверов принтеров или плоттеров. Видеодрайвер осуществляет доступ к аппаратуре видеомонитора или преобразует команды GDI в коды или команды, воспринимаемые различными принтерами. Разные видеоадаптеры и принтеры требуют различных файлов драйверов.

Поскольку к IBM PC совместимым компьютерам может быть подключено множество различных устройств отображения, одной из основных задач GDI является поддержка аппаратно-независимой графики. Программы для Windows должны нормально работать на любых графических устройствах отображения, которые поддерживаются Windows. GDI выполняет эту задачу, предоставляя возможность отделить ваши программы от конкретных характеристик различных устройств отображения.

Все графические устройства отображения делятся на две больших группы: растровые устройства и векторные устройства. Большинство устройств, подключаемых к PC — растровые устройства, т. е. они представляют графические образы как шаблон точек. Эта группа включает видеоадаптеры, матричные принтеры и лазерные принтеры. Группа векторных устройств, отображающих графические образы с использованием линий, в основном, состоит из плоттеров.

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

Устройство отображения оперирует пикселями для создания графических образов, тогда как программа при связи с интерфейсом не использует понятие пикселя. Несмотря на то, что Windows GDI — это высокоуровневая векторная система рисования, она также может применяться и для относительно низкоуровневых манипуляций с пикселями.

С этой точки зрения, Windows GDI это такой же традиционный графический язык, как C — язык программирования. Язык C — хорошо известен своей высокой степенью переносимости относительно разных операционных систем и сред. C также хорошо известен тем, что дает программисту возможность выполнять низкоуровневые системные функции, что часто недоступно в других языках программирования высокого уровня.

Также как C иногда называют "ассемблером высокого уровня", так можно считать, что GDI — это высокоуровневый интерфейс для аппаратных средств графики.

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

Pages:     | 1 || 3 | 4 |   ...   | 12 |



© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.