5. Клавиатура

• 5.1. Клавиатурные сообщения
• 5.2. Параметры клавиатурных сообщений
• 5.3. Символьные клавиатурные сообщения
• 5.4. Стандарты кодов символов
• 5.5. Приложение OEM2ANSI
• 5.6. Текстовый курсор
• 5.7. Приложение KBMSG

Способы работы с клавиатурой в среде Windows коренным образом отличаются от тех, к которым вы привыкли, когда составляли программы для MS-DOS. Из-за чрезвычайно слабой поддержки клавиатуры со стороны MS-DOS программы обычно вызывали прерывание INT16h, обработчик которого находится в BIOS. Приложения Windows не могут воспользоваться этим прерыванием, но в их распоряжении находится куда более мощный механизм сообщений.

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

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

Для распределения сообщений от клавиатуры используется концепция так называемого фокуса ввода (input focus). Фокус ввода - это атрибут, который может присваиваться окну, созданному приложением или Windows. Если окно имеет фокус ввода, соответствующая функция окна получает все клавиатурные сообщения из системной очереди.

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

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

Программный интерфейс Windows содержит две функции, позволяющие узнать или изменить окно, владеющее фокусом ввода. Эти функции имеют соответственно имена GetFocus и SetFocus.

Сообщения, генерируемые драйвером клавиатуры, являются сообщениями низкого уровня. Они несут в себе такую информацию, как, например, скан-код нажатой клавиши. Приложения не пользуются такими сообщениями. Операционная система Windows выполняет преобразование клавиатурных сообщений низкого уровня в сообщения, которые содержат коды виртуальных клавиш (virtual-key code).

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

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

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

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

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

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

Некоторые приложения могут даже полностью игнорировать присутствие клавиатуры. Так, например, поступали все наши предыдущие примеры приложений.

5.1. Клавиатурные сообщения

От клавиатуры может поступать четыре сообщения - WM_KEYDOWN, WM_KEYUP, WM_SYSKEYDOWN, WM_SYSKEYUP. Когда вы нажимаете клавишу, генерируется сообщение WM_KEYDOWN или WM_SYSKEYDOWN, в зависимости от того, какая была нажата клавиша и была ли эта клавиша нажата в комбинации с клавишей <Alt>. При отпускании клавиши генерируется сообщение WM_KEYUP или WM_SYSKEYUP.

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

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

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

5.2. Параметры клавиатурных сообщений

Сообщения WM_KEYDOWN, WM_KEYUP, WM_SYSKEYDOWN, WM_SYSKEYUP передают информацию о нажатой клавише через параметры lParam и wParam.

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

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

Приведем описание отдельных бит парамера lParam.

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

Для сообщений WM_KEYDOWN и WM_KEYUP значение кода контекста (бит 29) и флага изменения состояния (бит 31) всегда равно 0.

Для сообщений WM_SYSKEYUP и WM_SYSKEYDOWN бит 31 равен 1. Но есть два исключения.

Во-первых, если активное окно свернуто в пиктограмму, все сообщения от клавиатуры преобразовываются в системные и, если клавиша <Alt> не нажата, код контекста равен 0.

Во-вторых, на некоторых клавиатурах для ввода символов национального языка могут использоваться комбинации с участием клавиш <Alt>, <Control>, <Shift> и т. п. В этом случае код контекста может быть равен 1, хотя сообщение не является системным.

Обработчик клавиатурного сообщения должен возвратить значение 0 для всех перехваченных сообщений.

Теперь мы расскажем вам о параметре wParam.

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

Многие коды виртуальных клавиш имеют символьное обозначение, определенное в файле windows.h. Приведем полный список кодов виртуальных клавиш. Те из них, которые определены в файле windows.h, имеют префикс VK_ (от слов Virtual Key).

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

Для определения состояния клавиш <Shift>, <Caps Lock>, <Control>, <Num Lock> сразу после получения сообщения функция окна должна вызвать функцию с именем GetKeyState, которая входит в программный интерфейс Windows. Приведем прототип этой функции:

int WINAPI GetKeyState(int vkey);

Параметр функции vkey должен указывать код виртуальной клавиши, для которой необходимо вернуть состояние.

Старший бит возвращаемого значения, установленный в 1, говорит о том, что указанная клавиша была нажата. Если этот бит равен 0, клавиша не была нажата.

Младший бит возвращаемого значения указывает состояние переключения. Если он равен 1, клавиша (такая, как <Caps Lock> или <Num Lock>) находится во включенном состоянии, то есть она была нажата нечетное число раз после включения компьютера. Учтите, что при помощи программы установки параметров компьютера SETUP, расположенной в BIOS, вы можете задать произвольное состояние переключающих клавиш после запуска системы.

Функция GetKeyState возвращает состояние клавиши на момент извлечения сообщения из очереди приложения функцией GetMessage.

Для того чтобы узнать состояние клавиш в любой произвольный момент времени, можно воспользоваться функцией GetAsyncKeyState:
int WINAPI GetAsyncKeyState (int vkey);

Параметр функции vkey должен указывать код виртуальной клавиши, для которой необходимо вернуть состояние.

Старший бит возвращаемого значения, установленный в 1, говорит о том, что указанная клавиша была нажата в момент вызова функции. Если этот бит равен 0, клавиша не была нажата.

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

Если для функции в качестве параметра задать значения VK_LBUTTON или VK_RBUTTON, можно узнать состояние клавиш, расположенных на корпусе мыши.

Есть возможность определить и изменить состояние для всех клавиш одновременно.

Для определения состояния клавиш воспользуйтесь функцией GetKeyboardState:

void WINAPI GetKeyboardState (BYTE FAR* lpbKeyState);

Единственный параметр lpbKeyState этой функции - дальний указатель на массив из 256 байт. После вызова функции этот массив будет заполнен информацией о состоянии всех виртуальных клавиш в момент генерации клавиатурного сообщения. В этом смысле функция аналогична функции GetKeyState.

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

После вызова функции GetKeyboardState вы можете изменить содержимое массива и вызвать функцию SetKeyboardState, изменяющую состояние клавиатуры:

void WINAPI SetKeyboardState(BYTE FAR* lpbKeyState);

Функция GetKeyboardType позволит вам определить тип клавиатуры и количество имеющихся на ней функциональных клавиш:

int WINAPI GetKeyboardType(int fnKeybInfo);

В зависимости от значения параметра fnKeybInfo функция может возвращать различную информацию о клавиатуре.

Если задать значение параметра fnKeybInfo, равное 0, функция вернет код типа клавиатуры:

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

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

Интересна также функция GetKeyNameText, возвращающая для заданного кода виртуальной клавиши название соответствующей клавиши в виде текстовой строки. Названия виртуальных клавиш определены в драйвере клавиатуры.

Приведем прототип функции GetKeyNameText:

int WINAPI GetKeyNameText(LONG lParam, 
   LPSTR lpszBuffer, int cbMaxKey);

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

Второй параметр - lpszBuffer является указателем на буфер, в который будет записано название клавиши.

Третий параметр - cbMaxKey должен быть равен длине буфера, уменьшенной на 1.

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

Листинг 5.1. Файл kbtype\kbtype.cpp

// ----------------------------------------
// Определение типа клавиатуры
// ----------------------------------------

#define STRICT
#include <windows.h>

