Microsoft visual C++ и MFC.

Обработка сообщений

Как вы знаете из предыдущих томов серии “Библиотека системного программиста”, работа приложений операционной системы Windows основана на обработке сообщений. Когда пользователь работает с устройствами ввода/вывода компьютера, например клавиатурой или мышью, драйверы этих устройств создают сообщения, описывающие его действия. Каждое нажатие на клавиши клавиатуры вызывает генерацию ряда сообщений, определяющих, какая клавиша нажата. Перемещение мыши вызывает сообщения, описывающие траекторию перемещения указателя мыши и т. д. Другие сообщения могут вырабатываться операционной системой или самими приложениями.

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

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


MSG message;
while(GetMessage(&message, 0, 0, 0))
{
	DispatchMessage(&message);
}

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

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

Функция обработки, сообщения опознает, какое именно сообщение поступило для обработки и выполняет соответствующие действия. Сообщения распознаются по его коду. Обычно функция окна содержит оператор switch, который служит для определения кода сообщений. Вот пример типичной функции окна:


long FAR PASCAL _export 
WndProc(HWND hWnd, UINT message, UINT wParam, LONG lParam)
	{
	HDC			hdc ;
	PAINTSTRUCT	ps ;
	RECT			rect ;

	switch(message)
	{
		case WM_PAINT:
			hdc = BeginPaint(hWnd, &ps) ;

			GetClientRect(hWnd, &rect) ;

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

			EndPaint(hWnd, &ps) ;
			return 0 ;

		case WM_DESTROY:
			PostQuitMessage(0) ;
			return 0 ;
	}

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

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

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

Если вы используете библиотеку классов MFC, то за обработку сообщений отвечают классы. Любой класс, наследованный от базового класса CCmdTarget XE "CCmdTarget" , может обрабатывать сообщения. Чтобы класс смог обрабатывать сообщения, необходимо, чтобы он имел таблицу сообщений XE "таблица сообщений" класса. В этой таблице для каждого сообщения указан метод класса, предназначенный для его обработки.

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

· оконные сообщения XE "оконные сообщения" ;

· сообщения от органов управления XE "сообщения от органов управления" ;

· команды XE "команды"

Оконные сообщения

Эта группа включает сообщения, предназначенные для обработкой функцией окна. Практически все сообщения, идентификаторы которых начинаются префиксом WM_, за исключением сообщения WM_COMMAND XE "WM_COMMAND" , относятся к этой группе.

Оконные сообщения предназначаются для обработки объектами, представляющими окна. Это могут быть практически любые объекты класса CWnd XE "CWnd" или классов, наследованных от него, например CFrameWnd XE "CFrameWnd" , CMDIFrameWnd XE "CMDIFrameWnd" , CMDIChildWnd XE "CMDIChildWnd" , CView XE "CView" , CDialog XE "CDialog" . Характерной чертой этих классов является то, что они включают идентификатор окна.

Большинство этих сообщений имеют параметры, детально характеризующие сообщение. Например сообщение WM_SIZE XE "WM_SIZE" передается окну, когда пользователь меняет его размер и имеет параметры, определяющие новый размер окна.

Сообщения от органов управления

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

Исключение составляет сообщение WM_COMMAND с кодом извещения BN_CLICKED XE "BN_CLICKED" . Это сообщение передается кнопкой, когда пользователь на нее нажимает. Обработка сообщений с кодом извещения BN_CLICKED от органов управления происходит аналогично обработке командных сообщений.

Командные сообщения

Сообщения WM_COMMAND XE "WM_COMMAND" от меню, кнопок панели управления и клавиш акселераторов. В отличие от оконных сообщений и сообщений от органов управления, командные сообщения могут быть обработаны более широким спектром объектов. Эти сообщения обрабатывают не только объекты, представляющие окна, но также объекты классов, представляющих приложение, документы и шаблон документов.

Характерной особенностью командных сообщений является идентификатор. Идентификатор командного сообщения определяет объект, который вырабатывает (посылает) данное сообщение.

В приложении MFMenu строка Beep меню Test имеет идентификатор ID_TEST_BEEP. Когда пользователь выберет данную строку, в очередь приложения поступит сообщение WM_COMMAND с идентификатором ID_TEST_BEEP или другими словами, командное сообщение ID_TEST_BEEP.

Таблица сообщений

В библиотеке классов MFC для обработки сообщений используется специальный механизм, который получил название Message Map XE "message map" - таблица сообщений XE "таблица сообщений" .

Таблица сообщений состоит из набора специальных макрокоманд, ограниченных макрокомандами BEGIN_MESSAGE_MAP XE "BEGIN_MESSAGE_MAP" и END_MESSAGE_MAP XE "END_MESSAGE_MAP" . Между ними расположены макрокоманды, отвечающие за обработку отдельных сообщений.

Макрокоманда BEGIN_MESSAGE_MAP представляет собой заголовок таблицы сообщений. Она имеет два параметра. Первый параметр содержит имя класса таблицы сообщений. Второй параметр указывает его базовый класс.

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

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

· Стандартные сообщения Windows обрабатываются функцией “default window procedure”

· Командные сообщения передаются по цепочке следующему объекту, который может обработать командное сообщение. Более подробно мы расскажем об этой цепочке в главах “Однооконный интерфейс” и “Многооконный интерфейс”

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

Макрокоманда	Устанавливает методы для обработки сообщений
ON_WM_ XE "ON_WM_" <name>	Стандартных сообщений операционной системы Windows
ON_REGISTERED_MESSAGE XE "ON_REGISTERED_MESSAGE"	Зарегистрированные сообщения операционной системы Windows
ON_MESSAGE XE "ON_MESSAGE"	Сообщений, определенных пользователем
ON_COMMAND XE "ON_COMMAND" , ON_COMMAND_RANGE XE "ON_COMMAND_RANGE"	Командных сообщений
ON_UPDATE_COMMAND_UI XE "ON_UPDATE_COMMAND_UI" , ON_UPDATE_COMMAND_UI_RANGE XE "ON_UPDATE_COMMAND_UI_RANGE"	Сообщений, предназначенных для обновления пользовательского интерфейса
ON_ XE "ON_" <name>, ON_CONTROL_RANGE XE "ON_CONTROL_RANGE"	Сообщений от органов управления

Перечисленные в таблице макрокоманды имеют различное количество параметров в зависимости от типа обрабатываемых ими сообщений.

Макрокоманда ON_WM_ XE "ON_WM_" <name>

Обрабатывает стандартные сообщения операционной системы Windows. Вместо <name> указывается имя сообщения без префикса WM_. Так, например для обработки сообщения WM_SIZE XE "WM_SIZE" предназначена макрокоманда ON_WM_SIZE.

Для обработки сообщений, определенных в таблице сообщений макрокомандами ON_WM_<name>, вызываются одноименные методы. Имя метода обработчика соответствует названию сообщения, без учета префикса WM_.

В классе CWnd XE "CWnd" определены обработчики для стандартных сообщений. Эти обработчики будут использоваться по умолчанию. Вот некоторые из таких методов.

Сообщение	Макрокоманда	Метод обработчик
WM_CHAR	ON_WM_CHAR()	afx_msg void OnChar(UINT, UINT, UINT);
WM_CREATE	ON_WM_CREATE()	afx_msg int OnCreate(LPCREATESTRUCT );
WM_HSCROLL	ON_WM_HSCROLL()	afx_msg void OnHScroll(UINT, UINT, CWnd*);
WM_KEYDOWN	ON_WM_KEYDOWN()	afx_msg void OnKeyDown(UINT, UINT, UINT);
WM_KEYUP	ON_WM_KEYUP()	afx_msg void OnKeyUp(UINT, UINT, UINT);
WM_LBUTTONDOWN	ON_WM_LBUTTONDOWN()	afx_msg void OnLButtonDown(UINT, CPoint);
WM_LBUTTONUP	ON_WM_LBUTTONUP()	afx_msg void OnLButtonUp(UINT, CPoint);
WM_PAINT	ON_WM_PAINT()	afx_msg void OnPaint();
WM_SIZE	ON_WM_SIZE()	afx_msg void OnSize(UINT, int, int);
WM_TIMER	ON_WM_TIMER()	afx_msg void OnTimer(UINT);
WM_VSCROLL	ON_WM_VSCROLL()	afx_msg void OnVScroll(UINT, UINT, CWnd*);

Все методы-обработчики определены с ключевым словом afx_msg. Оно позволяет отличить эти методы от остальных методов класса. На этапе препроцессорной обработки ключевое слово afx_msg удаляется. Определение afx_msg вы можете найти в файле afxwin.h:

#define afx_msg XE "afx_msg"

Макрокоманды ON_WM_<name> не имеют параметров. Однако методы, которые вызываются для обработки соответствующих сообщений, имеют параметры, количество и назначение которых зависит от обрабатываемого сообщения.

Когда вы определяете обработчик стандартного сообщения Windows в своем классе, он будет использоваться вместо обработчика определенного в классе CWnd (или другом базовом классе). В любом случае вы можете вызвать метод обработчик базового класса из своего метода обработчика.

Макрокоманда ON_REGISTERED_MESSAGE

Макрокоманда ON_REGISTERED_MESSAGE XE "ON_REGISTERED_MESSAGE" обслуживает сообщения операционной системы Windows, зарегистрированные с помощью функции RegisterWindowMessage. Параметр nMessageVariable указывает идентификатор сообщения, для которого будет вызываться метод memberFxn.


ON_REGISTERED_MESSAGE(nMessageVariable, memberFxn)

Макрокоманда ON_MESSAGE

Макрокоманда ON_MESSAGE XE "ON_MESSAGE" обрабатывает сообщения, определенные пользователем. Идентификатор сообщения (его имя) указывается параметром message. Метод, который вызывается для обработки сообщения, указывается параметром memberFxn.

ON_MESSAGE(message, memberFxn)

Макрокоманда ON_COMMAND

Макрокоманды ON_COMMAND XE "ON_COMMAND" предназначены для обработки командных сообщений. Командные сообщения поступают от меню, кнопок панели управления и клавиш акселераторов. Характерной особенностью командных сообщений является то, что с ними связан идентификатор сообщения.

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

ON_COMMAND(id, memberFxn)

В общем случае командные сообщения не имеют обработчиков, используемых по умолчанию. Существует только небольшая группа стандартных командных сообщений, имеющих методы обработчики, вызываемые по умолчанию. Эти сообщения соответствуют стандартным строкам меню приложения. Так, например, если вы (или MFC AppWizard) присвоите строке Open меню File идентификатор ID_FILE_OPEN, то для его обработки будет вызван метод OnFileOpen, определенный в классе CWinApp. Список стандартных командных сообщений и их описание представлены в главах “Однооконный интерфейс” и “Многооконный интерфейс”.

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

Макрокоманда ON_COMMAND_RANGE

Макрокоманда ON_COMMAND ставит в соответствие одному командному сообщению один метод-обработчик. В некоторых случаях более удобно, когда один и тот же метод-обработчик применяется для обработки сразу нескольких командных сообщений с различными идентификаторами. Для этого предназначена макрокоманда ON_COMMAND_RANGE XE "ON_COMMAND_RANGE" .

Она назначает один метод memberFxn для обработки ряда командных сообщений, идентификаторы которых лежат в интервале от id1 до id2.

ON_COMMAND_RANGE(id1, id2, memberFxn)

Макрокоманда ON_UPDATE_COMMAND_UI

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

Параметр id указывает идентификатор сообщения, а параметр memberFxn имя метода для его обработки.

ON_UPDATE_COMMAND_UI(id, memberFxn)

Методы, предназначенные для обработки данного класса сообщений, должны быть определены с ключевым словом afx_msg XE "afx_msg" и иметь один параметр - указатель на объект класса CCmdUI XE "CCmdUI" . Для удобства, имена методов, предназначенных для обновления пользовательского интерфейса, начинаются с OnUpdate:

afx_msg void OnUpdate<имя_обработчика>(CCmdUI* pCmdUI);

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

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

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

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

Дополнительную информацию об обновлении пользовательского интерфейса приложения вы можете получить в разделе “Однооконный интерфейс”.

Макрокоманда ON_UPDATE_COMMAND_UI_RANGE

Макрокоманда ON_UPDATE_COMMAND_UI_RANGE XE "ON_UPDATE_COMMAND_UI_RANGE" обеспечивает обработку сообщений, предназначенных для обновления пользовательского интерфейса, идентификаторы которых лежат в интервале от id1 до id2. Параметр memberFxn указывает метод используемый для обработки.

ON_UPDATE_COMMAND_UI_RANGE(id1, id2, memberFxn)

Макрокоманда ON_<name>

Макрокоманды ON_ XE "ON_" <name> предназначены для обработки сообщений от органов управления. Такие сообщения могут передаваться органами управления диалоговой панели. Сообщения от органов управления не имеют обработчиков, используемых по умолчанию. При необходимости вы должны определить их самостоятельно.

Все макрокоманды ON_<name> имеют два параметра. В первом параметре id указывается идентификатор органа управления. Сообщения от этого органа управления будут обрабатываться методом memberFxn.

 ON_BN_CLICKED(id, memberFxn)

Макрокоманда ON_CONTROL_RANGE

Макрокоманда ON_CONTROL_RANGE XE "ON_CONTROL_RANGE" обрабатывает сообщения, идентификаторы которых находятся в интервале от id1 до id2. Параметр wNotifyCode содержит код извещения. Метод-обработчик указывается параметром memberFxn.

ON_CONTROL_RANGE(wNotifyCode, id1, id2, memberFxn)

Забегая вперед

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

Однако ClassWizard не всесилен. Так он не позволяет определить один метод для обработки нескольких сообщений. Как вы уже знаете, для этих целей предназначены макрокоманды ON_COMMAND_RANGE и ON_CONTROL_RANGE. Если вы решите воспользоваться этими макрокомандами, вам придется редактировать таблицу сообщений непосредственно, без использования ClassWizard.

Более подробно об использовании ClassWizard для создания обработчиков сообщений вы можете прочитать в разделе “Средства ClassWizard” главы “Приложение с главной диалоговой панелью”. А сейчас мы рассмотрим механизм обработки сообщений, используемый MFC, на примере нескольких приложений.

Приложение MFMenu

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

Сейчас мы рассмотрим приложение MFMenu, которое имеет меню и содержит обработчики сообщений, передаваемых приложению, когда пользователь открывает меню и выбирает из него строки. Для создания приложения MFMenu мы также не станем пользоваться средствами автоматизированной разработки MFC AppWizard, и наберем текст приложения вручную. Этот позволит вам лучше разобраться с механизмом сообщений.

Создайте новый проект под названием MFMenu. В качестве типа приложения выберите из списка Type строку Application (рис. 4.1 из главы “Приложение с главной диалоговой панелью”). Наберите в редакторе исходный текст приложения и сохраните его в файле MFMenu.cpp (листинг 2.7). Чтобы быстрее набрать текст приложения, вы можете получить его, изменив исходный текст приложения MFStart. Затем включите этот файл в проект.

Листинг 2.7. Файл MFMenu.cpp


// Включаемый файл для MFC
#include <afxwin.h>
#include "MFMenuRes.h"

//===================================================== 
// Класс CMFMenuApp - главный класс приложения 
//===================================================== 
class CMFMenuApp : public CWinApp
{
public:
	// Мы будем переопределять метод InitInstance,
	// предназначенный для инициализации приложения
	virtual BOOL InitInstance();
};
 
// Создаем объект приложение класса CMFMenuApp
CMFMenuApp MFMenuApp;
 
//===================================================== 
// Класс CMFMenuWindow - представляет главное окно 
//===================================================== 
class CMFMenuWindow : public CFrameWnd
{
public:
	// Объявляем конструктор класса CMFMenuWindow
	CMFMenuWindow();

	// Объявляем методы для обработки команд меню
	afx_msg void MenuCommand();
	afx_msg void ExitApp();

	// Макрокоманда необходима, так как класс 
	// CMFMenuWindow обрабатывает сообщения
	DECLARE_MESSAGE_MAP()    
}; 

//===================================================== 
// Метод MenuCommand
// Обрабатывает команду ID_TEST_BEEP
//===================================================== 
void CMFMenuWindow::MenuCommand()
{
	MessageBeep(0);	
}

//===================================================== 
// Метод ExitApp
//===================================================== 
void CMFMenuWindow::ExitApp()
{
	DestroyWindow();
}

//===================================================== 
// Таблица сообщений класса CMFMenuWindow
//===================================================== 
BEGIN_MESSAGE_MAP(CMFMenuWindow, CFrameWnd)
	ON_COMMAND(ID_TEST_BEEP, MenuCommand)
	ON_COMMAND(ID_TEST_EXIT, ExitApp)
END_MESSAGE_MAP()

//===================================================== 
// Метод InitInstance класса CMFMenuApp
//===================================================== 
BOOL CMFMenuApp::InitInstance()
{
	// Создаем объект класса CMFMenuWindow
	m_pMainWnd = new CMFMenuWindow();

	// Отображаем окно на экране
	m_pMainWnd -> ShowWindow(m_nCmdShow);

	// Обновляем содержимое окна
	m_pMainWnd -> UpdateWindow();
	return TRUE;
}

//===================================================== 
// Конструктор класса CMFMenuWindow
//===================================================== 
CMFMenuWindow::CMFMenuWindow()
{ 
	// Создаем окно приложения, соответствующее 
	// данному объекту класса CMFMenuWindow
	Create(NULL, "Hello MFC", WS_OVERLAPPEDWINDOW,
			rectDefault, NULL, MAKEINTRESOURCE(IDR_MENU)); 
}

Ресурсы приложения

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

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

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

Среда Visual C++ версии 4.0 не только позволяет просматривать и редактировать ресурсы приложения, она позволяет сразу после создания ресурса вызвать ClassWizard и подключить к ресурсу управляющий программный код. Пока мы не будем использовать ClassWizard, а код, управляющий ресурсами приложения, создадим вручную.

Создание меню для приложения MFMenu

Так как наше приложение будет содержать меню, мы приступим к созданию ресурсов приложения. Для этого создайте новый файл ресурсов. Выберите из меню File строку New, а затем из открывшейся диалоговой панели выберите строку Resource Script и нажмите кнопку OK.

Теперь надо создать меню. Выберите из меню Insert строку Resource. На экране появится диалоговая панель Insert Resource. Выберите из нее строку Menu и нажмите кнопку OK. Вы сможете в диалоговом режиме разработать меню. Чтобы быстрее перейти к редактированию меню, вы можете нажать кнопку New Menu () из панели управления Project или просто нажать комбинацию кнопок <Ctrl+2>.

Создайте меню, содержащее единственную строку Test, при выборе которой открывается меню, содержащее три строки - Beep и Exit. Внешний вид меню во время разработки представлен на рисунке 2.22.

Рис. 2.22. Разработка меню приложения

Когда вы создаете новое меню верхнего уровня или определяете строки, входящие в это меню, на экране появляется диалоговое окно Menu Item Properties (рис. 2.23). В нем полностью описывается выбранный элемент меню. В поле Caption задается название меню или строки меню. В названии вы можете вставить символ &. Он будет означать, что символ, следующий за ним, можно будет использовать для быстрого выбора данного элемента меню. Например, если перед названием строки меню Beep поставить символ &, то во время работы приложения символ B будет отображаться с подчеркиванием, и строку Beep можно будет выбрать, нажав комбинацию клавиш <Alt+B>.

Рис. 2.23. Диалоговая панель Menu Item Properties

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

Редактор ресурсов сам предлагает вам название идентификатора, создавая его из названия главного меню и строки меню. Так например строке Beep меню Test по умолчанию будет присвоен идентификатор ID_TEST_BEEP.

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

Если вы разрабатываете приложение с помощью средств MFC AppWizard, то при выборе пользователем строк меню их описание будет появляться в панели состояния StatusBar. Что интересно, для этого вам не потребуется написать ни одной строки текста программы. Это будет сделано автоматически благодаря возможностям библиотеки классов MFC и MFC AppWizard.

Остальные переключатели диалоговой панели Menu Item Properties описаны в следующей таблице.

Переключатель	Описание
Break	Этот переключатель может принимать три различных значения - None, Column и Bar. Он позволяет задать структуру меню. По умолчанию выбрано значение None оно соответствует нормальному виду меню без деления на колонки. Если выбрать значение Column, тогда пункт меню будет размещен в новом столбце. Значение Bar соответствует Column, за исключением меню верхнего уровня. Если указать Bar для меню верхнего уровня, то новая колонка будет отделена от старой вертикальной линией
Checked	Если установить переключатель, то строка меню будет выделена символом . Потом, обращаясь к специальным методам, вы сможете удалять или отображать этот символ
Grayed	Если включить переключатель Grayed, тогда пункт меню будет отображаться серым цветом и будет недоступен для выбора пользователем. Такая возможность удобна, если вам надо сделать недоступным какие-либо возможности приложения. Впоследствии приложение может сделать пункт меню доступным. Для этого надо вызвать соответствующий метод
Help	Если установить переключатель Help, тогда для него будет установлено выравнивание по правому краю. Обычно этот переключатель устанавливают для меню верхнего уровня, которое управляет справочной системной приложения
Inactive	Если включен переключатель Grayed, тогда переключатель недоступен. В противном случае вы можете установить переключатель Inactive. В этом случае пункт меню будет неактивен
Pop-up	Вы можете создавать многоуровневые меню. Если вы включите переключатель Pop-up, то данный пункт меню будет являться меню верхнего уровня, которое можно открыть. По умолчанию, все пункты главного меню имеют установленный переключатель Pop-up. Так как меню верхнего уровня служит только для объединения других пунктов меню, то оно не имеет идентификатора
Separator	Если переключатель установлен, тогда в меню вставляется разделитель. Для разделителя все остальные поля и переключатели диалоговой панели не используются

Сохраните файл ресурсов в файле с именем MFMenu.rc. Редактор ресурсов создает кроме самого файла ресурсов еще включаемый файл, в котором определяются константы, используемые в файле ресурсов. В нашем случае в нем определяются идентификаторы меню приложения. По умолчанию этот файл сохраняется под именем resource.h XE "resource.h" . Вы можете изменить его, выбрав из меню View строку Resource Includes. Для нашего приложения мы изменили имя включаемого файла для ресурсов на MFMenuRes.h. Содержимое этого файла представлено листингом 2.8.

Листинг 2.8. Файл MFMenuRes.h


//{{NO_DEPENDENCIES}}
// Включаемый файл, созданный Microsoft Developer Studio
// Используется в файле ресурсов MFMenu.rc
//
#define IDR_MENU                        101
#define ID_TEST_BEEP                    40001
#define ID_TEST_EXIT                    40002

// Следующие значения идентификаторов используются по 
// умолчанию для новых объектов
#ifdef APSTUDIO_INVOKED
	#ifndef APSTUDIO_READONLY_SYMBOLS
		#define _APS_NEXT_RESOURCE_VALUE        102
		#define _APS_NEXT_COMMAND_VALUE         40003
		#define _APS_NEXT_CONTROL_VALUE         1000
		#define _APS_NEXT_SYMED_VALUE           101
	#endif
#endif

В листинге 2.9 мы привели файл ресурсов MFMenuRes.rc приложения. Этот файл был подготовлен редактором ресурсов Visual C++. Одна из первых строк файла содержит директиву #include которой подключается файл MFMenuRes.h, содержащий описание идентификаторов ресурсов (листинг 2.8).

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

Листинг 2.9. Файл MFMenuRes.rc


// Файл описания ресурсов приложения, созданный 
// Microsoft Developer Studio
#include "MFMenuRes.h"

#define APSTUDIO_READONLY_SYMBOLS
//////////////////////////////////////////////////////////////
// Включаем файл afxres.h, содержащий определения стандартных 
// идентификаторов
#include "afxres.h"

//////////////////////////////////////////////////////////////
#undef APSTUDIO_READONLY_SYMBOLS

//////////////////////////////////////////////////////////////
// Руссификацированные ресурсы
#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_RUS)
	#ifdef _WIN32
		LANGUAGE LANG_RUSSIAN, SUBLANG_DEFAULT
		#pragma code_page(1251)
	#endif //_WIN32

	////////////////////////////////////////////////////////////	// Меню
	//
	IDR_MENU MENU DISCARDABLE 
	BEGIN
		POPUP "Test"
		BEGIN
			MENUITEM "Beep",                        ID_TEST_BEEP
			MENUITEM SEPARATOR
			MENUITEM "Exit",                        ID_TEST_EXIT
		END
	END

	#ifdef APSTUDIO_INVOKED
		
		////////////////////////////////////////////////////////
		// Ресурсы TEXTINCLUDE
		//
		1 TEXTINCLUDE DISCARDABLE 
		BEGIN
			"MFMenuRes.h\0"
		END

		2 TEXTINCLUDE DISCARDABLE 
		BEGIN
			"#include ""afxres.h""\r\n"
			"\0"
		END

		3 TEXTINCLUDE DISCARDABLE 
		BEGIN
			"\r\n"
			"\0\"
		END

	#endif    	// APSTUDIO_INVOKED

#endif    		// Руссификацированные ресурсы

//////////////////////////////////////////////////////////////
#ifndef APSTUDIO_INVOKED
#endif

Когда вы создадите ресурсы приложения и включите файл ресурсов в проект обратите внимание на окно Project Workspace. В нем появится еще одна, четвертая страница ResourceView (рис. 2.24). Эта страница показывает все ресурсы, входящие в проект. В приложении MFMenu определен только один ресурс - меню, имеющее идентификатор IDR_MENU.

Вы можете быстро перейти к редактированию меню, если выберите его идентификатор и щелкните два раза левой кнопкой мыши.

Рис. 2.24. Страница ResourceView окна Project Workspace

Теперь проект готов. Вы можете построить его и запустить полученное приложение MFMenu. Внешний вид приложения представлен на рисунке 2.25. Как видите окно приложения имеет меню Test, состоящее из двух строк - Beep и Exit.

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

Когда вы завершите работу с приложением, его можно закрыть. Для этого воспользуйтесь системным меню приложения или выберите из меню Test строку Exit.

Рис. 2.25. Приложение MFMenu

Чтобы объекты класса могли обрабатывать сообщения, в определении этого класса необходимо поместить макрокоманду DECLARE_MESSAGE_MAP. По принятым соглашениям эта макрокоманда должна записываться в конце определения класса в секции public.


//===================================================== 
// Класс CMFMenuWindow - представляет главное окно 
//===================================================== 
class CMFMenuWindow : public CFrameWnd
{
public:
	// Объявляем конструктор класса CMFMenuWindow
	CMFMenuWindow();

	// Объявляем методы для обработки команд меню
	afx_msg void MenuCommand();
	afx_msg void ExitApp();

	// Макрокоманда необходима, так как класс 
	// CMFMenuWindow обрабатывает сообщения
	DECLARE_MESSAGE_MAP()    
};

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

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

Приложение MFMenu обрабатывает только две команды от меню приложения. Первая команда имеет идентификатор ID_TEST_BEEP и передается, когда пользователь выбирает из меню Test строку Beep. Для обработки этой команды вызывается метод MenuCommand. Вторая команда с идентификатором ID_TEST_EXIT передается приложению, когда пользователь выбирает из меню Test строку Exit. Обработка этого сообщения выполняется методом ExitApp.


//===================================================== 
// Таблица сообщений класса CMFMenuWindow
//===================================================== 
BEGIN_MESSAGE_MAP(CMFMenuWindow, CFrameWnd)
	ON_COMMAND(ID_TEST_BEEP, MenuCommand)
	ON_COMMAND(ID_TEST_EXIT, ExitApp)
END_MESSAGE_MAP()

Конечно, приложению MFMenu может поступать гораздо больше сообщений и команд, чем указано в таблице сообщений класса CMFMenuWindow. Необработанные сообщения передаются для обработки базовому классу CMFMenuWindow - классу CFrameWnd XE "CFrameWnd" . Класс, который будет обрабатывать сообщения, не указанные в таблице сообщений, указывается во втором параметре макрокоманды BEGIN_MESSAGE_MAP.