Ввод-вывод с использованием WinAPI

9.1.3. Функции чтения-записи в файл

Для операций чтения-записи в файл Microsoft Windows применяются следующие функции:

9.1.4. Стандартные "диалоги" открытия и сохранения файлов

Основным способом задания имени файла для его открытия (или сохранения) средствами Windows является не командная строка, а диалоговые окна "Open" (для открытия файла) и "Save As" (для задания имени сохраняемого файла). Эти диалоговые окна вызываются с помощью ниже перечисленных функций:

Описание синтаксиса структуры, описывающей внешний вид и поведение диалоговых окон, смотри в приложение №2 (п. 9.5) к данной лекции.

9.2. Пример создания "каркаса" приложения средствами WinAPI в C++

9.2.1. "Низкоуровневое" программирование в операционной системе Microsoft Windows

Программирование на языке C++ в операционной системе Microsoft Windows условно можно разделить на "высокоуровневое" и "низкоуровневое". К "высокому уровню программирования" на языке C++ можно отнести программирование с использованием библиотеки MFC в Microsoft Visual C++, библиотеки ObjectVision в Borland C/C++ и других, менее распространённых библиотек. При написании этих библиотек учтён весь опыт программирования интерфейсов, поэтому с помощью этих библиотек легко сделать "рабочий шаблон" для своего проекта, и уже потом наполнять его нужными функциями. Это очень удобно.… Однако автор всё-таки советует для создания небольших утилит с ограниченной функциональностью использовать "низкоуровневое" программирование в Windows.

При программировании на "низком уровне" пользователю приходится напрямую использовать функции API Windows (что в "высокоуровневых" библиотеках делать запрещено) и "вручную заниматься" выделением памяти, созданием/освобождением/закрытием контекста устройств, описывать реакцию приложения на поступившие сообщения о нажатых клавишах, событий от мыши и системных событий. Это всё гораздо сложнее.… Но не стоит расстраиваться. Для создания приложений можно использовать один или несколько предопределённых "шаблонов", которые могут быть созданы для определённых классов задач, и включать в себя все "наиболее важные и наиболее типичные" настройки для узкого круга задач и приложений. Все остальные настройки "наследуются Windows" по-умолчанию. Часть из этих шаблонов, предназначенных для обработки текстов, приведена в данном разделе.

9.2.2. Функция WinMain

Основной функцией создаваемого приложения Microsoft Windows является функция WinMain. Эта функция - аналог функции "main" для MS-DOS. Её задача - определить класс окна, создать главное окно приложения и "присоединить к нему" функцию обработки сообщений Windows. В отличие от функции main все входящие в неё параметры обязательны.

Схематически алгоритм вызова любой функции WinMain можно описать следующим образом:

int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow)

Шаблон этой функции, пригодный для создания программ для текстовой обработки данных, представлен в приложениях III и так далее к данной лекции.

9.2.3. Инициализация приложения

Для инициализации приложения Microsoft Windows используется функция InitApp. Назначение этой функции - заполнить структуру WNDCLASS и вызвать функцию регистрации класса окна. В случае неуспешной инициализации функция возвращает значение: "FALSE".

В структуре WNDCLASS заполняются следующие поля:

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

9.2.4. Функция WndProc

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

"Линейная последовательность вычислений", применяемая в MS-DOS, не годится для программирования многозадачных операционных систем, таких как Windows. Во-первых, ресурсы ЭВМ при многозадачной обработке должны быть эффективно распределены между приложениями, а не предоставляться в "монопольное пользование" отдельной программе. Во-вторых, реализация реакции операционной системы MS-DOS на внешние и внутренние события, такие как прерывания от таймера ("системных часов"), от клавиатуры (на нажатие-отпускание клавиши), от мыши и т.д. далеки от совершенства. Как правило, приложению MS-DOS приходилось ждать, когда операционная система "обработает" эти прерывания. А это приводит к непроизводительному расходу ресурсов. Список неудобств можно продолжить.

Чтобы "обойти" эти недостатки, уже в конце 80-х - начале 90-х годов XX века корпорацией Microsoft был разработан механизм эффективного использования ресурсов ЭВМ на основе архитектуры x86, полностью совместимый с MS-DOS. Этот механизм был использован сначала в файловой оболочке, а затем и в операционной системе Microsoft Windows. В его реализации используются "сообщения", которые генерируются операционной системой Microsoft Windows, ставятся в очередь на исполнение и затем передаются на обработку приложениям. После обработки сообщения приложением оно возвращает результат обратно операционной системе, на основе которого вновь генерируются сообщения и т.д. Поскольку сообщения генерируются постоянно и для всех приложений, им ничего не надо делать, кроме как "слушать" системную очередь сообщений, "отлавливать" своё сообщение и обрабатывать его. А из-за того, что все сообщения помещаются в одну очередь, не будет "опасений" по-поводу того, что сообщение "потеряется", или того, что сообщения поступят приложению не в той последовательности. И роль "всё слышащего уха" приложения Windows выполняет как раз функция WndProc.

Синтаксис функции WndProc следующий:

LRESULT CALLBACK _export WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

где

Среди идентификаторов сообщений важнейшими являются следующие идентификаторы:

Для описания реакции на сообщение Windows алгоритм функции WndProc пишется следующим образом:

default:
	return DefWindowProc(hwnd, msg, wParam, lParam);

Примечание. Фактически, следуя формулировкам объектно-ориентированного программирования, сообщение "WM_CREATE" является конструктором приложения Windows, сообщение "WM_DESTROY" - деструктор приложения, а все остальные сообщения являются как бы "методами" этого приложения.

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

9.2.5. Пример "стандартного каркаса" для приложения Microsoft Windows

Пример "стандартного каркаса" приложения Microsoft Windows, разработанный для компиляторов Borland C/C++ версий от 3.1 до 5.5, представлен в приложении № III к данной лекции. В приложении № IV представлен пример программы для вывода текстовых строк в окно Windows. В приложениях №№ V и VI представлены те же программы, переписанные для системы Microsoft Visual Studio .Net 2003. Эти программы разработаны для 32-х битного режима Microsoft Windows и рационально используют ресурсы новых ЭВМ на основе технологий Intel и AMD.

9.3. Резюме

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

9.4. Приложение № I. Описание функций создания и открытия файлов

typedef struct tagOFSTRUCT
{
	BYTE	cBytes;
	BYTE	fFixedDisk;
	UINT	nErrCode;
	BYTE	reserved[4];
	char	szPathName[128];
} OFSTRUCT;