#pragma argsused
int PASCAL
WinMain(HINSTANCE hInstance,
        HINSTANCE hPrevInstance,
        LPSTR     lpszCmdLine,
        int       nCmdShow)
{
  // Рабочий буфер
  char szBuf[80];

  // Рабочие переменные
  int type, subtype, nfkeys, size;

  // Типы клавиатур
  char *apszKbTypes[] =
  {
    "IBM PX/XT",
    "Olivetti ICO",
    "IBM AT",
    "IBM Enhanced",
    "Nokia 1050",
    "Nokia 9140",
    "Японская",
  };

  // Определяем тип клавиатуры
  type = GetKeyboardType(0);

  // Он должен лежать в интервале от
  // 1 до 7. Если это не так, завершаем
  // работу приложения с сообщением об ошибке
  if (type == 0 || type > 7)
  {
    MessageBox(NULL, "Ошибка в типе клавиатуры",
      "KBTYPE Application", MB_ICONSTOP);
    return 0;
  }

  // Определяем подтип клавиатуры
  subtype = GetKeyboardType(1);

  // Определяем количество функциональных
  // клавиш
  nfkeys  = GetKeyboardType(2);

  // Подготавливаем буфер и выводим его
  size = wsprintf(szBuf,
    "Клавиатура %s,\nподтип %d,\n",
    (LPSTR)apszKbTypes[type-1], subtype);

  wsprintf(szBuf + size,
    " %d функциональных клавиш",
    nfkeys);

  MessageBox(NULL, szBuf,
    "KBTYPE Application", MB_OK | MB_ICONINFORMATION);
  return 0;
}

Приложение использует файл определения модуля, приведенный в листинге 5.2.

Листинг 5.2. Файл kbtype\kbtype.def

; =============================
; Файл определения модуля
; =============================
NAME        KBTYPE
DESCRIPTION 'Приложение KBTYPE, (C) 1994, Frolov A.V.'
EXETYPE     windows
STUB        'winstub.exe'
STACKSIZE   5120
HEAPSIZE    1024
CODE        preload moveable discardable
DATA        preload moveable multiple

Работа приложения KBTYPE понятна без дополнительных комментариев. Единственное, на чем нам хотелось бы остановиться, так это на использовании для подготовки текстового буфера функции wsprintf.

Функция wsprintf входит в ядро Windows и используется аналогично функции sprintf. Эта функция определена в файле windows.h следующим образом:

int FAR CDECL wsprintf(LPSTR lpszOut, LPCSTR lpszFmt, ...);

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

Второй параметр - указатель на строку формата, определяющую формат строки, которая будет записана в буфер. Допустимо использовать следующие спецификаторы форматов вывода:

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

Для вывода текстовых строк необходимо использовать явное преобразование типа, как это сделано в нашем примере:

size = wsprintf(szBuf,
  "Клавиатура %s,\nподтип %d,\n",
  (LPSTR)apszKbTypes[type-1], subtype);

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

На рис. 5.1 представлено сообщение, которое было выведено при запуске приложения KBTYPE на компьютере одного из авторов этой книги.

Рис. 5.1. Сообщение приложения KBTYPE

Прежде чем перейти к следующему разделу, приведем исходные тексты еще одного приложения, демонстрирующего использование функций GetKeyboardState и SetKeyboardState для изменения состояния клавиш <Num Lock>, <Caps Lock>, <Scroll Lock>. Это приложение называется KBLED. Исходный текст основного файла приложения приведен в листинге 5.3.

Листинг 5.3. Файл kbled\kbled.cpp

// ----------------------------------------
// Переключение состояния виртуальных
// клавиш
// ----------------------------------------

#define STRICT
#include <windows.h>

#pragma argsused
int PASCAL
WinMain(HINSTANCE hInstance,
        HINSTANCE hPrevInstance,
        LPSTR     lpszCmdLine,
        int       nCmdShow)
{
  // Буфер для записи состояния клавиш
  BYTE aKBState[256];

  // Определяем состояние клавиш
  GetKeyboardState(aKBState);

  MessageBox(NULL, "Нажмите 'OK' для"
    " переключения клавиш <NumLock>, "
    "<ScrollLock>, <CapsLock>",
    "KBLED Application", MB_OK | MB_ICONINFORMATION);

  // Инвертируем текущее состояние клавиш
  // <NumLock>, <ScrollLock>, <CapsLock>
  aKBState[VK_NUMLOCK] ^= 1;
  aKBState[VK_SCROLL]  ^= 1;
  aKBState[VK_CAPITAL] ^= 1;

  // Устанавливаем новое состояние клавиш
  SetKeyboardState(aKBState);

  MessageBox(NULL, "Нажмите 'OK' для обратного"
    " переключения",
    "KBLED Application", MB_OK | MB_ICONINFORMATION);

  // Возвращаем исходное состояние клавиш
  // <NumLock>, <ScrollLock>, <CapsLock>
  aKBState[VK_NUMLOCK] ^= 1;
  aKBState[VK_SCROLL]  ^= 1;
  aKBState[VK_CAPITAL] ^= 1;

  // Устанавливаем новое состояние клавиш
  SetKeyboardState(aKBState);

  return 0;
}

Это простое приложение выводит на экран сообщение, в котором говорится, что для переключения состояния виртуальных клавиш надо нажать кнопку "OK". Когда вы нажмете эту кнопку, состояние трех виртуальных клавиш изменится на противоположное. Это нетрудно проконтролировать при помощи светодиодов, расположенных на клавиатуре: все они должны изменить свое состояние на противоположное.

Когда вы ответите на второе сообщение, приложение возвратит исходное состояние клавиш (и светодиодов).

Файл определения модуля для приложения KBLED приведен в листинге 5.4.

Листинг 5.4. Файл kbled\kbled.def

; =============================
; Файл определения модуля
; =============================
NAME        KBLED
DESCRIPTION 'Приложение KBLED, (C) 1994, Frolov A.V.'
EXETYPE     windows
STUB        'winstub.exe'
STACKSIZE   5120
HEAPSIZE    1024
CODE        preload moveable discardable
DATA        preload moveable multiple

5.3. Символьные клавиатурные сообщения

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

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

while(GetMessage(&msg, 0, 0, 0))
{
  TranslateMessageTranslateMessage(&msg);
  DispatchMessage(&msg);
}

Функция TranslateMessage преобразует клавиатурные сообщения WM_KEYDOWN, WM_KEYUP, WM_SYSKEYDOWN и WM_SYSKEYUP в символьные сообщения WM_CHAR, WM_DEADCHAR, WM_SYSCHAR, WM_SYSDEADCHAR. Образованные символьные сообщения помещаются в очередь сообщений приложения, причем оригинальные клавиатурные сообщения из этой очереди не удаляются.

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

Параметр wParam содержит код символа, соответствующего нажатой клавише в так называемом стандарте ANSI, принятом в Windows для представления символов. Этот код определяется функцией TranslateMessage с учетом состояния клавиш <Control>, <Shift>, <Alt>, <Caps Lock> и используемого национального языка.

Из всех четырех символьных сообщений приложения чаще всего используют сообщение WM_CHAR, которое передается функции окна в результате трансляции сообщения WM_KEYDOWN. Сообщение WM_SYSCHAR образуется из сообщения WM_SYSKEYDOWN и обычно игнорируется приложением (передается функции DefWindowProc).

