Библиотека классов MFC

Элементы управления Windows

В данном пункте рассмотрим подробнее стандартные элементы управления.

Списки

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

Прием идентификационных кодов списка

Список может генерировать сообщения различных типов. Например, сообщения посылаются при двойном щелчке на элементе списка, при потере списком фокуса ввода и при выборе другого элемента из списка. Каждое такое событие описывается идентификационным кодом. Этот код является частью сообщения WM_COMMAND. Некоторые другие элементы также используют идентификационные коды. Рассмотрим код LBN_DBLCLK. Он посылается, когда пользователь выполняет двойной щелчок на элементе списка. При определении списка в ресурсах должна быть установлена опция Notify, чтобы он мог генерировать это сообщение. Когда выбор произведен, необходимо запросить список, чтобы узнать о том, какой элемент выбран. Для обработки сообщения LBN_DBLCLK необходимо поместить его обработчик в карту сообщений. Но это будет не макрос ON_COMMAND(). Вместо этого используются специальные макрокоманды. Для нашего сообщения это будет ON_LBN_DBLCLK(). Она имеет такой вид:

ON_LBN_DBLCLK (ИдентификаторСписка, ИмяОбработчика)

Многие сообщения обрабатываются подобным образом. Названия всех макросов для таких сообщений начинаются с префикса ON_LBN_.

Передача сообщений списку

В традиционных Windows-программах сообщения посылаются элементам управления с помощью API-функций, например SendDlgItemMessage(). Но, в программах на MFC, для этих целей применяются соответствующие функции-члены класса. Эти функции автоматически посылают необходимое сообщение элементу управления. В этом заключается преимущество использования MFC по сравнению с традиционным методом программирования. Списку может быть послано несколько разных сообщений. Для каждого сообщения класс CListBox содержит отдельный член-функцию класса. Например, рассмотрим следующие функции:

int CListBox::AddString(LPCSTR StringToAdd);
int CListBox::GetCurSel() const;
int CListBox::GetText(int Index, LPCSTR StringVariable);

Функция AddString(…) вставляет указанную строку в список. По умолчанию, она вставляется в конец списка, при этом, начало списка имеет индекс 0. Функция GetCurSel() возвращает индекс текущего выделенного элемента. Если ни один элемент не выбран, то функция возвращает LB_ERR. Функция GetText(…) получает строку, связанную с указанным индексом. Строка копируется в символьный массив по адресу StringVariable.

Получение указателя на список

Функции CListBox работают с объектами CListBox. Поэтому, необходимо получить указатель на объект списка, что делается с помощью функции GetDlgItem(), являющейся членом класса CWnd:

СWnd *CWnd::GetDlgItem(int ItemIdentifier) const ;

Функция возвращает указатель на объект, чей идентификатор передан как параметр. Если такой объект не существует, то возвращается 0. Значение, возвращенное функцией, должно быть приведено к типу указателя на конкретный класс управления. Например, в нашем случае это тип CListBox*.

Инициализация списка

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

Поле ввода

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

int CWnd::GetWindowText(LPSTR StringVariable, int MaxStringLen) const;

В результате выполнения функции, содержимое поля ввода будет скопировано в строку по адресу StringVariable. Эта функция позволяет получить текст, связанный с любым окном или элементом управления. Применительно к обычному окну, функция получает заголовок окна. В момент создания поле ввода является пустым. Для инициализации его содержимым используется еще одна функция-член класса CWnd – SetWindowText(). Она отображает строку в элементе управления, который вызвал эту функцию. Ее прототип:

void CWnd::SetWindowText(LPCSTR String);

Контрольные переключатели

Контрольный переключатель – это элемент управления, предназначенный для установки или снятия определенной опции. Визуально он состоит из маленького прямоугольного поля, в котором может стоять метка выбора. Кроме этого, с переключателем связано текстовое поле с описанием предоставляемой переключателем опции. Если в переключателе стоит метка выбора, то говорится, что он выбран (установлен). Контрольные переключатели в MFC описываются с помощью класса CButton (так как контрольный переключатель – разновидность кнопки). Контрольные переключатели могут быть автоматическими и программными. Автоматический переключатель сам меняет свое состояние при щелчке мышью. Программный же этого не делает, а подразумевается, что сообщение о щелчке будет обработано в программе, и она изменит состояние переключателя. На практике почти всегда используются автоматические переключатели.

Сообщения контрольного переключателя

Каждый раз, когда пользователь щелкает мышью на контрольном переключателе (или нажимает клавишу Spacebar, когда фокус ввода находится на переключателе), диалогу посылается сообщение WM_COMMAND с идентификационным кодом BN_CLICKED. Это сообщение обрабатывается с помощью макроса ON_BN_CLICKED(). При работе с автоматическими переключателями отвечать на это сообщение нет необходимости. Но при работе с программными переключателями, чтобы изменять их состояние, необходимо отвечать на это сообщение. Для этого необходимо поместить макрос в карту сообщений и написать обработчик.

Установка и чтение состояния контрольного переключателя

Чтобы установить контрольный переключатель в заданное состояние, необходиимо использовать функцию SetCheck(…) c прототипом:

void CButton::SetCheck(int Status);

Параметр определяет требуемое состояние: если он равен 1, то переключатель устанавливается, если 0 - сбрасывается. По умолчанию, при первом вызове диалога переключатель будет сброшен. Автоматический переключатель также может быть установлен в требуемое состояние этой функцией. Текущее состояние переключателя можно определить с помощью функции GetCheck():

int CButton::GetCheck() const;

Функция возвращает 1, если переключатель установлен, и 0 в противном случае.

Инициализация контрольных переключателей

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

Статические элементы управления

Статическим называется элемент, который не принимает и не генерирует сообщений. Формально, этим термином называют то, что просто отображается в диалоговом окне, например, текстовая строка или рамка, предназначенная для визуального объединения нескольких элементов управления, или рисунок. Если элементу присвоен идентификатор IDC_STATIC (-1), то он не будет принимать и генерировать сообщений. Но, в общем случае, статические элементы управления могут генерировать и принимать сообщения. Для этого элементу нужно присвоить другой идентификатор. Тогда элемент уже не будет статическим. Это часто используется. Например, можно поменять текст в текстовой строке с помощью функции SetWindowText(), чтобы отобразить некоторую информацию.

Селекторные кнопки

