• Приложение без главного окна
• Приложение с главным окном
• Обработка окном сообщений
  • Группы сообщений
  • Таблица сообщений
  • Приложение, обрабатывающее сообщения

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

	// Класс CFirstApp - главный класс приложения.

	// Наследуется от базового класса
 CWinApp.
	class CFirstApp:public CWinApp
	{
	public:
		// Переопределение метода InitInstance,

		// предназначенного для инициализациии приложения.

		virtual BOOL InitInstance();
	};

	// Создание объекта приложения класса CFirstApp.

	CFirstApp theApp;

	// Метод InitInstance

	// Переопределение виртуального метода InitInstance класса CWinApp.

	// Он вызывается каждый раз при запуске приложения.

	BOOL CFirstApp::InitInstance()
	{
		AfxMessageBox("First MFC-application");
		return FALSE;
	}

В этом приложении определен только один класс - CFirstApp, наследованный от базового класса CWinApp . В класс CFirstApp входит метод InitInstance . Кроме того, определена одна глобальная переменная - theApp.

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

	#include <windows.h>
	int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
			LPSTR lpCmdLine, int nShowCmd)
	{
		// Отображение диалоговой панели.

		MessageBox(NULL,"First MFC-application","Message",MB_OK);
		// Завершение работы приложения

		return 0;
	}

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

В приложениях, основанных на классах MFC, функция WinMain скрыта от программиста в определении класса CWinApp . В каждом приложении определяется главный класс приложения, наследуемый от базового класса CWinApp . Приложение должно иметь только один объект главного класса приложения, наследованного от класса CWinApp .

Класс CWinApp выполняет все действия, которые обычно выполняет функция WinMain , - инициализирует приложение, обрабатывает сообщения и завершает приложение. Для этого класс CWinApp включает виртуальные методы InitApplication, InitInstance, Run и ExitInstance .

Чтобы выполнить инициализацию приложения, функция WinMain вызывает методы InitApplication и InitInstance для объекта главного класса приложения. Метод InitApplication выполняет инициализацию на уровне приложения. Программист может переопределить этот метод в своем приложении. Метод InitInstance выполняет инициализацию каждой копии приложения. Обычно этот метод создает главное окно приложения. Программист должен обязательно переопределить этот метод в своем приложении. Остальные методы, например Run, можно не переопределять.

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

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

В случае приложения first главный класс приложения CFirstApp наследуется от базового класса CWinApp . При этом базовый класс указан как public . Это означает, что в программе доступны все элементы базового класса CWinApp , объявленные как public . Можно вызывать методы класса CWinApp для объектов класса CFirstApp и обращаться к элементам данных класса CWinApp .

В объявлении класса CFirstApp объявлен виртуальный метод InitInstance . Этот метод переопределяется в приложении. Изначально метод InitInstance определен в классе CWinApp . Он отвечает за инициализацию приложения. Он вызывается каждый раз, когда пользователь запускает приложение. Если пользователь запустит приложение несколько раз, то метод InitInstance будет вызываться каждый раз.

Сразу после объявления главного класса приложения создается объект theApp этого класса. Объект главного класса приложения должен быть определен как глобальный . В этом случае он будет создан сразу при запуске приложения и сможет управлять всей работой приложения. После создания глобального объекта вызывается функция WinMain , определенная в классе CWinApp . Она выполняет свои обычные функции - регистрирует классы окон, создает окно и т.д.

Метод InitInstance главного класса приложения CFirstApp служит для инициализации. Он вызывается автоматически всякий раз, когда запускается очередная копия приложения. В приложении first метод InitInstance используется для вывода на экран диалоговой панели при помощи функции AfxMessageBox , определенной в MFC.

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

	::MessageBox(NULL,"First MFC-application","Message",MB_OK);

В конце метода InitInstance вызывается оператор return и возвращается значение FALSE. Приложение сразу же завершается. Если метод InitInsatnce вернет значение TRUE, приложение продолжит свою работу и приступит к обработке очереди сообщений.

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

Точно так же, как и в приложении first, во втором приложении используется класс CWinApp в качестве главного класса приложения. Для управления окном приложения создается еще один класс, наследуемый от базового класса CFrameWnd, входящего в библиотеку MFC.

Файл start.h

	#include <afxwin.h>
	class CStartApp: public CWinApp
	{
		public:
		virtual BOOL InitInstance();
	};
Файл startm.h

	#include <afxwin.h>
	// Класс CMainWindow - представляет главное окно приложения.

	class CMainWindow : public CFrameWnd
	{
	public:
		CMainWindow();
	};
Файл start.cpp

	#include <afxwin.h>
	#include "start.h"
	#include "startm.h"
	BOOL CStartApp::InitInstance()
	{
		// Создание объекта класса CMainWindow

		m_pMainWnd= new CMainWindow();
		// Отображение окна на экране.
		// Параметр m_nCmdShow определяет режим отображения окна.

		m_pMainWnd->ShowWindow(m_nCmdShow);
		// Обновление содержимого окна.

		m_pMainWnd->UpdateWindow();
		return TRUE;
	}
	CStartApp theApp;
Файл startm.cpp

	#include <afxwin.h>
	#include "startm.h"
	// Конструктор класса CMainWindow

	CMainWindow::CMainWindow()
	{
		// Создание окна приложения

		Create(NULL,"Hello");
	}

В исходных текстах определяется главный класс CStartApp приложения, который наследуется от базового класса CWinApp . При этом базовый класс указан как public . Можно вызывать методы класса CWinApp для объектов класса CStartApp и обращаться к элементам данных класса CWinApp .

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