Поле cBytes содержит размер самой структуры OFSTRUCT в байтах.

С помощью поля fFixedDisk приложение может определить, находится ли открытый файл на жёстком диске, на флоппи-диске или другом съёмном носителе. Если содержимое этого поля отлично от нуля, то файл находится на жёстком диске.

Если при открытии файла произошла ошибка, в поле nErrCode записывается код ошибки. Возможные значения для кода ошибки приведены в приложении №I к книге [37].

Поле reserved зарезервировано, и не должно использоваться.

В поле szPathName находится полный путь к файлу в кодировке OEM.

9.5. Приложение № II. Основные опции стандартных диалогов GetOpenFileName и GetSaveFileName

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;

В таблице 9.3 представлено назначение полей данной структуры. В таблице 9.4 представлено описание и расшифровка режимов вывода файлов, записанных в переменную Flags.

9.6. Приложение № III

/* Файл INIT.CPP */
/**********************************************************
 * Каркас приложений Windows,
 * на основе которого можно строить более
 * сложные приложения MS WINDOWS.
 * Каркас использует правила для написани
 * программ на платформе Turbo C++ 3.1
 * 16-ти разрядных версий Windows.
 *
 * Более подробную информацию о "низкоуровневом" написании
 * программ для Microsoft Windows смотри А.В. Фролов, Г.В.
 * Фролов, "Операционная система Microsoft Windows 3.1.
 * для программиста". -- М. "ДИАЛОГ-МИФИ", 1994 г. и др.
 * книги этих авторов.
**********************************************************/
#define STRICT
#include <windows.h>
#include <mem.h>
// Прототипы функций
// Первая функция - для инициализации
// приложения Windows, вторая функция -
// для обработки системных сообщений.
BOOL InitApp(HINSTANCE);
LRESULT CALLBACK _export WndProc(HWND, UINT, WPARAM, LPARAM);
/* Значения класса и заголовка впоследствии нужно заменить */
// Имя класса окна
char const szClassName[]   = "WindowAppClass";
// Заголовок окна
char const szWindowTitle[] = "Window Application";
// =====================================
/***************************************
 * Функция WinMain
 * Получает управление при запуске
 * приложени
***************************************/
// =====================================
#pragma argsused
int PASCAL
WinMain(HINSTANCE hInstance,     // идентификатор текущей
				 // копии приложени
	HINSTANCE hPrevInstance, // идентификатор предыдущей
				 // копии приложени
	LPSTR     lpszCmdLine,   // указатель на командную строку
	int       nCmdShow)      // способ отображения главного
	                         // окна приложени
{
  MSG  msg;   // структура для работы с сообщениями
  HWND hwnd;  // идентификатор главного окна приложени
  // Проверяем, не запускалось ли это приложение ранее
//  if(!hPrevInstance)
//  {
    // Если не запускалось, вызываем функцию InitApp
    // для инициализации приложения.
/*****************************************************
 * Вызываем функцию InitApp
 * для инициализации приложения.
 * Если инициализацию выполнить не удалось,
 * завершаем приложение
*****************************************************/
    if(!InitApp(hInstance))
      return FALSE;
//  }
/****************************************************
 * После успешной инициализации приложения создаём
 * главное окно приложени
****************************************************/
  hwnd = CreateWindow(
    szClassName,         // имя класса окна (см. Выше )
    szWindowTitle,       // заголовок окна (см. Выше)
    WS_OVERLAPPEDWINDOW, // стиль окна
/****************************************************
 * В данном случае это перекрывающееся окно, но эту
 * опцию можно изменить для других типов окон
*****************************************************/
    CW_USEDEFAULT,       // задаём размеры и расположение
    CW_USEDEFAULT,       // окна, принятые по умолчанию
    CW_USEDEFAULT,
    CW_USEDEFAULT,
    0,                   // идентификатор родительского окна
			// Для главного окна его менять нельз
    0,                   // идентификатор меню
/**********************************************************
 * В случае, если у окна необходимо создать меню, вместо
 * нуля сюда вставляется идентификатор меню (тип HMENU),
 * созданный с помощью функции LoadMenu.
 *
 * Если меню подключается как ресурс приложения в функции
 * InitApp, в этом поле также нужно оставить 0
**********************************************************/
    hInstance,           // идентификатор приложени
    NULL);               // указатель на дополнительные
			 // параметры
/**********************************************************
 * Далее код лучше не менять *
**********************************************************/
  // Если создать окно не удалось, завершаем приложение
  if(!hwnd)
    return FALSE;
/**********************************************************
 * В случае если Вам не нужно рисовать главное окно
 * приложения (например, Вы пишете программу мастер)
 * две нижеперечисленные функции:  ShowWindow и
 * UpdateWindow, указывать не надо
**********************************************************/
  // Рисуем окно. Для этого после функции ShowWindow, рисующей
  // окно, вызываем функцию UpdateWindows, посылающую
  // сообщение WM_PAINT в функцию окна
  ShowWindow(hwnd, nCmdShow);
  UpdateWindow(hwnd);
/**********************************************************
 * Далее до конца функции код лучше не менять *
**********************************************************/
  // Запускаем цикл обработки сообщений
  while(GetMessage(msg, 0, 0, 0))
  {
    DispatchMessage(msg);
  }
  // Возвращаем значение WParam, переданное
  // в качестве параметра функции PostQuitMessage
  // в процессе инициирования завершения работы
  // приложения из функции окна.
  // Затем завершаем работу приложени
  return msg.wParam;
}
/* Конец функции WinMain *|
// =====================================
/**********************************************************
 * Функция InitApp
 * Вызывается из функции WinMain дл
 * инициализации приложения.
 * Выполняет регистрацию класса окна
**********************************************************/
// =====================================
BOOL InitApp(HINSTANCE hInstance)
{
  ATOM aWndClass; // атом для кода возврата
  WNDCLASS wc;    // структура для регистрации
                  // класса окна
  // Записываем нулевые значения во все поля структуры
  memset(wc, 0, sizeof(wc));
  // Стиль окна
/**********************************************************
 * Поле style задаёт стиль класса окна и задаётся в виде
 * констант, описанных в файле <windows.h>. Описани
 * констант стилей начинается с префикса CS_. Стиль окна
 * задаёт реакцию окна на изменения его размера, на
 * выполнение в окне операции двойного щелчка мышью, а
 * также задаёт другие характеристики окна.
 * Если в главное окно предполагается вывод информации,
 * необходимо указать, по крайней мере:
 *   wc.style = CS_HREDRAW | CS_REDRAW;
 * в противном случае записать:
 *   wc.style = 0;
**********************************************************/
  wc.style = 0;
  // Указатель на функцию окна, обрабатывающую
  // сообщения, предназначенные для всех окон,
  // созданных на основе данного класса
  /* Желательно не менять! */
  wc.lpfnWndProc = (WNDPROC) WndProc;
  // Размер дополнительной области данных,
  // зарезервированной в описании класса окна
  /* Желательно не менять! */
  wc.cbClsExtra = 0;
  // Размер дополнительной области данных,
  // зарезервированной для каждого окна,
  // созданного на основе данного класса
  /* Желательно не менять! */
  wc.cbWndExtra = 0;
  // Идентификатор приложения, которое
  // создало данный класс
  /* Желательно не менять! */
  wc.hInstance = hInstance;
  // Идентификатор пиктограммы, используемой
  // для окно данного класса
/**********************************************************
 * Иконки создаются или "подгружаются" из специальных
 * файлов с "ресурсами", с помощью команды LoadIcon.
 * Первый параметр функции содержит идентификатор
 * приложения, в котором ищется иконка (значение NULL дл
 * системных областей), второй параметр задаёт имя ресурса-
 * пиктограммы. Если Вы не уверены, то этот параметр
 * менять не нужно.
**********************************************************/
  wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
  // Идентификатор курсора, используемого
  // для окна данного класса
/**********************************************************
 * Курсоры создаются или "подгружаются" из специальных
 * файлов с "ресурсами", с помощью команды LoadCursor.
 * Первый параметр функции содержит идентификатор
 * приложения, в котором ищется курсор (значение NULL дл
 * системных областей), второй параметр задаёт имя ресурса-
 * курсора. Если Вы не уверены, то этот параметр менять
 * не нужно (оставляем стандартный курсор в виде стрелки).
**********************************************************/
  wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  // Цвет фона окна
  /* Желательно не менять, оставить системный цвет */
  wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
  // Идентификатор меню
/**********************************************************
 * В случае если у окна необходимо создать меню, в это
 * поле нужно указать адрес текстовой строки, содержащей
 * имя шаблона меню в файле ресурсов. Все перекрывающиеся и
 * временные окна, созданные на базе этого класса, будут
 * иметь меню, определённое данным шаблоном. Пример:
 *  wc.lpszMenuName = "APP_MENU";
 * Если для идентификации шаблона использовать целые
 * числа, необходимо использовать макрокоманду
 * MAKEINTRESOURCE. Например, в файле описания ресурсов и в
 * файле исходного приложения определена константа:
 * #define APP_MENU 123
 * В этом случае строка примет вид:
 *  wc.lpszMenuName = MAKEINTRESOURCE( APP_MENU );
 * Если в окне меню не нужно, оставьте параметр без
 * изменения.
**********************************************************/
  wc.lpszMenuName = (LPSTR)NULL;
  /* Желательно не менять остальные операторы до конца
     функции */
  // Имя, которое присваивается создаваемому
  // классу и используется при создании
  // окон данного класса
  wc.lpszClassName = (LPSTR)szClassName;
  // Регистрация класса
  aWndClass = RegisterClass(wc);
  // Возвращаем результат регистрации класса
  return (aWndClass != 0);
}
/* Файл WinProc.cpp */
#define STRICT
#include <windows.h>
#include <mem.h>
// =====================================
/**********************************************************
 * Функция WndProc
 * НЕ ВЫЗЫВАЕТСЯ ни из одной функции приложения.
 * Эту функцию вызывает Windows в процессе
 * обработки сообщений. Для этого адрес функции WndProc
 * указывается при регистрации класса окна.
 * Функция выполняет обработку сообщений главного
 * окна приложени
 *
 * Более подробную информацию о "низкоуровневом" написании
 * программ для Microsoft Windows смотри А.В. Фролов, Г.В.
 * Фролов, "Операционная система Microsoft Windows 3.1.
 * для программиста". -- М. "ДИАЛОГ-МИФИ", 1994 г. и др.
 * книги этих авторов.
**********************************************************/
// =====================================
LRESULT CALLBACK _export WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
  // Выполняем обработку сообщений. Идентификатор
  // сообщения передаётся через параметр msg
  switch (msg)
  {
/**********************************************************
 * Это сообщение приходит, когда создаётся окно приложени
 * Здесь нужно вызвать контекст экрана, сохранить в
 * переменных его метрики и освободить его.
**********************************************************/

    case WM_CREATE:
    {
      // Получаем контекст отображения,
      // необходимый для определения метрик.
	return 0;
    }
/**********************************************************
 * Это сообщение приходит, когда "рисуется" окно приложения.
 * Здесь нужно вызвать контекст экрана, вывести необходимые
 * данные на экран, и освободить контекст.
**********************************************************/

    case WM_PAINT:
    {
      // Инициализируем текущую позицию вывода текста
      // Получаем контекст экрана
      // Освобождаем контекст экрана
         return 0;
    }
/*********************************************************
    // Это сообщение приходит, когда вы поместили курсор
    // мыши в область главного окна приложения и нажали
    // левую клавишу мыши
    case WM_LBUTTONDOWN:
      {
	return 0;
      }
    // Это сообщение приходит, когда вы поместили курсор
    // мыши в область главного окна приложения и нажали
    // правую клавишу мыши
    case WM_RBUTTONDOWN:
      {
	return 0;
      }
**********************************************************/
/**********************************************************
 * Это сообщение приходит, когда вы завершаете
 * работу приложения стандартным дл
 * Windows способом
**********************************************************/
    case WM_DESTROY:
    {
      // Инициируем завершение работы приложения,
      // помещая в очередь приложения сообщение
      // WM_QUIT. Это приведёт к завершению
      // цикла обработки сообщений в функции WinMain
      PostQuitMessage(0);
      return 0;
    }
  }
  // Все сообщения, которые не обрабатываются нашей
  // функцией окна, ДОЛЖНЫ передаваться функции
  // DefWindowProc
  return DefWindowProc(hwnd, msg, wParam, lParam);
}
/* Файл WINDOW.DEF */
; =============================
; Файл определения модул
; =============================
; Имя приложени
NAME WINDOW
; Описание приложени
DESCRIPTION 'Приложение WINDOW, (C) 1994, Frolov A.V.'
; Определение типа загрузочного модуля как
; приложения Windows
EXETYPE windows
; Программа, которая будет записана в начало файла
; приложения. Эта программа получит управление
; при попытке запуска приложения в среде MS-DOS
STUB 'winstub.exe'
; Размер стека в байтах
STACKSIZE 5120
; Размер локальной кучи памяти приложения в байтах
HEAPSIZE 1024
; Атрибуты сегмента кода
CODE preload moveable discardable
; Атрибуты сегмента данных
DATA preload moveable multiple