Использование селекторных кнопок очень похоже на использование контрольных переключателей. Только их работа организована таким образом, что из группы кнопок может быть установлена только одна. При установке другой кнопки, предыдущая установка сбрасывается. Селекторные кнопки бывают программные и автоматические; но, так как управлять радиокнопками сложно, то сейчас почти всегда используются автоматические. Радиокнопки объединяются в группы. В одном диалоге может быть несколько групп. Для первой радиокнопки каждой группы в редакторе ресурсов нужно установить опцию Group, а для других радиокнопок группы она должна быть сброшена. Радиокнопки нумеруются в порядке значений их идентификаторов (то есть в порядке их создания в редакторе ресурсов). Если в диалоге все радиокнопки образуют одну группу, то опцию Group можно не устанавливать. Селекторные кнопки управляются с помощью класса CButton. Также как для контрольных переключателей, состояние селекторных кнопок можно изменять с помощью функции SetCheck() и читать с помощью функции GetCheck(). При создании диалога все селекторные кнопки сброшены. Таким образом, в функции OnInitDialog() необходимо установить начальное состояние программно. Хотя из программы можно установить сразу несколько селекторных кнопок или сбросить все, хороший стиль программирования под Windows предполагает, что всегда будет установлена одна и только одна селекторная кнопка.

Полосы прокрутки

В Windows есть два типа полос прокрутки. Элементы первого типа являются частью окна (включая диалоговое окно), поэтому их называют полосами прокрутки окна. Элементы второго типа существуют независимо и называются независимыми полосами прокрутки. Элементы первого типа описываются классом CWnd, а второго - CScrollBar.

Создание стандартных полос прокрутки

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

Независимые полосы прокрутки в диалогах

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

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

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

afx_msg void CWnd::OnVScroll(UINT SBCode, int Pos, CScrollBar *SB);
afx_msg void CWnd::OnHScroll(UINT SBCode, int Pos, CScrollBar *SB);

Следует отметить, что при наличии нескольких горизонтальных или вертикальных полос прокрутки для всех них будет вызываться один и тот же обработчик. Первый параметр, SBCode, содержит код выполненного над полосой прокрутки действия. Если работа ведется с вертикальной полосой прокрутки, то при каждом изменении положения ползунка на одну позицию вверх посылается код SB_LINEUP. При изменении позиции на одну вниз посылается код SB_LINEDOWN. Аналогично, при постраничном перемещении генерируются коды SB_PAGEUP и SB_PAGEDOWN. Если работа ведется с горизонтальной полосой прокрутки, то при каждом передвижении ползунка на одну позицию влево посылается код SB_LINELEFT. При изменении его положения на одну позицию вправо посылается код SB_LINERIGHT. При постраничном перемещении генерируются сообщения SB_PAGELEFT и SB_PAGERIGHT. Для обоих типов полос прокрутки при перемещении ползунка на новую позицию посылается код SB_THUMBPOSITION. Если при этом кнопка мыши удерживается нажатой, то дополнительно генерируется сообщение с кодом SB_THUMBTRACK. Это позволяет отслеживать перемещения ползунка, прежде чем мышь будет отпущена. Параметр Pos указывает текущую позицию ползунка. Если сообщение сгенерировано стандартной полосой прокрутки, то параметр SB будет равен 0. Если же оно было сгенерировано независимой полосой прокрутки, то этот параметр будет содержать указатель на объект. Это предоставляет весьма неуклюжий способ различать, какая конкретно независимая полоса прокрутки сгенерировала сообщение. Для этого нужно использовать функцию CWnd:: GetDlgCtrlID(), которая возвращает идентификатор элемента управления. Такое неудобство связано с тем, что MFC повторяет внутреннее устройство Windows, а не является библиотекой сверхвысокого уровня для быстрой разработки приложений.

Управление полосой прокрутки

Ранее, для установки различных параметров полосы прокрутки, использовались отдельные функции, которые были в Windows 3.1. С появлением Windows 95 появилась возможность управления полосами прокрутки с помощью одной функции SetScrollInfo(). Эта функция позволяет сделать полосу прокрутки пропорциональной (в этом случае, чем меньше диапазон полосы прокрутки, тем длиннее будет ее ползунок). Функция GetScrollInfo() предназначена для чтения параметров полосы прокрутки. В отличие от старых функций, эти функции работают с 32-разрядными данными. Для стандартных полос прокрутки используется функция:

BOOL CWnd::SetScrollInfo(int Which, LPSCROLLINFO pSI, BOOL Redraw = TRUE);

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

BOOL CScrollBar::SetScrollInfo(LPSCROLLINFO pSI, BOOL Redraw = TRUE);

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

BOOL CWnd::GetScrollInfo(int Which, LPSCROLLINFO pSI, UINT Mask = SIF_ALL);

Информация, получаемая от полосы прокрутки, записывается в структуру по адресу pSI. Значение параметра Mask определяет, какая информация записывается в структуру. По умолчанию заполняются все поля. Для независимых полос прокрутки вариант функции таков:

BOOL CScrollBar::SetScrollInfo(LPSCROLLINFO pSI, UINT Mask = SIF_ALL);

Значение параметров аналогичное предыдущему случаю. Во всех вариантах функций используется следующая структура типа SCROLLINFO:

typedef struct tagSCROLLINFO
 {
UINT cbSize; // размер самой структуры
UINT fMask; // маска для параметров
int nMin; // нижняя граница диапазона
int nMax; // верхняя граница диапазона
UINT nPage; // размер страницы
int nPos; // позиция ползунка
int nTrackPos; // позиция ползунка во время перемещения
} SCROLLINFO;

Поле fMask определяет, какое из полей структуры содержит требуемую информацию. Используются константы с префиксом SIF_, которые можно объединять операцией "| ". Поле nPos содержит статическую позицию ползунка. Поле nPage содержит размер страницы для пропорциональных полос прокрутки. Для получения обычной пропорциональной полосы прокрутки в этом поле нужно задать значение 1. Поля nMin и nMax содержат нижнюю и верхнюю границы диапазона полосы прокрутки. Поле nTracksPos содержит позицию ползунка при его перемещении, это значение не может быть установлено.

Графический вывод

Классические функции графического устройства

При выводе на экран графической информации: линии, текста, изображения и т.п. программа обращается к функциям GDI (graphic device interface) интерфейса графического устройства. Эти функции поддерживаются каркасом MFC и для удобства разработчика объединены в классы. Основным классом для работы с графикой является класс CDC и производные от него CPaintDC, CClientDC, CWindowDC, которые отличаются от базового класса только конструкторами и деструкторами. Исключением является класс CMetaFileDC. Класс CDC инкапсулирует понятие контекста устройства DC (device context).

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

Особенности производных классов контекста устройства

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

Классы CClientDC и CWindowDC отличаются друг от друга лишь тем, что представляют для рисования различные области окна. CClientDC представляет клиентскую часть (часть окна без рамки, заголовка, меню, панели управления и строки состояния). CWindowDC – полнооконный контекст устройства, позволяет рисовать в произвольной области окна программы.