Сообщения WM_DEADCHAR и WM_SYSDEADCHAR образуются при использовании клавиатур, имеющих дополнительную клавишу для снабжения символов диакритическими знаками (например, символ "Ў" снабжен диакритическим знаком). Такие дополнительные клавиши называются "мертвыми" клавишами, так как они не образуют символов, а лишь изменяют действие следующей нажимаемой клавиши. Эти клавиши определяются на основе информации об используемом национальном алфавите.

Если после "мертвой" клавиши была нажата правильная, обычная клавиша (не все символы могут иметь диакритические знаки), в очередь приложения помещаются два сообщения - WM_DEADCHAR и WM_CHAR. Последнее в параметре wParam передает ANSI-код введенного символа, имеющего диакритический знак.

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

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

5.4. Стандарты кодов символов

В операционной системе MS-DOS использовался расширенный набор символов, определенный фирмой IBM (IBM extended character set). В этот набор входят буквы английского алфавита, знаки пунктуации и псевдографики (рис. 5.2).

Рис. 5.2. Расширенный набор символов IBM

Для обеспечения возможности работы с символами кириллицы фирма Microsoft разработала набор символов, соответствующий 866-й кодовой странице (рис. 5.3). Этот набор символов был использован сначала в локализованной MS-DOS версии 4.01, а затем в локализованных версиях 5.0 и 6.0 этой операционной системы.

Рис. 5.3. Расширенный набор символов с кириллицей

В терминологии Windows приведенные выше наборы символов называются наборами символов OEM. OEM (Original Equipment Manufacturer) означает "производители оригинальной (в смысле подлинной) аппаратуры". Набор символов OEM соответствует естественному для данной аппаратуры набору. Он может меняться в зависимости от производителя, от страны, для которой выполнялась локализация операционной системы MS-DOS или изготавливалась аппаратура.

Операционная система Windows для представления символов использует набор символов ANSI (рис. 5.4).

Рис. 5.4. Набор символов ANSI

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

На рис. 5.5 изображен набор символов ANSI с добавлением кириллицы. Такой набор устанавливается в локализованной версии Windows или после локализации Windows с помощью специального программного продукта CyrWin, добавляющего в Windows возможность работы с русскими символами.

Рис. 5.5. Набор символов ANSI с символами кириллицы

Если программа MS-DOS запускается в окне Windows, для нее выбирается набор символов OEM. Поэтому в Windows используются как набор символов ANSI, так и набор символов OEM. Соответствующим выбором шрифта вы можете добиться отображения текста в окне Windows с использованием как набора ANSI, так и набора OEM. По умолчанию в контекст отображения выбирается системный шрифт, для которого используется набор ANSI.

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

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

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

Для перекодировки строки символов, закрытой двоичным нулем, из набора ANSI в набор OEM предназначена функция AnsiToOem:

void WINAPI AnsiToOem(const char _huge* hpszWindowsStr,
    char _huge* hpszOemStr);

Первый параметр (hpszWindowsStr) представляет собой указатель типа _huge на преобразуемую строку, второй (hpszOemStr) - на буфер для записи результата преобразования.

Похожая по назначению функция AnsiToOemBuff выполняет преобразование буфера заданного размера:

void WINAPI AnsiToOemBuff(LPCSTR lpszWindowsStr,
   LPSTR lpszOemStr, UINT cbWindowsStr);

Первый параметр этой функции (lpszWindowsStr) является дальним указателем на буфер, содержащий преобразуемые данные, второй (lpszOemStr) - на буфер для записи результата. Третий параметр (cbWindowsStr) определяет размер входного буфера, причем нулевой размер соответствует буферу длиной 64 Кбайт (65536 байт).

Обратное преобразование выполняется функциями OemToAnsi и OemToAnsiBuff:

void WINAPI OemToAnsi(const char _huge* hpszOemStr, 
   char _huge* lpszWindowsStr);
void WINAPI OemToAnsiBuff(LPCSTR lpszOemStr, 
   LPSTR lpszWindowsStr, UINT cbOemStr);

Назначение параметров этих функций аналогично назначению параметров функций AnsiToOem и AnsiToOemBuff.

Для преобразований символов в строчные или прописные приложение Windows должно пользоваться функциями AnsiLower, AnsiLowerBuff, AnsiUpper, AnsiUpperBuff.

Функция AnsiLower преобразует закрытую двоичным нулем текстовую строку в строчные буквы:

LPSTR WINAPI AnsiLower(LPSTR);

Единственный параметр функции - дальний указатель на преобразуемую строку.

Функция AnsiUpper преобразует закрытую двоичным нулем текстовую строку в прописные буквы:

LPSTR WINAPI AnsiLower(LPSTR lpsz);

Параметр функции lpsz - дальний указатель на преобразуемую строку.

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

Функция AnsiLowerBuff позволяет преобразовать в строчные буквы заданное количество символов:

UINT WINAPI AnsiLowerBuff(LPSTR lpszString, UINT cbString);

Первый параметр функции (lpszString) является указателем на буфер, содержащий преобразуемые символы, второй (cbString) определяет количество преобразуемых символов (размер буфера). Нулевой размер соответствует буферу длиной 64 Кбайт (65536 байт).

Функция возвращает количество преобразованных символов.

Функция AnsiUpperBuff позволяет преобразовать в прописные буквы заданное количество символов:

UINT WINAPI AnsiUpperBuff(LPSTR lpszString, UINT cbString);

Первый параметр функции lpszString(lpszString) является указателем на буфер, содержащий преобразуемые символы, второй (cbString) определяет количество преобразуемых символов (размер буфера). Нулевой размер соответствует буферу длиной 64 Кбайт (65536 байт).

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

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

Функция возвращает новое значение для указателя, передвинутое вперед по строке на одни символ:

LPSTR WINAPI AnsiNext(LPCSTR lpchCurrentChar);

Параметр функции указывает на текущий символ. Возвращаемое значение является указателем на следующий символ в строке или на закрывающий строку двоичный ноль.

Функция AnsiPrev выполняет передвижение указателя в направлении к началу строки:

LPSTR WINAPI AnsiPrev(LPCSTR lpchStart, 
   LPCSTR lpchCurrentChar);

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

В составе программного интерфейса Windows имеются функции для преобразования символа ANSI в код виртуальной клавиши (VkKeyScan) или в соответствующий OEM скан-код и состояние (OemKeyScan).

Функция VkKeyScan используется для преобразования кода символа ANSI в код и состояние виртуальной клавиши:

UINT WINAPI VkKeyScan(UINT uChar);

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

Младший байт возвращаемого значения содержит код виртуальной клавиши, старший - состояние клавиш сдвига (<Shift>, <Alt>, <Control>):

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

Функция OemKeyScan преобразует символ OEM в скан-код и состояние для набора OEM:

DWORD WINAPI OemKeyScan(UINT uOemChar);

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

Младшее слово возвращаемого значения содержит OEM скан-код для указанного символа.

Старшее слово указывает состояние клавиш сдвига для заданного символа. Если в этом слове установлен бит 1, нажата клавиша <Shift>, если бит 2 - клавиша <Control>.

Если преобразуемое значение не принадлежит к набору OEM, возвращается значение -1 (и в старшем, и в младшем слове).

5.5. Приложение OEM2ANSI

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

Исходный текст основного файла приложения OEM2ANSI представлен в листинге 5.5.