Второй класс, класс CMainWindow, наследуется от базового класса CFrameWnd как public и представляет главное окно приложения. В классе главного окна определяется только конструктор.

В данном приложении метод InitInstance используется для отображения на экране окна приложения. Для этого создается объект класса CMainWindow и записывается указатель на этот объект в элемент данных m_pMainWnd класса CWinThread (этот класс является базовым для класса CWinApp ). Таким образом, объект приложения и объект окна приложения связываются вместе.

Само окно появится на экране только после того, как будет вызван метод ShowWindow . В качестве параметра методу ShowWindow передается значение m_nCmdShow . Переменная m_nCmdShow является элементом класса CWinApp . Его назначение соответствует параметру функции WinMain , который определяет, как должно отображаться главное окно приложения сразу после его запуска.

После появления окна на экране ему передается сообщение WM_PAINT при помощи вызова метода UpdateWindow . По этому сообщению приложение должно обновить содержимое окна.

В конце метода InitInstance вызывается оператор return и возвращается значение TRUE, означающее, что инициализация приложения завершилась успешно и можно приступать к обработке очереди сообщений (eсли метод InitInstance вернет значение FALSE, приложение немедленно завершится; эта возможность использовалась в приложении first).

Для создания окна приложения создается объект класса CMainWindow. Такой объект - это не окно, которое пользователь видит на экране компьютера . Этот объект является внутренним представлением окна . Для создания окна предназначается метод Create , определенный в классе CFrameWnd . Он создает окно и связывает его с объектом C++, в случае приложения start - с объектом класса CMainWindow. Метод Create вызывается в конструкторе класса CMainWindow.

Приложение в цикле, который называется циклом обработки сообщений , получает сообщения из очереди приложения и направляет их соответствующей функции окна, которая и выполняет обработку сообщения. Цикл обработки сообщений в традиционной Windows-программе обычно состоял из оператора while, в котором циклически вызывались функции GetMessage и DispatchMessage. Для более сложных приложений цикл обработки сообщений содержал вызовы других функций (TranslateMess age, TranslateAccelerator). Они обеспечивали предварительную обработку сообщений.

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

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

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

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

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

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

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

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

	BEGIN_MESSAGE_MAP(ИмяКласса,ИмяБазовогоКласса
)
		// макросы

	END_MESSAGE_MAP()

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

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

Макрокоманда ON_WM_<name>. Обрабатывает стандартные сообщения операционной системы Windows. Вместо <name> указывается имя сообщения без префикса WM_. Например:

	ON_WM_CREATE()

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

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

	ON_REGISTERED_MESSAGE(nMessageVariable, memberFxn)

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

	ON_MESSAGE(message,memberFxn)

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

	ON_COMMAND(id,memberFxn)

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

	ON_COMMAND_RANGE(id1,id2,memberFxn)

	ON_UPDATE_COMMAND_UI(id,memberFxn)

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

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

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

	ON_UPDATE_COMMAND_UI_RANGE(id1,id2,memberFxn)

	ON_BN_CLICKED(id,memberFxn)

	ON_CONTROL_RANGE(wNotifyCode,id1,id2,memberFxn)

Файл resource.h

	#define IDR_MENU		101
	#define ID_TEST_BEEP	40001
	#define ID_TEST_EXIT	40002
Файл resource.rc

	#include "resource.h"
	IDR_MENU MENU DISCARDABLE 
	BEGIN
		POPUP "Test"
		BEGIN
			MENUITEM "Beep",	ID_TEST_BEEP
			MENUITEM SEPARATOR
			MENUITEM "Exit",	ID_TEST_EXIT
		END
	END

Файл menu.h

	#include <afxwin.h>
	class CMenuApp: public CWinApp
	{
	public:
		virtual BOOL InitInstance();
	};
Файл menu.cpp

	#include <afxwin.h>
	#include "menu.h"
	#include "menum.h"
	BOOL CMenuApp::InitInstance()
	{
		m_pMainWnd= new CMainWindow();
		m_pMainWnd->ShowWindow(m_nCmdShow);
		m_pMainWnd->UpdateWindow();
		return TRUE;
	}
	CMenuApp theApp;
Файл menum.h

	#include <afxwin.h>
	class CMainWindow : public CFrameWnd
	{
	public:
		CMainWindow();
		afx_msg void TestBeep();
		afx_msg void TestExit();
		// макрокоманда необходима, так как класс обрабатывает сообщения

		DECLARE_MESSAGE_MAP()
	};
Файл menum.cpp

	#include <afxwin.h>
	#include "menum.h"
	#include "resource.h"
	// Таблица сообщений класса

	BEGIN_MESSAGE_MAP(CMainWindow,CFrameWnd)
		ON_COMMAND(ID_TEST_BEEP,TestBeep)
		ON_COMMAND(ID_TEST_EXIT,TestExit)
	END_MESSAGE_MAP()
	CMainWindow::CMainWindow()
	{
		Create(NULL,"Hello",WS_OVERLAPPEDWINDOW,rectDefault,
			NULL,MAKEINTRESOURCE(IDR_MENU));
	}
	void CMainWindow::TestBeep()// Метод TestBeep - обрабатывает команду меню

	{
		MessageBeep(0);
	}
	void CMainWindow::TestExit()// Метод TestExit - обрабатывает команду меню

	{
		DestroyWindow();
	}

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

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

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

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