Объекты класса CPaintDC используются только в обработчике сообщения WM_PAINT, генерируемого в ответ на вызов функций UpdateWindow или RedrawWindow и необходимы, если требуется переопределить функцию OnPaint() для конкретного дисплея. По умолчанию обработчик OnPaint() вызывает OnDraw(CDC*) с уже настроенным нужным образом контекстом. Конструктор CPaintDC определен так, что выполняет все действия необходимые для инициализации данного дисплея.

Создание и уничтожение объектов CDC

Управление созданием и удалением объектов CDC является важной частью каждой программы. При неправильной работе с контекстами теряется память до завершения работы программы. Рассмотрим два варианта корректной работы с объектами CDC.

1. Создать объект в стеке, тогда он будет уничтожен автоматически:

void CMyView::SomeFunction(...)
{
CRect cr;
CClientDC dc(this);
dc.GetClipBox(cr);
}

2. Получить указатель на объект с помощью CWnd::GetDC(), при этом перед выходом из функции вызвать ReleaseDC():

void CMyView::SomeFunction(...)
{
  CRect rect;
  CDC* pDC = GetDC();
  pDC->GetClipBox(rect);
  ReleaseDC(pDC);
}

Замечание: нельзя удалять CDC – объект, указатель на который передается функции OnDraw. За его удаление отвечает каркас MFC.

Состояние контекста устройства. Объекты GDI

Состояние контекста устройства определяется связанными с ним графическими объектами. Свойства контекста устройства назначаются с помощью методов класса CDC. GDI- объекты загружаются в контекст устройства вызовом перегруженной функции SelectObject. В любой текущий момент с контекстом может быть связан только один объект каждого типа. Все объекты GDI представлены в MFC с помощью классов. CGdiObject – базовый абстрактный класс для GDI объектов, которые являются экземплярами классов наследников.

При создании GDI объектов вызываются конструкторы соответствующих классов. Но для некоторых этого недостаточно. Например, создание объектов типа CFont или CRgn требует вызова CreateFont(…) или CreatePolygonRgn(…). Прежде чем удалять GDI объект, его требуется вначале "отсоединить" от контекста устройства. Память, выделенная под GDI объекты, принадлежит процессу и освобождается при его завершении. Такие объекты как растровые изображение занимают значительный объем памяти и за их своевременным удалением необходимо следить.

Пример работы с GDI – объектом:

void CMyView::OnDraw(CDC* pDC)
{
  CPen myPen(PS_SOLID, 2, RGB(255,0,0));
  CPen *oldPen = pDC->SelectObject(myPen);  //Присоединение нового пера и сохранение старого
//------------------------------------
  //Рисование....
//------------------------------------
 
pDC->SelectObject(oldPen);  //Возвращение контекста устройства в прежнее состояние
} //созданное в стеке перо будет удалено при выходе из функции

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

Основные методы класса CDC контекста устройства

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

BOOL CreateDC(LPCTSTR lpszDriverName, LPCTSTR lpszDeviceName, LPCTSTR lpszOutput, const void* lpInitData)

Это основная функция для инициализации контекста устройства. Первый параметр – указатель на строку с именем драйвера устройства. Второй параметр – указатель на строку с именем устройства, необходим, если драйвер поддерживает несколько устройств. Третий параметр – указатель на строку с именем файла или порта, куда будет осуществляться вывод. Четвертый – содержит особые параметры для настройки данного устройства. Функция возвращает true или false в зависимости от успеха или неудачи. Эта функция редко используется, обычно каркас MFC сам создает необходимый контекст.

BOOL CreateCompatibleDC(CDC* pDC)

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

SelectObject(…)

Это основная функция для связи с контекстом устройства GDI объекта. Рассмотри подробнее ее прототип. CPen* SelectObject (CPen* pPen) – связывает перо, указатель на которое передан в качестве параметра, с контекстом устройства. Возвращает указатель на перо, которое находилось в контексте устройства, до вызова функции. При неудаче возвращает NULL. Далее приведены перегруженные варианты данной функции.

CBrush* SelectObject(CBrush* pBrush)
virtual CFont* SeiectObject (CFont* pFont) 
CBitmap* SelectObject (CBitmap* pBitmap) 
int SelectObject (CRgn* pRgn)

В зависимости от типа параметра с контекстом устройства связывается соответствующий GDI объект.

virtual CGdiObject* SelectStockObject (int nlndex)

Связывает с контекстом один из стандартных объектов, идентификатор которого передается в качестве параметра. Также как и SelectObject(…), возвращает указатель на объект, который был связан с контекстом до ее вызова, в случае успеха, в случае неудачи – NULL.

CPen* GetCurrentPen( ) const

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

CPalette* GetCurrentPalette( ) const
CBrush* GetCurrentBrush( ) const

Функции с префиксом Get возвращают определенные параметры контекста устройства.

int SetBkMode (int nBkMode)

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

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

Будут далее рассмотрены подробнее. Ниже приведены их прототипы.

virtual int SetMapMode(int nMapMode)
virtual CPoint SetViewportOrg(CPoint point) 
СPoint SetWindowOrg(CPoint point)
virtual CSize SetViewportExt(CSize size)
virtual CSize SetWindowExt(CSize size)
void DPtoLP(LPPOINT lpPoints, int nCount = 1) const
void LPtoDP(LPPOINT lpPoints, int nCount = 1) const

СOLORREF SetPixel(int X, int Y, COLORREF Color)

Закрашивает пиксель области с координатами (X,Y) переданными в качестве первых двух аргументов цветом Color (третий аргумент функции). Возвращает цвет, который имел пиксель до вызова данной функции.

BOOL Rectangle(int upX, int upY, int lowX, int lowY)

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

BOOL RoundRect(int upX, int upY, int lowX, int lowY, int curveX, int curveY)

Рисует и заполняет текущей кистью контекста прямоугольник со скругленными углами. Параметры curveX и curveY задают ширину и высоту эллипса, определяющего дугу для скругленных углов.

BOOL Ellipse(int upX, int upY, int lowX, int lowY)

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

CPoint MoveTo(CPoint point)

Перемещает фокус в точку point. Возвращает предыдущие координаты фокуса.

BOOL LineTo(POINT point)

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

Битовые образы

Битовые образы – очень важная часть Windows. При хранении битовых образов в отдельном файле, обычно используется расширение BMP (это единственный растровый формат, который напрямую поддерживается Windows). Битовые образы могут храниться и в ресурсах. Битовые образы используются чаще, чем все остальные ресурсы. Это объясняется наличием для них чрезвычайно мощной поддержки. В Windows многие вещи, которые можно легко нарисовать программно, отображаются с помощью готовых битовых образов. Например, кнопки в нажатом и отпущенном состоянии, каркасы для целых окон. Так как компьютеры теперь имеют большие жесткие диски, то выбор между программным рисованием объекта и готовой картинкой часто однозначно решается в пользу последней.