Листинг 5.5. Файл oem2ansi\oem2ansi.cpp

// ----------------------------------------
// Перекодировка текстового файла
// из OEM в ANSI
// ----------------------------------------

#define STRICT
#include <windows.h>
#include <commdlg.h>
#include <mem.h>

// Прототипы функций
HFILE GetSrcFile(void);
HFILE GetDstFile(void);
void  Oem2Ansi(HFILE, HFILE);

// -------------------------------
// Функция WinMain
// -------------------------------

#pragma argsused
int PASCAL
WinMain(HINSTANCE hInstance,
        HINSTANCE hPrevInstance,
        LPSTR     lpszCmdLine,
        int       nCmdShow)
{
  // Переменные для хранения
  // идентификаторов входного и выходного
  // файлов
  HFILE hfSrc, hfDst;

  // Открываем входной файл.
  // В случае ошибки или отказа от выбора
  // файла завершаем работу приложения
  hfSrc = GetSrcFile();
  if(!hfSrc) return 0;

  // Открываем выходной файл
  hfDst = GetDstFile();
  if(!hfDst) return 0;

  // Выполняем перекодировку файла
  Oem2Ansi(hfSrc, hfDst);

  // Закрываем входной и выходной файлы
  _lclose(hfSrc);
  _lclose(hfDst);

  return 0;
}

// -------------------------------
// Функция GetSrcFile
// Выбор файла для перекодировки
// -------------------------------

HFILE GetSrcFile(void)
{
  // Структура для выбора файла
  OPENFILENAME ofn;

  // Буфер для записи пути к выбранному файлу
  char szFile[256];

  // Буфер для записи имени выбранного файла
  char szFileTitle[256];

  // Фильтр расширений имени файлов
  char szFilter[256] =
         "Text Files\0*.txt;*.doc\0Any Files\0*.*\0";

  // Идентификатор открываемого файла
  HFILE hf;

  // Инициализация имени выбираемого файла
  // не нужна, поэтому создаем пустую строку
  szFile[0] = '\0';

  // Записываем нулевые значения во все поля
  // структуры, которая будет использована для
  // выбора файла
  memset(&ofn, 0, sizeof(OPENFILENAME));

  // Инициализируем нужные нам поля

  // Размер структуры
  ofn.lStructSize       = sizeof(OPENFILENAME);

  // Идентификатор окна
  ofn.hwndOwner         = NULL;

  // Адрес строки фильтра
  ofn.lpstrFilter       = szFilter;

  // Номер позиции выбора
  ofn.nFilterIndex      = 1;

  // Адрес буфера для записи пути
  // выбранного файла
  ofn.lpstrFile         = szFile;

  // Размер буфера для записи пути
  // выбранного файла
  ofn.nMaxFile          = sizeof(szFile);

  // Адрес буфера для записи имени
  // выбранного файла
  ofn.lpstrFileTitle    = szFileTitle;

  // Размер буфера для записи имени
  // выбранного файла
  ofn.nMaxFileTitle     = sizeof(szFileTitle);

  // В качестве начального каталога для
  // поиска выбираем текущий каталог
  ofn.lpstrInitialDir   = NULL;

  // Определяем режимы выбора файла
  ofn.Flags =   OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST
                                  | OFN_HIDEREADONLY;

  // Выбираем входной файл
  if (GetOpenFileName(&ofn)) {

    // Открываем выбранный файл
    hf = _lopen(ofn.lpstrFile, OF_READ);

    // Возвращаем идентификатор файла
    return hf;
  }
  // При отказе от выбора возвращаем
  // нулевое значение
  else return 0;
}

// -------------------------------
// Функция GetDstFile
// Выбор файла для записи
// результата перекодировки
// -------------------------------

HFILE GetDstFile(void)
{
  OPENFILENAME ofn;

  char szFile[256];
  char szFileTitle[256];
  char szFilter[256] =
         "Text Files\0*.txt;*.doc\0Any Files\0*.*\0";

  HFILE hf;

  szFile[0] = '\0';

  memset(&ofn, 0, sizeof(OPENFILENAME));

  ofn.lStructSize       = sizeof(OPENFILENAME);
  ofn.hwndOwner         = NULL;
  ofn.lpstrFilter       = szFilter;
  ofn.nFilterIndex      = 1;
  ofn.lpstrFile         = szFile;
  ofn.nMaxFile          = sizeof(szFile);
  ofn.lpstrFileTitle    = szFileTitle;
  ofn.nMaxFileTitle     = sizeof(szFileTitle);
  ofn.lpstrInitialDir   = NULL;
  ofn.Flags             = OFN_HIDEREADONLY;

  // Выбираем выходной файл
  if (GetSaveFileName(&ofn)) {

    // При необходимости создаем файл
    hf = _lcreat(ofn.lpstrFile, 0);
    return hf;
  }
  else return 0;
}

// -------------------------------
// Функция Oem2Ansi
// Перекодировка файла
// -------------------------------

void Oem2Ansi(HFILE hfSrcFile, HFILE hfDstFile)
{
  // Счетчик прочитанных байт
  int cbRead;

  // Буфер для считанных данных
  BYTE bBuf[2048];

  // Читаем в цикле файл и перекодируем его,
  // записывая результат в другой файл
  do {
    // Читаем в буфер 2048 байт из входного файла
    cbRead = _lread(hfSrcFile, bBuf, 2048);

    // Перекодируем содержимое буфера
    OemToAnsiBuff(bBuf, bBuf, cbRead);

    // Сохраняем содержимое буфера в
    // выходном файле
    _lwrite(hfDstFile, bBuf, cbRead);

  // Завершаем цикл по концу входного файла
  } while (cbRead != 0);
}

Дополнительно к стандартному для всех приложений Windows файлу windows.h в главный файл приложения включен файл commdlg.h, который содержит определения для функций стандартных диалогов Windows версии 3.1. Загрузочные модули этих функций расположены в отдельной библиотеке динамической загрузки (DLL) с именем commdlg.dll.

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

В функции WinMain определены переменные для хранения идентификаторов файлов (file handle), вовлеченных в процесс перекодировки:

HFILE hfSrc, hfDst;

Тип HFILE определен в файле windows.h следующим образом:

typedef int HFILE; 

Работа функции WinMain начинается с вызова функции GetSrcFile, определенной в нашем приложении. Эта функция используется для поиска и открытия файла. Функция GetSrcFile возвращает идентификатор файла, подлежащего перекодировке, или ноль, если вы отказались от выбора файла. Полученный идентификатор можно использовать для выполнения операций файлового ввода/вывода.

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

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

В заключение функция WinMain закрывает оба файла, вызывая функцию _lclose из программного интерфейса Windows.

Функция GetSrcFile вызывает функцию GetOpenFileName, которая выводит на экран знакомую вам по стандартным приложениям Windows диалоговую панель "Open", позволяющую выбрать файл для перекодировки (рис. 5.6).

Рис. 5.6. Диалоговая панель "Open"

Внешний вид этой диалоговой панели определяется структурой типа OPENFILENAME, определенной в файле commdlg.h (этот файл находится в каталоге include системы разработки Borland C++ или Microsoft Visual C++):