9.7. Приложение № IV

/* Файл INIT.CPP */
/**********************************************************
 * Каркас приложений Windows,
 * на основе которого можно строить более
 * сложные приложения MS WINDOWS.
 * Каркас использует правила для написани
 * программ на платформе Turbo C++ 3.1
 * 16-ти разрядных версий Windows.
 *
 * Более подробную информацию о "низкоуровневом" написании
 * программ для Microsoft Windows смотри А.В. Фролов, Г.В.
 * Фролов, "Операционная система Microsoft Windows 3.1.
 * для программиста". -- М. "ДИАЛОГ-МИФИ", 1994 г. и др.
 * книги этих авторов.
**********************************************************/
#define STRICT
#include <windows.h>
#include <mem.h>
// Прототипы функций
// Первая функция - для инициализации
// приложения Windows, вторая функция -
// для обработки системных сообщений.
BOOL InitApp(HINSTANCE);
LRESULT CALLBACK _export WndProc(HWND, UINT, WPARAM, LPARAM);
/* Значения класса и заголовка впоследствии нужно заменить */
// Имя класса окна
char const szClassName[]   = "WindowAppClass";
// Заголовок окна
char const szWindowTitle[] = "Window Application";
// =====================================
/***************************************
 * Функция WinMain
 * Получает управление при запуске
 * приложени
***************************************/
// =====================================
#pragma argsused
int PASCAL
WinMain(HINSTANCE hInstance,     // идентификатор текущей
				 // копии приложени
	HINSTANCE hPrevInstance, // идентификатор предыдущей
				 // копии приложени
	LPSTR     lpszCmdLine,   // указатель на командную строку
	int       nCmdShow)      // способ отображения главного
	                         // окна приложени
{
  MSG  msg;   // структура для работы с сообщениями
  HWND hwnd;  // идентификатор главного окна приложени
  // Проверяем, не запускалось ли это приложение ранее
//  if(!hPrevInstance)
//  {
    // Если не запускалось, вызываем функцию InitApp
    // для инициализации приложения.
/*****************************************************
 * Вызываем функцию InitApp
 * для инициализации приложения.
 * Если инициализацию выполнить не удалось,
 * завершаем приложение
*****************************************************/
    if(!InitApp(hInstance))
      return FALSE;
//  }
/****************************************************
 * После успешной инициализации приложения создаём
 * главное окно приложени
****************************************************/
  hwnd = CreateWindow(
    szClassName,         // имя класса окна (см. Выше )
    szWindowTitle,       // заголовок окна (см. Выше)
    WS_OVERLAPPEDWINDOW, // стиль окна
/****************************************************
 * В данном случае это перекрывающееся окно, но эту
 * опцию можно изменить для других типов окон
*****************************************************/
    CW_USEDEFAULT,       // задаём размеры и расположение
    CW_USEDEFAULT,       // окна, принятые по умолчанию
    CW_USEDEFAULT,
    CW_USEDEFAULT,
    0,                   // идентификатор родительского окна
			// Для главного окна его менять нельз
    0,                   // идентификатор меню
/**********************************************************
 * В случае если у окна необходимо создать меню, вместо
 * нуля сюда вставляется идентификатор меню (тип HMENU),
 * созданный с помощью функции LoadMenu.
 *
 * Если меню подключается как ресурс приложения в функции
 * InitApp, в этом поле также нужно оставить 0
**********************************************************/
    hInstance,           // идентификатор приложени
    NULL);               // указатель на дополнительные
			 // параметры
/**********************************************************
 * Далее код лучше не менять *
**********************************************************/
  // Если создать окно не удалось, завершаем приложение
  if(!hwnd)
    return FALSE;
/**********************************************************
 * В случае если Вам не нужно рисовать главное окно
 * приложения (например, Вы пишете программу-мастер)
 * две нижеперечисленные функции:  ShowWindow и
 * UpdateWindow, указывать не надо
**********************************************************/
  // Рисуем окно. Для этого после функции ShowWindow, рисующей
  // окно, вызываем функцию UpdateWindows, посылающую
  // сообщение WM_PAINT в функцию окна
  ShowWindow(hwnd, nCmdShow);
  UpdateWindow(hwnd);
/**********************************************************
 * Далее до конца функции код лучше не менять *
**********************************************************/
  // Запускаем цикл обработки сообщений
  while(GetMessage(msg, 0, 0, 0))
  {
    DispatchMessage(msg);
  }
  // Возвращаем значение WParam, переданное
  // в качестве параметра функции PostQuitMessage
  // в процессе инициирования завершения работы
  // приложения из функции окна.
  // Затем завершаем работу приложени
  return msg.wParam;
}
/* Конец функции WinMain *|
// =====================================
/**********************************************************
 * Функция InitApp
 * Вызывается из функции WinMain дл
 * инициализации приложения.
 * Выполняет регистрацию класса окна
**********************************************************/
// =====================================
BOOL InitApp(HINSTANCE hInstance)
{
  ATOM aWndClass; // атом для кода возврата
  WNDCLASS wc;    // структура для регистрации
                  // класса окна
  // Записываем нулевые значения во все поля структуры
  memset(wc, 0, sizeof(wc));
  // Стиль окна
/**********************************************************
 * Поле style задаёт стиль класса окна и задаётся в виде
 * констант, описанных в файле <windows.h>. Описани
 * констант стилей начинается с префикса CS_. Стиль окна
 * задаёт реакцию окна на изменения его размера, на
 * выполнения в окне операции двойного щелчка мышью, а
 * также задаёт другие характеристики окна.
 * Если в главное окно предполагается вывод информации,
 * необходимо указать, по крайней мере:
 *   wc.style = CS_HREDRAW | CS_REDRAW;
 * в противном случае записать:
 *   wc.style = 0;
**********************************************************/
  wc.style = 0;
  // Указатель на функцию окна, обрабатывающую
  // сообщения, предназначенные для всех окон,
  // созданных на основе данного класса
  /* Желательно не менять! */
  wc.lpfnWndProc = (WNDPROC) WndProc;
  // Размер дополнительной области данных,
  // зарезервированной в описании класса окна
  /* Желательно не менять! */
  wc.cbClsExtra = 0;
  // Размер дополнительной области данных,
  // зарезервированной для каждого окна,
  // созданного на основе данного класса
  /* Желательно не менять! */
  wc.cbWndExtra = 0;
  // Идентификатор приложения, которое
  // создало данный класс
  /* Желательно не менять! */
  wc.hInstance = hInstance;
  // Идентификатор пиктограммы, используемой
  // для окно данного класса
/**********************************************************
 * Иконки создаются или "подгружаются" из специальных
 * файлов с "ресурсами", с помощью команды LoadIcon.
 * Первый параметр функции содержит идентификатор
 * приложения, в котором ищется иконка (значение NULL дл
 * системных областей), второй параметр задаёт имя ресурса-
 * пиктограммы. Если Вы не уверены, то этот параметр
 * менять не нужно.
**********************************************************/
  wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
  // Идентификатор курсора, используемого
  // для окно данного класса
/**********************************************************
 * Курсоры создаются или "подгружаются" из специальных
 * файлов с "ресурсами", с помощью команды LoadCursor.
 * Первый параметр функции содержит идентификатор
 * приложения, в котором ищется курсор (значение NULL дл
 * системных областей), второй параметр задаёт имя ресурса-
 * курсора. Если Вы не уверены, то этот параметр менять
 * не нужно (оставляем стандартный курсор в виде стрелки).
**********************************************************/
  wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  // Цвет фона окна
  /* Желательно не менять, оставить системный цвет */
  wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
  // Идентификатор меню
/**********************************************************
 * В случае если у окна необходимо создать меню, в это
 * поле нужно указать адрес текстовой строки, содержащей
 * имя шаблона меню в файле ресурсов. Все перекрывающиеся и
 * временные окна, созданные на базе этого класса, будут
 * иметь меню, определённое данным шаблоном. Пример:
 *  wc.lpszMenuName = "APP_MENU";
 * Если для идентификации шаблона использовать целые
 * числа, необходимо использовать макрокоманду
 * MAKEINTRESOURCE. Например, в файле описания ресурсов и в
 * файле исходного приложения определена константа:
 * #define APP_MENU 123
 * В этом случае строка примет вид:
 *  wc.lpszMenuName = MAKEINTRESOURCE( APP_MENU );
 * Если в окне меню не нужно, оставьте параметр без
 * изменения.
**********************************************************/
  wc.lpszMenuName = (LPSTR)NULL;
  /* Желательно не менять остальные операторы до конца
     функции */
  // Имя, которое присваивается создаваемому
  // классу и используется при создании
  // окон данного класса
  wc.lpszClassName = (LPSTR)szClassName;
  // Регистрация класса
  aWndClass = RegisterClass(wc);
  // Возвращаем результат регистрации класса
  return (aWndClass != 0);
}
/* Файл TEXTW.CPP */
/**********************************************************
 * Функция WndProc
**********************************************************/
#define STRICT
#include <windows.h>
#include <stdio.h>
#include <string.h>
// Задание максимальной длины символьного буфера строки
// для вывода в окно
#ifndef SCREEN_BUFSIZE
#define SCREEN_BUFSIZE	80
#endif
// Прототип функции для печати строки символов
void Print(HDC, char *, int);
void PrintLn(void);
/**********************************************************
 * cxChar -- значение ширины для самой широкой литеры
 * cyChar -- max высота литеры с учётом междустрочного
 *           интервала.
 * cxCurrentPosition -- текущая гориз. позиция вывода текста
 * cyCurrentPosition -- текущая верт. позиция вывода текста
**********************************************************/
static int cxChar, cyChar;
static int cxCurrentPosition;
static int cyCurrentPosition;
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);
      // Заполняем структуру информацией
      // о метрике шрифта, выбранного в
      // контекст отображени
      GetTextMetrics(hdc, tm);
      // Запоминаем значение ширины дл
      // самого широкого символа
      cxChar = tm.tmMaxCharWidth;
      // Запоминаем значение высоты букв с
      // учётом межстрочного интервала
      cyChar = tm.tmHeight + tm.tmExternalLeading;
      // Инициализируем текущую позицию
      // вывода текста
      cxCurrentPosition = cxChar;
      cyCurrentPosition = cyChar;
      // Освобождаем контекст
      ReleaseDC(hwnd, hdc);
      return 0;
    }
    case WM_PAINT:
    {
      // Инициализируем текущую позицию
      // вывода текста
      cxCurrentPosition = cxChar;
      cyCurrentPosition = cyChar;
      hdc = BeginPaint(hwnd, ps);
      // Выводим последовательно строки:
      Print(hdc, "Первая строка", 0); PrintLn();
      Print(hdc, "Вторая строка", 0); PrintLn();
      Print(hdc, "Третья строка( смещённая )", 10); PrintLn();
      EndPaint(hwnd, ps);
      return 0;
    }
    case WM_DESTROY:
    {
      PostQuitMessage(0);
      return 0;
    }
  }
  return DefWindowProc(hwnd, msg, wParam, lParam);
}
/**********************************************************
 * Функция Print
 * Функция предназначена для вывода текста
 * в окно.
 *
 * ВХОДНЫЕ ЗНАЧЕНИЯ:
 * HDC hdc -- индекс контекста устройства;
 * char *str -- указатель на выводимую строку;
 * int iOFFSET -- смещение горизонтальной позиции
 * вывода текста в окно, указанное в символах;
 *
 * ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ:
 * cxChar -- значение ширины для самой широкой литеры
 * cyChar -- max высота литеры с учётом междустрочного
 *           интервала.
 * cxCurrentPosition -- текущая гориз. позиция вывода текста
 * cyCurrentPosition -- текущая верт. позиция вывода текста
 *
 * ФУНКЦИЯ ВОЗВРАЩАЕТ:
 * 	Возвращаемых значений нет.
 *
 * ПРИМЕЧАНИЕ:
 * Эта функция может быть переписана Вами под Ваши
 * нужды для вывода не только текста, но и числовых
 * значений, а также для форматирования в строке вывода.
 *
**********************************************************/
void Print(HDC hdc, char *str, int iOFFSET )
{
  char buf[SCREEN_BUFSIZE];
  int i;
/* Проверяем смещение на неравенство единице
   и корректируем его */
  if( iOFFSET < 0 ) iOFFSET = 0;
  // Подготавливаем в рабочем буфере
  i = strlen(str);
  // Проверка, что строка умещается в буфере
  if( i < SCREEN_BUFSIZE - 1 )
  // и выводим строку в зависимости от проверки
	sprintf(buf, "%s", str);
  else
	sprintf(buf, "%.*s", SCREEN_BUFSIZE-1, str);
  // Выводим текст в окно, начиная с текущей позиции
  // вывода текста + смещение в максимальном
  // количестве символов
  TextOut(hdc,
    cxCurrentPosition + iOFFSET * cxChar,
    cyCurrentPosition,
    buf, i);
}
/**********************************************************
 * Функция PrintLn
 * Функция предназначена для перевода на новую строку
 * при выводе в окно.
 *
 * ВХОДНЫЕ ЗНАЧЕНИЯ:
 * Не имеет.
 *
 * ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ:
 * cxChar -- значение ширины для самой широкой литеры
 * cyChar -- max высота литеры с учётом междустрочного
 *           интервала.
 * cxCurrentPosition -- текущая гориз. позиция вывода текста
 * cyCurrentPosition -- текущая верт. позиция вывода текста
 *
 * ФУНКЦИЯ ВОЗВРАЩАЕТ:
 * 	Возвращаемых значений нет.
 *
 * ПРИМЕЧАНИЕ:
 * Эта функция может быть переписана Вами под Ваши
 * нужды для вывода не только текста, но и числовых
 * значений, а также для форматирования в строке вывода.
 *
**********************************************************/
void PrintLn( void )
{
  // Увеличиваем текущую позицию по
  // вертикали на высоту символа
  cyCurrentPosition += cyChar;
}
/* Файл TEXTWN.DEF*/
; =============================
; Файл определения модул
; =============================
; Имя приложени
NAME TEXTWIN
; Описание приложени
DESCRIPTION 'Приложение WINDOW, (C) 1994, Frolov A.V.'
; Определение типа загрузочного модуля как
; приложения Windows
EXETYPE windows
; Программа, которая будет записана в начало файла
; приложения. Эта программа получит управление
; при попытке запуска приложения в среде MS-DOS
STUB 'winstub.exe'
; Размер стека в байтах
STACKSIZE 5120
; Размер локальной кучи памяти приложения в байтах
HEAPSIZE 1024
; Атрибуты сегмента кода
CODE preload moveable discardable
; Атрибуты сегмента данных
DATA preload moveable multiple