Создание битовых образов

В MFC битовые образы описываются классом CBitmap. Для их создания можно использовать либо ресурсный редактор, либо импортировать в ресурсы готовые файлы BMP, созданные при помощи графических пакетов. Битовый образ является таким же ресурсом, как иконка, или диалог. Необходимо помнить, что область ресурсов с битовыми образами в EXE-файле может занимать большой размер. Но это не критично, так как ресурсы автоматически не загружаются в память.

Вывод битового образа на экран

Когда битовый образ помещен в ресурсы, его можно выводить на экран. Сначала необходимо создать объект типа CBitmap и с помощью функции LoadBitmap() загрузить в него битовый образ из ресурсов. Прототип функции:

BOOL CBitmap::LoadBitmap(LPCSTR ResourceName);

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

CPaintDC clientDC(this);
CDC memDC; // Контекст памяти
// Создать совместимый контекст памяти 
memDC.CreateCompatibleDC(clientDC);
// Выбрать битовый образ в контекст устройства
memDC.SelectObject(backgroundBitmap);
// Получить характеристики битового образа в структуру BITMAP
BITMAP bmp;
backgroundBitmap.GetBitmap(bmp); 
// Скопировать битовый образ из контекста памяти в контекст клиентской области
clientDC.BitBlt(0, 0, bmp.bmWidth, bmp.bmHeight, memDC, 0, 0, SRCCOPY);

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

virtual BOOL CDC::CreateCompatibleDC(CDC *pDC);

Область памяти используется для вывода изображения на экран. Перед выводом на экран изображение должно быть выбрано в контекст устройства, связанный с областью памяти, с помощью функции SelectObject(…). Мы используем ее вариант с прототипом:

CBitmap *CDC::SelectObject(CBitmap *pBmp);

Параметр pBmp – это указатель на объект битового образа. Для вывода изображения на экран используется функция BitBlt(…), которая копирует изображение из исходного контекста устройства в контекст, связанный с вызывающим функцию объектом. Прототип функции такой:

BOOL CDC::BitBlt(int x, int y, int Width, int Height, CDC *pSourceDC, int SourceX, int SourceY, DWORD RasterOpCode);

Первые два параметра задают координаты начальной точки изображения. Размеры изображения задают следующие два параметра. Параметр pSourceDC является указателем на исходный контекст устройства. Координаты SourceX и SourceY задают левый верхний угол изображения и обычно равны 0. Последний параметр задает код операции, которая будет проделана при передаче изображения из одного контекста в другой. Мы будем использовать только значение SRCCOPY, в этом случае изображение просто копируется. Существует также много других констант. Следует отметить, что указанным методом нельзя корректно выводить битовые образы более чем с 16 цветами в видеорежимах с 256 цветами. В режимах же HiColor и TrueColor без всяких проблем этим методом выводятся любые битовые образы. Так как на всех современных компьютерах используются, по крайней мере, HiColor режимы, мы не будем рассматривать ограничения худших режимов и манипуляции с палитрой. В библиотеке MFC, распространяющейся вместе с MS Visual Studio 2005 Professional, встроен класс CImage, который упрощает работу с битовыми образами. Принципы работы с ним рассмотрены далее.

Настройка системы координат

Стандартные функции каркаса MFC для настройки систем координат

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

Основные правила при работе с системами координат:

Рассмотрим функции для работы с системами координат.

Функция virtual int SetMapMode(int nMapMode) устанавливает направления осей и определяет логические единицы. Возможные значения параметра nMapMode приведены в таблице:

Функции для перемещения центров систем координат: virtual CPoint SetViewportOrg(CPoint point) и СPoint SetWindowOrg(CPoint point) . Первая смещает центр аппаратных координат, а вторая – логических, в точку, переданную в качестве параметра. Обе функции возвращают координаты предыдущего центра.

Функции virtual CSize SetViewportExt(CSize size) и virtual CSize SetWindowExt(CSize size) используются для задания единиц измерения. Первая функция устанавливает единицы измерения аппаратной системы координат, вторая – логической.

Для перехода от аппаратных координат к логическим используется функция void DPtoLP(LPPOINT lpPoints, int nCount = 1) const, а для перехода от логических к аппаратным – void LPtoDP(LPPOINT lpPoints, int nCount = 1) const. Аргументами обоих функций являются указатель на массив с точками, которые нужно преобразовать, и размерность этого массива.

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

Разработка Windows-приложения c использованем библиотеки MFC

Создание и вывод Windows-окна на экран с использованием MFC

Создадим простейшую программу под Windows средствами Visual C++ 2005

Введем код программы:

#include "afxwin.h"       //MFC основные и стандартные компоненты

class CMyApp : public CWinApp
{
public:
  CMyApp();        //Конструктор по умолчанию
  virtual BOOL InitInstance();  //Стандартная инициализация
};

class CMainWnd : public CFrameWnd
{
public:
  CMainWnd();        //Конструктор по умолчанию
};

CMainWnd::CMainWnd()
{
Create(NULL,"Окно приложения пользователя", WS_OVERLAPPEDWINDOW, rectDefault, NULL, NULL);    //Создать окно программы
}  

CMyApp::CMyApp()        //Конструктор главного класса приложения
{}

BOOL CMyApp::InitInstance()     //Стандартная инициализация
{
  m_pMainWnd=new CMainWnd();    //Создать указатель на класс окна
  ASSERT(m_pMainWnd);      //Проверить его правильность
  m_pMainWnd->ShowWindow(SW_SHOW);  //Показать окно
  m_pMainWnd->UpdateWindow();    //Обновить окно
  return TRUE;        //Вернуть, что все нормально
};
CMyApp theApp;          //Запуск приложения

Комментарий к программе

Первая строка – файл заголовков afxwin.h, предназначен для программирования под Windows с использованием библиотеки MFC. Он включает описание классов, функций и переменных, а также ссылается на windows.h.

Замечание: В каждой программе на С++ есть главная функция программы. В Dos, это main(), в Windows – WinMain(). В рассматриваемой программе ее нет, так как в MFC есть класс CWinApp, который включает главную функцию программы.

Во второй строке создается класс CMyApp, как производный от CWinApp и который наследует все его свойства, методы и т.д. В этом классе объявлен конструктор по умолчанию (без параметров). Он необходим, иначе не скомпилировать программу. В конце программы от класса CMyApp создается объект класса CMyApp theApp. Он тоже без параметров. CWinApp имеет виртуальный метод InitInstance(). Этот метод должен возвращать ненулевое значение, если инициализация прошла нормально, а иначе 0. Он предназначен, чтобы описать класс окна программы и отобразить окно на экране. В конструкторе класса CMainWnd вызывается функция создания окна Create(…), в которой есть несколько параметров. Первый параметр указывает на имя класса окна, он пока не нужен и поэтому NULL, дальше указатель – имя окна программы. WS_OVERLAPPEDWINDOW определяет стиль окна (обычное перекрывающее окно с заголовком, кнопкой вызова системного меню, кнопками минимизации и максимизации и рамкой). Параметр rectDefault говорит о том, что размер окна присвоит Windows по умолчанию. Рассмотрим функцию Create(…) подробнее:

BOOL CFrameWnd::Create(LPCSTR ClassName, LPCSTR Title, DWORD Style = WS_OVERLAPPEDWINDOW, const RECT XYSize = rectDefault, CWnd *Parent = 0, LPCSTR MenuName = 0, DWORD ExStyle = 0, CCreateContext *Context = 0);

Первый параметр, ClassName, определяет имя класса окна для оконной подсистемы Windows. Обычно его не нужно явно задавать, так как MFC выполняет всю необходимую работу. Параметр Title определяет заголовок окна. Параметр Style задает стиль окна. По умолчанию создается стандартное перекрываемое окно. Можно задать свой стиль, объединив с помощью операции "или" (|)несколько констант из приведенных ниже:

В примере используется член-функция со следующим прототипом:

virtual BOOL CWinApp::InitInstance();

Это виртуальная функция, которая вызывается каждый раз при запуске программы. В ней должны производиться все действия, связанные с инициализацией приложения. Функция должна возвращать TRUE при успешном завершении и FALSE в противном случае. В программе в функции сначала создается объект класса CMainWnd, и указатель на него запоминается в переменной m_pMainWnd. Эта переменная является членом класса CWinThread. Она имеет тип CWnd* и используется почти во всех MFC-программах, так как содержит указатель на главное окно. Так как m_pMainWnd указывает на CMainWnd, то можно вывести на экран окно:

m_pMainWnd->ShowWindow(SW_SHOW);

Параметр определяет, каким образом окно будет показано на экране. Наиболее распространенные значения следующие:

Показать окно:

m_pMainWnd->UpdateWindow();

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

Дополнение. При создании окна часто используют структуру Rect.

Пример:

RECT x;
x.top = 30;
x.left = 30;
x.bottom = 300;
x.right = 300;
Сreate(NULL, "My New Window", WS_OVERLAPPEDWINDOW, x);

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

Продолжение программы. Вставка элементов управления в окно (Controls)

Для работы возьмем наш первый проект и внесем изменения. Добавим следующий код после всех #include:

#define IDC_MYBUTTON 100  //Идентификатор кнопки
#define IDC_MYEDIT 102    //Идентификатор поля редактирования

Необходимо изменить описания конструктора класса окна:

class CMainWnd : public CFrameWnd
{
public:
CMainWnd();    //Конструктор по умолчанию
  ~CMainWnd();     //Деструктор
private:
  CStatic* MyStatic;  //Указатель на объект надпись
  CButton* MyButton;  //Указатель на объект кнопка
  CEdit* MyEdit;    //Указатель на объект поле редактирования
};
CMainWnd::CMainWnd()
{
  Create(NULL,"Окно пользователя", WS_OVERLAPPEDWINDOW, rectDefault, NULL, NULL);    //Создать окно программы
  MyStatic = new CStatic();
  if (MyStatic!=NULL) 
    MyStatic->Create("MyStatic", WS_CHILD|WS_VISIBLE|SS_CENTER, CRect(10, 10, 100, 50),this);  
  MyButton = new CButton();
  if (MyButton!=NULL) 
    MyButton->Create("MyButton", WS_CHILD|WS_VISIBLE|SS_CENTER,  CRect(120, 10, 220, 50), this, IDC_MYBUTTON);
  MyEdit = new CEdit();
  if (MyEdit != NULL) 
    MyEdit->Create(WS_CHILD|WS_VISIBLE|WS_BORDER, CRect(240, 10, 340, 50), this, IDC_MYEDIT);
}

CMainWnd::~CMainWnd()          //Деструктор класса
{
  if (MyStatic != NULL) delete MyStatic;  //Удалить динамический объект
  if (MyButton != NULL) delete MyButton;  //Удалить динамический объект
  if (MyEdit != NULL) delete MyEdit;    //Удалить динамический объект
}

Комментарии к программе

Результат создания объектов оператором new проверяется через проверку на NULL. Если ошибка, то все действия с этим элементом отменятся. Программный код реализации элементов управления находится в DLL Windows. То есть, в компиляторе нет реализации этих функций в библиотеках (lib), там только ссылки. Все элементы управления должны иметь идентификатор – число, которое определяет этот элемент управления. Первыми двумя строками, используя #define, объявляем идентификаторы. Дальше в класс рамки окна вставляются указатели на объекты элементов управления. Это только указатели. Объекта самого нет. Каждый объект использует память и, до того как он не понадобится, хранится только указатель. В конструкторе окна создадим соответствующие объекты с помощью оператора new, а после этого вызовем функцию Create(…), которая из объекта создаст элемент управления. Заметим, что у MyStatic нет идентификатора. Он задан по умолчанию, как 0xffff.

Функция Create(…) используется очень часто и есть у многих объектов. Обычно она требует:

Продолжение программы. События элемента управления

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

#include "afxwin.h"    //MFC Основные и стандартные компоненты

#define IDC_MYBUTTON 100  //Идентификатор кнопки
#define IDC_MYEDIT 102    //Идентификатор поля редактирования

class CMyButton: public CButton  //Создание нового класса
{
public:
  afx_msg void OnLButtonDown(UINT, CPoint);
  afx_msg void OnRButtonDown(UINT, CPoint);
private:
  DECLARE_MESSAGE_MAP(); //Таблица откликов кнопки
};
void CMyButton::OnLButtonDown(UINT, CPoint)
{
  MoveWindow(10, 110, 90, 30);
}

void CMyButton::OnRButtonDown(UINT, CPoint)
{
  MoveWindow(10, 40, 90, 30);
}

BEGIN_MESSAGE_MAP(CMyButton, CButton) //Таблица откликов на сообщения для кнопки
  ON_WM_LBUTTONDOWN()
  ON_WM_RBUTTONDOWN()
END_MESSAGE_MAP()

class CMainWnd : public CFrameWnd
{
public:
  CMainWnd();          //Конструктор по умолчанию
  ~CMainWnd();         //Деструктор
private:
  …
  CMyButton* MyButton;    //Указатель на объект кнопка
  …    
};
…
CMyApp theApp;

Продолжение программы. Создание строки состояния

Задача. Создать строку состояния (пока пустую). В описания включаемых файлов добавим:

#include "afxext.h"  //MFC расширения

В описание класса рамки окна:

class CMainWnd : public CFrameWnd
{
public:
  CMainWnd();  //Конструктор по умолчанию 
  int OnCreate(LPCREATESTRUCT lpCreateStruct);  
  ~CMainWnd();      // Деструктор
private:
  CStatic* MyStatic;    //Указатель на объект надпись
  CMyButton* MyButton;    //Элемент управления кнопка
  CEdit* MyEdit;      //Указатель на объект поле редактирования
  CStatusBar m_wndStatusBar;  //Класс панели состояния
  DECLARE_MESSAGE_MAP();    //Таблица откликов
};

В таблице откликов:

BEGIN_MESSAGE_MAP(CMainWnd, CFrameWnd)  //Таблица откликов на сообщения
  ON_WM_CREATE()        //Событие создания окна
END_MESSAGE_MAP()

Реализация объявленной процедуры:

int CMainWnd::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
  if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
    return -1;
  m_wndStatusBar.Create(this);
  return 0;
}

Продолжение программы. Создание меню

Задача. Создать меню со следующими элементами: Программа $$\to$$ Выход; Движение $$\to$$ Старт; Движение $$\to$$ Стоп. Добавить обработку выбора пункта меню Программа $$\to$$ Выход, остальные пункты пока не обрабатывать. Чтобы создать меню, необходимо создать файл ресурсов:

Добавим код:

…
#include "afxext.h"    // MFC Расширения
#include "resource.h"    // Идентификаторы ресурсов
#define IDC_MYBUTTON 100  // Идентификатор кнопки
…
class CMainWnd : public CFrameWnd
{
  …
  int OnCreate(LPCREATESTRUCT lpCreateStruct);//функция вызывается при создании окна
  void MenuExit();    //Процедура реакции на выбор пункта меню
   ~CMainWnd();    //Деструктор 
private:
  CStatic* MyStatic;    //Указатель на объект надпись
  CMyButton* MyButton;    //Элемент управления кнопка
  CEdit* MyEdit;      //Указатель на объект поле редактирования
  CStatusBar m_wndStatusBar;  //Класс панели состояния
  CMenu m_wndMenu;      //Это наш класс Меню
  DECLARE_MESSAGE_MAP();    //Таблица сообщений
};

CMainWnd::CMainWnd()
{
  Create(NULL,"Окно приложения пользователя",WS_OVERLAPPEDWINDOW,rectDefault,NULL,NULL);  //Создать окно программы
  ON_WM_CREATE()          //Событие создания окна
  ON_COMMAND(ID_FILE_EXIT, MenuExit)    //Обработка реакции на выбор меню
END_MESSAGE_MAP()
  …
  if (CFrameWnd::OnCreate(lpCreateStruct) == -1) return -1;
  m_wndStatusBar.Create(this); 
  m_wndMenu.LoadMenu(IDR_MENU);    // Загрузить меню из файла ресурса
  SetMenu(m_wndMenu);      // Установить меню
    return 0;
}
void CMainWnd::MenuExit()
{
  DestroyWindow();       // Уничтожить окно 
}

CMyApp theApp;

Скомпилируем и проверим работу программы с меню.

Продолжение программы. Таймер

Задача. Вывести в клиентскую часть окна круг, который при выборе пункта меню Движение $$\to$$ Старт, начинает движение и отскакивает от стенок клиентской области, а при выборе пункта меню Движение $$\to$$ Стоп, останавливается. Обработать нажатие клавиш: " $$\gets$$, $$\uparrow$$, $$\to$$, $$\downarrow$$ " ускоряющих (замедляющих) движение шарика в направлениях указанных стрелками. Добавим в описание класса окна следующий код:

class CMainWnd : public CFrameWnd
{
…
private:
  int VX, sgn_x;  //Приращение координаты по оси x и знак приращения
  int VY, sgn_y;  //Приращение координаты по оси y и знак приращения
  CRect newPlace;  //квадрат, в который вписан отображаемый круг
  CRect oldPlace;  //квадрат, в который был вписан отображаемый круг в предыдущий момент
  …
  DECLARE_MESSAGE_MAP();    // таблица откликов окна
public:
  …
  afx_msg void MenuStart();  // процедура реакции на выбор пункта меню 
  afx_msg void MenuStop();  // процедура реакции на выбор пункта меню 
  afx_msg void OnTimer(UINT_PTR);  // обработка сообщения WM_TIMER
  afx_msg void OnPaint();      // обработка WM_PAINT
  afx_msg void OnKeyDown(UINT, UINT, UINT);  //обработка нажатия клавиши клавиатуры
};

В карту сообщений окна добавим:

BEGIN_MESSAGE_MAP(CMainWnd, CFrameWnd)    // таблица откликов на сообщения
  …
  ON_COMMAND(ID_MOTION_START,MenuStart)  //выбор пункта "старт"
  ON_COMMAND(ID_MOTION_STOP,MenuStop)    //выбор пункта "стоп"
  ON_WM_TIMER()
  ON_WM_PAINT()
  ON_WM_KEYDOWN()      // реакция на нажатие клавиши
END_MESSAGE_MAP()

Добавим инициализацию полей в конструкторе класса:

CMainWnd::CMainWnd()
{
  oldPlace.left = 150;
  oldPlace.top = 150;
  oldPlace.right = 170;
  oldPlace.bottom = 170;
  newPlace = oldPlace;
  VX = VY = sgn_x = sgn_y = 1;
  …
}

Реализация объявленных методов:

void CMainWnd::MenuStart()
{
  SetTimer(ID_TIMER_FOR_MOT,10,NULL);    //Запуск таймера
}

void CMainWnd::MenuStop()
{
  KillTimer(ID_TIMER_FOR_MOT);      //Остановка таймера
}

void CMainWnd::OnTimer(UINT_PTR nIDEvent)
{
  CRect rectClient;
  GetClientRect(rectClient);
  rectClient.bottom -= 20;
  rectClient.left += 110;
  if(newPlace.right > rectClient.right || newPlace.left < rectClient.left)
    sgn_x = -sgn_x;
  if(newPlace.bottom > rectClient.bottom || newPlace.top < rectClient.top)
    sgn_y = -sgn_y;
  newPlace.left+= sgn_x*VX;  
  newPlace.right += sgn_x*VX;
  newPlace.top += sgn_y*VY;
  newPlace.bottom += sgn_y*VY;
  InvalidateRect(oldPlace);    //Затирается круг со старым центром
  ValidateRect(newPlace);    //Прорисовка круга с новым центром
  oldPlace = newPlace;
}

void CMainWnd::OnPaint()
{
  CPaintDC dc(this);
  CBrush bBrush(RGB(0,0,255));
  dc.SelectObject(bBrush);
  dc.Ellipse(newPlace);
}