typedef struct tagOFN
{
    DWORD   lStructSize;
    HWND    hwndOwner;
    HINSTANCE hInstance;
    LPCSTR  lpstrFilter;
    LPSTR   lpstrCustomFilter;
    DWORD   nMaxCustFilter;
    DWORD   nFilterIndex;
    LPSTR   lpstrFile;
    DWORD   nMaxFile;
    LPSTR   lpstrFileTitle;
    DWORD   nMaxFileTitle;
    LPCSTR  lpstrInitialDir;
    LPCSTR  lpstrTitle;
    DWORD   Flags;
    UINT    nFileOffset;
    UINT    nFileExtension;
    LPCSTR  lpstrDefExt;
    LPARAM  lCustData;
    UINT    (CALLBACK *lpfnHook)(HWND, UINT, WPARAM, LPARAM);
    LPCSTR  lpTemplateName;
}   OPENFILENAME;

Адрес структуры передается функции GetOpenFileName в качестве параметра lpfn:

BOOL WINAPI GetOpenFileName(OPENFILENAME FAR* lpofn);

Функция возвращает ненулевое значение, если вы сделали выбор файла, и ноль, если вы отказались от выбора, нажав кнопку "Cancel" или выбрав строку "Close" из системного меню диалоговой панели. Нулевое значение возвращается также при возникновении ошибки.

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

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

Прежде всего перед вызовом функции GetOpenFileName наше приложение записывает во все поля структуры нулевые значения:

memset(&ofn, 0, sizeof(OPENFILENAME));

Затем в поле lStructSize записывается размер самой структуры в байтах:

ofn.lStructSize       = sizeof(OPENFILENAME);

Поле hwndOwner должно содержать идентификатор окна, создавшего диалоговую панель. Так как наше приложение не создает ни одного окна, в качестве идентификатора используется значение NULL, при этом диалоговая панель не имеет окна-владельца (похожим образом мы поступали при вызове функции MessageBox):

ofn.hwndOwner         = NULL;

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

ofn.lpstrFilter       = szFilter;

Наше приложение использует в качестве фильтра такую строку:

char szFilter[256] =
  "Text Files\0*.txt;*.doc\0Any Files\0*.*\0";

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

Первая строка в паре строк описывает название фильтра, например "Text Files" (текстовые файлы), во второй строке пары через символ ";" перечисляются возможные шаблоны для имен файлов.

В нашем приложении определены две пары строк. Одна из них предназначена для выбора только текстовых файлов с расширениями имени *.txt и *.doc, вторая - для выбора любых файлов (с любым расширением имени).

Поле nFilterIndex определяет номер пары строк, используемой для фильтра. В нашем случае этот номер задается как 1, поэтому из двух фильтров выбирается первый, предназначенный для поиска текстовых файлов:

ofn.nFilterIndex      = 1;

Поле lpstrFile должно содержать адрес текстовой строки, в которую будет записан полный путь к выбранному файлу:

ofn.lpstrFile         = szFile;

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

szFile[0] = '\0';

Поле nMaxFile должно содержать размер буфера, расположенного по адресу, указанному в поле lpstrFile:

ofn.nMaxFile          = sizeof(szFile);

Размер этого буфера должен быть достаточным для записи полного пути к файлу. Файловая система MS-DOS допускает использование для указания пути к файлу не более 128 символов.

В поле lpstrFileTitle необходимо записать адрес буфера, в который после выбора будет записано имя файла с расширением, но без пути к файлу:

ofn.lpstrFileTitle    = szFileTitle;

Это поле должно быть использовано приложением для отображения имени выбранного файла.

Поле nMaxFileTitle должно содержать размер указанного выше буфера:

ofn.nMaxFileTitle     = sizeof(szFileTitle);

Поле lpstrInitialDir позволяет указать начальный каталог, который будет выбран для поиска файла сразу после отображения диалоговой панели "Open". Наше приложение начинает поиск в текущем каталоге, поэтому в это поле мы записали значение NULL:

ofn.lpstrInitialDir   = NULL;

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

ofn.Flags =   OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST
              | OFN_HIDEREADONLY;

Флаг OFN_PATHMUSTEXIST указывает, что можно выбирать только такие пути, которые соответствуют существующим каталогам. Аналогично флаг OFN_FILEMUSTEXIST определяет, что при выборе можно указывать только существующие файлы. Флаг OFN_HIDEREADONLY убирает из диалоговой панели переключатель, позволяющий открыть файл в режиме "только чтение" (мы не пользуемся этим режимом, так как не собираемся изменять открываемый файл).

После подготовки структуры мы вызываем функцию GetOpenFileName и проверяем возвращаемое ей значение:

  if (GetOpenFileName(&ofn)) {
    hf = _lopen(ofn.lpstrFile, OF_READ);
         return hf;
  }
  else return 0;

Если возвращаемое функцией GetOpenFileName значение отлично от нуля, поле lpstrFile содержит путь к выбранному файлу. Этот путь приложение передает функции _lopen, открывающей файл на чтение. Затем функция GetSrcFile возвращает идентификатор открытого файла (точнее, результат, полученный при попытке открыть файл).

При ошибке или отказе от выбора файла функция GetSrcFile возвращает нулевое значение.

Для выбора файла, в который будет записан результат перекодировки, функция WinMain вызывает функцию GetDstFile. Эта функция вызывает функцию GetSaveFileName, которая выводит стандартную диалоговую панель "Save As..." (рис. 5.7).

Рис. 5.7. Диалоговая панель "Save As..."

Диалоговая панель "Save As..." используется многими стандартными приложениями Windows для выбора файла, в который будет записан результат работы приложения.

Функция GetSaveFileName описана в файле commdlg.h:

BOOL WINAPI GetSaveFileName(OPENFILENAME FAR* lpofn);

Она используется аналогично функции GetOpenFileName.

Вначале приложение подготавливает структуру OPENFILENAME:

  szFile[0] = '\0';
  memset(&ofn, 0, sizeof(OPENFILENAME));
  ofn.lStructSize       = sizeof(OPENFILENAME);
  ofn.hwndOwner         = NULL;
  ofn.lpstrFilter       = szFilter;
  ofn.nFilterIndex      = 1;
  ofn.lpstrFile         = szFile;
  ofn.nMaxFile          = sizeof(szFile);
  ofn.lpstrFileTitle    = szFileTitle;
  ofn.nMaxFileTitle     = sizeof(szFileTitle);
  ofn.lpstrInitialDir   = NULL;
  ofn.Flags             = OFN_HIDEREADONLY;

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

Затем приложение вызывает функцию GetSaveFileName и проверяет возвращаемое ей значение:

  if ((&ofn)) {
        hf = _lcreat(ofn.lpstrFile, 0);
         return hf;
  }
  else return 0;

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

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

Для перекодирования файла функция WinMain вызывает функцию Oem2Ansi. Эта функция считывает в цикле содержимое входного файла в буфер, перекодирует буфер и затем записывает его в выходной файл:

do {
  cbRead = _lread(hfSrcFile, bBuf, 2048);
  OemToAnsiBuff(bBuf, bBuf, cbRead);
  _lwrite(hfDstFile, bBuf, cbRead);
} while (cbRead != 0);

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

Запись буфера в файл выполняется функцией _lwrite, которая также входит в состав программного интерфейса Windows. Параметры этой функции аналогичны параметрам функции _lread.

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

Для перекодировки буфера используется знакомая вам функция OemToAnsiBuff. И первый, и второй параметры этой функции указывают на один и тот же буфер, поэтому перекодировка будет выполняться "по месту".