9.8. Приложение № V

Примечание: Для создания данного приложения средствами Microsoft Visual Studio 2008 вначале создайте "пустой проект", а затем заполните его этими файлами.

/* stdafx.cpp*/
// stdafx.cpp : исходный файл, который включает в себя стандартные заголовочные файлы.
// WINDOW.pch будет заголовком предпроцессора
// stdafx.obj будет содержать информацию предварительной компиляции
#include "stdafx.h"
// Поместите сюда всю дополнительную информацию, которая Вам нужна,
// в этот файл, а ни где-либо ещё.
/* stdafx.h */
// stdafx.h : заголовочный файл, со стандартными системными заголовочными файлами
// или специфичные для всего проекта часто используемые заголовочные файлы,
// но изменяемые не часто
//
#pragma once
#pragma once
// Измените следующие определения, если Вы используете платформу из тех, что обозначена ниже.
// Укажите MSDN последнюю информацию на соответствующее значение для разных платформ.
#ifndef WINVER				// Позволяет использовать особенности, характерные для Windows XP и поздних версий.
#define WINVER 0x0501		// Измените значение на соответствующую величину текущей версии Windows.
#endif
#ifndef _WIN32_WINNT		// Позволяет использовать особенности, характерные для Windows XP и поздних версий.
#define _WIN32_WINNT 0x0501	// Измените значение на соответствующую величину текущей версии Windows.
#endif
#ifndef _WIN32_WINDOWS		// Позволяет использовать особенности, характерные для Windows 98 и поздних версий.
#define _WIN32_WINDOWS 0x0410 // Измените значение на соответствующую величину текущей версии Windows Me or later.
#endif
#ifndef _WIN32_IE			// Позволяет использовать особенности, характерные для  IE 6.0 и поздних версий.
#define _WIN32_IE 0x0600	// Измените значение на соответствующую величину текущей версии IE.
#endif
#define WIN32_LEAN_AND_MEAN		// Не допущение ранее используемого наполнения из заголовка Windows.
// Заголовочный файл Windows:
#include <windows.h>
// Заголовочные файлы C RunTime
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
// TODO: разместите дополнительные заголовки модулей, необходимых для Вашего проекта, здесь
/* WINDOW.h*/
#pragma once
#include "resource.h"
/* WINDOW.cpp */
// WINDOW.cpp : Определяет точку входа для приложения.
//
#include "stdafx.h"
#include "WINDOW.h"
#define MAX_LOADSTRING 100
// Глобальные переменные:
HINSTANCE hInst;								// текущий экземпляр класса
TCHAR szTitle[MAX_LOADSTRING];					// Текст главного меню
TCHAR szWindowClass[MAX_LOADSTRING];			// имя класса главного окна
// Далее идут объявления функций, включённых в модуль Code:
ATOM				MyRegisterClass(HINSTANCE hInstance);
BOOL				InitInstance(HINSTANCE, int);
LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK	About(HWND, UINT, WPARAM, LPARAM);
int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
	// Отмена определения параметров hPrevInstance (предыдущий
	// Экземпляр приложения) и lpCmdLine (командная строка)
	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(lpCmdLine);
 	// TODO: Поместите свой код здесь.
	MSG msg;
	HACCEL hAccelTable;
	// Инициализация глобальных настроек
	LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
	LoadString(hInstance, IDC_WINDOW, szWindowClass, MAX_LOADSTRING);
	MyRegisterClass(hInstance);
	// Подготовить инициализацию приложения:
	if (!InitInstance (hInstance, nCmdShow))
	{
		return FALSE;
	}
	hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_WINDOW));
	// Основной цикл сообщений:
	while (GetMessage(msg, NULL, 0, 0))
	{
		if (!TranslateAccelerator(msg.hwnd, hAccelTable, msg))
		{
			TranslateMessage(msg);
			DispatchMessage(msg);
		}
	}
	return (int) msg.wParam;
}
//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Регистрирует класс окна.
//
//  COMMENTS:
//
//    Эта функция и её использование необходимо только
//    в том случае, если Вы хотите, чтобы этот код
//    был совместим с кодом системы Win32 прежде, чем функция 'RegisterClassEx'
//   была добавлена в Windows 95. Очень важно использовать эту функцию так
//    чтобы это приложение давала "правильно оформленными" иконками, ассоциированных с ними
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
	WNDCLASSEX wcex;
	wcex.cbSize = sizeof(WNDCLASSEX);
	wcex.style			= CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc	= WndProc;
	wcex.cbClsExtra		= 0;
	wcex.cbWndExtra		= 0;
	wcex.hInstance		= hInstance;
	wcex.hIcon			= LoadIcon(hInstance, MAKEINTRESOURCE(IDI_WINDOW));
	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
	wcex.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
	wcex.lpszMenuName	= MAKEINTRESOURCE(IDC_WINDOW);
	wcex.lpszClassName	= szWindowClass;
	wcex.hIconSm		= LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
	return RegisterClassEx(wcex);
}
//
//   FUNCTION: InitInstance(HINSTANCE, int)
//
//
//   PURPOSE: Сохраняет экземпляр класса и создаёт основное окно
//
//   COMMENTS:
//
//        В этой функции мы сохраняем дескриптор экземпляр класса в глобальную переменную и
//        создаёт и показывает основное окно программы..
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;
   hInst = hInstance; // Store instance handle in our global variable
   hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
   if (!hWnd)
   {
      return FALSE;
   }
   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);
   return TRUE;
}
//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Обработка сообщений для главного окна.
//
//  WM_COMMAND	- обрабатывает меню приложени
//  WM_PAINT	- Рисует основное окно
//  WM_DESTROY	- Посылает завершающее сообщение и выход
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	int wmId, wmEvent;
	PAINTSTRUCT ps;
	HDC hdc;
	switch (message)
	{
	case WM_COMMAND:
		wmId    = LOWORD(wParam);
		wmEvent = HIWORD(wParam);
		// Сканирует раздел меню:
		switch (wmId)
		{
		case IDM_ABOUT:
			DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
			break;
		case IDM_EXIT:
			DestroyWindow(hWnd);
			break;
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
		}
		break;
	case WM_PAINT:
		hdc = BeginPaint(hWnd, ps);
		// TODO: Добавьте сюда любой "рисующий" код...
		EndPaint(hWnd, ps);
		break;
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;
}
// Дескриптор сообщения окна About.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	UNREFERENCED_PARAMETER(lParam);
	switch (message)
	{
	case WM_INITDIALOG:
		return (INT_PTR)TRUE;
	case WM_COMMAND:
		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
		{
			EndDialog(hDlg, LOWORD(wParam));
			return (INT_PTR)TRUE;
		}
		break;
	}
	return (INT_PTR)FALSE;
}