void CMainWnd::OnKeyDown(UINT nChar, UINT, UINT)
{
  switch(nChar)  //Обработка символов с соответствующими кодами
  {
  case 40: if(sgn_y > 0) VY++;
       else VY--;
       break;
  case 38: if(sgn_y > 0) VY--;
       else VY++;
       break;
  case 37: if(sgn_x > 0) VX--;
       else VX++;
       break;
  case 39: if(sgn_x > 0) VX++;
       else VX--;
       break;
  }
}

Комментарий

Функция SetTimer(…) запускает системный таймер с идентификатором, указанным в параметрах, и генерирует синхронно сообщение WM_TIMER для окна, вызвавшего ее, пока таймер не будет уничтожен функцией KillTimer(…) с соответсвующим параметром – идентификатором работающего таймера. Для одного окна может быть запущено несколько таймеров.

Продолжение программы. Вывод данных в строку состояния

Задача. Отобразить в панели состояния текущие координаты курсора.

В проекте создадим ресурс, содержащий две строки: Resource View $$\to$$ клик правой кнопкой мыши $$\to$$ Add Resource… Выберем тип ресурса String Table. Нажмем OK. Появится новый ресурс. Он используется для хранения текстовых строк. В него нужно добавить две строки:

Создадим массив, в котором будут находиться идентификаторы строк (после #define ):

static UINT indicators[] =
{
  IDS_STRING_X,    //Идентификатор первой строки в ресурсах
  IDS_STRING_Y    //Идентификатор второй строки в ресурсах
};

Изменим функцию OnCreate для того, чтобы установить индикаторы:

int CMainWnd::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
  if (CFrameWnd::OnCreate(lpCreateStruct) == -1) 
    return -1;
  m_wndStatusBar.Create(this);    //Создать строку состояния
  m_wndStatusBar.SetIndicators(indicators,sizeof(indicators)/sizeof(UINT));  //Установить в строку идентификаторы
  m_wndStatusBar.SetPaneInfo(0,0,0,50);  //Изменение размеров первой секции строки состояния
  m_wndStatusBar.SetPaneInfo(1,0,0,50);  //Изменение размеров второй секции строки состояния
  m_wndMenu.LoadMenu(IDR_MENU);    //Загрузить 
  …
}

В таблицу откликов занесем реакцию на движение мыши:

BEGIN_MESSAGE_MAP(CMainWnd, CFrameWnd)  //Таблица откликов окна
  …
  ON_WM_CREATE()        //Событие создания окна
  ON_WM_MOUSEMOVE()        //Движение мыши
  …
END_MESSAGE_MAP()

И описание соответствующей функции в классе рамки окна:

class CMainWnd : public CFrameWnd
{
public:
  …
  afx_msg void OnMouseMove(UINT, CPoint cp);    //Движение мыши
  …
};

Реализация:

void CMainWnd::OnMouseMove(UINT, CPoint cp)
{
  char chX[10];          //Буфер для координат
  char chY[10];          //Буфер для координат
  itoa(cp.x,chX,10);        //Число переводим в строку
  itoa(cp.y,chY,10);        //Число переводим в строку
  CString csStatusX(chX);        //Формируем строку
  CString csStatusY(chY);        //Формируем строку
  m_wndStatusBar.SetPaneText(0,csStatusX);  //Выводим первую панель
  m_wndStatusBar.SetPaneText(1,csStatusY);  //Выводим вторую панель 
}

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

Комментарии

Для отображения в панели состояния, необходимо создать массив идентификаторов. Это необходимо для начала работы панели, а массив служит как шаблон. При запуске будет выведено именно то, что есть в строках, находящихся в ресурсах. Функция SetIndicators(...) говорит панели состояния о том, что у нее будут две панели. В параметрах – массив идентификаторов и количество элементов:

BOOL SetIndicators(const UINT* lpIDArray, int nIDCount);

Параметр lpIDArray – указатель на массив, nIDCount – количество элементов в массиве, sizeof(indicators)/sizeof(UINT) – размер массива/размер одного элемента

Движение мыши отслеживается с помощью сообщения – ON_WM_MOUSEMOVE(). Обработчиком этого сообщения является функция – OnMouseMove(). Этой функции передается положение мыши в виде Point. Далее, необходимо сделать перевод числа в строку - itoa, использовать объект класса CString, и, для вывода в строку состояния, использовать функцию SetPaneText(...)

BOOL SetPaneText( int nIndex, LPCTSTR lpszNewText, BOOL bUpdate = TRUE );

nIndex – номер панели для вывода, lpszNewText – текст для вывода, bUpdate – обновлять.

Окончательный текст программы

#include <afxwin.h>       //MFC основные и стандартные компоненты
#include <afxext.h>      //MFC расширения
#include "resource.h"      //Идентификаторы ресурсов
#define IDC_MYBUTTON 100    //Идентификатор кнопки
#define IDC_MYEDIT 102      //Идентификатор поля редактирования
#define ID_TIMER_FOR_MOT 104    //Идентификатор для таймера

static UINT indicators[] =
{
  IDS_STRING_X,    //Идентификатор первой строки в ресурсах
  IDS_STRING_Y    //Идентификатор второй строки в ресурсах
};


class CMyButton: public CButton  //Создание нового класса
{
public:
  afx_msg void OnLButtonDown(UINT, CPoint);
  afx_msg void OnRButtonDown(UINT, CPoint);
private:
  DECLARE_MESSAGE_MAP(); //Таблица откликов кнопки
};

class CMyApp : public CWinApp
{
public:
  CMyApp();            //конструктор по умолчанию
  virtual BOOL InitInstance();      //стандартная инициализация
};

class CMainWnd : public CFrameWnd
{
public:
  CMainWnd();          //Конструктор по умолчанию
  int OnCreate(LPCREATESTRUCT lpCreateStruct);  
  ~CMainWnd();         //Деструктор
private:
  int VX, sgn_x;  //Приращение координаты по оси x и знак приращения
  int VY, sgn_y;  //Приращение координаты по оси y и знак приращения
  CRect newPlace;  //Квадрат, в который вписан отображаемый круг
  CRect oldPlace;  //Квадрат, в который был вписан отображаемый круг в предыдущий момент
  CStatic* MyStatic;    //Указатель на объект надпись
  CMyButton* MyButton;    //Указатель на объект кнопка
  CEdit* MyEdit;      //Указатель на объект поле редактирования
  CStatusBar m_wndStatusBar;  //Объект строки состояния
  CMenu m_wndMenu;      //Объект меню
  DECLARE_MESSAGE_MAP();    //Таблица откликов окна
public:
  afx_msg void MenuExit();  //Процедура реакции на выбор пункта меню "выход" 
  afx_msg void MenuStart();  //Процедура реакции на выбор пункта меню "старт" 
  afx_msg void MenuStop();  //Процедура реакции на выбор пункта меню "стоп"
  afx_msg void OnTimer(UINT_PTR);
  afx_msg void OnPaint();
  afx_msg void OnKeyDown(UINT, UINT, UINT);
  afx_msg void OnMouseMove(UINT, CPoint cp);  //Движение мыши
};