Вы можете добавить до или после функции OemToAnsiBuff свою собственную функцию перекодировки, выполняющую какие-либо дополнительные перекодирующие действия.

На рис. 5.8 представлен результат перекодировки приложением OEM2ANSI текстового файла, подготовленного в MS-DOS и содержащего символы кириллицы.

Рис. 5.8. Исходный и преобразованный файлы

В верхней части рис. 5.8 изображено окно редактирования системы разработки Borland C++ for Windows, в которое загружен текст в кодировке OEM. Этот текст содержит символы кириллицы, которые в кодировке ANSI отображаются в виде различных "нечитаемых" символов. В нижней части рис. 5.8 расположено окно, в которое загружен перекодированный текст.

Если при использовании нашего приложения OEM2ANSI вы получили результаты, отличные от представленного на рис. 5.8, вам следует убедиться в том, что на вашем компьютере была выполнена локализация операционной системы Windows и что она была выполнена правильно. Для локализации Windows можно использовать такие программные средства, как CyrWin или ParaWin. Вы можете также приобрести локализованную версию Windows 3.1, которая поставляется в России фирмой Microsoft A.O.

На базе приложения OEM2ANSI вы без труда сможете создать приложение с названием, например, ANSI2OEM, выполняющее обратную перекодировку. Мы предлагаем вам создать такое приложение самостоятельно.

Файл определения модуля для приложения OEM2ANSI представлен в листинге 5.6.

Листинг 5.6. Файл oem2ansi\oem2ansi.def

; =============================
; Файл определения модуля
; =============================
NAME        OEM2ANSI
DESCRIPTION 'Приложение OEM2ANSI, (C) 1994, Frolov A.V.'
EXETYPE     windows
STUB        'winstub.exe'
STACKSIZE   5120
HEAPSIZE    1024
CODE        preload moveable discardable
DATA        preload moveable multiple

5.6. Текстовый курсор

При вводе текста в среде MS-DOS используется текстовый курсор, указывающий позицию ввода очередного символа. Текстовый курсор в MS-DOS формируется автоматически функциями BIOS или создается программой. В последнем случае программа должна сама следить за перемещением текстового курсора.

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

Заметим, что в операционной системе Windows используются два курсора. Один курсор называется cursor и означает курсор мыши. Второй курсор называется caret (знак вставки) и означает текстовый курсор.

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

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

Когда окно теряет фокус ввода, оно должно уничтожить текстовый курсор. При потере фокуса ввода функции окна передается сообщение WM_KILLFOCUS, обработчик которого и должен удалить текстовый курсор, созданный при обработке сообщения WM_SETFOCUS.

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

void WINAPI CreateCaret(HWND hwnd, HBITMAP hbmp, 
  int nWidth, int nHeight);

Первый параметр функции (hwnd) - идентификатор окна, создающего текстовый курсор.

Второй параметр (hbmp) может принимать значения NULL, 1 или он может быть идентификатором битового изображения курсора (bitmap). Если этот параметр равен NULL, текстовый курсор представляет собой вертикальную черту черного цвета. Если этот параметр равен 1, текстовый курсор изображается серым цветом. Вы также можете нарисовать курсор любой произвольной формы в виде битового образа (bitmap) и использовать этот свой курсор, загрузив его из ресурсов приложения и указав идентификатор. В этом случае третий и четвертый параметры функции игнорируются. О ресурсах и битовых образах вы узнаете позже, так как это тема для отдельного разговора.

Третий параметр (nWidth) определяет ширину курсора в логических единицах. Если задать для ширины значение NULL, курсор будет иметь ширину, равную ширине рамки, создаваемой вокруг окна. Это значение возвращается функцией GetSystemMetrics, когда ей в качестве параметра указывается константа SM_CXBORDER.

Последний, четвертый параметр (nHeight) функции CreateCaret определяет высоту текстового курсора в логических единицах. Для этого параметра также можно указать значение NULL, при этом высота текстового курсора будет равна высоте рамки окна. Это значение возвращается функцией GetSystemMetrics, когда ей в качестве параметра указывается константа SM_CYBORDER.

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

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

Когда функция окна получает сообщение WM_KILLFOCUS, она должна уничтожить текстовый курсор, вызвав функцию DestroyCaret:

void WINAPI DestroyCaret(void);

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

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

void WINAPI ShowCaret (HWND hwnd);

В качестве параметра этой функции передается идентификатор окна hwnd, создавшего текстовый курсор.

Перед тем как перерисовывать окно, приложение должно выключить (скрыть) текстовый курсор. Так как курсор постоянно мигает, если его не выключить во время перерисовки окна, изображение курсора может "размножаться" на экране. Функция BeginPaint самостоятельно скрывает курсор, но, если вы перерисовываете окно во время обработки других сообщений, курсор необходимо выключить (но не уничтожить!), вызвав функцию HideCaret:

void WINAPI HideCaret(HWND hwnd);

В качестве параметра этой функции передается идентификатор окна hwnd, создавшего текстовый курсор.

Функции ShowCaret и HideCaret обладают свойством накопления. Если вы несколько раз подряд вызвали функцию HideCaret, для того чтобы текстовый курсор вновь стал видимым, вам придется столько же раз вызвать функцию ShowCaret. Аналогично, если вы несколько раз вызвали функцию ShowCaret, для того чтобы скрыть текстовый курсор, вам придется столько же раз вызвать функцию HideCaret.

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

void WINAPI SetCaretPos(int x, int y);

Первый параметр этой функции определяет горизонтальную X-координату курсора, второй - вертикальную Y-координату курсора.

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

void WINAPI GetCaretPos(POINT FAR* lppt);

Единственный параметр этой функции lppt указывает на структуру типа POINT, в которую будет записана информация о расположении курсора. Тип POINT описан в файле windows.h:

typedef struct tagPOINT {
   int x;
   int y;
} POINT;

После возврата из функции GetCaretPos поля x и y структуры будут содержать соответственно X- и Y-координаты текстового курсора.

С помощью функций GetCaretBlinkTime и SetCaretBlinkTime приложение может соответственно узнать и изменить период мигания текстового курсора.

Функция GetCaretBlinkTime возвращает период мигания текстового курсора в миллисекундах:

UINT WINAPI GetCaretBlinkTime(void);

С помощью функции SetCaretBlinkTime вы можете установить новое значение периода мигания курсора, указав его в качестве параметра функции (также в миллисекундах):

void WINAPI SetCaretBlinkTime(UINT uMSeconds);

Управлять текстовым курсором непросто, особенно если учесть, что при редактировании текста могут быть использованы разные шрифты с переменной шириной букв (и даже с наклонными буквами). Но у вас едва ли появится необходимость создания собственного текстового редактора, аналогичного Microsoft Word for Windows (если, конечно, ваша основная работа не связана именно с созданием таких текстовых редакторов!).

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

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

5.7. Приложение KBMSG

Наше следующее приложение с названием KBMSG поможет вам "почувствовать" клавиатурные сообщения. Это приложение создает одно главное окно, функция которого обрабатывает все сообщения от клавиатуры. Для каждого сообщения в окно выводится символическое имя кода сообщения, параметры сообщения wParam и lParam, а также название виртуальной клавиши, определенное в драйвере клавиатуры.