9.9. Приложение № VI

Примечание: Для создания данного приложения средствами Microsoft Visual Studio 2008 вначале создайте "пустой проект", а затем заполните его этими файлами.

/* stdafx.cpp*/
// stdafx.cpp : исходный файл, который включает в себя стандартные заголовочные файлы.
// textwin.pch будет заголовком предпроцессора
// stdafx.obj будет содержать информацию предварительной компиляции
#include "stdafx.h"
// Поместите сюда всю дополнительную информацию, которая Вам нужна,
// в этот файл, а ни где-либо
/* stdafx.h */
// stdafx.h : заголовочный файл, со стандартными системными заголовочными файлами
// или специфичные для всего проекта часто используемые заголовочные файлы,
// но изменяемые не часто
//
#pragma once
#define WIN32_LEAN_AND_MEAN		// Использовать ранее использованный шаблон заголовков Windows
// Windows Заголовочный файл Windows:
#include <windows.h>
// Общие заголовки языка Си
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
// TODO: Укажите здесь дополнительные заголовочные файлы
// для Вашей программы
/* textwin.h */
#pragma once
#include "resource.h"
/* textwin.cpp*/
// textwin.cpp : Определение точек входа в программу.
//
#include "stdafx.h"
#include "textwin.h"
#define MAX_LOADSTRING 100
// Файлы с описанием функций
#ifndef __STDIO_H
#include <stdio.h>
#endif
#ifndef __STRING_H
#include <string.h>
#endif
/* Глобальные константы */
// Задание максимальной длины символьного буфера строки
// для вывода в окно
#ifndef SCREEN_BUFSIZE
#define SCREEN_BUFSIZE	80
#endif
// Прототип функции для печати строки символов
void Print(HDC, char *, int);
void PrintLn(void);
/* Глобальные переменные */
/**********************************************************
 * cxChar -- значение ширины для самой широкой литеры
 * cyChar -- max высота литеры с учётом междустрочного
 *           интервала.
 * cxCurrentPosition -- текущая гориз. позиция вывода текста
 * cyCurrentPosition -- текущая верт. позиция вывода текста
**********************************************************/
static int cxChar, cyChar;
static int cxCurrentPosition;
static int cyCurrentPosition;
// Global Variables:
HINSTANCE hInst;								// current instance
TCHAR szTitle[MAX_LOADSTRING];					// The title bar text
TCHAR szWindowClass[MAX_LOADSTRING];			// the main window class name
// Далее находятся описания функций, включённых в модули кода
ATOM				MyRegisterClass(HINSTANCE hInstance);
BOOL				InitInstance(HINSTANCE, int);
LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK	About(HWND, UINT, WPARAM, LPARAM);
int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
 	// TODO: Поместите код здесь
	MSG msg;
	HACCEL hAccelTable;
	// Инициализация глобальных строк
	LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
	LoadString(hInstance, IDC_TEXTWIN, szWindowClass, MAX_LOADSTRING);
	MyRegisterClass(hInstance);
	// Подготовка к инициализации приложения:
	if (!InitInstance (hInstance, nCmdShow))
	{
		return FALSE;
	}
	hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_TEXTWIN);
	// Основной цикл сообщений:
	while (GetMessage(msg, NULL, 0, 0))
	{
		if (!TranslateAccelerator(msg.hwnd, hAccelTable, msg))
		{
			TranslateMessage(msg);
			DispatchMessage(msg);
		}
	}
	return (int) msg.wParam;
}
//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Регистрация класса окна.
//
//  COMMENTS:
//
//    Эта функция и её использование необходима только
//    в том случае, если Вы хотите, чтобы этот код
//    был совместим с кодом системы Win32 прежде, чем функция 'RegisterClassEx'
//    была добавлена в Windows 95. Очень важно использовать эту функцию так
//    чтобы это приложение давала "правильно оформленными" иконками, ассоциированных с ними
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
	WNDCLASSEX wcex;
	wcex.cbSize = sizeof(WNDCLASSEX);
	wcex.style			= CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc		= (WNDPROC)WndProc;
	wcex.cbClsExtra		= 0;
	wcex.cbWndExtra		= 0;
	wcex.hInstance			= hInstance;
	wcex.hIcon			= LoadIcon(hInstance, (LPCTSTR)IDI_TEXTWIN);
	wcex.hCursor			= LoadCursor(NULL, IDC_ARROW);
	wcex.hbrBackground		= (HBRUSH)(COLOR_WINDOW+1);
	wcex.lpszMenuName		= (LPCTSTR)IDC_TEXTWIN;
	wcex.lpszClassName		= szWindowClass;
	wcex.hIconSm			= LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);
	return RegisterClassEx(wcex);
}
//
//   FUNCTION: InitInstance(HANDLE, int)
//
//   PURPOSE: Сохраняет экземпляр класса и создаёт основное окно
//
//   COMMENTS:
//
//        В этой функции мы сохраняем дескриптор экземпляр класса в глобальную переменную и
//        создаём и показываем основное окно программы..
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;
   hInst = hInstance;	// Сохраняем дескриптор экземпляра класса 			// в нашу глобальную переменную
   hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
   if (!hWnd)
   {
      return FALSE;
   }
   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);
   return TRUE;
}
//
//  FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
//
//  PURPOSE:  Обработка сообщений для главного окна.
//
//  WM_COMMAND	- обрабатывает меню приложени
//  WM_PAINT	- Рисует основное окно
//  WM_DESTROY	- Посылает завершающее сообщение и выход
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	int wmId, wmEvent;
	PAINTSTRUCT ps;        // структура для рисовани
	HDC hdc;               // индекс контекста устройства
    static TEXTMETRIC tm;  // структура для записи метрик
                           // шрифта
	switch (message)
	{
    case WM_CREATE:
    {
      // Получаем контекст отображения,
      // необходимый для определения метрик шрифта
      hdc = GetDC(hWnd);
      // Заполняем структуру информацией
      // о метрике шрифта, выбранного в
      // контекст отображени
      GetTextMetrics(hdc, tm);
      // Запоминаем значение ширины дл
      // самого широкого символа
      cxChar = tm.tmMaxCharWidth;
      // Запоминаем значение высоты букв с
      // учётом межстрочного интервала
      cyChar = tm.tmHeight + tm.tmExternalLeading;
      // Инициализируем текущую позицию
      // вывода текста
      cxCurrentPosition = cxChar;
      cyCurrentPosition = cyChar;
      // Освобождаем контекст
      ReleaseDC(hWnd, hdc);
      return 0;
    }
	case WM_COMMAND:
		wmId    = LOWORD(wParam);
		wmEvent = HIWORD(wParam);
		// Сканируем секцию меню:
		switch (wmId)
		{
		case IDM_ABOUT:
			DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
			break;
		case IDM_EXIT:
			DestroyWindow(hWnd);
			break;
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
		}
		break;
	case WM_PAINT:
		hdc = BeginPaint(hWnd, ps);
		// TODO: Добавляем код для рисования здесь...
      // Инициализируем текущую позицию
      // вывода текста
      cxCurrentPosition = cxChar;
      cyCurrentPosition = cyChar;
	  // Выводим последовательно строки:
      Print(hdc, "Первая строка", 0); PrintLn();
      Print(hdc, "Вторая строка", 0); PrintLn();
      Print(hdc, "Третья строка( смещённая )", 10); PrintLn();
		EndPaint(hWnd, ps);
		break;
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;
}
// Дескриптор диалогового окна сообщения: About.
LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
	case WM_INITDIALOG:
		return TRUE;
	case WM_COMMAND:
		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
		{
			EndDialog(hDlg, LOWORD(wParam));
			return TRUE;
		}
		break;
	}
	return FALSE;
}
/**********************************************************
 * Функция Print
 * Функция предназначена для вывода текста
 * в окно.
 *
 * ВХОДНЫЕ ЗНАЧЕНИЯ:
 * HDC hdc -- индекс контекста устройства;
 * char *str -- указатель на выводимую строку;
 * int iOFFSET -- смещение горизонтальной позиции
 * вывода текста в окно, указанное в символах;
 *
 * ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ:
 * cxChar -- значение ширины для самой широкой литеры
 * cyChar -- max высота литеры с учётом междустрочного
 *           интервала.
 * cxCurrentPosition -- текущая гориз. позиция вывода текста
 * cyCurrentPosition -- текущая верт. позиция вывода текста
 *
 * ФУНКЦИЯ ВОЗВРАЩАЕТ:
 * 	Возвращаемых значений нет.
 *
 * ПРИМЕЧАНИЕ:
 * Эта функция может быть переписана Вами под Ваши
 * нужды для вывода не только текста, но и числовых
 * значений, а также для форматирования в строке вывода.
 *
**********************************************************/
void Print(HDC hdc, char *str, int iOFFSET )
{
  char buf[SCREEN_BUFSIZE];
  int i;
/* Проверяем смещение на неравенство единице
   и корректируем его */
  if( iOFFSET < 0 ) iOFFSET = 0;
  // Подготавливаем в рабочем буфере
  i = strlen(str);
  // Проверка, что строка умещается в буфере
  if( i < SCREEN_BUFSIZE - 1 )
  // и выводим строку в зависимости от проверки
	sprintf(buf, "%s", str);
  else
	sprintf(buf, "%.*s", SCREEN_BUFSIZE-1, str);
  // Выводим текст в окно, начиная с текущей позиции
  // вывода текста + смещение в максимальном
  // количестве символов
  TextOut(hdc,
    cxCurrentPosition + iOFFSET * cxChar,
    cyCurrentPosition,
    buf, i);
}
/**********************************************************
 * Функция PrintLn
 * Функция предназначена для перевода на новую строку
 * при выводе в окно.
 *
 * ВХОДНЫЕ ЗНАЧЕНИЯ:
 * Не имеет.
 *
 * ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ:
 * cxChar -- значение ширины для самой широкой литеры
 * cyChar -- max высота литеры с учётом междустрочного
 *           интервала.
 * cxCurrentPosition -- текущая гориз. позиция вывода текста
 * cyCurrentPosition -- текущая верт. позиция вывода текста
 *
 * ФУНКЦИЯ ВОЗВРАЩАЕТ:
 * 	Возвращаемых значений нет.
 *
 * ПРИМЕЧАНИЕ:
 * Эта функция может быть переписана Вами под Ваши
 * нужды для вывода не только текста, но и числовых
 * значений, а также для форматирования в строке вывода.
 *
**********************************************************/
void PrintLn( void )
{
  // Увеличиваем текущую позицию по
  // вертикали на высоту символа
  cyCurrentPosition += cyChar;
}