BEGIN_MESSAGE_MAP(CMyButton, CButton) //Таблица откликов на сообщения для кнопки
  ON_WM_LBUTTONDOWN()
  ON_WM_RBUTTONDOWN()
END_MESSAGE_MAP()

BEGIN_MESSAGE_MAP(CMainWnd, CFrameWnd)    //Таблица откликов на сообщения
  ON_WM_CREATE()          //Событие создания окна
  ON_COMMAND(ID_APP_EXIT,MenuExit)    //Обработка реакции на выбор меню "выход"
  ON_COMMAND(ID_MOTION_START,MenuStart)  //Выбор пункта "старт"
  ON_COMMAND(ID_MOTION_STOP,MenuStop)    //Выбор пункта "стоп"
  ON_WM_TIMER()          //Обработка WM_TIMER
  ON_WM_PAINT()      
  ON_WM_KEYDOWN()          //Реакция на нажатие клавиши
  ON_WM_MOUSEMOVE()
END_MESSAGE_MAP()

void CMyButton::OnLButtonDown(UINT, CPoint)
{
  MoveWindow(10,110,90,30);
}

void CMyButton::OnRButtonDown(UINT, CPoint)
{
  MoveWindow(10,40,90,30);
}

CMyApp::CMyApp(){}      // конструктор главного класса приложения

BOOL CMyApp::InitInstance()     // стандартная инициализация
{
  m_pMainWnd=new CMainWnd();    // создать указатель на класс окна
  ASSERT(m_pMainWnd);      // проверить его правильность
  m_pMainWnd->ShowWindow(SW_SHOW);  // показать окно
  m_pMainWnd->UpdateWindow();    // обновить окно
  return TRUE;        // вернуть, что все нормально
};

CMainWnd::CMainWnd()
{
  oldPlace.left = 150;
  oldPlace.top = 150;
  oldPlace.right = 170;
  oldPlace.bottom = 170;
  newPlace = oldPlace;
  VX = VY = sgn_x = sgn_y = 1;
  Create(NULL,"Окно приложения пользователя", WS_OVERLAPPEDWINDOW, rectDefault, NULL, NULL);    // создать окно программы
  MyStatic = new CStatic();
  if (MyStatic != NULL) 
    MyStatic->Create("Надпись", WS_CHILD|WS_VISIBLE|SS_CENTER, CRect(10, 10, 100, 30), this);  
  MyButton = new CMyButton();
  if (MyButton != NULL) 
    MyButton->Create("Кнопка", WS_CHILD|WS_VISIBLE|SS_CENTER, CRect(10, 40, 100, 70), this, IDC_MYBUTTON);
  MyEdit = new CEdit();
  if (MyEdit != NULL) 
    MyEdit->Create(WS_CHILD|WS_VISIBLE|WS_BORDER, CRect(10, 80, 100, 100), this, IDC_MYEDIT);
}  

CMainWnd::~CMainWnd()            //Деструктор класса
{
  if (MyStatic != NULL) delete MyStatic;  //Удалить динамический объект
  if (MyButton != NULL) delete MyButton;  //Удалить динамический объект
  if (MyEdit != NULL) delete MyEdit;    //Удалить динамический объект
}

int CMainWnd::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
  if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
    return -1;
  m_wndStatusBar.Create(this);
  m_wndStatusBar.SetIndicators(indicators, sizeof(indicators)/sizeof(UINT));
  m_wndStatusBar.SetPaneInfo(0, 0, 0, 50);  //Изменение размеров первой секции строки состояния
  m_wndStatusBar.SetPaneInfo(1, 0, 0, 50);  //Изменение размеров второй секции строки состояния
  m_wndMenu.LoadMenu(IDR_MENU1);      //Загрузить меню из файла ресурса
  SetMenu(m_wndMenu);          //Установить меню
  return 0;
}

void CMainWnd::MenuExit()
{
  DestroyWindow();       //Уничтожить окно 
}

void CMainWnd::MenuStart()
{
  SetTimer(ID_TIMER_FOR_MOT,10,NULL);  //Запустить таймер
}

void CMainWnd::MenuStop()
{
  KillTimer(ID_TIMER_FOR_MOT);  //Остановить таймер
}

void CMainWnd::OnTimer(UINT_PTR nIDEvent)
{
  CRect rectClient;
  GetClientRect(rectClient);
  rectClient.bottom -= 20;
  rectClient.left += 110;
  if(newPlace.right > rectClient.right || newPlace.left < rectClient.left)
    sgn_x = -sgn_x;
  if(newPlace.bottom > rectClient.bottom || newPlace.top < rectClient.top)
    sgn_y = -sgn_y;
  newPlace.left += sgn_x*VX;
  newPlace.right += sgn_x*VX;
  newPlace.top += sgn_y*VY;
  newPlace.bottom += sgn_y*VY;
  InvalidateRect(oldPlace);  //Обновить прямоугольник, в котором был круг
  InvalidateRect(newPlace);  //Обновить прямоугольник, в котором круг сейчас
  oldPlace = newPlace;
}

void CMainWnd::OnPaint()
{
  CPaintDC dc(this);
  CBrush bBrush(RGB(0,0,255));
  dc.SelectObject(bBrush);
  dc.Ellipse(newPlace);
}

void CMainWnd::OnKeyDown(UINT nChar, UINT, UINT)
{
  switch(nChar)  //Обработка в зависимости от кода символа
  {
  case 40: if(sgn_y > 0) VY++;
       else VY--;
       break;
  case 38: if(sgn_y > 0) VY--;
       else VY++;
       break;
  case 37: if(sgn_x > 0) VX--;
       else VX++;
       break;
  case 39: if(sgn_x > 0) VX++;
       else VX--;
       break;
  }
}

void CMainWnd::OnMouseMove(UINT, CPoint cp)
{
  char chX[10];          //Буфер для координат
  char chY[10];          //Буфер для координат
  itoa(cp.x,chX,10);        //Число переводим в строку
  itoa(cp.y,chY,10);        //Число переводим в строку
  CString csStatusX(chX);        //Формируем строку
  CString csStatusY(chY);        //Формируем строку
  m_wndStatusBar.SetPaneText(0,csStatusX);  //Выводим первую панель
  m_wndStatusBar.SetPaneText(1,csStatusY);  //Выводим вторую панель 
}

CMyApp theApp;            //Запуск приложения

В результате компиляции и запуска на выполнение. В результате получим окно приложения следующего вида:рис 2.1