В верхней части главного окна приложения расположены две строки заголовка отдельных полей параметров сообщения. В остальной части окна организован построчный вывод самих параметров сообщения со сверткой (рис. 5.9).

Рис. 5.9. Главное окно приложения KBMSG

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

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

Функция WinMain приложения KBMSG определена в файле kbmsg.cpp (листинг 5.7).

Листинг 5.7. Файл kbmsg\kbmsg.cpp

// ----------------------------------------
// Просмотр сообщений от клавиатуры
// ----------------------------------------

#define STRICT
#include <windows.h>
#include <mem.h>

BOOL InitApp(HINSTANCE);
LRESULT CALLBACK _export WndProc(HWND, UINT, WPARAM, LPARAM);

char const szClassName[]   = "KBMSGAppClass";
char const szWindowTitle[] = "KBMSG Application";

// =====================================
// Функция WinMain
// =====================================
#pragma argsused

int PASCAL
WinMain(HINSTANCE hInstance,
        HINSTANCE hPrevInstance,
        LPSTR     lpszCmdLine,
        int       nCmdShow)
{
  MSG  msg;   // структура для работы с сообщениями
  HWND hwnd;  // идентификатор главного окна приложения

  if(!InitApp(hInstance))
      return FALSE;

  hwnd = CreateWindow(
    szClassName, szWindowTitle, 
    WS_OVERLAPPEDWINDOW,
    CW_USEDEFAULT, CW_USEDEFAULT,
    CW_USEDEFAULT, CW_USEDEFAULT,
    0, 0, hInstance, NULL); 

  if(!hwnd)
    return FALSE;

  ShowWindow(hwnd, nCmdShow);
  UpdateWindow(hwnd);

  while(GetMessage(&msg, 0, 0, 0))
  {
    // Вызываем функцию, создающую
    // символьные сообщения
    TranslateMessage(&msg);

    DispatchMessage(&msg);
  }
  return msg.wParam;
}

// =====================================
// Функция InitApp
// =====================================

BOOL
InitApp(HINSTANCE hInstance)
{
  ATOM aWndClass; // атом для кода возврата
  WNDCLASS wc;    // структура для регистрации
                  // класса окна

  memset(&wc, 0, sizeof(wc));
  wc.style         = CS_HREDRAW | CS_VREDRAW;
  wc.lpfnWndProc   = (WNDPROC) WndProc;
  wc.cbClsExtra    = 0;
  wc.cbWndExtra    = 0;
  wc.hInstance     = hInstance;
  wc.hIcon   = LoadIcon(NULL, IDI_APPLICATION);
  wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
  wc.lpszMenuName  = (LPSTR)NULL;
  wc.lpszClassName = (LPSTR)szClassName;

  aWndClass = RegisterClass(&wc);
  return (aWndClass != 0);
}

Обратите внимание на цикл обработки сообщений, созданный в функции WinMain:

while(GetMessage(&msg, 0, 0, 0))
{
  TranslateMessage(&msg);
  DispatchMessage(&msg);
}

Перед обычной функцией DispatchMessage вызывается функция TranslateMessage, которая на основе сообщений WM_KEYDOWN, WM_KEYUP, WM_SYSKEYDOWN, WM_SYSKEYUP создает сообщения WM_CHAR, WM_SYSCHAR, WM_DEADCHAR и WM_SYSDEADCHAR.

При регистрации класса окна указывается стиль класса, который требует перерисовки окна при изменении его вертикального или горизонтального размера:

wc.style = CS_HREDRAW | CS_VREDRAW;

Других особенностей (по сравнению с нашими предыдущими приложениями) функция WinMain не имеет.

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

Листинг 5.8. Файл kbmsg\wndproc.cpp

// =====================================
// Функция WndProc
// =====================================

#define STRICT
#include <windows.h>
#include <stdio.h>
#include <string.h>

void PrintMsg(HWND, WPARAM, LPARAM, char *);

static int cxChar, cyChar;
RECT rect;

LRESULT CALLBACK _export
WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
  HDC hdc;              // индекс контекста устройства
  PAINTSTRUCT ps;       // структура для рисования
  static TEXTMETRIC tm; // структура для записи метрик
                        // шрифта

  switch (msg)
  {
    case WM_CREATE:
    {
      // Получаем контекст отображения,
      // необходимый для определения метрик шрифта
      hdc = GetDC(hwnd);

      // Выбираем шрифт с фиксированной шириной букв
      SelectObject(hdc, GetStockObject(SYSTEM_FIXED_FONT));

      // Заполняем структуру информацией
      // о метрике шрифта, выбранного в
      // контекст отображения
      GetTextMetrics(hdc, &tm);

      // Запоминаем значение ширины для
      // самого широкого символа
      cxChar = tm.tmMaxCharWidth;

      // Запоминаем значение высоты букв с
      // учетом межстрочного интервала
      cyChar = tm.tmHeight + tm.tmExternalLeading;

      // Освобождаем контекст
      ReleaseDC(hwnd, hdc);

      // Задаем верхнюю границу несвертываемой
      // области окна. Эта область будет использована
      // для двух строк заголовка
      rect.top = 3 * cyChar;

      return 0;
    }

    case WM_SIZE:
    {
      // Сохраняем координаты нижнего правого
      // угла окна
      rect.right  = LOWORD(lParam);
      rect.bottom = HIWORD(lParam);

      // Перерисовываем все окно
      InvalidateRect(hwnd, NULL, TRUE);
      UpdateWindow(hwnd);

      return 0;
    }

    case WM_PAINT:
    {
      // Две строки заголовка сообщений
      char szHead1[] =
          "Message              Char  wParam lParam   KeyName";
      char szHead2[] =
          "-------              ----  ------ ------   -------";

      hdc = BeginPaint(hwnd, &ps);

      // Выбираем шрифт с фиксированной шириной букв
      SelectObject(hdc, GetStockObject(SYSTEM_FIXED_FONT));

      // Выводим строки заголовка
      TextOut(hdc, cxChar, cyChar/2,
        szHead1, sizeof(szHead1) - 1);
      TextOut(hdc, cxChar, cyChar/2 + cyChar,
        szHead2, sizeof(szHead2) - 1);

      EndPaint(hwnd, &ps);
      return 0;
    }

    case WM_KEYDOWN:
    {
      PrintMsg(hwnd, wParam, lParam, "WM_KEYDOWN");
      break;
    }

    case WM_KEYUP:
    {
      PrintMsg(hwnd, wParam, lParam, "WM_KEYUP");
      break;
    }

    case WM_SYSKEYDOWN:
    {
      PrintMsg(hwnd, wParam, lParam, "WM_SYSKEYDOWN");
      break;
    }

    case WM_SYSKEYUP:
    {
      PrintMsg(hwnd, wParam, lParam, "WM_SYSKEYUP");
      break;
    }

    case WM_CHAR:
    {
      PrintMsg(hwnd, wParam, lParam, "WM_CHAR");
      break;
    }

    case WM_SYSCHAR:
    {
      PrintMsg(hwnd, wParam, lParam, "WM_SYSCHAR");
      break;
    }

    case WM_DEADCHAR:
    {
      PrintMsg(hwnd, wParam, lParam, "WM_DEADCHAR");
      break;
    }

    case WM_SYSDEADCHAR:
    {
      PrintMsg(hwnd, wParam, lParam, "WM_SYSDEADCHAR");
      break;
    }

    case WM_DESTROY:
    {
      PostQuitMessage(0);
      return 0;
    }
  }
  return DefWindowProc(hwnd, msg, wParam, lParam);
}

// ==========================================
// Функция для вывода параметров сообщений
// от клавиатуры в окно
// ==========================================

void PrintMsg(HWND hwnd, WPARAM wParam, LPARAM lParam,
        char *szMsg)
{
  HDC  hdc;
  char szBuf[256];
  char szKeyName[20];
  int  nBufSize;
  int  rc;

  // Сворачиваем часть окна, не занятую заголовком
  ScrollWindow(hwnd, 0, -cyChar, &rect, &rect);

  hdc = GetDC(hwnd);

  // Выбираем шрифт с фиксированной шириной букв
  SelectObject(hdc, GetStockObject(SYSTEM_FIXED_FONT));

  // Получаем имя клавиши, определенное в
  // драйвере клавиатуры
  rc = GetKeyNameText(lParam, szKeyName, 20);
  if(!rc) MessageBeep(0);

  // Подготавливаем строку, описывающую сообщение
  nBufSize = wsprintf(szBuf,
    "%-14s       %c     %02x     %08lX %-20s",
    (LPSTR)szMsg, (BYTE)wParam, (BYTE)wParam,
    lParam, (LPSTR)szKeyName);

  // Выводим строку в нижнюю часть окна
  TextOut(hdc, cxChar, rect.bottom - cyChar,
     szBuf, nBufSize);

  ReleaseDC(hwnd, hdc);

  // Удаляем всю внутреннюю часть окна из
  // списка областей, требующих обновления
  ValidateRect(hwnd, NULL);
}

При создании главного окна приложения (функцией CreateWindow) функция окна получает сообщение WM_CREATE. Наш обработчик этого сообщения создает контекст отображения и выбирает в него системный шрифт с фиксированной шириной букв, для чего вызывает функции GetStockObject и SelectObject:

SelectObject(hdc, GetStockObject(SYSTEM_FIXED_FONT));

Эти функции будут описаны позже. Сейчас мы только отметим, что после выполнения приведенной выше строки системный шрифт с переменной шириной букв будет заменен на системный шрифт с фиксированной шириной букв. С таким шрифтом проще работать, так как можно использовать известные вам по MS-DOS методы вывода таблиц.

После выбора шрифта обработчик сообщения WM_CREATE определяет метрики шрифта. В переменные cxChar и cyChar записывается соответственно ширина и высота букв.

Далее контекст отображения освобождается.

В поле top переменной rect типа RECT записывается координата верхней границы сворачиваемой области главного окна приложения:

rect.top = 3 * cyChar;

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

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

При отображении окна функцией ShowWindow функция окна получает среди прочих сообщение WM_SIZE. Обработчик этого сообщения определяет координаты правого нижнего угла окна, сохраняя их в переменной rect:

rect.right  = LOWORD(lParam);
rect.bottom = HIWORD(lParam);

Поле bottom, содержащее y-координату нижней границы окна, будет использовано для вывода параметров сообщения в нижней части окна функцией TextOut.

После определения координат обработчик сообщения WM_SIZE объявляет все окно как требующее перерисовки и генерирует сообщение WM_PAINT, вызывая функцию UpdateWindow:

InvalidateRect(hwnd, NULL, TRUE);
UpdateWindow(hwnd);

Это приводит к тому, что при изменении размеров окна содержимое окна стирается и в него выводятся только две строки заголовка.

Обработчик сообщения WM_PAINT выбирает в контекст отображения системный шрифт с фиксированной шириной букв и выводит две строки заголовка. Этим его функции и ограничиваются.

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

case WM_KEYDOWN:
{
  PrintMsg(hwnd, wParam, lParam, "WM_KEYDOWN");
  break;
}

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

Отображение параметров сообщения выполняется функцией PrintMsg, определенной в нашем приложении.

Кроме идентификатора окна, нужного для свертки окна и получения контекста отображения, функции PrintMsg передаются параметры сообщения и текстовая строка символического имени сообщения.

Функция PrintMsg начинает свою работу со свертки окна для освобождения в его нижней части места для вывода параметров очередного сообщения:

ScrollWindow(hwnd, 0, -cyChar, &rect, &rect);

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

void WINAPI ScrollWindow(HWND hwnd, int dx, int dy,
   const RECT FAR* lprcScroll, const RECT FAR* lprcClip);

Первый параметр (hwnd) этой функции определяет идентификатор сворачиваемого окна.

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

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

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

В качестве четвертого и пятого параметра можно задать значение NULL, в этом случае будет свернута вся внутренняя область окна.

Далее функция PrintMsg выбирает системный шрифт с фиксированной шириной букв и получает имя клавиши, соответствующее параметру lParam. Для получения имени клавиши, определенном в драйвере клавиатуры, вызывается уже знакомая вам функция GetKeyNameText:

rc = GetKeyNameText(lParam, szKeyName, 20);
if(!rc) MessageBeep(0);

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

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

Для вывода строки вызывается функция TextOut:

TextOut(hdc, cxChar, rect.bottom - cyChar, szBuf, nBufSize);

Строка выводится начиная с позиции (cxChar, rect.bottom - cyChar), то есть в нижней части главного окна приложения.

Перед завершением работы функция PrintMsg вызывает функцию ValidateRect:

ValidateRect(hwnd, NULL);

Эта функция описана в файле windows.h:

void WINAPI ValidateRect(HWND hwnd, const RECT FAR* lprc);

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

Для чего здесь вызывается эта функция?

Дело в том, что после вызова функции ScrollWindow область свертки помечается как требующая обновления, поэтому функция окна получит сообщение WM_PAINT и только что выведенная строка будет стерта.

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

Файл определения модуля для приложения KBMSG приведен в листинге 5.9.

Листинг 5.9. Файл kbmsg\kbmsg.def

; =============================
; Файл определения модуля
; =============================
NAME        KBMSG
DESCRIPTION 'Приложение KBMSG, (C) 1994, Frolov A.V.'
EXETYPE     windows
STUB        'winstub.exe'
STACKSIZE   5120
HEAPSIZE    1024
CODE        preload moveable discardable
DATA        preload moveable multiple

Программный интерфейс Windows версии 3.1 содержит еще одну функцию, предназначенную для свертки окна, - функцию ScrollWindowEx:

int WINAPI ScrollWindowEx(HWND hwnd, int dx, int dy,
    const RECT FAR* lprcScroll, const RECT FAR* lprcClip,
    HRGN hrgnUpdate, RECT FAR* lprcUpdate, UINT fuScroll);

Эта функция аналогична функции ScrollWindow, но имеет три дополнительных параметра - hrgnUpdate, lprcUpdate, и fuScroll.

Параметр hrgnUpdate определяет область, которая будет обновлена в результате свертки. Этот параметр можно указывать как NULL.

Параметр lprcUpdate является указателем на структуру типа RECT, в которую после вызова функции ScrollWindowEx будут записаны координаты границ области, обновленной в результате свертки. Этот параметр также можно указывать как NULL.

Параметр fuScroll определяет флаги, которые используются для управления режимом свертки:

Если не указаны флаги SW_INVALIDATE или SW_ERASE, функция ScrollWindowEx не объявляет требующей обновления область, из которой было выдвинуто изображение в результате выполнения свертки.